Sziasztok!
Segítségeteket kérném. Le kell adnom egy torpedó játékot, úgy érzem a koncepcióm jó, de valahol valami félrecsúszott a megvalósításban. Közeleg a határidő, és a sorok kezdenek összefolyni, A kódom szerintem jó strukturált, nem hosszú, és a téma is érdekes. Örülnek ha valaki bele tudna kukkantani.
Szóval egy 10*10 mezőre kéne feldobni véletlenszerűen 10 darab hajót (4db 2es méretűt, 3db 3as, 2 db 4es, 1db 5os) vízszintesen vagy függőlegesen, úgy hogy a hajók csak a sarkoknál érintkezhetnek, máshol egy szabad helyet kell hagyni közöttük.
Algoritmusom a következő:
-Generálok egy véletlen sorrendű mátrixot a hajók méreteivel, és eszerint próbálom őket felpakolni a fieldre.
-generálok egy véletlen számot, hogy a hajót először vízszintesen (addig megyek a sorokban amíg találok neki helyet) vagy függőlegesen( addig....az oszlopokban..) próbálja felrakni
-Generálok egy másik véletlen sorrendű mátrixot a field index számaival. Az index egyrészt a sorokra vagy oszlopokra tett próbálkozások, ill. az adott sorban vagy oszlopban a hajó kezdőpontjára tett kísérleteknek a sorrendjét is jelöli. Minden hajót eszerint próbálok feltenni.
-Ha egy hajót se egyik sorrba se egyik oszlopba nem lehet berakni, kezdődik a cirkusz előröl. (ide a loop meg hianyzik)
-Biztos van sokkal jobba algoritmus az enyémnél, hatékonysága kérdéses, de ha nem elvetemült az ötletem, ragaszkodnék az enyémhez (idő hiánya miatt is), ezt kéne valahogy működésre bírni....
Néhány metódus magyarázat:
hajotSorra(int x, int[] arr, int size): a size méretű hajót próbálja berakni az x.dik sorba, az arr matrix szerinti kezdőpontsorrenddel balról jobbra.
hajotOszlopra(int y, int[] arr, int size): a size méretű hajót próbálja berakni az y.dik oszlopba, az arr matrix szerinti kezdőpontsorrenddel fentről lefele.
hajotVizszintesre(int[] arr, int size): a hajot az arr szerinti sorsorrendbe próbálja berakni valamelyik sorba.
public boolean hajotFuggolegesre: a hajot az arr szerinti oszlopsorrendbe próbálja berakni valamelyik oszlopba.
Es a kicsike:
public class torpedo {
private final int rows;
private final int cols;
private final boolean[][] hits;
private final boolean[][] ships;
public torpedo (int numRows, int numCols) {
this.rows = numRows;
this.cols = numCols;
this.hits = new boolean[rows][cols];
this.ships = new boolean[rows][cols];
}
public void startGame() {
placeShips();
printfield();
}
private void placeShips() {
int [] shiporder ={2,2,2,2,3,3,3,4,4,5};
for(int j = 0; j < shiporder.length; j++){
int n = (int)(Math.random()*10);
int b = shiporder[n];
shiporder[n] = shiporder[j];
shiporder[j] = b;
}
int [] randomarray ={0,1,2,3,4,5,6,7,8,9};
for(int j = 0; j < randomarray.length; j++){
int w = (int)(Math.random()*10);
int g = randomarray[w];
randomarray[w] = randomarray[j];
randomarray[j] = g;
}
for(int j = 0; j < shiporder.length; j++){
int ship = shiporder[j];
int e = (int)(Math.random()*2);
if ( e == 0 && (hajotVizszintesre( randomarray, ship) ||hajotFuggolegesre( randomarray, ship ) ));
if ( e == 1 && ( hajotFuggolegesre( randomarray, ship) || hajotVizszintesre( randomarray, ship ) ));
}
}
public boolean hajotSorra(int x, int[] arr, int size){
boolean shipreadyleft = false;
boolean shipreadyright = false;
for( int k = 0; k < arr.length; k++){
int point = arr[k];
for( int j = point; j >= 0; j--){
if( ships[x][j] || ships[ Math.max(0,x-1)][j] || ships[ Math.min(9,x+1)][j] ){
if (point - j >= 2) shipreadyleft =true;
break;
}
if( !ships[x][0] && !ships[ Math.max(0,x-1)][0] && !ships[ Math.min(9,x+1)][0] ) shipreadyleft =true;
}
if (shipreadyleft){
for( int j = point; j < ships.length; j++){
if( ships[x][j] || ships[ Math.max(0,x-1)][j] || ships[ Math.min(9,x+1)][j]){
if (j - point >= size + 1 ) shipreadyright =true;
break;
}
if( !ships[x][ships.length-1] && !ships[ Math.max(0,x-1)][ships.length-1] && !ships[ Math.min(9,x+1)][ships.length-1] && ships.length - 1 - point >= size + 1 ) shipreadyright =true;
}
}
if ( shipreadyright ){
for( int j = point; j - point + 1 <= size; j++){
ships[x][j] = true;
}
}
if ( shipreadyright && shipreadyleft) break;
}
return shipreadyright && shipreadyleft;
}
public boolean hajotOszlopra(int y, int[] arr, int size){
boolean shipreadyup = false;
boolean shipreadydown = false;
for( int k = 0; k < arr.length; k++){
int point = arr[k];
for( int j = point; j >= 0; j--){
if( ships[j][y] || ships[j][ Math.max(0,y-1)] || ships[j][Math.min(9,y+1)] ){
if (point - j >= 2) shipreadyup =true;
break;
}
if( !ships[0][y] && !ships[0][ Math.max(0,y-1)] && !ships[0][Math.min(9,y+1)] ) shipreadyup =true;
}
if (shipreadyup){
for( int j = point; j < ships.length; j++){
if( ships[j][y] || ships[j][ Math.max(0,y-1)] || ships[j][Math.min(9,y+1)]){
if (j - point >= size + 1 ) shipreadydown =true;
break;
}
if( !ships[ships.length-1][y] && !ships[ships.length-1][ Math.max(0,y-1)] && !ships[ships.length-1][Math.min(9,y+1)] && ships.length - 1 - point >= size + 1 ) shipreadydown =true;
}
}
if ( shipreadydown ){
for( int j = point; j - point + 1 <= size; j++){
ships[j][y] = true;
}
}
if ( shipreadydown && shipreadyup ) break;
}
return shipreadydown && shipreadyup;
}
public boolean hajotVizszintesre(int[] arr, int size){
for( int k = 0; k < arr.length; k++){
int p1 = arr[k];
if ( hajotSorra(p1, arr, size)) return true;
}
return false;
}
public boolean hajotFuggolegesre(int[] arr, int size){
for( int k = 0; k < arr.length; k++){
int p2 = arr[k];
if ( hajotOszlopra(p2, arr, size )) return true;
}
return false;
}
public void printfield(){
for(int i = 0; i < ships.length; i++){
for(int j = 0; j < ships[i].length; j++){
if (ships[i][j])
System.out.print("H");
else
System.out.print("-");
}
System.out.println();
}
}
}