Modified some core logic and made the code a little-bit more concise

.env

@@ -0,0 +1 @@
+XML_FILES='$(shell find $(SRC_DIR) -type f -name'

src/main/java/Handlers/KeyHandler.java

@@ -0,0 +1,46 @@
+package Handlers;
+
+
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.util.HashMap;
+import java.util.Map;
+
+public class KeyHandler implements KeyListener {
+    public boolean up, down, right, left, speedUp;
+    private final Map<Integer, Runnable> keyPressedActions = new HashMap<>();
+    private final Map<Integer, Runnable> keyReleasedAction = new HashMap<>();
+    private void KeyPressedReleased(Integer key, Runnable pressed, Runnable released){
+        keyPressedActions.put(key, pressed);
+        keyReleasedAction.put(key, released);
+    }
+
+    public KeyHandler(){
+        KeyPressedReleased(KeyEvent.VK_W, () -> up = true, () -> up = false);
+        KeyPressedReleased(KeyEvent.VK_S, () -> down = true, () -> down = false);
+        KeyPressedReleased(KeyEvent.VK_A, () -> left = true, () -> left = false);
+        KeyPressedReleased(KeyEvent.VK_D, () -> right = true, () -> right = false);
+
+        KeyPressedReleased(KeyEvent.VK_SHIFT, () -> speedUp = true, () -> speedUp = false);
+
+        KeyPressedReleased(KeyEvent.VK_UP, () -> up = true, () -> up = false);
+        KeyPressedReleased(KeyEvent.VK_DOWN, () -> down = true, () -> down = false);
+        KeyPressedReleased(KeyEvent.VK_LEFT, () -> left = true, () -> left = false);
+        KeyPressedReleased(KeyEvent.VK_RIGHT, () -> right = true, () -> right = false);
+    }
+    @Override
+    public void keyTyped(KeyEvent e) {
+    }
+
+    @Override
+    public void keyPressed(KeyEvent e) {
+        keyPressedActions.getOrDefault(e.getKeyCode(), () -> {}).run();
+    }
+
+    @Override
+    public void keyReleased(KeyEvent e) {
+        keyReleasedAction.getOrDefault(e.getKeyCode(), () -> {}).run();
+    }
+
+
+}

src/main/java/Handlers/PlayerHaandler.java

@@ -0,0 +1,10 @@
+package Handlers;
+
+import entity.Player;
+import main.GamePanel;
+
+public class PlayerHaandler extends Player {
+    public PlayerHaandler(GamePanel gp, KeyHandler keyH) {
+        super(gp, keyH);
+    }
+}

src/main/java/entity/Entity.java

@@ -2,10 +2,13 @@
 
 import java.awt.image.BufferedImage;
 
-public class Entity {
-    protected   int entityX, entityY;
+abstract class Entity {
+    protected   int entityX;
+    protected int entityY;
     protected   int speed;
-
+    protected  int stepCount;
+    protected  int stepLimit;
+    protected  boolean spriteMoved;
     protected   BufferedImage currentImage;
     public enum Direction{
         UP,
@@ -16,9 +19,4 @@ public enum Direction{
     protected  Direction currentDirection;
 
 
-
-    protected  int stepCount;
-    protected  int stepLimit;
-    protected  boolean spriteMoved;
-
 }

src/main/java/entity/Player.java

@@ -1,31 +1,29 @@
 package entity;
-import tile.Tile;
 import tile.TileManager;
 import utils.ImageLoader;
 
 import main.GamePanel;
-import main.KeyHandler;
+import Handlers.KeyHandler;
 
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.util.EnumMap;
 
 public class Player extends Entity{
 
-    private final GamePanel GP;
-    private final KeyHandler KEY_H;
-
+    private final GamePanel gamePanel;
+    private final KeyHandler keyHandlerObject;
+    private final int SCREEN_X, SCREEN_Y;
     private final EnumMap<Direction, BufferedImage[]> DIRECTION_IMAGES = new EnumMap<>(Direction.class);
 
-    private final int SCREEN_X;
-    private final int SCREEN_Y;
 
-    public Player(GamePanel gp, KeyHandler keyH){
-        this.GP = gp;
-        this.KEY_H = keyH;
 
-        this.SCREEN_X = GP.SCREEN_WIDTH / 2 - (GP.TILE_SIZE / 2); // center of the screen - half player size
-        this.SCREEN_Y = GP.SCREEN_HEIGHT / 2 - (GP.TILE_SIZE / 2);
+    public Player(GamePanel gamePanel, KeyHandler keyHandler){
+        this.gamePanel = gamePanel;
+        this.keyHandlerObject = keyHandler;
+
+        this.SCREEN_X = this.gamePanel.SCREEN_WIDTH / 2 - (this.gamePanel.TILE_SIZE / 2); // center of the screen - half player size
+        this.SCREEN_Y = this.gamePanel.SCREEN_HEIGHT / 2 - (this.gamePanel.TILE_SIZE / 2);
 
         setDefault();
         loadPlayerImages();
@@ -57,8 +55,8 @@ public void loadPlayerImages(){
     }
 
     private void setDefault(){
-        entityX = GP.TILE_SIZE * (TileManager.WORLD_MAX_ROW / 2);
-        entityY = GP.TILE_SIZE * (TileManager.WORLD_MAX_COL / 2);
+        entityX = gamePanel.TILE_SIZE * (TileManager.WORLD_MAX_ROW / 2);
+        entityY = gamePanel.TILE_SIZE * (TileManager.WORLD_MAX_COL / 2);
 
         speed = 3;
 
@@ -71,18 +69,18 @@ private void setDefault(){
     }
     private boolean updatePlayerDirection(){
         Direction newDirection = null;
-        int currentSpeed = speed + (KEY_H.speedUp ? 1 : 0);
+        int currentSpeed = speed + (keyHandlerObject.speedUp ? 1 : 0);
 
-        if (KEY_H.up) {
+        if (keyHandlerObject.up) {
             entityY -= currentSpeed;
             newDirection = Direction.UP;
-        } else if (KEY_H.down) {
+        } else if (keyHandlerObject.down) {
             entityY += currentSpeed;
             newDirection = Direction.DOWN;
-        } else if (KEY_H.left) {
+        } else if (keyHandlerObject.left) {
             entityX -= currentSpeed;
             newDirection = Direction.LEFT;
-        } else if (KEY_H.right) {
+        } else if (keyHandlerObject.right) {
             entityX += currentSpeed;
             newDirection = Direction.RIGHT;
         }
@@ -116,7 +114,7 @@ private void getCurrentImage(){
     public void draw(Graphics2D g2){
         getCurrentImage();
 
-        g2.drawImage(currentImage, SCREEN_X, SCREEN_Y, GP.TILE_SIZE, GP.TILE_SIZE, null);
+        g2.drawImage(currentImage, SCREEN_X, SCREEN_Y, gamePanel.TILE_SIZE, gamePanel.TILE_SIZE, null);
     }
 
 

src/main/java/main/GamePanel.java

@@ -1,18 +1,19 @@
 package main;
 
+import Handlers.KeyHandler;
 import entity.Player;
 import tile.TileManager;
 
 import javax.swing.*;
 import java.awt.*;
 
 // works as a game screen
-public class GamePanel extends JPanel implements Runnable{
+public final class GamePanel extends JPanel implements Runnable{
     // screen settings
-        final int originalTileSize = 16; // 16 * 16 tile (size of characters npcs and map in this game)
-        final int SCALE = 3; //scale the tile size
+        final int originalTileSize = 16; // 16 * 16 tile (size of characters, NPCs and map in this game)
+        final int SCALE = 4; //scale the tile size
 
-        public final int TILE_SIZE = originalTileSize * SCALE; // 48 * 48
+        public final int TILE_SIZE = originalTileSize * SCALE; // 64 px
         public final int MAX_SCREEN_COL = 16;
 
         public final int MAX_SCREEN_ROW = 12;

src/main/java/tile/Tile.java

@@ -8,8 +8,8 @@ public class Tile {
 
     public enum TileType{
         GRASS(0),
-        WATER(2),
         WALL(1),
+        WATER(2),
         EARTH(3),
         SAND(4),
         TREE(5);

src/main/java/tile/TileManager.java

@@ -25,15 +25,10 @@ public TileManager(GamePanel gp){
     }
     private void loadTileImages(){
 
-        for(Tile.TileType type: Tile.TileType.values()){
-            TILES.put(type, createTile("/tiles/" + type.name().toLowerCase() + ".png", type != Tile.TileType.GRASS));
+        for(var tile: Tile.TileType.values()){
+            TILES.put(tile, createTile("/tiles/" + tile.name().toLowerCase() + ".png", tile != Tile.TileType.GRASS));
         }
-//        tiles.put(Tile.TileType.GRASS, createTile("/tiles/grass.png", false));
-//        tiles.put(Tile.TileType.EARTH, createTile("/tiles/earth.png", false));
-//        tiles.put(Tile.TileType.SAND, createTile("/tiles/sand.png", false));
-//        tiles.put(Tile.TileType.WATER, createTile("/tiles/water.png", true));
-//        tiles.put(Tile.TileType.WALL, createTile("/tiles/wall.png", true));
-//        tiles.put(Tile.TileType.TREE, createTile("/tiles/tree.png", true));
+
     }
 
     private void loadTilesMap(){
@@ -50,7 +45,6 @@ private Tile createTile(String imagePath, boolean collision){
 
     public void draw(Graphics2D g2){
 
-
        for(int row = 0; row < GP.MAX_SCREEN_ROW; row++){
            for(int col = 0; col < GP.MAX_SCREEN_COL; col++){
                Tile tile = TILES.get(Tile.TileType.fromId(tileMap[col][row]));