Level

package main;

import java.awt.Shape;
import java.awt.geom.Rectangle2D;
import org.newdawn.slick.*;
import org.newdawn.slick.state.*;
import user.Main;

public class Level extends BasicGameState {

    private Animation IDLE, UP, DOWN, LEFT, RIGHT;
    private int state, GridX, GridY, ScreenX, ScreenY;
    private boolean[] walls;
    private boolean initialized = false;
    private Hero hero;
    private float relative_x, relative_y;
    public static Grid grid;
    private IMaze maze;
    private int nextstate;

    public Level(int state, IMaze maze) {
        this.state = state;
        this.maze = maze;
    }

    @Override
    public int getID() {
        return state;
    }

    @Override
    public void init(GameContainer gc, StateBasedGame sbg) throws SlickException {
        int[] duration = {100, 100, 100};

        hero = Hero.getInstance();
        hero.setDuration(duration);
        hero.setSpriteSheet(new Image("res/char.png"), 32, 48, 0);

        //Main.getInstance().getState(Main.getInstance().getmyOwnCurrentState()).leave(gc, Main.getInstance());
        Main.getInstance().setCurrentState(state);
        grid = Main.getInstance().getGrid();

        grid.setWallSpriteSheet(new Image("res/fence.png"), 99, 135, 0);

        grid.setGroundSpriteSheet(new Image("res/ground.png"), 32, 32, 1);

        grid.setDoorSpriteSheet(new Image("res/gate.png"), 64, 63, 0);

        Image[] walkUP = {hero.getSheet().getSprite(0, 3), hero.getSheet().getSprite(1, 3), hero.getSheet().getSprite(2, 3)};
        Image[] walkDOWN = {hero.getSheet().getSprite(0, 0), hero.getSheet().getSprite(1, 0), hero.getSheet().getSprite(2, 0)};
        Image[] walkLEFT = {hero.getSheet().getSprite(0, 1), hero.getSheet().getSprite(1, 1), hero.getSheet().getSprite(2, 1)};
        Image[] walkRIGHT = {hero.getSheet().getSprite(0, 2), hero.getSheet().getSprite(1, 2), hero.getSheet().getSprite(2, 2)};

        hero.setAnimation(walkUP, walkDOWN, walkLEFT, walkRIGHT);

        UP = hero.getAnim_UP();
        DOWN = hero.getAnim_DOWN();
        LEFT = hero.getAnim_LEFT();
        RIGHT = hero.getAnim_RIGHT();
        IDLE = DOWN;

        maze.generate();

        grid.unlock(); //zatial nesu kluce

        initialized = true;
    }

    @Override
    public void render(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException {
        if (initialized) {
            GridX = grid.getX();
            GridY = grid.getY();
            ScreenX = Main.app.getWidth();
            ScreenY = Main.app.getHeight();

            hero.setX(0);
            hero.setY(0);

            grid.setTypeOfWall(3);
            grid.setTypeOfGround(3);

            int counterX = 0;
            int counterY = 0;
            for (int i = 0; i < GridX; i++) {
                for (int j = 0; j < GridY; j++) {
                    Main.getInstance().getGrid().getBlock(i, j).setHeight(100);
                    Main.getInstance().getGrid().getBlock(i, j).setWidth(100);
                    Main.getInstance().getGrid().getBlock(i, j).setCollision(hero.getX() + relative_x - 34 + counterX, hero.getY() + relative_y - 26 + counterY);
                    walls = Main.getInstance().getGrid().getBlock(i, j).getWalls();

                    g.drawImage(grid.getGround(), hero.getX() + relative_x - 34 + counterX, hero.getY() + relative_y - 10 + counterY);

                    if ((i == GridX - 1) && (j == GridY - 1)) {
                        g.drawImage(grid.getDoor(), hero.getX() + relative_x - 30 + counterX, hero.getY() + relative_y - 0 + counterY);
                    }
                    if (walls[0] == true) { //UP
                        g.drawImage(grid.getFrontWall(), hero.getX() + relative_x - 34 + counterX, hero.getY() + relative_y - 26 + counterY);
                        //g.drawLine(hero.getX() + relative_x - 34 + counterX, hero.getY() + relative_y - 26 + counterY, hero.getX() + relative_x + 66 + counterX, hero.getY() + relative_y - 26 + counterY);
                    }
                    if (walls[1] == true) { //DOWN
                        g.drawImage(grid.getFrontWall(), hero.getX() + relative_x - 34 + counterX, hero.getY() + relative_y + 74 + counterY);
                        //g.drawLine(hero.getX() + relative_x - 34 + counterX, hero.getY() + relative_y + 74 + counterY, hero.getX() + relative_x + 66 + counterX, hero.getY() + relative_y + 74 + counterY);
                    }
                    if (walls[2] == true) { //LEFT
                        g.drawImage(grid.getSideWall(), hero.getX() + relative_x - 34 + counterX, hero.getY() + relative_y - 26 + counterY);
                        //g.drawLine(hero.getX() + relative_x - 34 + counterX, hero.getY() + relative_y - 26 + counterY, hero.getX() + relative_x - 34 + counterX, hero.getY() + relative_y + 74 + counterY);
                    }
                    if (walls[3] == true) { //RIGHT
                        g.drawImage(grid.getSideWall(), hero.getX() + relative_x + 66 + counterX, hero.getY() + relative_y - 26 + counterY);
                        //g.drawLine(hero.getX() + relative_x + 66 + counterX, hero.getY() + relative_y - 26 + counterY, hero.getX() + relative_x + 66 + counterX, hero.getY() + relative_y + 74 + counterY);
                    }
                    if ((relative_x - 34 + counterX < 0) && (relative_y - 26 + counterY < 0) && (relative_x + 66 + counterX > 0) && (relative_y + 74 + counterY > 0)) {
                        hero.setBlockNumber(i, j);
                    }
                    counterY += Main.getInstance().getGrid().getBlock(i, j).getHeight();
                }
                counterX += Main.getInstance().getGrid().getBlock(i, 0).getWidth();
                counterY = 0;
            }
            IDLE.draw(hero.getX(), hero.getY());

            if ((hero.getBlockX() == GridX - 1) && (hero.getBlockY() == GridY - 1) && (grid.getLockState())) {
                    if (state == (Main.getInstance().getStateCount() - 2)) {
                        nextstate = 0;
                    } else {
                        nextstate = state + 1;
                    }
                    //Main.getInstance().getState(state).leave(gc, sbg);
                    //Main.getInstance().getState(nextstate).init(gc, Main.getInstance());
                    //Main.getInstance().getState(nextstate).enter(gc, Main.getInstance());
                    Main.getInstance().enterState(nextstate);
                    initialized = false;
            }
        }
    }

    @Override
    public void update(GameContainer gc, StateBasedGame sbg, int i) throws SlickException {
        if (initialized) {
            System.out.println(state);
            Input input = gc.getInput();
            int key;

            hero.setLocation();
            IDLE.start();


            if (input.isKeyDown(Input.KEY_SPACE)) {
                {
                    Main.getInstance().setCurrentState(state);
                    Main.getInstance().enterState(10);
                }
            }

            if (input.isKeyDown(Input.KEY_UP)) {
                relative_y += i * 0.1f;
                IDLE = UP;
                key = Input.KEY_UP;

                for (int j = 0; j < GridX; j++) {
                    for (int k = 0; k < GridY; k++) {
                        walls = Main.getInstance().getGrid().getBlock(j, k).getWalls();
                        Shape[] corners = Main.getInstance().getGrid().getBlock(j, k).getCollisionCorners();
                        Shape[] shapes = Main.getInstance().getGrid().getBlock(j, k).getCollisionWalls();
                        if (walls[0] == true && initialized) {
                            if (hero.getLocation().intersects((Rectangle2D) shapes[0])) {
                                relative_y -= i * 0.25f;
                            }
                        }
                        if (walls[2] == true && initialized) {
                            if (hero.getLocation().intersects((Rectangle2D) corners[2])) {
                                relative_y -= i * 0.25f;
                            }
                        }
                    }
                }

            } else if (input.isKeyDown(Input.KEY_DOWN)) {
                relative_y -= i * 0.1f;
                IDLE = DOWN;
                key = Input.KEY_DOWN;

                for (int j = 0; j < GridX; j++) {
                    for (int k = 0; k < GridY; k++) {
                        walls = Main.getInstance().getGrid().getBlock(j, k).getWalls();
                        Shape[] shapes = Main.getInstance().getGrid().getBlock(j, k).getCollisionWalls();
                        Shape[] corners = Main.getInstance().getGrid().getBlock(j, k).getCollisionCorners();
                        if (walls[1] == true && initialized) {
                            if (hero.getLocation().intersects((Rectangle2D) shapes[1])) {
                                relative_y += i * 0.25f;
                            }
                        }
                        if (walls[3] == true && initialized) {
                            if (hero.getLocation().intersects((Rectangle2D) corners[3])) {
                                relative_y += i * 0.25f;
                            }
                        }
                    }
                }

            } else if (input.isKeyDown(Input.KEY_LEFT)) {
                relative_x += i * 0.1f;
                IDLE = LEFT;
                key = Input.KEY_LEFT;

                for (int j = 0; j < GridX; j++) {
                    for (int k = 0; k < GridY; k++) {
                        walls = Main.getInstance().getGrid().getBlock(j, k).getWalls();
                        Shape[] shapes = Main.getInstance().getGrid().getBlock(j, k).getCollisionWalls();
                        Shape[] corners = Main.getInstance().getGrid().getBlock(j, k).getCollisionCorners();
                        if (walls[2] == true && initialized) {
                            if (hero.getLocation().intersects((Rectangle2D) shapes[2])) {
                                relative_x -= i * 0.25f;
                            }
                        }
                        if (walls[1] == true && initialized) {
                            if (hero.getLocation().intersects((Rectangle2D) corners[1])) {
                                relative_x -= i * 0.25f;
                            }
                        }
                    }
                }

            } else if (input.isKeyDown(Input.KEY_RIGHT)) {
                relative_x -= i * 0.1f;
                IDLE = RIGHT;
                key = Input.KEY_RIGHT;

                for (int j = 0; j < GridX; j++) {
                    for (int k = 0; k < GridY; k++) {
                        walls = Main.getInstance().getGrid().getBlock(j, k).getWalls();
                        Shape[] shapes = Main.getInstance().getGrid().getBlock(j, k).getCollisionWalls();
                        Shape[] corners = Main.getInstance().getGrid().getBlock(j, k).getCollisionCorners();
                        if (walls[3] == true && initialized) {
                            if (hero.getLocation().intersects((Rectangle2D) shapes[3])) {
                                relative_x += i * 0.25f;
                            }
                        }
                        if (walls[0] == true && initialized) {
                            if (hero.getLocation().intersects((Rectangle2D) corners[0])) {
                                relative_x += i * 0.25f;
                            }
                        }
                    }
                }
            } else {
                IDLE.stop();
            }
        }
    }
}