feat: Enemy hitting player animation and refactor

pom.xml

@@ -116,6 +116,12 @@
             <version>2.18.2</version>
         </dependency>
 
+        <dependency>
+            <groupId>com.fasterxml.jackson.dataformat</groupId>
+            <artifactId>jackson-dataformat-yaml</artifactId>
+            <version>2.18.2</version>
+        </dependency>
+
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>

src/main/java/cz/jzitnik/Game.java

@@ -18,7 +18,11 @@ public class Game {
         ScheduledTaskManager scheduledTaskManager = dependencyManager.getDependencyOrThrow(ScheduledTaskManager.class);
         GlobalIOHandlerRepository globalIOHandlerRepository = dependencyManager.getDependencyOrThrow(GlobalIOHandlerRepository.class);
 
-        gameSetup.setup();
+        try {
+            gameSetup.setup();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
         threadManager.startAll();
         scheduledTaskManager.startAll();
         globalIOHandlerRepository.setup();

src/main/java/cz/jzitnik/events/RerenderPart.java

@@ -0,0 +1,14 @@
+package cz.jzitnik.events;
+
+import cz.jzitnik.utils.events.Event;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class RerenderPart implements Event {
+    private int forStartX;
+    private int forEndX;
+    private int forStartY;
+    private int forEndY;
+}

src/main/java/cz/jzitnik/events/handlers/DroppedItemRerenderHandler.java

@@ -1,20 +1,11 @@
 package cz.jzitnik.events.handlers;
 
-import com.googlecode.lanterna.TerminalPosition;
 import cz.jzitnik.annotations.EventHandler;
-import cz.jzitnik.annotations.injectors.InjectConfig;
 import cz.jzitnik.annotations.injectors.InjectDependency;
-import cz.jzitnik.annotations.injectors.InjectState;
-import cz.jzitnik.config.Debugging;
 import cz.jzitnik.events.DroppedItemRerender;
-import cz.jzitnik.events.RerenderScreen;
+import cz.jzitnik.events.RerenderPart;
-import cz.jzitnik.game.GameState;
-import cz.jzitnik.game.ResourceManager;
 import cz.jzitnik.game.utils.RoomCords;
-import cz.jzitnik.states.ScreenBuffer;
-import cz.jzitnik.states.TerminalState;
 import cz.jzitnik.utils.DependencyManager;
-import cz.jzitnik.utils.RerenderUtils;
 import cz.jzitnik.utils.events.AbstractEventHandler;
 import cz.jzitnik.utils.events.EventManager;
 
@@ -29,56 +20,16 @@ public class DroppedItemRerenderHandler extends AbstractEventHandler<DroppedItem
     @InjectDependency
     private EventManager eventManager;
 
-    @InjectDependency
-    private ResourceManager resourceManager;
-
-    @InjectState
-    private GameState gameState;
-
-    @InjectState
-    private TerminalState terminalState;
-
-    @InjectState
-    private ScreenBuffer screenBuffer;
-
-    @InjectConfig
-    private Debugging debugging;
-
     @Override
     public void handle(DroppedItemRerender event) {
         RoomCords droppedItemCords = event.droppedItem().getCords();
         BufferedImage droppedItemTexture = event.droppedItem().getTexture();
-        BufferedImage playerTexture = RerenderUtils.getPlayer(resourceManager, gameState.getPlayer());
-        BufferedImage room = resourceManager.getResource(gameState.getCurrentRoom().getTexture());
-        RoomCords start = RerenderUtils.getStart(room, terminalState.getTerminalScreen().getTerminalSize());
 
-        RerenderScreen.ScreenPart part = new RerenderScreen.ScreenPart(
+        eventManager.emitEvent(new RerenderPart(
-                new TerminalPosition(
-                        start.getX() + droppedItemCords.getX(),
-                        start.getY() + droppedItemCords.getY()
-                ),
-                new TerminalPosition(
-                        start.getX() + droppedItemCords.getX() + droppedItemTexture.getWidth(),
-                        start.getY() + droppedItemCords.getY() + droppedItemTexture.getHeight()
-                )
-        );
-
-        RerenderUtils.rerenderPart(
                 droppedItemCords.getX(),
                 droppedItemCords.getX() + droppedItemTexture.getWidth(),
                 droppedItemCords.getY(),
-                droppedItemCords.getY() + droppedItemTexture.getHeight(),
+                droppedItemCords.getY() + droppedItemTexture.getHeight()
-                start.getX(),
+        ));
-                start.getY(),
-                gameState.getCurrentRoom(),
-                room,
-                gameState.getPlayer(),
-                playerTexture,
-                screenBuffer,
-                resourceManager,
-                debugging
-        );
-
-        eventManager.emitEvent(new RerenderScreen(part));
     }
 }

src/main/java/cz/jzitnik/events/handlers/FullRoomDrawHandler.java

@@ -73,7 +73,7 @@ public class FullRoomDrawHandler extends AbstractEventHandler<FullRoomDraw> {
 
             BufferedImage room = resourceManager.getResource(currentRoom.getTexture());
             Player player = gameState.getPlayer();
-            BufferedImage playerTexture = RerenderUtils.getPlayer(resourceManager, player);
+            BufferedImage playerTexture = player.getTexture(resourceManager);
             TerminalSize terminalSize = terminalScreen.getTerminalSize();
 
             int width = room.getWidth();

src/main/java/cz/jzitnik/events/handlers/MouseMoveEventHandler.java

@@ -100,7 +100,7 @@ public class MouseMoveEventHandler extends AbstractEventHandler<MouseMoveEvent>
         BufferedImage room = resourceManager.getResource(currentRoom.getTexture());
         Player player = gameState.getPlayer();
         RoomCords playerCords = player.getPlayerCords();
-        BufferedImage playerTexture = RerenderUtils.getPlayer(resourceManager, player);
+        BufferedImage playerTexture = player.getTexture(resourceManager);
 
         var start = RerenderUtils.getStart(room, terminalState.getTerminalScreen().getTerminalSize());
         int startX = start.getX();

src/main/java/cz/jzitnik/events/handlers/PlayerMoveEventHandler.java

@@ -140,7 +140,7 @@ public class PlayerMoveEventHandler extends AbstractEventHandler<PlayerMoveEvent
         if (logging.isShowPlayerCordsLogs()) {
             log.debug("x: {}, y: {}", newPlayerX, newPlayerY);
         }
-        BufferedImage playerTexture = RerenderUtils.getPlayer(resourceManager, player);
+        BufferedImage playerTexture = player.getTexture(resourceManager);
         int forStartX = Math.min(originalPlayerX, newPlayerX);
         int forStartY = Math.min(originalPlayerY, newPlayerY);
         int forEndX = Math.max(originalPlayerX, newPlayerX) + playerTexture.getWidth();

src/main/java/cz/jzitnik/events/handlers/RerenderPartHandler.java

@@ -0,0 +1,83 @@
+package cz.jzitnik.events.handlers;
+
+import com.googlecode.lanterna.TerminalPosition;
+import cz.jzitnik.annotations.EventHandler;
+import cz.jzitnik.annotations.injectors.InjectConfig;
+import cz.jzitnik.annotations.injectors.InjectDependency;
+import cz.jzitnik.annotations.injectors.InjectState;
+import cz.jzitnik.config.Debugging;
+import cz.jzitnik.events.RerenderPart;
+import cz.jzitnik.events.RerenderScreen;
+import cz.jzitnik.game.GameRoom;
+import cz.jzitnik.game.GameState;
+import cz.jzitnik.game.ResourceManager;
+import cz.jzitnik.game.utils.RoomCords;
+import cz.jzitnik.states.ScreenBuffer;
+import cz.jzitnik.states.TerminalState;
+import cz.jzitnik.utils.DependencyManager;
+import cz.jzitnik.utils.RerenderUtils;
+import cz.jzitnik.utils.events.AbstractEventHandler;
+import cz.jzitnik.utils.events.EventManager;
+
+import java.awt.image.BufferedImage;
+
+@EventHandler(RerenderPart.class)
+public class RerenderPartHandler extends AbstractEventHandler<RerenderPart> {
+    public RerenderPartHandler(DependencyManager dm) {
+        super(dm);
+    }
+
+    @InjectState
+    private TerminalState terminalState;
+
+    @InjectState
+    private GameState gameState;
+
+    @InjectState
+    private ScreenBuffer screenBuffer;
+
+    @InjectConfig
+    private Debugging debugging;
+
+    @InjectDependency
+    private ResourceManager resourceManager;
+
+    @InjectDependency
+    private EventManager eventManager;
+
+    @Override
+    public void handle(RerenderPart event) {
+        int forStartX = event.getForStartX();
+        int forEndX = event.getForEndX();
+        int forStartY = event.getForStartY();
+        int forEndY = event.getForEndY();
+
+        GameRoom currentRoom = gameState.getCurrentRoom();
+        BufferedImage room = resourceManager.getResource(currentRoom.getTexture());
+
+        RoomCords start = RerenderUtils.getStart(room, terminalState.getTerminalScreen().getTerminalSize());
+
+        RerenderUtils.rerenderPart(
+                forStartX,
+                forEndX,
+                forStartY,
+                forEndY,
+                start.getX(),
+                start.getY(),
+                currentRoom,
+                room,
+                gameState.getPlayer(),
+                gameState.getPlayer().getTexture(resourceManager),
+                screenBuffer,
+                resourceManager,
+                debugging
+        );
+
+        eventManager.emitEvent(
+                new RerenderScreen(new RerenderScreen.ScreenPart(
+                        new TerminalPosition(forStartX, forStartY),
+                        new TerminalPosition(forEndX * 2 + 1 + start.getX(), forEndY + start.getY())
+                ))
+        );
+    }
+}

src/main/java/cz/jzitnik/game/Player.java

@@ -1,16 +1,24 @@
 package cz.jzitnik.game;
 
+import cz.jzitnik.events.RerenderPart;
 import cz.jzitnik.game.items.GameItem;
 import cz.jzitnik.game.items.types.interfaces.WeaponInterface;
+import cz.jzitnik.game.mobs.HittableMob;
 import cz.jzitnik.game.utils.RoomCords;
 import cz.jzitnik.ui.Inventory;
+import cz.jzitnik.utils.DependencyManager;
+import cz.jzitnik.utils.StateManager;
+import cz.jzitnik.utils.events.Event;
+import cz.jzitnik.utils.events.EventManager;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 
+import java.awt.image.BufferedImage;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 
 @RequiredArgsConstructor
@@ -31,6 +39,8 @@ public class Player {
     private int health = MAX_HEALTH;
     private int stamina = MAX_STAMINA;
     private boolean swinging = false;
+    private boolean hitAnimationOn = false;
+    private ScheduledFuture<?> currentTimeoutHitAnimation = null;
 
     public void increaseStamina() {
         stamina++;
@@ -44,7 +54,7 @@ public class Player {
         health = Math.min(MAX_HEALTH, health + amount);
     }
 
-    public boolean dealDamage(int amount) {
+    public boolean dealDamage(int amount, DependencyManager dependencyManager) {
         if (health - amount <= 0) {
             health = 0;
             return true;
@@ -52,9 +62,54 @@ public class Player {
 
         health -= amount;
 
+        if (hitAnimationOn) {
+            if (currentTimeoutHitAnimation != null && !currentTimeoutHitAnimation.isDone()) {
+                currentTimeoutHitAnimation.cancel(false);
+            }
+        } else {
+            hitAnimationOn = true;
+            rerender(dependencyManager);
+        }
+
+        currentTimeoutHitAnimation = scheduler.schedule(() -> {
+            hitAnimationOn = false;
+            rerender(dependencyManager);
+        }, 250, TimeUnit.MILLISECONDS);
+
         return false;
     }
 
+    private void rerender(DependencyManager dependencyManager) {
+        ResourceManager resourceManager = dependencyManager.getDependencyOrThrow(ResourceManager.class);
+        EventManager eventManager = dependencyManager.getDependencyOrThrow(EventManager.class);
+
+        int forStartX = playerCords.getX();
+        int forStartY = playerCords.getY();
+
+        BufferedImage playerTexture = getTexture(resourceManager);
+        int forEndX = playerCords.getX() + playerTexture.getWidth() - 1;
+        int forEndY = playerCords.getY() + playerTexture.getHeight();
+
+        eventManager.emitEvent(new Event[]{
+                new RerenderPart(forStartX, forEndX, forStartY, forEndY),
+        });
+    }
+
+    public BufferedImage getTexture(ResourceManager resourceManager) {
+        BufferedImage resource = resourceManager.getResource(switch (playerRotation) {
+            case FRONT -> ResourceManager.Resource.PLAYER_FRONT;
+            case BACK -> ResourceManager.Resource.PLAYER_BACK;
+            case LEFT -> ResourceManager.Resource.PLAYER_LEFT;
+            case RIGHT -> ResourceManager.Resource.PLAYER_RIGHT;
+        });
+
+        if (hitAnimationOn) {
+            return HittableMob.applyRedFactor(resource);
+        }
+
+        return resource;
+    }
+
     public int getDamageDeal() {
         int damage = 1;
 

src/main/java/cz/jzitnik/game/mobs/HittableMob.java

@@ -1,20 +1,11 @@
 package cz.jzitnik.game.mobs;
 
-import com.googlecode.lanterna.TerminalPosition;
-import cz.jzitnik.annotations.injectors.InjectConfig;
 import cz.jzitnik.annotations.injectors.InjectDependency;
 import cz.jzitnik.annotations.injectors.InjectState;
-import cz.jzitnik.config.Debugging;
+import cz.jzitnik.events.RerenderPart;
-import cz.jzitnik.events.RerenderScreen;
-import cz.jzitnik.game.GameRoom;
 import cz.jzitnik.game.GameState;
-import cz.jzitnik.game.Player;
-import cz.jzitnik.game.ResourceManager;
 import cz.jzitnik.game.utils.RoomCords;
-import cz.jzitnik.states.ScreenBuffer;
-import cz.jzitnik.states.TerminalState;
 import cz.jzitnik.utils.DependencyManager;
-import cz.jzitnik.utils.RerenderUtils;
 import cz.jzitnik.utils.events.EventManager;
 import cz.jzitnik.utils.roomtasks.RoomTask;
 import cz.jzitnik.utils.roomtasks.RoomTaskScheduler;
@@ -22,6 +13,7 @@ import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 
 import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferByte;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
@@ -32,25 +24,47 @@ public abstract class HittableMob extends Mob {
     public abstract void onKilled();
 
     private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+    @Getter
     protected int health;
     private ScheduledFuture<?> currentTimeoutHitAnimation = null;
 
-    @Getter
     private boolean hitAnimationOn = false;
 
+    @Override
+    public BufferedImage getTexture() {
+        if (hitAnimationOn) {
+            return applyRedFactor(texture);
+        }
+
+        return texture;
+    }
+
+    public static BufferedImage applyRedFactor(BufferedImage src) {
+        final float redFactor = 2f;
+        int width = src.getWidth();
+        int height = src.getHeight();
+
+        BufferedImage copy = new BufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR);
+        byte[] srcPixels = ((DataBufferByte) src.getRaster().getDataBuffer()).getData();
+        byte[] dstPixels = ((DataBufferByte) copy.getRaster().getDataBuffer()).getData();
+
+        System.arraycopy(srcPixels, 0, dstPixels, 0, srcPixels.length);
+
+        for (int i = 0; i < dstPixels.length; i += 4) {
+            int red = dstPixels[i + 3] & 0xFF;
+            red = (int) (red * redFactor);
+            if (red > 255) red = 255;
+            dstPixels[i + 3] = (byte) red;
+        }
+
+        return copy;
+    }
+
     @InjectDependency
     private EventManager eventManager;
     @InjectState
     private GameState gameState;
     @InjectDependency
-    private ResourceManager resourceManager;
-    @InjectState
-    private TerminalState terminalState;
-    @InjectState
-    private ScreenBuffer screenBuffer;
-    @InjectConfig
-    private Debugging debugging;
-    @InjectDependency
     private RoomTaskScheduler roomTaskScheduler;
 
     public HittableMob(BufferedImage texture, RoomTask task, RoomCords cords, int initialHealth) {
@@ -99,34 +113,11 @@ public abstract class HittableMob extends Mob {
         int forEndX = cords.getX() + texture.getWidth() - 1;
         int forEndY = cords.getY() + texture.getHeight();
 
-        GameRoom currentRoom = gameState.getCurrentRoom();
+        eventManager.emitEvent(new RerenderPart(
-        BufferedImage room = resourceManager.getResource(currentRoom.getTexture());
-        Player player = gameState.getPlayer();
-        BufferedImage playerTexture = RerenderUtils.getPlayer(resourceManager, player);
-
-        var start = RerenderUtils.getStart(room, terminalState.getTerminalScreen().getTerminalSize());
-        int startX = start.getX();
-        int startY = start.getY();
-
-        RerenderUtils.rerenderPart(
                 forStartX,
                 forEndX,
                 forStartY,
-                forEndY,
+                forEndY
-                startX,
+        ));
-                startY,
-                currentRoom,
-                room,
-                player,
-                playerTexture,
-                screenBuffer,
-                resourceManager,
-                debugging
-        );
-
-        eventManager.emitEvent(new RerenderScreen(new RerenderScreen.ScreenPart(
-                new TerminalPosition(forStartX, forStartY),
-                new TerminalPosition(forEndX * 2 + 1 + startX, forEndY + startY)
-        )));
     }
 }

src/main/java/cz/jzitnik/game/mobs/HittableMobDrops.java

@@ -43,6 +43,12 @@ public abstract class HittableMobDrops extends HittableMob {
 
     private static final int DROP_ITEM_ON_GROUND_RADIUS = 30;
 
+    /**
+     * Can be overwritten by an extending class
+     **/
+    public void afterKill() {
+    }
+
     @Override
     public final void onKilled() {
         GameItem[] items = itemDropSupplier.get();
@@ -77,6 +83,6 @@ public abstract class HittableMobDrops extends HittableMob {
             }
         }
 
-        eventManager.emitEvent(events);
+        eventManager.emitEvent(events, this::afterKill);
     }
 }

src/main/java/cz/jzitnik/game/mobs/HittableMobNoDrops.java

@@ -0,0 +1,17 @@
+package cz.jzitnik.game.mobs;
+
+import cz.jzitnik.game.utils.RoomCords;
+import cz.jzitnik.utils.roomtasks.RoomTask;
+
+import java.awt.image.BufferedImage;
+
+public abstract class HittableMobNoDrops extends HittableMob {
+    public HittableMobNoDrops(BufferedImage texture, RoomTask task, RoomCords cords, int initialHealth) {
+        super(texture, task, cords, initialHealth);
+    }
+
+    @Override
+    public void onKilled() {
+
+    }
+}

src/main/java/cz/jzitnik/game/mobs/tasks/EnemyPlayerHittingTask.java

@@ -6,6 +6,7 @@ import cz.jzitnik.events.RenderStats;
 import cz.jzitnik.game.GameState;
 import cz.jzitnik.game.mobs.Mob;
 import cz.jzitnik.game.utils.RoomCords;
+import cz.jzitnik.utils.DependencyManager;
 import cz.jzitnik.utils.events.EventManager;
 import cz.jzitnik.utils.roomtasks.RoomTask;
 import lombok.RequiredArgsConstructor;
@@ -32,6 +33,9 @@ public class EnemyPlayerHittingTask extends RoomTask {
         @InjectDependency
         private EventManager eventManager;
 
+        @InjectDependency
+        private DependencyManager dependencyManager;
+
         @Override
         public void run() {
             RoomCords playerCords = gameState.getPlayer().getPlayerCords();
@@ -44,7 +48,7 @@ public class EnemyPlayerHittingTask extends RoomTask {
 
             int damage = damageSupplier.get();
 
-            boolean isDead = gameState.getPlayer().dealDamage(damage);
+            boolean isDead = gameState.getPlayer().dealDamage(damage, dependencyManager);
             eventManager.emitEvent(new RenderStats());
 
             log.debug("Is dead: {}", isDead);

src/main/java/cz/jzitnik/game/mobs/tasks/MobFollowingPlayerTask.java

@@ -79,7 +79,7 @@ public class MobFollowingPlayerTask extends RoomTask {
                 int startY = start.getY();
 
                 Player player = gameState.getPlayer();
-                BufferedImage playerTexture = RerenderUtils.getPlayer(resourceManager, player);
+                BufferedImage playerTexture = player.getTexture(resourceManager);
 
                 RerenderUtils.rerenderPart(forStartX, forEndX, forStartY, forEndY, startX, startY, gameState.getCurrentRoom(), room, player, playerTexture, screenBuffer, resourceManager, debugging);
 

src/main/java/cz/jzitnik/game/objects/Chest.java

@@ -9,6 +9,7 @@ import cz.jzitnik.annotations.injectors.InjectState;
 import cz.jzitnik.config.Debugging;
 import cz.jzitnik.events.InventoryRerender;
 import cz.jzitnik.events.MouseAction;
+import cz.jzitnik.events.RerenderPart;
 import cz.jzitnik.events.RerenderScreen;
 import cz.jzitnik.game.GameRoom;
 import cz.jzitnik.game.GameState;
@@ -39,7 +40,6 @@ public final class Chest extends GameObject implements UIClickHandler {
     private static final int RENDER_PADDING = 1;
 
     private final List<GameItem> items;
-    private final DependencyManager dependencyManager;
 
     private int listenerHashCode;
 
@@ -49,8 +49,6 @@ public final class Chest extends GameObject implements UIClickHandler {
     private int chestUISizeX;
     private int chestUISizeY;
 
-    @InjectDependency
-    private StateManager sm;
     @InjectDependency
     private ResourceManager resourceManager;
     @InjectDependency
@@ -68,10 +66,9 @@ public final class Chest extends GameObject implements UIClickHandler {
     @InjectConfig
     private Debugging debugging;
 
-    public Chest(DependencyManager dm, ResourceManager resourceManager, RoomCords cords, GameItem[] items) {
+    public Chest(ResourceManager resourceManager, RoomCords cords, GameItem[] items) {
         super(resourceManager.getResource(ResourceManager.Resource.CHEST), cords, true);
         this.items = Lists.newArrayList(items);
-        this.dependencyManager = dm;
     }
 
     @Override
@@ -99,7 +96,7 @@ public final class Chest extends GameObject implements UIClickHandler {
         Player player = gameState.getPlayer();
 
         BufferedImage roomTexture = resourceManager.getResource(currentRoom.getTexture());
-        BufferedImage playerTexture = RerenderUtils.getPlayer(resourceManager, player);
+        BufferedImage playerTexture = player.getTexture(resourceManager);
         BufferedImage chestTexture = getTexture();
 
         var buffer = screenBuffer.getRenderedBuffer();
@@ -150,34 +147,19 @@ public final class Chest extends GameObject implements UIClickHandler {
 
         TerminalPosition guiStart = new TerminalPosition(renderMinX - RENDER_PADDING, renderMinY - RENDER_PADDING);
         TerminalPosition guiEnd = new TerminalPosition(renderMaxX + RENDER_PADDING, renderMaxY + RENDER_PADDING);
-
-        if (!items.isEmpty()) {
-            drawUI(currentGrid, buffer, overrideBuffer, start, guiStartX, guiStartY);
-        }
-
-        RerenderUtils.rerenderPart(
-                guiStart.getColumn() - start.getX(),
-                guiEnd.getColumn() - start.getX(),
-                guiStart.getRow() - start.getY(),
-                guiEnd.getRow() - start.getY(),
-                start.getX(),
-                start.getY(),
-                currentRoom,
-                roomTexture,
-                player,
-                playerTexture,
-                screenBuffer,
-                resourceManager,
-                debugging
-        );
-
         RerenderScreen.ScreenPart sp = new RerenderScreen.ScreenPart(guiStart, guiEnd);
 
         if (!items.isEmpty()) {
+            drawUI(currentGrid, buffer, overrideBuffer, start, guiStartX, guiStartY);
             listenerHashCode = uiRoomClickHandlerRepository.registerCurrentRoomHandler(sp, this);
         }
 
-        eventManager.emitEvent(new RerenderScreen(sp));
+        eventManager.emitEvent(new RerenderPart(
+                guiStart.getColumn() - start.getX(),
+                guiEnd.getColumn() - start.getX(),
+                guiStart.getRow() - start.getY(),
+                guiEnd.getRow() - start.getY()
+        ));
     }
 
     private void clearPreviousUI(

src/main/java/cz/jzitnik/game/setup/GameSetup.java

@@ -22,7 +22,7 @@ public class GameSetup {
     public void setup() {
         //gameState.setScreen(new IntroScene(dependencyManager));
 
-        GameRoom mainRoom = new MainRoom(dependencyManager, resourceManager);
+        GameRoom mainRoom = new MainRoom(resourceManager);
         GameRoom rightRoom = new GameRoom(ResourceManager.Resource.ROOM2);
         GameRoom topRightRoom = new GameRoom(ResourceManager.Resource.ROOM3);
         GameRoom topRightTop = new GameRoom(ResourceManager.Resource.ROOM4);

src/main/java/cz/jzitnik/game/setup/config/EnemiesConfigSetup.java

@@ -0,0 +1,14 @@
+package cz.jzitnik.game.setup.config;
+
+import cz.jzitnik.game.ResourceManager;
+
+public class EnemiesConfigSetup {
+    private class Enemy {
+        private ResourceManager.Resource texture;
+        private int initialHealth;
+    }
+
+    public void setup() {
+
+    }
+}

src/main/java/cz/jzitnik/game/setup/rooms/MainRoom.java

@@ -9,15 +9,14 @@ import cz.jzitnik.game.setup.items.WoodenSword;
 import cz.jzitnik.game.objects.Chest;
 import cz.jzitnik.game.setup.enemies.Zombie;
 import cz.jzitnik.game.utils.RoomCords;
-import cz.jzitnik.utils.DependencyManager;
 import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
 public class MainRoom extends GameRoom {
-    public MainRoom(DependencyManager dependencyManager, ResourceManager resourceManager) {
+    public MainRoom(ResourceManager resourceManager) {
         super(ResourceManager.Resource.ROOM1);
 
-        Chest chest = new Chest(dependencyManager, resourceManager, new RoomCords(100, 45), new GameItem[]{
+        Chest chest = new Chest(resourceManager, new RoomCords(100, 45), new GameItem[]{
                 new WoodenSword(resourceManager),
                 new Apple(resourceManager)
         });

src/main/java/cz/jzitnik/utils/DependencyManager.java

@@ -26,7 +26,7 @@ public class DependencyManager {
     private final ClassToInstanceMap<Object> data = MutableClassToInstanceMap.create();
 
     public <T> T getDependencyOrThrow(Class<T> clazz) {
-        T instance = get(clazz);
+        T instance = data.getInstance(clazz);
 
         if (instance == null) {
             throw new RuntimeException("Class was not found!");
@@ -36,12 +36,21 @@ public class DependencyManager {
     }
 
     public <T> Optional<T> getDependency(Class<T> clazz) {
-        return Optional.ofNullable(get(clazz));
+        return Optional.ofNullable(data.getInstance(clazz));
     }
 
-    @SuppressWarnings("unchecked")
+    public <T> Optional<T> getConfig(Class<T> clazz) {
-    private <T> T get(Class<T> clazz) {
+        return Optional.ofNullable(configs.getInstance(clazz));
-        return (T) data.get(clazz);
+    }
+
+    public <T> T getConfigOrThrow(Class<T> clazz) {
+        T instance = configs.getInstance(clazz);
+
+        if (instance == null) {
+            throw new RuntimeException("Class was not found!");
+        }
+
+        return instance;
     }
 
     public DependencyManager(Reflections reflections) {

src/main/java/cz/jzitnik/utils/RerenderUtils.java

@@ -99,13 +99,9 @@ public class RerenderUtils {
                 int r = (pixel >> 16) & 0xff;
                 int g = (pixel >> 8) & 0xff;
                 int b = pixel & 0xff;
-                float redFactor = 2f;
 
                 if (alpha != 0) {
-                    if (object instanceof HittableMob mob && mob.isHitAnimationOn()) {
+                    if (isSelected) {
-                        r = Math.min(255, (int) (r * redFactor));
-                        pixel = (alpha << 24) | (r << 16) | (g << 8) | b;
-                    } else if (isSelected) {
                         r = Math.min(255, (int) (r * factor));
                         g = Math.min(255, (int) (g * factor));
                         b = Math.min(255, (int) (b * factor));
@@ -192,15 +188,6 @@ public class RerenderUtils {
         return new PixelResult(room.getRGB(x, y), false);
     }
 
-    public static BufferedImage getPlayer(ResourceManager resourceManager, Player player) {
-        return resourceManager.getResource(switch (player.getPlayerRotation()) {
-            case FRONT -> ResourceManager.Resource.PLAYER_FRONT;
-            case BACK -> ResourceManager.Resource.PLAYER_BACK;
-            case LEFT -> ResourceManager.Resource.PLAYER_LEFT;
-            case RIGHT -> ResourceManager.Resource.PLAYER_RIGHT;
-        });
-    }
-
     public static Set<FullRoomDrawHandler.DoorPosition> getDoorPositions(GameRoom currentRoom) {
         Set<FullRoomDrawHandler.DoorPosition> doorPositions = new HashSet<>();
         if (currentRoom.getLeft() != null) doorPositions.add(FullRoomDrawHandler.DoorPosition.LEFT);

src/main/java/cz/jzitnik/utils/events/EventManager.java

@@ -49,6 +49,10 @@ public class EventManager extends Thread {
         eventQueue.add(new EventRecord(events.toArray(new Event[]{})));
     }
 
+    public void emitEvent(List<Event> events, Runnable callback) {
+        eventQueue.add(new EventRecord(events.toArray(new Event[]{}), callback));
+    }
+
     public void emitEvent(Event[] events, Runnable callback) {
         eventQueue.add(new EventRecord(events, callback));
     }

src/main/resources/enemies.yaml

@@ -0,0 +1,23 @@
+- id: zombie1
+  className: cz.jzitnik.game.setup.enemies.Zombie
+  health: 10
+  texture: PLAYER_FRONT
+  cords:
+    x: 100
+    y: 100
+  drops:
+    - apple1
+  tasks:
+    - className: cz.jzitnik.game.mobs.tasks.MobFollowingPlayerTask
+      args:
+        speed: 1
+        range: 100
+    - className: cz.jzitnik.game.mobs.tasks.EnemyPlayerHittingTask
+      args:
+        cooldown: 500
+        damage: 15
+        hitSupplier:
+          rules:
+            - if: "health > 5"
+              value: 5
+            - value: 2

src/main/resources/items.yaml

@@ -0,0 +1,15 @@
+- id: sword1
+  className: cz.jzitnik.game.setup.items.WoodenSword
+  name: "Wooden sword"
+  texture: WOODEN_SWORD
+  itemType: cz.jzitnik.game.items.types.weapons.Sword
+  properties:
+    damageDeal: 2
+
+- id: apple1
+  className: cz.jzitnik.game.setup.items.Apple
+  name: "Apple"
+  texture: APPLE
+  itemType: cz.jzitnik.game.items.types.food.Food
+  properties:
+    heal: 5

src/main/resources/rooms.yaml

@@ -0,0 +1,57 @@
+- id: room1
+  className: cz.jzitnik.game.setup.rooms.MainRoom
+  texture: ROOM1
+  objects:
+    - className: cz.jzitnik.game.objects.Chest
+      cords:
+        x: 100
+        y: 45
+      items:
+        - sword1
+        - apple1
+  colliders:
+    - from:
+        x: 60
+        y: 10
+      to:
+        x: 135
+        y: 15
+  mobs:
+    - zombie1
+  connections:
+    right: room2
+
+- id: room2
+  className: cz.jzitnik.game.GameRoom
+  texture: ROOM2
+  objects: []
+  colliders: []
+  mobs: []
+  connections:
+    up: room3
+
+- id: room3
+  className: cz.jzitnik.game.GameRoom
+  texture: ROOM3
+  objects: []
+  colliders: []
+  mobs: []
+  connections:
+    up: room4
+
+- id: room4
+  className: cz.jzitnik.game.GameRoom
+  texture: ROOM4
+  objects: []
+  colliders: []
+  mobs: []
+  connections:
+    left: roomFrozen
+
+- id: roomFrozen
+  className: cz.jzitnik.game.GameRoom
+  texture: ROOM_FROZEN
+  objects: []
+  colliders: []
+  mobs: []
+  connections: {}