# Probleme bei "Pixel-Fighting"-Spiel: Unausgewogene Mannschaften???



## tram2412 (22. Jun 2016)

Servus Leute!
Ich bin neu hier im Forum und möchte deswegen um eure Hilfe bitten! Ich habe gerade zum Spaß ein automatisches Pixel-Fighting-Spiel programmiert.
Die FAKTEN:
-2 Pixel-Mannschaften stehen sich gegenüber, beide haben gleich viele Kämpfer
-in jedem Durchlauf kämpfen die benachbarten Pixel gegeneinander. Zum Beispiel wenn ein roter  und ein blauer Pixel Kämpfen, und der blaue gewinnt, dann wird der rote Pixel blau!
-Wer gewinnt, entscheidet die Methode "nextBoolean()" aus der "Random"-Klasse

Das Problem:
-aus irgendeinem Grund gewinnt IMMER dieselbe Mannschaft! Ich poste euch hier den Code! berechne das ganze in der Main-Class und das Fenster in der Frame-Klasse

MAIN-CLASS

```
package com.tram.pixelfight;

import java.util.Random;

public class Main
{
    static Random r = new Random();
   
    static boolean[][] pixels = new boolean[100][100];
   
    public static void calculate()
    {
        for(int i = 0; i < pixels.length; i++)
        {
            for(int y = 0; y < pixels[i].length; y++)
            {
            w:    while(true)
                {
                    int next = r.nextInt(4); //Welcher pixel wird herausgefordert?
                    if(i == 0 && next == 0)continue;//verhindert ArrayIndexOutOfBoundException
                    if(y == 0 && next == 3)continue;                   
                    if(i == 99 && next == 2)continue;
                    if(y == 99 && next == 1)continue;
                   
                    switch(next) //gegen welchen Pixel soll gekämpft werden? LINKS, RECHTS, OBEN oder UNTEN?
                    {
                        case 0: if(pixels[i][y] != pixels[i-1][y])
                                {
                                    pixels[i-1][y] = (r.nextBoolean())? pixels[i-1][y] : !pixels[i-1][y];
                                }
                                break;

                        case 1: if(pixels[i][y] != pixels[i][y+1])
                                {
                                    pixels[i][y+1] = (r.nextBoolean())? pixels[i][y+1] : !pixels[i][y+1];
                                }
                                break;
                               
                        case 2: if(pixels[i][y] != pixels[i+1][y])
                                {
                                    pixels[i+1][y] = (r.nextBoolean())? pixels[i+1][y] : !pixels[i+1][y];
                                }
                                break;
                               
                        case 3: if(pixels[i][y] != pixels[i][y-1])
                                {
                                    pixels[i][y-1] = (r.nextBoolean())? pixels[i][y-1] : !pixels[i][y-1];
                                }
                                break;
                    }
                    break w;
                }               
            }
        }
    }
   
    public static void main(String[] args) throws InterruptedException
    {
        Frame f = new Frame();
       
        int fr = 0;
        int b = 0;
       
        for(int i = 0; i < pixels.length; i++)
        {
            for(int y = 0; y < pixels[i].length; y++)
            {
                if(i >= 50)
                {
                    pixels[i][y] = false;
                    b++;
                }
                else
                {
                    pixels[i][y] = true;
                    fr++;
                }
               
            }
        }
       
        System.out.println(b);
        System.out.println(fr);
       
        while(true)
        {
            calculate();
            Thread.sleep(1);
            f.screen.repaint();//Zeichnet das JFrame und Das JLabel neu
        }
       
    }
}
```

FRAME-CLASS

```
package com.tram.pixelfight;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.JFrame;
import javax.swing.JLabel;

public class Frame extends JFrame
{
    Screen screen = new Screen();
   
    public Frame()
    {
        super("Pixels Fighting");
        setSize(400,400);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setResizable(false);
        screen.setSize(this.getSize());
        add(screen);
        getContentPane().setPreferredSize(new Dimension(400,400));
        pack();
        setVisible(true);
       
    }
   
   
   
    class Screen extends JLabel
    {
         @Override
         protected void paintComponent(Graphics g)
         {
             super.paintComponent(g);
             for(int i = 0; i < Main.pixels.length; i++)
                {
                    for(int y = 0; y < Main.pixels[i].length; y++)
                    {
                        if(Main.pixels[i][y])
                        {
                            g.setColor(Color.cyan);
                            g.fillRect(i*4, y*4, 4, 4);
                        }
                        else
                        {
                            g.setColor(Color.red);
                            g.fillRect(i*4, y*4, 4, 4);
                        }
                    }
                }
            
         }
    }
}
```

Würde mich über Hilfe und Verschläge freuen!

MFG tram2412


----------



## cman (22. Jun 2016)

Versuchs mal mit:

```
static Random r = new SecureRandom();
```


----------



## tram2412 (22. Jun 2016)

cman hat gesagt.:


> Versuchs mal mit:
> 
> ```
> static Random r = new SecureRandom();
> ```


Das Hat leider nicht geklappt  Kann es sein, dass ich irgendwo die eine Mannschaft bevorzuge?


----------



## InfectedBytes (22. Jun 2016)

SecureRandom wird da nicht viel dran ändern. Das "Problem" liegt daran, dass du unfair kämpfst. Du gehst das Feld von links nach rechts durch und lässt jedes Feld "kämpfen".
d.h. nun aber dass erstmal nur die blauen kämpfen und schonmal einige rote besiegen. Wenn die roten dran sind, sind sie bereits in der Unterzahl und haben somit statistisch nur noch sehr geringe chancen zu gewinnen.


----------



## tram2412 (22. Jun 2016)

InfectedBytes hat gesagt.:


> SecureRandom wird da nicht viel dran ändern. Das "Problem" liegt daran, dass du unfair kämpfst. Du gehst das Feld von links nach rechts durch und lässt jedes Feld "kämpfen".
> d.h. nun aber dass erstmal nur die blauen kämpfen und schonmal einige rote besiegen. Wenn die roten dran sind, sind sie bereits in der Unterzahl und haben somit statistisch nur noch sehr geringe chancen zu gewinnen.


Genau das habe ich gebraucht! DANKE! <3  Also einmal von rechts nach links und dann von links nach rechts!? Das hat jedenfalls geklappt  Soll ich den Code Posten?


----------

