Create a new version of paste:

//package netbeans.pierwsza.aplikacja;
import java.util.*;
import javax.swing.*;
//import java.lang.Math.*;

class Host{
   
    protected String name;
    protected static int shipCount = 2;
    protected static int mapSize = 5;                                                   // żadany rozmiar mapy
    protected static int shipSize = 3;                                                  // żadany rozmiar statku
    protected static int trueSize = 2 * mapSize + 2;                                    // rzeczywisty wymiar tablicy
    public int shots = 0, hitsTaken = 0;
    protected char[] uHead =        {' ',' ','A',' ','B',' ','C',' ','D',' ','E',' ','F',' ','G',' ','H',' ','I',' '};
    protected char[] numbers =      {' ',' ','1',' ','2',' ','3',' ','4',' ','5',' ','6',' ','7',' ','8',' ','9',' '};
    protected int j,i, shipN = 0;
    Ship[] ships = new Ship[shipCount];
    protected char[][] mapa = new char[trueSize][trueSize];
    protected ArrayList<String> posList = new ArrayList<String>();
	
    public Host(){                                              // Konstruktor
        mapa = generateMap();
		setName("Gracz");
    }
    public boolean isThereChar(char[] array, char c){           // Czy w tablicy istnieje dany znak
    for(int i=0; i<array.length; i++){
        if (array[i] == c) return true;
    }
    return false;
    }
    public boolean strCheck(String s){                          // Zwraca true tylko jesli pole istnieje i jest puste
        int b = 0,a = 0;
        try
        {
            if (s.length() != 2) return false;                                  //jesli podano ciag o dl roznej 2 wyrzuc blad
            else
            {
                if(isThereChar(uHead, s.charAt(0)) == true)                     // pierwszy znak należy do uHeada
                {
                b = getCharIndex(uHead, s.charAt(0));      
                a = Character.getNumericValue(s.charAt(1))*2;
               
                    if (a > trueSize) return false;                             // uzytkownik podal nieistniejace pole
                    else if (mapa[a][b] == ' ') return true;                    // jesli to pole jest do zajecia zwroc OK
                         else return false;                                     // uzytkownik podal nieistniejace pole
                }
                else                                                               
                {
                    if((isThereChar(uHead, s.charAt(1)) == true))               // drugi znak należy do uHeada
                    {
                        a = Character.getNumericValue(s.charAt(0))*2;                  
                        b = getCharIndex(uHead,s.charAt(1));
                   
                        if (a > trueSize) return false;                             // uzytkownik podal nieistniejace pole
                        else if (mapa[a][b] == ' ') return true;
                             else return false;                                 // uzytkownik podal nieistniejace pole
                    }
                    return false;                                           // uzytkownik podal nieistniejace pole
                }
            }
        }
        catch(Exception e)
        {
            return false;
        }          
    }
    public char[][] generateMap(){                              // generuj pusta mape
        for( i = 0; i<trueSize;i++)
        {
            for(j = 0; j<trueSize;j++)
            {
           
                if(i%2==1 && j%2 == 1) mapa[i][j] = '+';    // wstawianie wezłow
                if(i%2==0 && j%2 == 1) mapa[i][j] = '|';    // wstawianie pionowych kresek
                if(i%2==1 && j%2 == 0) mapa[i][j] = '-';    // wstawianie poziomych kresek
                if(i%2==0 && j%2 == 0) mapa[i][j] = ' ';     // właściwe pola gry
       
                                                            //OPIS OSI (nadpisanie)
                if(i == 0) mapa[i][j] = uHead[j];           //jesli wiersz pierwszy podstaw elementy naglowka >> pierwszy if
                else if(j == 0) mapa[i][j] = numbers[i];    //jesli pierwszy znak w linii i nie jest to pierwsza linia wstaw elem. numaracji wiersza
            }
        }      
        return mapa;
    }    
    void shipSetup(){                                      		// stawianie statku
        int u,v,x,y;
        String str,str2,dirList = "Wprowadz nastepna pozycje ( ";
        StrMan rs = new StrMan();
        ArrayList<String> posTab = new ArrayList<String>(shipSize);
        String[] dirTab = new String[4];
        String[] dirTabR = new String[4];
       
        do
        {
            str = JOptionPane.showInputDialog("Podaj wspolrzedne");                                             // KROK 1 pobierz pole
            if (!strCheck(str)) JOptionPane.showMessageDialog(null, "Nieprawidlowa pozycja","Blad!", JOptionPane.ERROR_MESSAGE); //test pola
           
        }while(!strCheck(str));                                                                             // dopoki test nie wypadnie dobrze
       
            x=getRow(str);
            y=getCol(str);
            mapa[x][y] = '#';
            posTab.add(str);
			posList.add(str);
            printMap();
           
                                                                                                // KROK 2
                                dirTab[0] = String.valueOf(uHead[y]) + String.valueOf(numbers[x-2]);                // szukaj gdzie mozna postawic kolejny segment
            if(x == trueSize -2)dirTab[1] = "";                                             // IFy chronia przed wyjazdem za pamiec!
            else                dirTab[1] = String.valueOf(uHead[y]) + String.valueOf(numbers[x+2]);
            if(y == trueSize -2)dirTab[3] = "";
            else                dirTab[3] = String.valueOf(uHead[y+2]) + String.valueOf(numbers[x]);
                                dirTab[2] = String.valueOf(uHead[y-2]) + String.valueOf(numbers[x]);
 
            for(int i = 0; i < 4; i++) dirTabR[i]= rs.stringRev(dirTab[i]); // inicjuj tablice ze wspolrzednymi odwroconymi (w formacie [cyfra-litera])
            for (String temp : dirTab)                                      // składaj ciag z propozycja pola
            {
                if(strCheck(temp)) dirList = dirList + temp + " ";
                else dirList +="";
            }
            dirList += " )";                                                // zakończ ciag
            do
            {
                str2 = JOptionPane.showInputDialog(dirList);                // pobierz kolejna współrzędną
                if(!rs.isStringInTab(str2,dirTab) && !rs.isStringInTab(str2,dirTabR)) JOptionPane.showMessageDialog(null, "Niepoprawna pozycja, podaj jedną z proponowanych!","Blad!", JOptionPane.ERROR_MESSAGE);
            }while(!rs.isStringInTab(str2,dirTab) && !rs.isStringInTab(str2,dirTabR));
           
            u = getRow(str2);
            v = getCol(str2);
            mapa[u][v] = '#';
            posTab.add(str2);
			posList.add(str2);
            printMap();
            dirList = "Wprowadz nastepna pozycje ( ";
           
            if(v == y)                                                                  // KROK 3 jesli uklad jest pionowy
            {
               
                dirTab[0] = String.valueOf(uHead[y]) + String.valueOf(numbers[x-2]);                // szukaj gdzie mozna postawic kolejny segment
                if(x == trueSize - 2) dirTab[1] = "";                                               // IFy chronia przed wyjazdem za pamiec!
                else                 dirTab[1] = String.valueOf(uHead[y]) + String.valueOf(numbers[x+2]);
                dirTab[2] = String.valueOf(uHead[v]) + String.valueOf(numbers[u-2]);                // szukaj gdzie mozna postawic kolejny segment
                if(u == trueSize - 2) dirTab[3] = "";                                               // IFy chronia przed wyjazdem za pamiec!
                else                 dirTab[3] = String.valueOf(uHead[y]) + String.valueOf(numbers[u+2]);
            }
            if(x == u)                                                              //jesli układ poziomy
            {  
                dirTab[0] = String.valueOf(uHead[y-2]) + String.valueOf(numbers[x]);
                dirTab[2] = String.valueOf(uHead[v-2]) + String.valueOf(numbers[x]);
                if(y == trueSize - 2)dirTab[1] = "";
                else                dirTab[1] = String.valueOf(uHead[y+2]) + String.valueOf(numbers[x]);
               
                if(v == trueSize - 2)dirTab[3] = "";
                else                dirTab[3] = String.valueOf(uHead[v+2]) + String.valueOf(numbers[x]);
            }
            for(int i = 0; i < 4; i++) dirTabR[i]= rs.stringRev(dirTab[i]); // inicjuj tablice ze wspolrzednymi odwroconymi (w formacie [cyfra-litera])
                for (String temp : dirTab)                                  // składaj ciag z propozycja pola
                {
                if(strCheck(temp)) dirList = dirList + temp + " ";
                else dirList +="";
                }
                dirList += ")";                                             // zakończ ciag
                do
                {
                str2 = JOptionPane.showInputDialog(dirList);
               
                if(!rs.isStringInTab(str2,dirTab) && !rs.isStringInTab(str2,dirTabR)) JOptionPane.showMessageDialog(null, "Niepoprawna pozycja, podaj jedną z proponowanych!","Blad!", JOptionPane.ERROR_MESSAGE);
                }while(!rs.isStringInTab(str2,dirTab) && !rs.isStringInTab(str2,dirTabR));
               
                x=getRow(str2);
                y=getCol(str2);
                mapa[x][y] = '#';                                           // dodaj ostatnia czesc
               
                posTab.add(str2);
				posList.add(str2);
				ships[shipN] = new Ship(posTab, shipN);
				//System.out.println("rozmiar pos: " + ships[0]);
				//System.out.println("ships[n]: " + ships[shipN]);
				//ships[shipN].setShipID(shipN);
				//ships[shipN].setCoods(posTab);
				//System.out.println(posTab);
                //writeCoods(shipN,posTab);
                
                shipN++;
                wrapIt(posTab);                                      // otocz statek
 
                printMap();                                                
    }
    public void wrapIt(ArrayList<String> pos){                  // otocz statek
        int a,b;
 
        for(String temp : pos)
        {
            a = getRow(temp);
            b = getCol(temp);
           
            for (int i = a-2 ; i<=a+2; i+=2)
            {
                if(i == 0 || i == 2*mapSize+2) continue;
                for(int j = b-2; j<=b+2; j+=2)
                {      
                    if(j == 0 || j == 2*mapSize+2) continue;
                    if (mapa[i][j] == '#') continue;
                    mapa[i][j]='o';
                }
            }
        }
    }  
    public void cleanMap(){                                     // wyczysc mape
       
        for( i = 2; i<trueSize;i+=2)
        {
            for(j = 2; j<trueSize;j+=2) mapa[i][j] = ' ';
        }      
    }
    public void printMap(){                                     // DRUKUJ MAPE
        for( int i = 0; i<trueSize;i++)                        
        {            
            for(int j = 0; j<trueSize;j++)  System.out.print(mapa[i][j]);
            System.out.println();
        }
    }
    public int getCharIndex(char[] array, char c){              // zwroc miejsce na ktorym jest znak
    for(i=0; i<array.length; i++)
	{
        if (array[i] == c) return i;
    }
    return 0;
}
    public int getCol(String s){                                // nr kolumny
       
        if(isThereChar(uHead, s.charAt(0))) return getCharIndex(uHead, s.charAt(0));                       
        else return getCharIndex(uHead,s.charAt(1));               
 
    }
    public int getRow(String s){                                // nr wiersza
   
       
        if(isThereChar(uHead, s.charAt(0)) == true) return Character.getNumericValue(s.charAt(1))*2;       
        else return Character.getNumericValue(s.charAt(0))*2;                                                  
    }
	public void shipsCheck(String str){							// sprawdzanie trafien
	
		
		int a = getRow(str);
		int b = getCol(str);
		int n = -1;
		if(mapa[a][b] == 'x' || mapa[a][b] == 'o') System.out.println("Tu juz strzelano");
		else
		{
		if(posList.contains(str)) 
		{
			for(Ship ship : ships)
			{
				if(ship.getShipID(str) != -1) n = ship.getShipID(str);
			}
			
			//JOptionPane.showMessageDialog(null, "Trafiony!","Info", JOptionPane.PLAIN_MESSAGE);
			System.out.println("Trafiony");
			ships[n].removePos(str);
			hitsTaken++;
			if(ships[n].isDead()) shipN--;
			
			posList.remove(posList.indexOf(str));	
			mapa[a][b] = 'x';
		}
		else
		{
			
			//JOptionPane.showMessageDialog(null, "Pudlo","Info", JOptionPane.PLAIN_MESSAGE);
			System.out.println("Pudlo");
			mapa[a][b] = 'o';
			
		}
		//printMap();
		}
	}
	public void setName(String name){this.name = name;}
	public String getName() {return this.name;}
	
}
class CPU extends Host{

	protected ArrayList<String> history = new ArrayList<String>(); // lista strzalow
	protected ArrayList<String> posTab = new ArrayList<String>(); // lista strzalow
	public CPU(){
		generateMap();
		setName("CPU");
	}
    public String randHit(){
       
	   String str = new String();
	   
		do
		{
			RandomInt ri = new RandomInt();
			int randX = ri.rand(1,mapSize)*2;
			int randY = ri.rand(1,mapSize)*2;
			str = String.valueOf(uHead[randY]) + String.valueOf(numbers[randX]);
			if(history.contains(str) == true) System.out.println(str+" tu strzelano ponawiam...");
		}while(history.contains(str) == true);							//dopoki str bedzie nową pozycją
        System.out.println("Strzal losowy: " +str);
		history.add(str);
        return str;
    }
    @Override void shipSetup(){
		
       
        int a,b,n=0,c=0,d=0;
        String str = "", str2 = "";
        ArrayList<String> posTab = new ArrayList<String>(shipSize);
        RandomInt ri = new RandomInt();
        ArrayList<String> dirTab = new ArrayList<String>(0);
       
        do                                                      //KROK 1 losuj pole ktore jest wolne
        {  
            str = randHit();
            n++;
            if(n>100) break;
           
        }while(!strCheck(str));
        //System.out.println("1: " + str);
        a=getRow(str);
        b=getCol(str);
        mapa[a][b] = '#';                               // wyznaczanie nastepnej mozliwej pozycji
        n=0;
        if(a!=2) if(strCheck(String.valueOf(uHead[b]) + String.valueOf(numbers[a-2]))) dirTab.add(String.valueOf(uHead[b]) + String.valueOf(numbers[a-2]));
        if(b!=2) if(strCheck(String.valueOf(uHead[b-2]) + String.valueOf(numbers[a]))) dirTab.add(String.valueOf(uHead[b-2]) + String.valueOf(numbers[a]));
        if(a != trueSize -2) if(strCheck(String.valueOf(uHead[b]) + String.valueOf(numbers[a+2]))) dirTab.add(String.valueOf(uHead[b]) + String.valueOf(numbers[a+2]));      
        if(b != trueSize -2) if(strCheck(String.valueOf(uHead[b+2]) + String.valueOf(numbers[a]))) dirTab.add(String.valueOf(uHead[b+2]) + String.valueOf(numbers[a]));
        n = dirTab.size();
        //System.out.println(dirTab);
 
        if(dirTab.size() == 0)
        {
			//printMap();
            mapa[a][b] = ' ';
            //mapa[c][d] = ' ';
            System.out.println("[Krok 1 blad rozstawiania]");
			System.out.println("Wylosowano "+str);
            
        }
        else
        {
            //System.out.println(ri.rand(0,n));                                 // KROK 2
            str2 = dirTab.get(ri.rand(0,n-1));                  //losuj z tabeli dostepnych kierunkow
            //System.out.println("Wybrano: "+str2);
       
       
            c=getRow(str2);
            d=getCol(str2);
            mapa[c][d] = '#';
       
            //System.out.println("2: " + str2);
       
       
            dirTab.clear();                                         // KROK 3 czyszczenie dirTabu
 
        }
 
        n=0;                                                    // zerowanie licznikow     
       
        if(a == c)                                              // jesli uklad poziomy
        {                                                       // sprawdzenie mozliwych kierunkow dolozenia pola
            if(b!=2) if(strCheck(String.valueOf(uHead[b-2]) + String.valueOf(numbers[a]))) dirTab.add(String.valueOf(uHead[b-2]) + String.valueOf(numbers[a]));
            if(b != trueSize -2) if(strCheck(String.valueOf(uHead[b+2]) + String.valueOf(numbers[a]))) dirTab.add(String.valueOf(uHead[b+2]) + String.valueOf(numbers[a]));
            if(d!=2) if(strCheck(String.valueOf(uHead[d-2]) + String.valueOf(numbers[c]))) dirTab.add(String.valueOf(uHead[d-2]) + String.valueOf(numbers[c]));
            if(d != trueSize -2) if(strCheck(String.valueOf(uHead[d+2]) + String.valueOf(numbers[c]))) dirTab.add(String.valueOf(uHead[d+2]) + String.valueOf(numbers[c]));
        }
        if(b == d)                                                      // jesli uklad pionowy
        {                                                               // sprawdzenie mozliwych kierunkow dolozenia pola
            if(a!=2 && strCheck(String.valueOf(uHead[b]) + String.valueOf(numbers[a-2]))) dirTab.add(String.valueOf(uHead[b]) + String.valueOf(numbers[a-2]));
            if(a != trueSize -2 && strCheck(String.valueOf(uHead[b]) + String.valueOf(numbers[a+2]))) dirTab.add(String.valueOf(uHead[b]) + String.valueOf(numbers[a+2]));
            if(c!=2 && strCheck(String.valueOf(uHead[d]) + String.valueOf(numbers[c-2]))) dirTab.add(String.valueOf(uHead[d]) + String.valueOf(numbers[c-2]));
            if(c != trueSize -2 && strCheck(String.valueOf(uHead[d]) + String.valueOf(numbers[c+2]))) dirTab.add(String.valueOf(uHead[d]) + String.valueOf(numbers[c+2]));
        }
       
        if(dirTab.size() == 0)
        {
			printMap();
            mapa[a][b] = ' ';
            mapa[c][d] = ' ';
            System.out.println("[KROK 2 blad rozstawiania]");
            System.out.println("ShipN: " + shipN + " Wylosowano " + str + " oraz " + str2);
        }
        else
        {
           
            posTab.add(str);
            posTab.add(str2);
			
			posList.add(str);
			posList.add(str2);
			
            n = dirTab.size();
            str2 = dirTab.get(ri.rand(0,n-1));                  // losuj z tabeli dostepnych kierunkow
           
            c = getRow(str2);
            d = getCol(str2);
            mapa[c][d] = '#';
			
            posTab.add(str2);
			posList.add(str2);
			
            ships[shipN] = new Ship(posTab, shipN); 
            wrapIt(posTab);

            shipN++;
			if(shipN == shipCount-1)
			
				System.out.println("koniec rozstawu czysczcznie pamieci");
				history.clear();
			}							// jesli to bylo ostatnie rozstawienie czysc pamiec na potrzeby SI
        }       	

		//tutaj magia									//przeszukać historię i sprawdzać które było trafione, od nich sprawdzaj mozliwe kierunki i tam strzelaj
														// jesli nie ma dostepnych kierunkow sztrzelaj losowo
														// otoczyc po zatopieniu
	public String wisePlay(char[][] enemyMap){
		
		String wynik = new String();
		
		if(history.size() == 0) return randHit();         // brak historii, pierwszy raz strzelaj losowo (randHit tez zapisze historie)
		else 
		{
			RandomInt ri = new RandomInt();
			String lastHit = history.get(history.size() -1); // pobieranie ostatniego strzalu
			ArrayList<String> dirTab = new ArrayList<String>();
			int a = getRow(lastHit);
			int b = getCol(lastHit);      
			
			if(enemyMap[a][b] == 'x')                    // jesli ostatnio trafiono
			{
				if(history.size() > 1)					 // jesli to nie pierwszy strzal -tu jeszcze duzo mozliwosci trzeba opracowac prosty test 
				{
					String beforeLast = history.get(history.size() -2);
					int c = getRow(beforeLast);
					int d = getCol(beforeLast);
					if(enemyMap[c][d] == 'x') 			// jesli trafiono drugi raz z rzędu to mozna okreslic orientacje statku to powinno wynikac z okreslonej wczesniej puli
					{									// wyjatkiem moze byc sytuacja gdy zatopiono statek i od razu trafiono nastepny
						if(a == c)                                              // jesli uklad poziomy
						{                                                       // sprawdzenie mozliwych kierunkow dolozenia pola
							if(b!=2) if(strCheck(String.valueOf(uHead[b-2]) + String.valueOf(numbers[a]))) dirTab.add(String.valueOf(uHead[b-2]) + String.valueOf(numbers[a]));
							if(b != trueSize -2) if(strCheck(String.valueOf(uHead[b+2]) + String.valueOf(numbers[a]))) dirTab.add(String.valueOf(uHead[b+2]) + String.valueOf(numbers[a]));
							if(d!=2) if(strCheck(String.valueOf(uHead[d-2]) + String.valueOf(numbers[c]))) dirTab.add(String.valueOf(uHead[d-2]) + String.valueOf(numbers[c]));
							if(d != trueSize -2) if(strCheck(String.valueOf(uHead[d+2]) + String.valueOf(numbers[c]))) dirTab.add(String.valueOf(uHead[d+2]) + String.valueOf(numbers[c]));
							}
						if(b == d)                                                      // jesli uklad pionowy
						{                                                               // sprawdzenie mozliwych kierunkow dolozenia pola
							if(a!=2 && strCheck(String.valueOf(uHead[b]) + String.valueOf(numbers[a-2]))) dirTab.add(String.valueOf(uHead[b]) + String.valueOf(numbers[a-2]));
							if(a != trueSize -2 && strCheck(String.valueOf(uHead[b]) + String.valueOf(numbers[a+2]))) dirTab.add(String.valueOf(uHead[b]) + String.valueOf(numbers[a+2]));
							if(c!=2 && strCheck(String.valueOf(uHead[d]) + String.valueOf(numbers[c-2]))) dirTab.add(String.valueOf(uHead[d]) + String.valueOf(numbers[c-2]));
							if(c != trueSize -2 && strCheck(String.valueOf(uHead[d]) + String.valueOf(numbers[c+2]))) dirTab.add(String.valueOf(uHead[d]) + String.valueOf(numbers[c+2]));
						} 
						int n = dirTab.size();
						if (n==0) return randHit();
						return dirTab.get(ri.rand(0,n-1));
					}
					else								// ostatnio trafiono a przedostatnio nie tzn ze ostatni byl pierwszym z serii
					{
						if(a!=2) if(strCheck(String.valueOf(uHead[b]) + String.valueOf(numbers[a-2]))) dirTab.add(String.valueOf(uHead[b]) + String.valueOf(numbers[a-2]));
						if(b!=2) if(strCheck(String.valueOf(uHead[b-2]) + String.valueOf(numbers[a]))) dirTab.add(String.valueOf(uHead[b-2]) + String.valueOf(numbers[a]));
						if(a != trueSize -2) if(strCheck(String.valueOf(uHead[b]) + String.valueOf(numbers[a+2]))) dirTab.add(String.valueOf(uHead[b]) + String.valueOf(numbers[a+2]));      
						if(b != trueSize -2) if(strCheck(String.valueOf(uHead[b+2]) + String.valueOf(numbers[a]))) dirTab.add(String.valueOf(uHead[b+2]) + String.valueOf(numbers[a]));
						int n = dirTab.size();
						wynik = dirTab.get(ri.rand(0,n-1));
						history.add(wynik);
						return wynik;
					}
					
				}
				else 			// jesli ostatni strzal byl pierwszym i trafionym 
				{
					//badanie sasiadujacych pol oraz granicznych polozen w celu unikniecia wyjazdu za pamiec, pozycje mozliwe do zagrania dodaj do dirTab
			
					if(a!=2) if(strCheck(String.valueOf(uHead[b]) + String.valueOf(numbers[a-2]))) dirTab.add(String.valueOf(uHead[b]) + String.valueOf(numbers[a-2]));
					if(b!=2) if(strCheck(String.valueOf(uHead[b-2]) + String.valueOf(numbers[a]))) dirTab.add(String.valueOf(uHead[b-2]) + String.valueOf(numbers[a]));
					if(a != trueSize -2) if(strCheck(String.valueOf(uHead[b]) + String.valueOf(numbers[a+2]))) dirTab.add(String.valueOf(uHead[b]) + String.valueOf(numbers[a+2]));      
					if(b != trueSize -2) if(strCheck(String.valueOf(uHead[b+2]) + String.valueOf(numbers[a]))) dirTab.add(String.valueOf(uHead[b+2]) + String.valueOf(numbers[a]));
					int n = dirTab.size();
					// 'if' ponizej powinien byc zawsze prawdą, prawda? :)
					if(n>0)   //gdy wolne sa jakies kierunki wybierz losowo spomiedzy nich 	
					{
						wynik = dirTab.get(ri.rand(0,n-1));
						history.add(wynik);
						return wynik;
					}
				}
			}	
			else 										//ostatnio nie trafiono...
			{
				if(history.size() > 1) 					// ... ale cos tam juz strzelano
				{
					String beforeLast = history.get(history.size() -2); // pobierz przedostatni strzal
					int c = getRow(beforeLast);
					int d = getCol(beforeLast);
					if(enemyMap[c][d] == 'x') //ostatnio nie trafiono ale przedostatnio tak, trzeba wziac ostatni celny wyznaczyc mozliwe kierunki ale juz bez tego pudla
					{
						//badanie sasiadujacych pol oraz granicznych polozen w celu unikniecia wyjazdu za pamiec, pozycje mozliwe do zagrania dodaj do dirTab
						if(c!=2) if(strCheck(String.valueOf(uHead[d]) + String.valueOf(numbers[c-2]))) dirTab.add(String.valueOf(uHead[d]) + String.valueOf(numbers[c-2]));
						if(d!=2) if(strCheck(String.valueOf(uHead[d-2]) + String.valueOf(numbers[c]))) dirTab.add(String.valueOf(uHead[d-2]) + String.valueOf(numbers[c]));
						if(c != trueSize -2) if(strCheck(String.valueOf(uHead[d]) + String.valueOf(numbers[c+2]))) dirTab.add(String.valueOf(uHead[d]) + String.valueOf(numbers[c+2]));      
						if(d != trueSize -2) if(strCheck(String.valueOf(uHead[d+2]) + String.valueOf(numbers[c]))) dirTab.add(String.valueOf(uHead[d+2]) + String.valueOf(numbers[c]));
						int n = dirTab.size(); //w bloku powyzej podana pozycja lastHit nie powinna byc brana pod uwage, tam bedzie stalo juz 'o'
						
						wynik = dirTab.get(ri.rand(0,n-1));// losuj z pozostalych kierunkow
						history.add(wynik);
						return wynik;
						
					}
					else //ostatnie dwa strzaly nietrafione 
					{
						return randHit();
					}
				}
				else return randHit(); 					//ostatnio nie trafiono a strzelano tylko raz, strzelaj losowo dalej 
			}				
		}
		return wynik;
	}
	public void showHistory(){
		System.out.println(history);
	}
}

class Ship{
	private int shipID;
	public ArrayList<String> coods = new ArrayList<String>();
	public Ship (ArrayList<String> posTab, int id){
		
		for(String temp : posTab) coods.add(temp);
		setShipID(id);
	}
	public void setShipID(int n){ shipID = n; }
	public int getShipID()		{ return shipID; }
	public int getShipID(String str){
		if(coods.contains(str)) return shipID;
		else return -1;
	}
	public void removePos(String str){coods.remove(str);}
	public boolean isDead(){
		if(coods.size() == 0)
		{
			System.out.println("Zatopiony!");
			//JOptionPane.showMessageDialog(null, "Zatopiony!","Statek "+shipID, JOptionPane.PLAIN_MESSAGE);
			return true;
		}
		else return false;
	}
}
class StrMan{
    public boolean isStringInTab(String input, String[] tab){
        boolean flag = false;
        for(int i =0; i<4;i++) if(Arrays.asList(tab[i]).contains(input)) flag = true;
        return flag;
    }
    public String stringRev(String input){
        String output ="";
        char[] temparray = input.toCharArray();
        int left, right=0;
        right = temparray.length-1;
 
        for (left=0; left < right ; left++ ,right--)
        {
            char temp = temparray[left];
            temparray[left] = temparray[right];
            temparray[right]=temp;
        }
        for (int i = 0; i <input.length(); i++) output += String.valueOf(temparray[i]);
        return output;
    }
}
class RandomInt{
   
    public int rand(int min, int max){
        int range = (max - min) + 1;    
        return (int)(Math.random() * range) + min;
    }
}

public class Siatka{
 
   public static void main(String[] args){
		RandomInt ri = new RandomInt();
		int i = 0;
		String str;
		CPU p1 = new CPU();
		Host p2 = new Host();
	   
       do //p1 setup
        {
           p1.shipSetup();
		   i++;
           if (i>1000) break;
        }while(p1.shipN != p1.shipCount);
		p1.showHistory();
		do //p2 setup
        {
           
		   p2.shipSetup();
		   i++;
           if (i>1000) break;
        }while(p2.shipN != p2.shipCount);
		
        p1.printMap();
		p2.printMap();
		p1.cleanMap();
	    p2.cleanMap();
		System.out.flush();
		//p1.printMap();
		//p2.printMap();
        System.out.println("Statki rozstawione");
		//JOptionPane.showMessageDialog(null, "Statki rozstawione!","info ", JOptionPane.PLAIN_MESSAGE);
	    i = ri.rand(1,2);
	  do{
	   
			if(i%2 == 0) // przy parzystych strzela p1
			{
				p2.printMap();
				do
				{
					System.out.println("P1: ");
					str = p1.wisePlay(p2.mapa); 		
				}while(!p2.strCheck(str));
				p1.showHistory();
				p2.shipsCheck(str);
				p1.shots++;
			}
			else		
			{
				p1.printMap();
				do				// przy nieparzystych p2
				{
					//strzal komputera str = p2.randHit();
					str = JOptionPane.showInputDialog("Podaj wspolrzedne");                                           
					if (!p1.strCheck(str)) JOptionPane.showMessageDialog(null, "Nieprawidlowa pozycja","Blad!", JOptionPane.ERROR_MESSAGE); //test pola
					System.out.println("P2 "+str);
				}while(!p1.strCheck(str));
				
				p1.shipsCheck(str);
				p2.shots++;
			}
			i++;
			
	    }while(p1.shipN != 0 && p2.shipN != 0); // dopoki ilosc statkow jednego z graczy nie osiagnie zera
		System.out.println("Koniec gry, "+p1.getName()+" strzelal "+p1.shots+" trafien: "+p2.hitsTaken);
		System.out.println("Koniec gry, "+p2.getName()+" strzelal "+p2.shots+" trafien: "+p1.hitsTaken);
    
	}
}