Risiko

[eclipseworker]

Ich möchte ein Programm schreiben, dass das beliebte Brettspiel Risiko simuliert. (Wer Risiko nicht kennt es wird zu zwei oder zu mehrt gespielt, jeder hat eine gewisse Anzahl an Ländern und Armen und er kann wenn er daran ist veruschen das Land eines Mitschreiters zu erobern. Er gewinnt wenn er alle Verteidigereinheiten besiegt hat, ansonsten kann er den Angriff abbrechen bzw. wenn dem Angreifer nur noch eine Einheit bleibt muss er ab brechen weil er die eine Einheit zum Sichern seines Landes braucht. Dazu würfeln für jede Schlacht Angreifer und Verteidiger, der Angreifer mit 3 Würfeln der Verteidiger mit 2 Würfeln. Es werden die höchsten zwei Werte des Angreifers mit denen des Verteidigers verglichen, wer den höhren Wert hat gewinnt. Sind die Werte gleich gewinnt der Verteidiger (Heimbonus)). Ich habe einen Code geschrieben der mein Programm testen soll, aber irgendetwas muss ich falsch gemacht haben den der Verteidiger gewinnt immer. Hier ist mein Code:

public class risiko
{
    private int[] angreifer;
    private int[] angreifergeordnet;
    private int[] verteidiger;
    private int[] verteidigergeordnet;
    
    public risiko(int c)
    {
        if(c>10000){
            c=10000;
        }
        angreifer = new int[3];
        angreifergeordnet = new int[2];
        verteidiger = new int[2];  
        verteidigergeordnet = new int[2];
        int siege=0;
        int u=0;
        int niederlagen=0;
        for(int i=1; i<=c;i++){
            switch(siegAngreifer()){
                case 2: System.out.println("Runde "+i+": Sieg"); siege++; break;
                case 1: System.out.println("Runde "+i+": Unentschieden"); 
                        System.err.println("Runde "+i+": Unentschieden"); u++; break;
                case 0: System.err.println("Runde "+i+": Niederlage"); niederlagen++; break;
            }
        }
        System.out.println(siege+" Siege von "+c+" Runden");
        System.out.println(siege+" Unentschieden von "+c+" Runden");
        System.err.println(siege+" Unentschieden von "+c+" Runden");
        System.err.println(niederlagen+" Niederlagen "+c+" Runden");
            }
    
    public int siegAngreifer(){
        fuelle(angreifer);
        fuelle(verteidiger);
        int[] angreifervergleichwerte=outer(angreifer);
        angreifergeordnet=array2WerteNachGroesseGeordnet(angreifervergleichwerte);
        verteidigergeordnet=array2WerteNachGroesseGeordnet(verteidiger);
        int i=0;
        for(int k=0; k<verteidiger.length;k++){
         if(entscheidung(angreifergeordnet[i], verteidigergeordnet[i])==true){
            i++;
            }
        }
        return i;
    }
    
    private int[] array2WerteNachGroesseGeordnet(int[] unordnung){
        int[] geordnet=new int[unordnung.length];
        geordnet[0]=kleinster(unordnung);
        geordnet[1]=groesster(unordnung);
        return geordnet;
    }
    
    private boolean entscheidung(int angreifer, int verteidiger){
        if(angreifer>verteidiger){
            return true;
        }else{
            return false;
        }
    }
    
    private void fuelle(int[] leer){
        for(int i=0; i<leer.length; i++){
            leer[i]=myRandom();
        }
    }
    
    private int summe(int[] zaehler){
        int summe=0;
        for(int i=0; i<zaehler.length; i++){
            summe+=zaehler[i];
        }
        return summe;
    }
    
    private int[] outer(int[] etwas){
        int[] outer=new int[etwas.length-1];
        for(int i=0; i<etwas.length;i++){
            int j=0;
            if(i!=kleinstenindex(etwas)){
                outer[j]=etwas[i];
            }
            j++;
        }
        return outer;
    }
    
   private int kleinstenindex(int[] bigger){
        int mini=6;
        int j=0;
        for(int i=0;i<bigger.length;i++){
            if(bigger[i]<mini){
                mini=bigger[i];
                j=i;
            }
        }
        return j;
    }
    
    private int kleinster(int[] bigger){
        int mini=6;
        for(int i=0;i<bigger.length;i++){
            if(bigger[i]<mini){
                mini=bigger[i];
            }
        }
        return mini;
    }
    
      private int groesster(int[] bigger){
        int max=1;
        for(int i=0;i<bigger.length;i++){
            if(bigger[i]>max){
                max=bigger[i];
            }
        }
        return max;
    }

        private int myRandom() {  
        int zufallswert= new Double(Math.random() * 6).intValue();
       return zufallswert;
    }  
}

 

[TKausL]

Hast du denn mal ausgegeben, was genau gewürfelt wird?

PS: Dein Regelwerk ist etwas ungenau. Der Angreifer würfelt nicht mit 3 Würfeln sondern genau mit sovielen, die er Armeen schickt. (Maximal 3). Der Verteidiger, mit wievielen Armeen er auf dem Land steht (maximal 2). Dabei werden die beiden höchsten würfe verglichen, danach die beiden zweithöchsten. Bei gleichstand oder höher vom Verteidiger stirbt eine Armee vom Angreifer, andernfals eine Armee des verteidigers.

 

[Marco13]

Auaua... da sind einige stilistische Fragwürdigkeiten drin... (und "Fragwürdigkeiten" ist hier ein Euphemismus )

Kurz:
- Klassennamen groß schreiben ("Risiko")
- Wenige und sinnvolle Instanzvariablen verwenden
- Auf solche Sachen...

private int kleinster(int[] bigger){
    return bigger[kleinstenIndex(bigger)];
}

.. sollte man kommen
- Methodennamen sollten meistens Verben sein - und IMHO auf englisch
- Lieber java.util.Random statt Math.random verwenden. Ersteres erlaubt es, immer die gleichen Zufallszahlen zu erzeugen, was die Fehlersuche erleichtert.


Insgesamt ist das unglaublich kompliziert geschrieben. Du solltest dir vielleicht den möglichen Ablauf des Spiels (und ggf. welche Klassen mit welchen Methode es geben wird) genauer überlegen. Bis dahin ein Vorschlag:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class Risiko
{
    public static void main(String[] args)
    {
        Risiko r = new Risiko();
    }
    
    private static final Random random = new Random(1);
    
    public Risiko()
    {
        int moves = 10;
        
        int won = 0;
        int undecided= 0;
        int lost = 0;
        for (int i = 1; i <= moves; i++)
        {
            List<Integer> attack = rollDices(3);
            List<Integer> defense = rollDices(2);
            switch (findWinner(attack, defense))
            {
                case 2:
                    System.out.println("Runde " + i + ": Sieg - "+attack+" vs. "+defense);
                    won++;
                    break;
                case 1:
                    System.out.println("Runde " + i + ": Unentschieden - "+attack+" vs. "+defense);
                    undecided++;
                    break;
                case 0:
                    System.out.println("Runde " + i + ": Niederlage - "+attack+" vs. "+defense);
                    lost++;
                    break;
            }
        }
        System.out.println(won + " Siege von " + moves + " Runden");
        System.out.println(undecided + " Unentschieden von " + moves + " Runden");
        System.out.println(lost + " Niederlagen " + moves + " Runden");
    }

    private static int findWinner(List<Integer> attack, List<Integer> defense)
    {
        Collections.sort(attack, Collections.reverseOrder());
        Collections.sort(defense, Collections.reverseOrder());
        int result = 0;
        for (int i=0; i<defense.size(); i++)
        {
            int a = attack.get(i);
            int d = defense.get(i);
            if (a > d)
            {
                result++;
            }
        }
        return result;
    }

    private static List<Integer> rollDices(int numDices)
    {
        List<Integer> result = new ArrayList<Integer>();
        for (int i=0; i<numDices; i++)
        {
            int value = random.nextInt(6) + 1;
            result.add(value);
        }
        return result;
    }
    
}