enhance build script with progress output and structured asset copying

build.sh

@@ -1,10 +1,24 @@
-rm -rf out/app
+#!/bin/bash
 
-jpackage \
-  --input out/artifacts/JGame2D_jar/ \
-  --main-jar JGame2D.jar \
-  --main-class de.miaurizius.jgame2d.core.Boot \
-  --name JGame2D \
-  --type app-image \
-  --add-modules ALL-MODULE-PATH \
-  --dest out/app
+echo "[1/4] Clearing old files..."
+rm -rf "out/app"
+
+echo "[2/4] Building game..."
+jpackage --type app-image \
+  --dest "out/app" \
+  --name "JGame2D" \
+  --input "out/artifacts/JGame2D_jar" \
+  --main-jar "JGame2D.jar" \
+  --main-class de.miaurizius.jgame2d.core.Boot
+
+echo "[3/4] Copy assets..."
+mkdir -p "out/app/JGame2D/assets"
+cp -r assets/* "out/app/JGame2D/assets/"
+
+echo "[4/4] Zipping..."
+cd out/app
+zip -r ../JGame2D.zip JGame2D
+
+cd ../..
+
+echo "Done!"

src/de/miaurizius/jgame2d/core/GamePanel.java

@@ -28,6 +28,10 @@ public class GamePanel extends JPanel implements Runnable {
     // SCREEN SETTINGS
     final int originalTileSize = 16; //16x16 tile
     final int scale = 3;
+    /*
+        final int originalTileSize = 48; //16x16 tile
+        final int scale = 1;
+     */
     public final int tileSize = originalTileSize * scale; //48x48 tile
     public final int maxScreenCol = 20;
     public final int maxScreenRow = 12;
@@ -207,13 +211,14 @@ public class GamePanel extends JPanel implements Runnable {
 
         // DEBUG
         if(keyH.debug) {
-            int start = 350;
+            int start = 300;
             fg2.setColor(Color.white);
             fg2.drawString("Draw Time: " + passed, 10, start);
             fg2.drawString("FPS: " + fpsMeasure, 10, start+tileSize);
             fg2.drawString("Invincible: " + player.invincibleCount, 10, start+tileSize*2);
             fg2.drawString("X, Y: " + player.worldX+", "+player.worldY, 10, start+tileSize*3);
             fg2.drawString("Col, Row: " + (player.worldX+player.solidArea.x)/tileSize+", "+(player.worldY+player.solidArea.y)/tileSize, 10, start+tileSize*4);
+            fg2.drawString("God Mode: " + keyH.godMode, 10, start+tileSize*5);
             Boot.logger.log(Level.FINE, "Draw Time: " + passed);
         }
     }

src/de/miaurizius/jgame2d/core/handlers/AssetSetter.java

@@ -3,7 +3,9 @@ package de.miaurizius.jgame2d.core.handlers;
 import de.miaurizius.jgame2d.core.GamePanel;
 import de.miaurizius.jgame2d.core.enums.Map;
 import de.miaurizius.jgame2d.entity.item.*;
+import de.miaurizius.jgame2d.entity.monster.BatMON;
 import de.miaurizius.jgame2d.entity.monster.OrcMON;
+import de.miaurizius.jgame2d.entity.monster.SkeletonLordMON;
 import de.miaurizius.jgame2d.entity.npc.BigRockNPC;
 import de.miaurizius.jgame2d.entity.npc.MerchantNPC;
 import de.miaurizius.jgame2d.entity.npc.OldManNPC;
@@ -134,6 +136,36 @@ public class AssetSetter {
         panel.monster[Map.OVERWORLD.getIndex()][i] = new OrcMON(panel);
         panel.monster[Map.OVERWORLD.getIndex()][i].worldX = panel.tileSize*12;
         panel.monster[Map.OVERWORLD.getIndex()][i].worldY = panel.tileSize*33;
+
+        i = 0;
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i] = new BatMON(panel);
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i].worldX = panel.tileSize*34;
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i].worldY = panel.tileSize*39;
+
+        i++;
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i] = new BatMON(panel);
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i].worldX = panel.tileSize*36;
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i].worldY = panel.tileSize*25;
+
+        i++;
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i] = new BatMON(panel);
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i].worldX = panel.tileSize*39;
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i].worldY = panel.tileSize*26;
+
+        i++;
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i] = new BatMON(panel);
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i].worldX = panel.tileSize*28;
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i].worldY = panel.tileSize*11;
+
+        i++;
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i] = new BatMON(panel);
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i].worldX = panel.tileSize*10;
+        panel.monster[Map.DUNGEON_FIRST_FLOOR.getIndex()][i].worldY = panel.tileSize*19;
+
+        i = 0;
+        panel.monster[Map.DUNGEON_SECOND_FLOOR.getIndex()][i] = new SkeletonLordMON(panel);
+        panel.monster[Map.DUNGEON_SECOND_FLOOR.getIndex()][i].worldX = panel.tileSize*23;
+        panel.monster[Map.DUNGEON_SECOND_FLOOR.getIndex()][i].worldY = panel.tileSize*16;
     }
 
     public void setITiles() {

src/de/miaurizius/jgame2d/core/handlers/EventHandler.java

@@ -68,6 +68,7 @@ public class EventHandler {
         if(hit(Map.OVERWORLD, 27,16, Direction.RIGHT)) damagePit();
         //if(hit(Map.OVERWORLD, 26,16, Direction.RIGHT)) changeMap(Map.DUNGEON_FIRST_FLOOR, 9, 41); //test
         else if(hit(Map.OVERWORLD, 23,12, null)) healingPool();
+        else if(hit(Map.DUNGEON_SECOND_FLOOR, 27, 39, null)) healingPool();
 
         // HUT
         else if(hit(Map.OVERWORLD, 10, 39, null)) changeMap(Map.HUT, 12, 13);

src/de/miaurizius/jgame2d/core/handlers/KeyHandler.java

@@ -15,6 +15,7 @@ public class KeyHandler implements KeyListener {
     public boolean upPressed, downPressed, leftPressed, rightPressed, spacePressed, shotKeyPressed, CTLKeyPressed;
     public GamePanel panel;
     public boolean debug;
+    public boolean godMode;
 
     public KeyHandler(GamePanel panel) {
         this.panel = panel;
@@ -70,6 +71,7 @@ public class KeyHandler implements KeyListener {
 
             // DEBUG OPTIONS
             case KeyEvent.VK_T -> debug = !debug;
+            case KeyEvent.VK_G -> godMode = !godMode;
             case KeyEvent.VK_R -> {for(Map m : Map.values()) panel.tileM.loadMap(m);}
 
             // GAME STATES

src/de/miaurizius/jgame2d/data/DataStorage.java

@@ -1,5 +1,7 @@
 package de.miaurizius.jgame2d.data;
 
+import de.miaurizius.jgame2d.core.enums.Map;
+
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
@@ -19,6 +21,7 @@ public class DataStorage implements Serializable {
     int nextLevelExp;
     int coins;
     int worldX, worldY;
+    Map currentMap;
 
     // PLAYER INVENTORY
     List<String> itemNames = new ArrayList<>();

src/de/miaurizius/jgame2d/data/SaveLoad.java

@@ -44,6 +44,7 @@ public class SaveLoad {
         ds.coins = panel.player.coins;
         ds.worldX = panel.player.worldX;
         ds.worldY = panel.player.worldY;
+        ds.currentMap = panel.currentMap;
 
         // PLAYER INVENTORY
         for(int i = 0; i < panel.player.inventory.size(); i++) {
@@ -95,7 +96,7 @@ public class SaveLoad {
         panel.player.coins = ds.coins;
         panel.player.worldX = ds.worldX;
         panel.player.worldY = ds.worldY;
-
+        panel.currentMap = ds.currentMap;
 
         // PLAYER INVENTORY
         panel.player.inventory.clear();

src/de/miaurizius/jgame2d/entity/Entity.java

@@ -51,6 +51,7 @@ public class Entity {
     public boolean onPath;
     public boolean knockback;
     public boolean guarding;
+    public boolean rage;
     public Direction knockbackDirection;
 
     // COUNTER
@@ -161,9 +162,9 @@ public class Entity {
         int screenX = worldX - panel.player.worldX + panel.player.screenX;
         int screenY = worldY - panel.player.worldY + panel.player.screenY;
 
-        if(worldX + panel.tileSize > panel.player.worldX - panel.player.screenX &&
+        if(worldX + panel.tileSize*5 > panel.player.worldX - panel.player.screenX &&
                 worldX - panel.tileSize < panel.player.worldX + panel.player.screenX &&
-                worldY + panel.tileSize > panel.player.worldY - panel.player.screenY &&
+                worldY + panel.tileSize*5 > panel.player.worldY - panel.player.screenY &&
                 worldY - panel.tileSize < panel.player.worldY + panel.player.screenY
         ) {
 
@@ -191,8 +192,8 @@ public class Entity {
             if(dying) dyingAnimation(graphics2d);
             if(type == EntityType.PLAYER || name.equals("orc")) { // only modify sprite render position for player because I dont know yet how monster attack sprite are gonna look
                 if(attacking) graphics2d.drawImage(parseSpriteATK(),
-                        (direction == Direction.LEFT) ? screenX - panel.tileSize : screenX,
-                        (direction == Direction.UP) ? screenY - panel.tileSize : screenY, null);
+                        (direction == Direction.LEFT) ? screenX - left1.getWidth() : screenX,
+                        (direction == Direction.UP) ? screenY - up1.getHeight() : screenY, null);
                 else if(guarding) graphics2d.drawImage(parseSpriteGRD(), screenX, screenY, null);
                 else graphics2d.drawImage(parseSprite(), screenX, screenY, null);
             } else graphics2d.drawImage(parseSprite(), screenX, screenY, null);
@@ -207,6 +208,19 @@ public class Entity {
 
     // INTERACTION
     public void setAction() {}
+    public void moveTowardPlayer(int interval) {
+        actionLock++;
+        if(actionLock > interval) {
+            if(dX(panel.player) > dY(panel.player)) {
+                if(panel.player.getCenterX() < getCenterX()) direction = Direction.LEFT;
+                else direction = Direction.RIGHT;
+            } else if(dX(panel.player) < dY(panel.player)) {
+                if(panel.player.getCenterY() < getCenterY()) direction = Direction.UP;
+                else direction = Direction.DOWN;
+            }
+            actionLock = 0;
+        }
+    }
     public void move(Direction direction) {}
     public void damageReaction() {}
     public void attacking() {
@@ -415,10 +429,16 @@ public class Entity {
         return (worldY + solidArea.y) / panel.tileSize;
     }
     public int dX(Entity target) {
-        return Math.abs(worldX - target.worldX);
+        return Math.abs(getCenterX() - target.getCenterX());
     }
     public int dY(Entity target) {
-        return Math.abs(worldY - target.worldY);
+        return Math.abs(getCenterY() - target.getCenterY());
+    }
+    public int getCenterX() {
+        return worldX + left1.getWidth()/2;
+    }
+    public int getCenterY() {
+        return worldY + up1.getHeight()/2;
     }
     public int dTile(Entity target) {
         //if(Objects.equals(name, "orc")) System.out.println("dX: " + dX(target) + " dY: " + dY(target));
@@ -589,16 +609,16 @@ public class Entity {
 
         switch(direction) {
             case UP -> {
-                if(panel.player.worldY < worldY && yDist < straight && xDist < horizontal) targetInRange = true;
+                if(panel.player.getCenterY() < getCenterY() && yDist < straight && xDist < horizontal) targetInRange = true;
             }
             case DOWN -> {
-                if(panel.player.worldY > worldY && yDist < straight && xDist < horizontal) targetInRange = true;
+                if(panel.player.getCenterY() > getCenterY() && yDist < straight && xDist < horizontal) targetInRange = true;
             }
             case LEFT -> {
-                if(panel.player.worldX < worldX && xDist < straight && yDist < horizontal) targetInRange = true;
+                if(panel.player.getCenterX() < getCenterX() && xDist < straight && yDist < horizontal) targetInRange = true;
             }
             case RIGHT -> {
-                if(panel.player.worldX > worldX && xDist < straight && yDist < horizontal) targetInRange = true;
+                if(panel.player.getCenterX() > getCenterX() && xDist < straight && yDist < horizontal) targetInRange = true;
             }
         }
 
@@ -610,9 +630,9 @@ public class Entity {
                 shotAvailableCount = 0;
             }
     }
-    public void setRandomDirection() {
+    public void setRandomDirection(int interval) {
         actionLock++;
-        if(actionLock == 120) { //lock action for x frames
+        if(actionLock > interval) { //lock action for x frames
             Random rand = new Random();
             int i = rand.nextInt(100)+1; //Generate number between 1 and 100
             if(i <= 25) direction = Direction.UP;

src/de/miaurizius/jgame2d/entity/Player.java

@@ -4,6 +4,7 @@ import de.miaurizius.jgame2d.core.*;
 import de.miaurizius.jgame2d.core.enums.Direction;
 import de.miaurizius.jgame2d.core.enums.EntityType;
 import de.miaurizius.jgame2d.core.enums.GameState;
+import de.miaurizius.jgame2d.core.enums.Map;
 import de.miaurizius.jgame2d.core.handlers.KeyHandler;
 import de.miaurizius.jgame2d.entity.item.KeyObj;
 import de.miaurizius.jgame2d.entity.item.LanternObj;
@@ -178,6 +179,7 @@ public class Player extends Entity {
         if(!invincible) return;
         invincibleCounting();
 
+        if(keyH.godMode) return;
         if(life <= 0) {
             panel.gameState = GameState.GAMEOVER;
             invincibleCount = 0;
@@ -312,8 +314,15 @@ public class Player extends Entity {
                 if(selectedItem.amt > 1) selectedItem.amt--; else inventory.remove(selectedItem);
     }
     public void setDefaultPositions() {
+        panel.currentMap = Map.OVERWORLD;
         worldX = panel.tileSize * 23;
         worldY = panel.tileSize * 21;
+
+//        panel.currentMap = Map.DUNGEON_SECOND_FLOOR;
+//        worldX = panel.tileSize * 26;
+//        worldY = panel.tileSize * 40;
+//        panel.player.inventory.add(new LanternObj(panel));
+
         direction = Direction.DOWN;
     }
     public void restoreStatus() {

src/de/miaurizius/jgame2d/entity/item/LanternObj.java

@@ -13,7 +13,7 @@ public class LanternObj extends Entity {
         down1 = initEntitySprites("objects/lantern");
         description = "[" + name + "]\nA lantern that lights up\nthe surrounding area.";
         price = 100;
-        lightRadius = 250;
+        lightRadius = 350;
     }
 
 }

src/de/miaurizius/jgame2d/entity/monster/BatMON.java

@@ -0,0 +1,65 @@
+package de.miaurizius.jgame2d.entity.monster;
+
+import de.miaurizius.jgame2d.core.GamePanel;
+import de.miaurizius.jgame2d.core.enums.EntityType;
+import de.miaurizius.jgame2d.entity.Entity;
+import de.miaurizius.jgame2d.entity.item.CoinObj;
+import de.miaurizius.jgame2d.entity.item.HeartObj;
+import de.miaurizius.jgame2d.entity.item.PotionObj;
+
+import java.util.Random;
+
+public class BatMON extends Entity {
+
+    public BatMON(GamePanel panel) {
+        super(panel);
+        type = EntityType.MONSTER;
+        name = "bat";
+        defaultSpeed = 4;
+        speed = defaultSpeed;
+        maxLife = 4;
+        life = maxLife;
+        attack = 1;
+        defense = 0;
+        exp = 2;
+
+        knockbackVal = 5;
+
+        solidArea.x = 3;
+        solidArea.y = 15;
+        solidArea.width = 42;
+        solidArea.height = 21;
+        solidAreaDefaultX = solidArea.x;
+        solidAreaDefaultY = solidArea.y;
+
+        getImage();
+    }
+
+    // INTERACTION
+    public void setAction() {
+        setRandomDirection(10);
+    }
+    public void damageReaction() {
+        actionLock = 0;
+        //onPath = true;
+    }
+    public void checkDrop() {
+        int i = new Random().nextInt(100)+1;
+        if(i < 50) dropItem(new CoinObj(panel));
+        if(i >= 50 && i < 75) dropItem(new HeartObj(panel));
+        if(i >= 75 && i < 100) dropItem(new PotionObj(panel));
+    }
+
+    // SETTING THINGS UP
+    public void getImage() {
+        up1 = initEntitySprites("monster/bat_down_1");
+        up2 = initEntitySprites("monster/bat_down_2");
+        down1 = initEntitySprites("monster/bat_down_1");
+        down2 = initEntitySprites("monster/bat_down_2");
+        left1 = initEntitySprites("monster/bat_down_1");
+        left2 = initEntitySprites("monster/bat_down_2");
+        right1 = initEntitySprites("monster/bat_down_1");
+        right2 = initEntitySprites("monster/bat_down_2");
+    }
+
+}

src/de/miaurizius/jgame2d/entity/monster/GreenSlimeMON.java

@@ -45,7 +45,7 @@ public class GreenSlimeMON extends Entity {
             followPlayer();
             return;
         }
-        setRandomDirection();
+        setRandomDirection(120);
         checkShooting(200, 30);
     }
     public void damageReaction() {

src/de/miaurizius/jgame2d/entity/monster/OrcMON.java

@@ -41,7 +41,7 @@ public class OrcMON extends Entity {
     public void setAction() {
         if(!onPath) checkStartChasing(panel.player, 10 ,100); else followPlayer();
         checkStopChasing(panel.player, 15, 100);
-        setRandomDirection();
+        setRandomDirection(120);
         if(!attacking) checkAttack(50, panel.tileSize*4, panel.tileSize);
     }
     public void damageReaction() {

src/de/miaurizius/jgame2d/entity/monster/SkeletonLordMON.java

@@ -0,0 +1,111 @@
+package de.miaurizius.jgame2d.entity.monster;
+
+import de.miaurizius.jgame2d.core.GamePanel;
+import de.miaurizius.jgame2d.core.enums.EntityType;
+import de.miaurizius.jgame2d.entity.Entity;
+import de.miaurizius.jgame2d.entity.item.CoinObj;
+import de.miaurizius.jgame2d.entity.item.HeartObj;
+import de.miaurizius.jgame2d.entity.item.PotionObj;
+
+import java.util.Random;
+
+public class SkeletonLordMON extends Entity {
+
+    private final int spriteScale = 5;
+
+    public SkeletonLordMON(GamePanel panel) {
+        super(panel);
+        type = EntityType.MONSTER;
+        name = "Skeleton Lord";
+        defaultSpeed = 1;
+        speed = defaultSpeed;
+        maxLife = 50;
+        life = maxLife;
+        attack = 10;
+        defense = 2;
+        exp = 50;
+        knockbackVal = 5;
+
+        int size = panel.tileSize*spriteScale;
+        solidArea.x = 48;
+        solidArea.y = 48;
+        solidArea.width = size-48*2;
+        solidArea.height = size-48;
+        solidAreaDefaultX = solidArea.x;
+        solidAreaDefaultY = solidArea.y;
+
+        attackArea.width = 170;
+        attackArea.height = 170;
+
+        getImage();
+        getAttackImage();
+    }
+
+    // INTERACTION
+    public void setAction() {
+        if(!rage && life < maxLife/2) {
+            rage = true;
+            getImage();
+            getAttackImage();
+            defaultSpeed++;
+            speed = defaultSpeed;
+            attack *= 2;
+        }
+        if(dTile(panel.player) < 10) moveTowardPlayer(60); else setRandomDirection(120);
+        if(!attacking) checkAttack(60, panel.tileSize*7, panel.tileSize*5);
+    }
+    public void damageReaction() {
+        actionLock = 0;
+    }
+    public void checkDrop() {
+        int i = new Random().nextInt(100)+1;
+        if(i < 50) dropItem(new CoinObj(panel));
+        if(i >= 50 && i < 75) dropItem(new HeartObj(panel));
+        if(i >= 75 && i < 100) dropItem(new PotionObj(panel));
+    }
+
+    // SETTING THINGS UP
+    public void getImage() {
+        if(rage) {
+            up1 = initEntitySprites("monster/skeletonlord_phase2_up_1", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+            up2 = initEntitySprites("monster/skeletonlord_phase2_up_2", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+            down1 = initEntitySprites("monster/skeletonlord_phase2_down_1", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+            down2 = initEntitySprites("monster/skeletonlord_phase2_down_2", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+            left1 = initEntitySprites("monster/skeletonlord_phase2_left_1", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+            left2 = initEntitySprites("monster/skeletonlord_phase2_left_2", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+            right1 = initEntitySprites("monster/skeletonlord_phase2_right_1", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+            right2 = initEntitySprites("monster/skeletonlord_phase2_right_2", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+            return;
+        }
+        up1 = initEntitySprites("monster/skeletonlord_up_1", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+        up2 = initEntitySprites("monster/skeletonlord_up_2", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+        down1 = initEntitySprites("monster/skeletonlord_down_1", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+        down2 = initEntitySprites("monster/skeletonlord_down_2", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+        left1 = initEntitySprites("monster/skeletonlord_left_1", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+        left2 = initEntitySprites("monster/skeletonlord_left_2", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+        right1 = initEntitySprites("monster/skeletonlord_right_1", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+        right2 = initEntitySprites("monster/skeletonlord_right_2", panel.tileSize * spriteScale, panel.tileSize * spriteScale);
+    }
+    public void getAttackImage() {
+        if(rage) {
+            attackUp1 = initEntitySprites("monster/skeletonlord_phase2_attack_up_1", panel.tileSize * spriteScale, panel.tileSize * 2 * spriteScale);
+            attackUp2 = initEntitySprites("monster/skeletonlord_phase2_attack_up_2", panel.tileSize * spriteScale, panel.tileSize * 2 * spriteScale);
+            attackDown1 = initEntitySprites("monster/skeletonlord_phase2_attack_down_1", panel.tileSize * spriteScale, panel.tileSize * 2 * spriteScale);
+            attackDown2 = initEntitySprites("monster/skeletonlord_phase2_attack_down_2", panel.tileSize * spriteScale, panel.tileSize * 2 * spriteScale);
+            attackLeft1 = initEntitySprites("monster/skeletonlord_phase2_attack_left_1", panel.tileSize*2*spriteScale, panel.tileSize*spriteScale);
+            attackLeft2 = initEntitySprites("monster/skeletonlord_phase2_attack_left_2", panel.tileSize*2*spriteScale, panel.tileSize*spriteScale);
+            attackRight1 = initEntitySprites("monster/skeletonlord_phase2_attack_right_1", panel.tileSize*2*spriteScale, panel.tileSize*spriteScale);
+            attackRight2 = initEntitySprites("monster/skeletonlord_phase2_attack_right_2", panel.tileSize*2*spriteScale, panel.tileSize*spriteScale);
+            return;
+        }
+        attackUp1 = initEntitySprites("monster/skeletonlord_attack_up_1", panel.tileSize * spriteScale, panel.tileSize * 2 * spriteScale);
+        attackUp2 = initEntitySprites("monster/skeletonlord_attack_up_2", panel.tileSize * spriteScale, panel.tileSize * 2 * spriteScale);
+        attackDown1 = initEntitySprites("monster/skeletonlord_attack_down_1", panel.tileSize * spriteScale, panel.tileSize * 2 * spriteScale);
+        attackDown2 = initEntitySprites("monster/skeletonlord_attack_down_2", panel.tileSize * spriteScale, panel.tileSize * 2 * spriteScale);
+        attackLeft1 = initEntitySprites("monster/skeletonlord_attack_left_1", panel.tileSize*2*spriteScale, panel.tileSize*spriteScale);
+        attackLeft2 = initEntitySprites("monster/skeletonlord_attack_left_2", panel.tileSize*2*spriteScale, panel.tileSize*spriteScale);
+        attackRight1 = initEntitySprites("monster/skeletonlord_attack_right_1", panel.tileSize*2*spriteScale, panel.tileSize*spriteScale);
+        attackRight2 = initEntitySprites("monster/skeletonlord_attack_right_2", panel.tileSize*2*spriteScale, panel.tileSize*spriteScale);
+    }
+
+}