MinionGame

import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;

import javax.swing.ButtonGroup;
import javax.swing.JFrame;
import javax.swing.JRadioButton;
import javax.swing.JSlider;
import javax.swing.JButton;
import javax.swing.JPanel;

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

public class MinionGUI {

    /*
     * Minion Spiel mit GUI v1.2 -- Vincent Mathis, Tilman Jungewelter
     *
     * Fuer den Grundaufbau des Codes und das Layout von den
     * Elementen wurde das WindowBuilder Plugin fuer Eclipse verwendet.
     *
     * Die Spiellogik wurde zuerst fuer eine Konsolenanwedung
     * entwickelt und anschließend fuer ein GUI umgeschrieben.
     *
     * Der Computer versucht die Anzahl der Minions auszugleichen,
     * dadurch ist der Spieler immer zueltzt am Zug, sobald keine
     * Minions außer Norbert mehr vorhanden sind.
     *
     * Dadurch kann der Spieler aber die selbe Taktik verwenden.
     * Sobald der Spieler durch ziehen von Minions die Anzahl der
     * linken und rechten Seite ausgeglichen hat, ist es dem
     * Computer nicht mehr möglich zu gewinnen. Außnahme fuer den
     * Fall, dass der Spieler sie Seiten wieder in Ungleichgewicht versetzt.
     *
     * Die Minions werden als Rechtecke durch die graphics Methode dargestellt.
     * Da der Computer unmittelbar nach dem Spieler zieht, ist es schwer
     * zu erkennen was passiert ist. Deshalb werden die vorheringen
     * Spielzüge durch Text ausgegeben.
     *
     * Die "Steuerung" des Spiels erfolgt rundenbasiert, d.h. der Spieler kann
     * sich für links oder rechts entscheiden (mithilfe eines RadioButtons) und einen
     * Wert zwischen 1-3 auswaehlen (Slider). Durch das betätigen des Buttons
     * wird der Zug ausgefuehrt. Bei Spielende erscheint eine Textausgabe, der Button
     * kann verwendet werden um das Spiel neuzustarten (die Werte werden neu initialisiert)
     *
     */


    // Variablen
    private JFrame frame;
    private int norbert, anzahl, links, rechts;
    private char seite;
    private boolean running = true;
    private boolean won;
    private String win = "Gewonnen! :)";
    private String loss = "Verloren! :(";
    private String stringSpieler, stringComputer, btnText;

    // Main Methode erstellt neues "Fenster" und setzt es sichtbar
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    MinionGUI window = new MinionGUI();
                    window.frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    public MinionGUI() {
        init();
        gui();
    }

    // Initialisierung der Position, etc.
    public void init() {
        norbert = (int) (11 * Math.random()); // Zufallszahl zwischen 0 und 11, Position von Norbert.
        links = norbert; // Anzahl der Minions links von Norbert.
        rechts = 10 - norbert; // Anzahl der Minions rechts von Norbert.
        stringComputer = "";
        stringSpieler = "";
        btnText = "Ziehen";
    }

    // JPanel mit Graphics fuer die Kaestchen
    public class gPanel extends JPanel {
        public void paintComponent(Graphics g) {
            // Antialiasing fuer Text
            Graphics2D g2 = (Graphics2D) g;
            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
            // Löscht alle gezeichneten Objekte bei jedem Aufruf
            g.setColor(getBackground());
            g.fillRect(0, 0, 550, 70);
            // Minions links von Norbert
            g.setColor(new Color(255, 220, 50));
            for(int i = 0; i < links; i++) {
                g.fillRoundRect(norbert*40 - 40 - i*40, 0, 30, 30, 10, 10);
            }
            // Minions rechts von Norbert
            for(int j = 0; j < rechts; j++) {
                g.fillRoundRect(40 + norbert*40 + j*40, 0, 30, 30, 10, 10);
            }
            // Norbert
            g.setColor(new Color(220, 40, 40));
            g.fillRoundRect(norbert*40, 0, 30, 30, 10, 10);
            // Ausgabe der letzten Spielzuege:
            g.setColor(Color.DARK_GRAY);
            g.setFont(new Font("Courier", Font.PLAIN, 14));
            g.drawString(stringSpieler, 0, 50);
            g.drawString(stringComputer, 0, 65);
            // Game gewonnen/verloren:
            if(!running) { // Wenn running false gesetzt wird (in playerZug oder computerZug)
                g.setColor(getBackground());
                g.fillRect(0, 0, 550, 40);
                g.setFont(new Font("Tahoma", Font.PLAIN, 20));
                FontMetrics fm = g.getFontMetrics();
                if(won) { // won ebefalls von player Logik oder computer Logik gesetzt
                    g.setColor(new Color(110, 220, 40));
                    g.drawString(win, getWidth()/2 - fm.stringWidth(win) / 2, 20); // zeichne Text "Gewonnen"
                } else {
                    g.setColor(new Color(220, 40, 40));
                    g.drawString(loss, getWidth()/2 - fm.stringWidth(loss) / 2 , 20); // zeichne Text "Verloren"
                }
            }
        }
    }

    // Graphical User Interface Elemente + Buttonlistener (Befehle wenn der Spieler den Knopf drückt)
    private void gui() {
        // Frame, Layout, Exit
        frame = new JFrame();
        frame.setBounds(100, 100, 470, 155);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Beendet das Programm wenn X gedrückt wird
        frame.getContentPane().setLayout(null); // Layout der Elemente = absolut (pixel positionen)

        // Kaestchen fuer linke Seite
        final JRadioButton rdbtnLinks = new JRadioButton("Links");
        rdbtnLinks.setSelected(true);
        rdbtnLinks.setBounds(8, 86, 70, 23);
        frame.getContentPane().add(rdbtnLinks);

        // Kaestchen fuer rechte Seite
        final JRadioButton rdbtnRechts = new JRadioButton("Rechts");
        rdbtnRechts.setBounds(77, 86, 88, 23);
        frame.getContentPane().add(rdbtnRechts);

        // Nur ein Kaestchen kann gewae¤hlt werden
        ButtonGroup group = new ButtonGroup();
        group.add(rdbtnLinks);
        group.add(rdbtnRechts);

        // Slider fuer Anzahl der zu ziehenden Minions
        final JSlider slider = new JSlider();
        slider.setMinorTickSpacing(1);
        slider.setValue(2);
        slider.setPaintTicks(true);
        slider.setMinimum(1);
        slider.setMaximum(3);
        slider.setBounds(162, 87, 165, 27);
        frame.getContentPane().add(slider);

        // Graphics Panel hinzufuegen (public class gPanel)
        final JPanel gPanel = new gPanel();
        gPanel.setBounds(12, 12, 440, 70);
        frame.getContentPane().add(gPanel);

        // Button hinzufuegen
        JButton btnStart = new JButton(btnText);
        btnStart.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) { // Button listener
                if(rdbtnLinks.isSelected()) seite = 'l'; // char 'seite' wird l
                else seite = 'r'; // char 'seite' wird r
                anzahl = slider.getValue(); // int anzahl = Wert des Auswahl Sliders
                if(running){ // falls das Spiel noch laeuft
                    playerZug(); // fuehre den Zug des Spielers aus (Methode playerZug)
                    computerZug(); // fuehre den Zug des Computers aus (Methode computerZug)
                    if(!running) {
                        btnStart.setText(btnText);
                    }
                } else { // Ansonsten soll der Button das Spiel neustarten
                    won = false;
                    running = true;
                    init(); // Position von Norbert neu bestimmen (erneute Initialisierung)
                    btnStart.setText(btnText);
                }
                gPanel.repaint(); // rufe paintComponent in gPanel auf (zeichne alles erneut)
            }
        });

        btnStart.setBounds(328, 85, 116, 25);
        frame.getContentPane().add(btnStart);
    }

    // Spieler Logik
    public void playerZug() {
        // Hat Spieler links ausgewaehlt?
        if(seite == 'l') {
            if(links - anzahl < 0) { // Wenn der Spieler mehr Minions ziehen will als vorhanden sind
                won = false; // Spieler verliert
                running = false;
                btnText = "Nochmal";
            } else { // Ansonsten ziehe die Anzahl von der linken seite ab.
                links -= anzahl;
                stringSpieler = "Spieler:     " + anzahl + " Minions von der linken Seite gezogen.";
            }
        } else if(seite == 'r') { // entrsprechend der rechten Seite
            if(rechts - anzahl < 0) {
                won = false;
                running = false;
                btnText = "Nochmal";
            } else {
                rechts -= anzahl;
                stringSpieler = "Spieler:     " + anzahl + " Minions von der rechten Seite gezogen.";
            }
        }
    }

    // Computer Logik
    public void computerZug() {
        // pruefe ob keine Minions vorhanden sind, bevor computer zieht.
        if (links == 0 && rechts == 0) {
            // Spieler hat gewonnen da Computer Norbert ziehen muss.
            won = true;
            running = false;
            btnText = "Nochmal";
        } if(links > rechts) { // pruefe ob links mehr Minions stehen als rechts
            anzahl = links - rechts; // ziehe soviel ab, dass beide seiten gleich viele Minions haben
            if(anzahl < 1) anzahl = 1; // setze die Anzahl der zu ziehenden Minions auf mindestens 1
            if(anzahl > 3) anzahl = 3; // setze die Anzahl der zu ziehenden Minions auf maximal 3
            links -= anzahl; // ziehe die Anzahl der Minions von der linken Seite ab
            stringComputer = "Computer:    " + anzahl + " Minions von der linken Seite gezogen.";
        } else { // entsprechend fuer rechte Seite:
            anzahl = rechts - links;
            if(anzahl < 1) anzahl = 1;
            if(anzahl > 3) anzahl = 3;
            rechts -= anzahl;
            stringComputer = "Computer:    " + anzahl + " Minions von der rechten Seite gezogen.";
        }
        // pruefe ob keine Minions vorhanden sind (und ob das spiel nicht zuvor beendet wurde), nachdem der Computer gezogen hat.
        if (running && links == 0 && rechts == 0) {
            // Spieler hat verloren, da Spieler Norbert ziehen muss.
            won = false;
            running = false;
            btnText = "Nochmal";
        }
    }
}