Generator rzutów kośćmi

Próbuję stworzyć generator rzutów koścmi. Chce aby rzuty były zapisane w macierzy gdzie wiersze to ilość rzutów, ilość kolumn jest równa ilości kości a ich wartość to wartość rzutu. Wypociłem cos takiego:

import java.util.Random;


public class Rzucaj {

	public static void main(String[] args) {
		
		
Random generator = new Random();
		
		int ilosc_rzutow = 2;
		int ilosc_scian = 6;
		int ilosc_kosci = 4;		
		int[][] rzuty = new int[ilosc_rzutow][ilosc_kosci];
		
		
		for(int i = 0; i == ilosc_rzutow; i++){
			for(int j = 0; j == ilosc_kosci; j++ ){
				rzuty[i][j] = generator.nextInt(ilosc_scian);
			};
		};
		
		for(int i = 0; i == ilosc_rzutow; i++){
			for(int j = 0; j == ilosc_kosci; j++ ){
				System.out.println(rzuty[i][j]); 
			};
		};
	}

}

niestety wynik nie jest wypisywany w konsoli. Co zrobiłem źle?

for(int i = 0; i == ilosc_rzutow; i++)

Najpierw pomyśl, czy powyższy warunek w pętli będzie kiedykolwiek spełniony.

Dziękuje,

for(int i = 0; i < ilosc_rzutow; i++)

ten warunek rozwiązał problem.

poprawiony kod

import java.util.Random;


public class Rzucaj {

	public static void main(String[] args) {
		
		
Random generator = new Random();
		
		int ilosc_rzutow = 4;
		int ilosc_scian = 6;
		int ilosc_kosci = 11;		
		int[][] rzuty = new int[ilosc_rzutow][ilosc_kosci];
		
		
		for(int i = 0; i < ilosc_rzutow; i++){
			for(int j = 0; j < ilosc_kosci; j++ ){
				rzuty[i][j] = generator.nextInt(ilosc_scian-1)+1;
			};
			
		};
		
		for(int i = 0; i < ilosc_rzutow; i++){
			for(int j = 0; j < ilosc_kosci; j++ ){
				System.out.print(rzuty[i][j] + "\t"); 
			};
			System.out.println("\n");
		};
	}

}

z zamknięciem kostki w osobnej klasie to chodziło o cos takiego?

import java.util.Random;


public class Kostka {
	
	
	public int rzut(int ilosc_scian){
	Random kostka = new Random();
		
	return kostka.nextInt(ilosc_scian-1)+1;
	
	}
	
}



public class Rzucaj {

	public static void main(String[] args) {
		
Kostka kostka = new Kostka();
		
		int ilosc_rzutow = 4;
		int ilosc_scian = 6;
		int ilosc_kosci = 11;		
		int[][] rzuty = new int[ilosc_rzutow][ilosc_kosci];
		
		
		for(int i = 0; i < ilosc_rzutow; i++){
			for(int j = 0; j < ilosc_kosci; j++ ){
				rzuty[i][j] = kostka.rzut(ilosc_scian);
			};
			
		};
		
		for(int i = 0; i < ilosc_rzutow; i++){
			for(int j = 0; j < ilosc_kosci; j++ ){
				System.out.print(rzuty[i][j] + ";"); 
			};
			System.out.println("\n");
		};
	}

}

A może spróbuj to zrobić w ten sposób:

import java.util.Random;

public class Kostka {

    public int[][] rzucKostka(int ileKosci, int ileRzutow, int ileScian) {
        Random random = new Random();
        int[][] rzuty = new int[ileKosci][ileRzutow];

        for (int i = 0; i < ileKosci; i++) {
            for (int j = 0; j < ileRzutow; j++) {
                rzuty[i][j] = random.nextInt(ileScian) + 1;
            }
        }

        return rzuty;
    }
}

public class Main {
    public static void main(String[] args) {
        Kostka kostka = new Kostka();
        int[][] rzuty = kostka.rzucKostka(2, 3, 6);

        System.out.println(Arrays.deepToString(rzuty));
    }
}

No to moja propozycja (z wykorzystanie Guava, ale to szczegół):

class Dice {

    private final int walls;

    private final Random gen;

    public Dice(int walls) {
        this.walls = walls;
        this.gen = new Random();
    }

    public int roll() {
        return 1 + gen.nextInt(walls);
    }
}

kostka wie ile ma ścian i ma własny generator, co przynajmniej w teorii zapewnia niezależność kostek.

public static void main(String[] args) {                                                              
    List<Dice> dices = Lists.newArrayList(new Dice(6), new Dice(6)); // 2k6                           
    for (int i = 0; i < 3; i++) { // 3 rzuty                                                          
        Collection<Integer> rollResult = Collections2.transform(dices, new Function<Dice, Integer>() {
            @Nullable                                                                                 
            @Override                                                                                 
            public Integer apply(@Nullable Dice input) {                                              
                return input.roll();                                                                  
            }                                                                                         
        });                                                                                           
        System.out.println(String.format("W rzucie %s wypadło: %s", i, rollResult.toString()));       
    }                                                                                                 
}

tworzymy NkX niezależnych kostek i rzucamy Z razy.

@Koziołek można i bez guavy ;)

        List<Dice> dices = Arrays.asList(new Dice(6), new Dice(6));
        for (int i = 0; i < 3; i++) {
            Stream<Integer> rollResult = dices.stream().map(Dice::roll);
            String stringResult = rollResult.map(Object::toString).collect(Collectors.joining(", "));
            System.out.println(String.format("W rzucie %s wypadło: %s", i, stringResult));
        }

Koziołek napisał(a):

No to moja propozycja (z wykorzystanie Guava, ale to szczegół):

class Dice {

    private final int walls;

    private final Random gen;

    public Dice(int walls) {
        this.walls = walls;
        this.gen = new Random();
    }

    public int roll() {
        return 1 + gen.nextInt(walls);
    }
}

kostka wie ile ma ścian i ma własny generator, co przynajmniej w teorii zapewnia niezależność kostek.

public static void main(String[] args) {                                                              
    List<Dice> dices = Lists.newArrayList(new Dice(6), new Dice(6)); // 2k6                           
    for (int i = 0; i < 3; i++) { // 3 rzuty                                                          
        Collection<Integer> rollResult = Collections2.transform(dices, new Function<Dice, Integer>() {
            @Nullable                                                                                 
            @Override                                                                                 
            public Integer apply(@Nullable Dice input) {                                              
                return input.roll();                                                                  
            }                                                                                         
        });                                                                                           
        System.out.println(String.format("W rzucie %s wypadło: %s", i, rollResult.toString()));       
    }                                                                                                 
}

tworzymy NkX niezależnych kostek i rzucamy Z razy.

tylko w tym wypadku nie moge dynamicznie stworzyc macierzy z dowolna iloscia kostek. Docelowo chce podac ile chce zrobic rzutów, jakimi kośćmi w jakiej ilości. Wszystko ma byc wyświetlone w macierzy gdzie kazdy rzut bedzie miał swój index.

Czy ten kod który wstawiłem jest zły? Tak jak juz wczesniej pisałem, jestem bardzo poczatkujacy i nie zauważam jest niuansów w rożnicy pomiedzy moja klasa Kostka a klasa Dice. Moja klasa zwraca wartość przy wywołaniu metody tymczasem klasa Dice zwraca ją czy jej stworzeniu?

Akurat dynamiczne tworzenie nie jest aż takie trudne.

public List<Dice> pickDices(int nbrOf, int walls){
    List<Dice> dices = new ArrayList<Dice>(nbrOf);
    for(int i =0; i< nbrOf; i++){                 
        dices.add(new Dice(walls));               
    }                                             
    return dices;                                 
}

Klasa Dice zwraca wartośc po wywołaniu metody roll. Co do założeń z numerowaniem rzutów to nie jest to problem. Po prostu osobny mechanizm korzystajacy z klasy Dice i zapisujący wyniki. Separacja zadań i odpowiedzialności. Poszukaj informacji o SRP ( http://koziolekweb.pl/2009/02/26/solidne-programowanie-czesc-1-czyli-monogamia/ ) wtedy postaraj się podzielić swój kod na takie segmenty, które mają jedno konkretne zadanie.

Zresztą jak ogarnę się po dzisiejszym spotkaniu z Uncle Bobem to poszukam mojego starego dice parsera.