Game.java

import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.util.LinkedList;
import java.util.Random;
import java.util.concurrent.TimeUnit;

public class Game {

    //Data:
    public int currentLevel;
    //Benutzerführung:
    public JTextArea levelAnzeige;
    public int click = 0;
    /**
     * (Aufbau für folgende Level ist identsch)
     * Erstellen des Levels (Level 0 = Lobby)
     * createLobby (createLevel) -> Konfiguration der Mappfade/Mover Pos/Gegner Position
     * + weitere nötige Variable damit das Spiel funktioniert (currentLevel für Spielmechanik,active für die GUI)
     */
    long starttime;
    /**
     * Spielmechanik für die Lobby
     */
    int difficulty = 5; // Schwierigkeit 1-6
    double startSpeed;
    int enemySpawn;
    double moverSpeed = 5;
    private int currentClick;
    private int currentSteps;
    private int dialog;
    private boolean active;
    private long timestamp;
    private KeyManager keyListener;
    private Level[] level;
    private boolean gameOver = false;
    /**
     * Spiel Klasse die vorgefertigte Level beinhaltet = eigentliche Spielumgebung-> Konfigurierbar
     */

    //Konfiguration:
    // Objekte kann man nicht konfigurieren da das Spiel vorprogrammiert ist!

    //Core Objects:
    private GamePanel gamePanel;

    /**
     * Game Klasse benötigt Bildschirm (Panel) und Tastatureingaben (keyListener) um
     * das Spiel laufen zu lassen
     */
    public Game(GamePanel gp, KeyManager pKeyListener) {
        gamePanel = gp;
        keyListener = pKeyListener;
        //DEBUGGING:
        levelAnzeige = new JTextArea("levelAnzeige");
        levelAnzeige.setFocusable(false);

        createLevel();
        createLobby();
        active = true;
    }

    private boolean gridLines;

    /**
     * Erstellen des Level Menus (kann in MenuUI miteinbezogen werden)
     */
    public MenuUI.MenuTab createLevelMenu() {
        String[] name = new String[level.length];
        name[0] = "Lobby";
        for (int i = 1; i < level.length; i++) {
            name[i] = Integer.toString(level[i].getLevel());
        }
        MenuUI.MenuTab lvlMenu = new MenuUI.MenuTab("", name, true, false, false);
        lvlMenu.setHeading("Level");
        //Lock Level 3 and above
        for (int i = 3; i < level.length; i++) {
            lvlMenu.getButtons()[i].setLocked();
        }
        return lvlMenu;
    }

    /**
     * Erstellen eines Level
     * -> mehrere Level = Level Arrray
     * -> benotigte Map- und Gegneranzahl werden im Vorraus angegeben und erstellt,
     * damit die Konfiguration einfacher und übersichtlicher ist (ist nicht zwingend nötig!)
     */
    private void createLevel() {
        level = new Level[4];
        for (int i = 0; i < level.length; i++) {
            level[i] = new Level(gamePanel, i, keyListener);
        }
    }

    public void createLobby() {
        level[0].createLevelObjects(1, 0);
        Character mover = level[0].getMover();

        level[0].setBaseMap("Content/Maps/menu.txt", "Border");
        mover.setLocation(100, 100);
        setCurrentLevel(0);
        int mapSizeY = level[0].getBaseMap().mapSizeY;
        int mapSizeX = level[0].getBaseMap().mapSizeX;
        level[0].getBaseMap().mapTiles[mapSizeX / 2][mapSizeY / 2].setColor(Color.orange);
        level[0].getBaseMap().mapTiles[mapSizeX / 2][mapSizeY / 2].setFill(true);
        checkDifficulty();
        starttime = System.currentTimeMillis();
    }

    private void checkDifficulty() {
        switch (difficulty) {
            case 1:
                startSpeed = 0.25;
                enemySpawn = 1;
                break;
            case 2:
                startSpeed = 0.25;
                enemySpawn = 1;
                break;
            case 3:
                startSpeed = 0.5;
                enemySpawn = 2;
                break;
            case 4:
                startSpeed = 0.75;
                enemySpawn = 2;
                break;
            case 5:
                startSpeed = 1;
                enemySpawn = 1;
                break;
            case 6:
                startSpeed = 1;
                enemySpawn = 2;
                break;

        }
    }

    public void level0GameMechanic() {
        int side = new Random().nextInt(3);
        LinkedList<Runner> enemy = level[0].getEnemyList();
        //Verschiedene Level
        int mapSizeY = 0;
        int mapSizeX = 0;
        if (level[0].getBaseMap() != null) {
            mapSizeY = level[0].getBaseMap().mapSizeY;
            mapSizeX = level[0].getBaseMap().mapSizeX;
        }
        if (elapsedTime(timestamp) > 1.5 && level[0].getMover().isOnThisTile(mapSizeX / 2, mapSizeY / 2, 3)) {
            Random r = new Random();
            for (int i = 0; i < enemySpawn; i++) {
                startSpeed += level[0].getEnemyList().size() * 0.1;
                if (startSpeed >= moverSpeed) {
                    startSpeed = moverSpeed - 0.1;
                }
                switch (side) {
                    case 0:
                        //oben
                        level[0].addNewEnemyOnTile(r.nextInt(mapSizeX - 2), 1, startSpeed);
                    case 1:
                        //rechts
                        level[0].addNewEnemyOnTile(mapSizeX - 2, r.nextInt(mapSizeY - 2), startSpeed);
                        break;
                    case 2:
                        //links
                        level[0].addNewEnemyOnTile(1, r.nextInt(mapSizeY - 2), startSpeed);
                        break;
                    case 3:
                        level[0].addNewEnemyOnTile(r.nextInt(mapSizeX - 2), mapSizeY - 2, startSpeed);
                        break;
                }
            }
        }
        Character mover = level[0].getMover();
        mover.setSpeed(moverSpeed);
        for (int i = 0; i < enemy.size(); i++) {
            enemy.get(i).movetotarget(mover);
            if (enemy.get(i).movercheck(mover) && !isGameOver()) {
                enemy.get(i).saySomething("Da haben wir dich!", true, 200);
                setGameOver(true);
                int dialogResult = JOptionPane.showConfirmDialog(gamePanel, "Dein Score beträgt " + enemy.size() + " innerhalb von " + elapsedTime(starttime) + " Sekunden \nOK : Neustart", "Game Over", JOptionPane.OK_CANCEL_OPTION);
                if (dialogResult == JOptionPane.OK_OPTION) {
                    respawn(0);
                }
            }
        }
    }
    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////


    //<editor-fold desc="LEVEL 1">
    ////LEVEL 1 - Intro = Das Attentat an den Präsidenten ////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    public void createlevel1() {
        level[1].createLevelObjects(2, 31);
        //Laden der Maps:
        Character mover = level[1].getMover();

        level[1].setBaseMap("Content/Maps/Level 1 Base.txt", "All");
        level[1].getBaseMap().mapTiles[24][19].setBlocked(false);
        level[1].getBaseMap().mapTiles[24][20].setBlocked(false);
        level[1].setMap(1, "Content/Maps/Level 1 Items.txt", "Item", new Point(0, 0));
        // Intialisierung der Spieler:
        mover.setLocationAtTile(7, 7);
        mover.setSpeed(5);
        createMarketSituation();
        dialog = 1;
        setCurrentLevel(1);
    }

    public void level1GameMechanic() {
        level1Dialog();
        if (dialog > 9 && dialog < 12) {
            for (int i = 3; i < 15; i++) {
                level[1].getEnemy(i).setSpeed(level[1].getMover().getSpeed() / 2);
                level[1].getEnemy(i).movetotarget(level[1].getMover());
            }
        }
        //Game Over check
        for (int i = 0; i < level[1].getEnemyList().size(); i++) {
            if (dialog > 10 && level[1].getEnemyList().get(i).movercheck(level[1].getMover()) && !isGameOver()) {
                int dialogResult = JOptionPane.showConfirmDialog(gamePanel, "Du wurdest erwischt\nJa : Neustart\nNein : zur Lobby ", "Game Over", JOptionPane.YES_NO_OPTION);

                if (dialogResult == JOptionPane.YES_OPTION) {
                    respawn(1);
                    setGameOver(false);
                }
                if (dialogResult == JOptionPane.NO_OPTION) {
                    respawn(0);
                    setGameOver(false);
                }
            }
        }
        if (level[1].getMover().dangerCheck() && !isGameOver()) {
            setGameOver(true);
            int dialogResult = JOptionPane.showConfirmDialog(gamePanel, "Du wurdest erwischt\nJa : Neustart\nNein : zur Lobby ", "Game Over", JOptionPane.YES_NO_OPTION);

            if (dialogResult == JOptionPane.YES_OPTION) {
                respawn(1);
            }
            if (dialogResult == JOptionPane.NO_OPTION) {
                respawn(0);
            }
        }

    }

    /**
     * Erstellen von Map Chapter
     * -> zur besseren Übersicht
     * -> zum Neustarten von Maps
     */
    public void createMarketSituation() {
        Random r = new Random();
        level[1].getEnemy(0).setLocationAtTile(14, 19);
        level[1].getEnemy(1).setLocationAtTile(13, 19);
        level[1].getEnemy(1).setImg(new ImageIcon("Content/Graphics/player/hurtguy.png").getImage().getScaledInstance(100, 100, BufferedImage.TYPE_4BYTE_ABGR));
        level[1].getEnemy(2).setLocationAtTile(13, 19);
        for (int i = 3; i < 15; i++) {
            level[1].getEnemy(i).setLocationAtTile(9 + r.nextInt(2), 17 + r.nextInt(2));
        }
        for (int i = 15; i < 20; i++) {
            level[1].getEnemy(i).setLocationAtTile(11 + r.nextInt(2), 18 + r.nextInt(3));
            level[1].getEnemy(i).setDirection(2);
        }
        for (int i = 20; i < 25; i++) {
            level[1].getEnemy(i).setLocationAtTile(10 + r.nextInt(5), 20 + r.nextInt(3));
            level[1].getEnemy(i).setDirection(3);
        }
        for (int i = 25; i < 30; i++) {
            level[1].getEnemy(i).setLocationAtTile(15 + r.nextInt(5), 16 + r.nextInt(3));
            level[1].getEnemy(i).setDirection(0);
        }
    }

    /**
     * Dialog
     * Reihenfolge des Gesprächs wird durch den int dialog angegeben
     * dialog wird immer einen hochgezählt wenn die Bedingung (welche frei konfigurierbar ist) erfüllt wird
     * BSP: dialog 2 - wird aufgerufen wenn dialog = 2 ist (bzw. der vorige Dialog ausgeführt wurde, der dialog auf 2 setzt)
     * UND einmal geklickt wurde (Differenz aus momentanen Klickstand - alten Klickstand muss > oder = 1 ergeben)
     * - mithilfe von setSpeaking kann Dialog Bedingung erzwingt werden = Character kann sich nicht bewegen
     * Weitere Bedingungen können bestimmte MoverPositionen / Schrittanzahl / Zeit sein
     * => Nur wichtig, dass diese im Bedingungkopf stehen
     */
    public void level1Dialog() {
        Character mover = level[1].mover;
        int speakingspeed = 800;
        if (dialog == 1) {
            for (int i = 0; i < level[1].getBaseMap().mapSizeX; i++) {
                level[1].getBaseMap().mapTiles[i][16].setBlocked(true);
            }
            mover.saySomething("Was ist denn da los?" + "\n" + "(Klicken für weiteren Dialog)", true, speakingspeed);
            mover.setSpeaking(true);
            currentClick = click;
            dialog = 2;
        }
//       //System.out.println("Click in Dialog 1 "+ click +"-"+ currentClick+"="+ (click - currentClick));
        if (dialog == 2 && click - currentClick >= 1) {
            mover.saySomething("W-A-S-D drücken um sich zu bewegen", true, speakingspeed);
            mover.setSpeaking(false);
            currentSteps = mover.getSteps();
            dialog = 3;
        }
        if (dialog == 3 && mover.getSteps() - currentSteps >= 50) {
            mover.saySomething("Super du kannst laufen !", true, speakingspeed);
            setTimestamp();
            dialog = 4;
        }
        if (dialog == 4 && elapsedTime(timestamp) > 2) {
            mover.saySomething("Gehe zum Markt (markiertes Feld)", true, speakingspeed);
            level[1].getBaseMap().mapTiles[17][15].setBorderInsets(new Insets(5, 5, 5, 5));
            dialog = 5;
        }

        if (dialog == 5) {
            for (int i = 0; i < level[1].getBaseMap().mapSizeX; i++) {
                level[1].getBaseMap().mapTiles[i][16].setBlocked(false);
            }
            level[1].getEnemy(0).enemystraightrun(new Point((int) level[1].getEnemy(0).getLocation().getX() / Tile.TILEWIDTH, 10), 0.5, 0, 1);
        }
        if (dialog == 5 && mover.isOnThisTile(17, 15, 4)) {
            mover.saySomething("! Ich glaube da ist ein Unfall...", true, speakingspeed);
            level[1].maps[0].mapTiles[17][15].setBorderInsets(new Insets(0, 0, 0, 0));
            level[1].maps[0].mapTiles[15][16].setBorderInsets(new Insets(5, 5, 5, 5));
            setTimestamp();
            dialog = 6;
        }
        if (dialog == 6 && mover.isOnThisTile(15, 16, 4)) {
            mover.saySomething("Ich muss helfen !!! Nichts wie hin", false, speakingspeed);
            level[1].maps[0].mapTiles[15][16].setBorderInsets(new Insets(0, 0, 0, 0));
            level[1].maps[0].mapTiles[13][18].setBorderInsets(new Insets(5, 5, 5, 5));
            setTimestamp();
            dialog = 7;
        }
        if (dialog == 7 && elapsedTime(timestamp) > 4) {
            mover.saySomething("Du warst zu langsam um zu helfen!", true, speakingspeed);
            createlevel1();
            setTimestamp();
            if (TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis() - timestamp) > 4) {
                dialog = 1;
            }
        }
        if (dialog == 7 && mover.isOnThisTile(13, 18, 4)) {
            mover.saySomething("Hallo ?! Ist alles okay, du siehts verletzt aus!", true, speakingspeed);
            level[1].maps[0].mapTiles[13][18].setBorderInsets(new Insets(0, 0, 0, 0));
            dialog = 8;
        }
        if (dialog == 8) {
            level[1].getEnemy(0).saySomething("DU hast den Präsidenten verletzt !!! ", true, speakingspeed);
            mover.saySomething("Nein ich habe nix gemacht! Ich wollte nur helfen...", true, speakingspeed);
            mover.setSpeaking(true);
            setTimestamp();
            dialog = 9;
        }
        if (dialog == 9 && elapsedTime(timestamp) > 2) {
            level[1].getEnemy(2).saySomething("Holt ihn euch!!", true, speakingspeed);
            dialog = 10;
        }
        if (dialog == 10) {
            mover.saySomething("Ich muss schnell weg !\n Ich bin UNSCHULDIG aber ich brauche Beweise", true, speakingspeed);
            dialog = 11;
        }
        if (dialog == 11 && mover.isInThisArea(new Point(23, 19), new Point(26, 18), 4)) {
            mover.speechBubble.setVisible(false);
            mover.saySomething("Du hast es geschafft vom Fluchtort zu fliehen!\n Die Fähigkeiten hast du schonmal. " +
                    "\nEs fehlen nur noch die Beweise! Das Intro ist nun beendet.\n Viel Spaß!", true, speakingspeed / 4);
            dialog = 12;
            setTimestamp();
        }
        if (dialog == 12 && elapsedTime(timestamp) > 4) {
            createlevel2();
        }
    }

    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //</editor-fold>

    //<editor-fold desc="LEVEL 2">

    /////EIGENE SPIELIDEEN REALISIERBAR


    ////LEVEL 2 - First Chapter - "Informatik GK - eigenes Spiel"   //////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    public void createlevel2() {
        /** Laden der Maps:
         *
         */
        level[2].createLevelObjects(1, 5);
        JOptionPane.showMessageDialog(null, "Soll im Informatik GK erstellet werden", "Info", JOptionPane.PLAIN_MESSAGE);
        level[2].setBaseMap("Content/Maps/1 Base Field Town Houses.txt", "All");
        level[2].getMover().setLocationAtTile(5, 5);
        level[2].getBaseMap().setTileAsAlert(5, 5, 2);
        level[2].getEnemy(1).setLocationAtTile(3, 3);
        level[2].getEnemy(1).repeatedRightRun(2, 5);
        setCurrentLevel(2);

        /** Intialisierung der Spieler:
         *
         */
    }

    public void level2GameMechanic() {
        /**
         * Spielmechanik
         */
        for (int i = 0; i < level[2].getEnemyList().size(); i++) {
            if (dialog > 11 && level[2].getEnemyList().get(i).movercheck(level[2].getMover()) && !isGameOver()) {
                int dialogResult = JOptionPane.showConfirmDialog(gamePanel, "Du wurdest erwischt\nJa : Neustart\nNein : zur Lobby ", "Game Over", JOptionPane.YES_NO_OPTION);

                if (dialogResult == JOptionPane.YES_OPTION) {
                    respawn(1);
                    setGameOver(false);
                }
                if (dialogResult == JOptionPane.NO_OPTION) {
                    respawn(0);
                    setGameOver(false);
                }
            }
        }
    }


    public void level2Dialog() {
        /**
         * Dialog
         */
    }

    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //</editor-fold>

    //<editor-fold desc="LEVEL 3">
    ////LEVEL 3 - "XXXXXXX"  /////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    public void createlevel3() {
    }

    public void level3GameMechanic() {
        /**
         * Spielmechanik
         */
    }


    public void level3Dialog() {
        /**
         * Dialog
         */
    }

    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //</editor-fold>


    public void respawn(int level) {
        switch (level) {
            case 0:
                createLobby();
                break;
            case 1:
                createlevel1();
                break;
            case 2:
                createlevel2();
                break;
            case 3:
                createlevel3();
                break;
        }
        gameOver = false;
    }

    public void renderLevel(Graphics2D g2d) {
        level[currentLevel].renderLevel(g2d);
    }

    /**
     * Allgemeine Spiel update Methode, die im Thread aufgerufen werden muss, damit das Spiel funktioniert !
     */
    public void updateLevel() {
        level[currentLevel].update();
        switch (currentLevel) {
            case 0:
                level0GameMechanic();
                break;
            case 1:
                level1GameMechanic();
                break;
            case 2:
                level2GameMechanic();
                break;
            case 3:
                level3GameMechanic();
                break;
        }
    }

    /**
     * Löschen aller Level Instanzen
     */
    public void clear() {
        //remove all Level Components
        active = false;
    }

    /**
     * set Methoden (Einstellen des Levels,Einstellen der GridLines)
     */
    public void setCurrentLevel(int currentLevel) {
        dialog = 1;
        this.currentLevel = currentLevel;
    }

    public void setGridLines() {
        for (int i = 0; i < level.length; i++) {
            if (level[i].isGridlines()) {
                level[i].setGridLines(false);
            } else {
                level[i].setGridLines(true);
            }
        }
    }

    public MenuUI.MenuTab createSettings() {
        return new MenuUI.MenuTab("", new String[]{"Schwierigkeitsgrad", "<html> Eigene<br>Schwierigkeit erstellen </html>"}, true, false, false);
    }

    /**
     * Funktionsmethoden (momentanes Level,ob das Spiel läuft,ob GridLines fürs Debuggen angezeigt werden sollen)
     */
    public void setTimestamp() {
        timestamp = System.currentTimeMillis();
    }

    public long elapsedTime(long timestamp) {
        return TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis() - timestamp);
    }

    public boolean isGridLines() {
        return gridLines;
    }

    public boolean isActive() {
        return active;
    }

    public int whichLevel() {
        return currentLevel;
    }

    public boolean isGameOver() {
        return gameOver;
    }

    public void setGameOver(boolean gameOver) {
        if (gameOver) {
            level[currentLevel].stop();
        }
        this.gameOver = gameOver;
    }

    public void setDifficulty(int difficulty) {
        this.difficulty = difficulty;
    }

    public void changeDifficulty() {
        Integer[] difficultySteps = new Integer[5];
        for (int i = 0; i < difficultySteps.length; i++) {
            difficultySteps[i] = i + 1;
        }
        while (difficulty > difficultySteps.length || difficulty == 0) {
            difficulty = new Random().nextInt(difficultySteps.length - 1);
        }
        this.difficulty = (int) JOptionPane.showInputDialog(gamePanel.getParent(),
                "Schwierigkeitsgrad wählen ?",
                "Schwierigkeitsgrad",
                JOptionPane.QUESTION_MESSAGE,
                null,
                difficultySteps,
                difficultySteps[this.difficulty - 1]);
        Object[] options = {"OK"};
        JOptionPane.showOptionDialog(gamePanel, "Du hast den Schwierigkeitsgrad " + difficulty + " ausgewählt", "",
                JOptionPane.PLAIN_MESSAGE, JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
    }

    public void createOwnDifficulty() {
        Meldungen m = ownDifficultyAbfrage();
        m.setVisible(true);
        try {
            JOptionPane.showMessageDialog(null, "Fehlerhafte Eingabe! Bitte nur Zahlen eingeben.", "", JOptionPane.WARNING_MESSAGE);
            startSpeed = Integer.parseInt(m.getUserInput(0));
            enemySpawn = Integer.parseInt(m.getUserInput(1));
            moverSpeed = Integer.parseInt(m.getUserInput(2));
        } catch (NumberFormatException e) {
            e.printStackTrace();
            JOptionPane.showMessageDialog(null, "Fehlerhafte Eingabe! Bitte erneut versuchen und nur Zahlen eingeben!.", "", JOptionPane.WARNING_MESSAGE);
        }
        m.setVisible(false);
    }

    private Meldungen ownDifficultyAbfrage() {
        Meldungen m = new Meldungen(null, true, "");
        m.createComponents(3, "Gegner Geschwindigkeit/Spawn Anzahl/Mover Geschwindigkeit einstellen:", false);
        m.getEingabe()[0].setText("Gegner Geschwindigkeit");
        m.getEingabe()[1].setText("Spawn Anzahl");
        m.getEingabe()[2].setText("Mover Geschwindigkeit");
        m.setModal(true);
        return m;
    }

    /**
     * MouseListener - wenn geklickt wird = click Variable (zum Klicks zählen) hochgezählt
     */
    public void mouseClicked(MouseEvent e) {
        click++;
    }
}