Player can move units

.gitignore

@@ -14,6 +14,7 @@ engine/target
 game/target
 d2tm/target
 target
+graphics/
 
 # Eclipse files
 engine/.classpath

src/main/java/com/fundynamic/d2tm/game/behaviors/Moveable.java

@@ -0,0 +1,9 @@
+package com.fundynamic.d2tm.game.behaviors;
+
+import com.fundynamic.d2tm.math.Vector2D;
+
+public interface Moveable {
+
+    void moveTo(Vector2D target);
+
+}

src/main/java/com/fundynamic/d2tm/game/controls/AbstractMouseBehavior.java

@@ -0,0 +1,18 @@
+package com.fundynamic.d2tm.game.controls;
+
+
+import com.fundynamic.d2tm.game.map.Cell;
+
+public abstract class AbstractMouseBehavior implements MouseBehavior {
+    protected final Mouse mouse;
+
+    public AbstractMouseBehavior(Mouse mouse) {
+        this.mouse = mouse;
+    }
+
+    public abstract void leftClicked();
+
+    public abstract void rightClicked();
+
+    public abstract void mouseMovedToCell(Cell cell);
+}

src/main/java/com/fundynamic/d2tm/game/controls/Mouse.java

@@ -1,73 +1,108 @@
 package com.fundynamic.d2tm.game.controls;
 
-import com.fundynamic.d2tm.game.behaviors.Selectable;
 import com.fundynamic.d2tm.game.entities.Entity;
+import com.fundynamic.d2tm.game.entities.Player;
 import com.fundynamic.d2tm.game.map.Cell;
-import com.fundynamic.d2tm.math.Vector2D;
+import org.newdawn.slick.GameContainer;
+import org.newdawn.slick.Image;
+import org.newdawn.slick.SlickException;
+
+import java.util.HashMap;
+import java.util.Map;
+
 
-/**
- * This class represents the state of the mouse. This is not about coordinates (we can get these via Slick listeners)
- * but about what structure is selected, the type of mouse being rendered (ie moving? attacking? placing structure? or
- * 'normal' ?)
- */
 public class Mouse {
 
-    private Cell hoverCell;
+    public enum MouseImages {
+        NORMAL, HOVER_OVER_SELECTABLE_ENTITY, MOVE, ATTACK, CUSTOM
+    }
+
+    private final Player controllingPlayer;
+    private final GameContainer gameContainer;
+
+    private MouseBehavior mouseBehavior;
     private Entity lastSelectedEntity;
+    private Cell hoverCell;
+    private MouseImages currentImage = null;
 
-    public Mouse(){}
+    private Map<MouseImages, Image> mouseImages;
 
-    public Mouse(Cell hoverCell) {
-        this.hoverCell = hoverCell;
+    public Mouse(Player controllingPlayer, GameContainer gameContainer) {
+        this.controllingPlayer = controllingPlayer;
+        this.mouseBehavior = null;
+        this.hoverCell = null;
+        this.gameContainer = gameContainer;
+        this.mouseImages = new HashMap<>();
     }
 
-    public void setHoverCell(Cell cell) {
-        if (cell == null) throw new IllegalArgumentException("argument cell may not be null");
-        this.hoverCell = cell;
+    public void init() {
+        this.mouseBehavior = new NormalMouse(this);
+        this.hoverCell = null;
     }
 
-    public Cell getHoverCell() {
-        return hoverCell;
+    public void leftClicked() {
+        mouseBehavior.leftClicked();
     }
 
-    public Vector2D getHoverCellMapVector() {
-        return hoverCell.getCoordinatesAsVector2D();
+    public void rightClicked() {
+        mouseBehavior.rightClicked();
     }
 
-    /**
-     * When a structure is bound to a cell, this method makes sure that is the only selected structure.
-     * If there is no structure bound to the cell then this automatically deselects the structure.
-     */
-    public void selectEntity() {
-        if (hoverCell == null) return;
-        Entity entity = hoverCell.getEntity();
-        if (entity == null) return;
-        if (!entity.isSelectable()) return;
-        lastSelectedEntity = entity;
-        ((Selectable)lastSelectedEntity).select();
+    public void mouseMovedToCell(Cell cell) {
+        mouseBehavior.mouseMovedToCell(cell);
     }
 
-    public boolean hasAnyEntitySelected() {
-        return this.lastSelectedEntity != null;
+    public void setMouseBehavior(MouseBehavior mouseBehavior) {
+        if (mouseBehavior == null) throw new IllegalArgumentException("MouseBehavior argument may not be null!");
+        System.out.println("Mouse behavior changed into " + mouseBehavior);
+        this.mouseBehavior = mouseBehavior;
     }
 
     public Entity getLastSelectedEntity() {
         return lastSelectedEntity;
     }
 
-    public void deselectEntity() {
-        if (lastSelectedEntity != null) {
-            if (lastSelectedEntity.isSelectable()) {
-                ((Selectable) lastSelectedEntity).deselect();
-            }
+    public void setLastSelectedEntity(Entity lastSelectedEntity) {
+        this.lastSelectedEntity = lastSelectedEntity;
+    }
+
+    public Cell getHoverCell() {
+        return hoverCell;
+    }
+
+    public void setHoverCell(Cell hoverCell) {
+        this.hoverCell = hoverCell;
+    }
+
+    public Player getControllingPlayer() {
+        return controllingPlayer;
+    }
+
+    public void setMouseImage(Image image, int hotSpotX, int hotSpotY) {
+        if (image == null) throw new IllegalArgumentException("Image to set for mouse cursor may not be null!");
+        if (!mouseImages.containsValue(image)) {
+            this.currentImage = MouseImages.CUSTOM;
+        }
+        try {
+            gameContainer.setMouseCursor(image, hotSpotX, hotSpotY);
+        } catch (SlickException e) {
+            e.printStackTrace();
         }
-        lastSelectedEntity = null;
     }
 
-    public boolean hoversOverSelectableEntity() {
-        Entity entity = hoverCell.getEntity();
-        if (entity == null) return false;
-        return entity.isSelectable();
+    public void setMouseImage(MouseImages key, int hotSpotX, int hotSpotY) {
+        if (key.equals(this.currentImage)) return;
+        this.currentImage = key;
+        setMouseImage(mouseImages.get(key), hotSpotX, hotSpotY);
+    }
+
+    public void addMouseImage(MouseImages key, Image image) {
+        if (image == null) throw new IllegalArgumentException("Image for mouse images cannot be null!");
+        this.mouseImages.put(key, image);
+    }
 
+    public MouseBehavior getMouseBehavior() {
+        return this.mouseBehavior;
     }
+
 }

src/main/java/com/fundynamic/d2tm/game/controls/MouseBehavior.java

@@ -0,0 +1,14 @@
+package com.fundynamic.d2tm.game.controls;
+
+
+import com.fundynamic.d2tm.game.map.Cell;
+
+public interface MouseBehavior {
+
+    void leftClicked();
+
+    void rightClicked();
+
+    void mouseMovedToCell(Cell cell);
+
+}

src/main/java/com/fundynamic/d2tm/game/controls/MovableSelectedMouse.java

@@ -0,0 +1,48 @@
+package com.fundynamic.d2tm.game.controls;
+
+
+import com.fundynamic.d2tm.game.behaviors.Moveable;
+import com.fundynamic.d2tm.game.entities.Entity;
+import com.fundynamic.d2tm.game.map.Cell;
+
+public class MovableSelectedMouse extends NormalMouse {
+
+    public MovableSelectedMouse(Mouse mouse) {
+        super(mouse);
+        mouse.setMouseImage(Mouse.MouseImages.MOVE, 16, 16);
+    }
+
+    @Override
+    public void leftClicked() {
+        Entity entity = hoveringOverSelectableEntity();
+        if (entity != null) {
+            deselectCurrentlySelectedEntity();
+            selectEntity(entity);
+        } else {
+            if (selectedEntityBelongsToControllingPlayer() && selectedEntityIsMovable()) {
+                ((Moveable) mouse.getLastSelectedEntity()).moveTo(mouse.getHoverCell().getCoordinatesAsVector2D());
+            }
+        }
+    }
+
+    @Override
+    public void mouseMovedToCell(Cell cell) {
+        if (cell == null) throw new IllegalArgumentException("argument cell may not be null");
+        mouse.setHoverCell(cell);
+        Entity entity = hoveringOverSelectableEntity();
+        if (entity == null) {
+            mouse.setMouseImage(Mouse.MouseImages.MOVE, 16, 16);
+            return;
+        }
+        if (entity.belongsToPlayer(mouse.getControllingPlayer())) {
+            mouse.setMouseImage(Mouse.MouseImages.HOVER_OVER_SELECTABLE_ENTITY, 16, 16);
+        } else {
+            mouse.setMouseImage(Mouse.MouseImages.ATTACK, 16, 16);
+        }
+    }
+
+    @Override
+    public void rightClicked() {
+        super.rightClicked();
+    }
+}

src/main/java/com/fundynamic/d2tm/game/controls/NormalMouse.java

@@ -0,0 +1,89 @@
+package com.fundynamic.d2tm.game.controls;
+
+
+import com.fundynamic.d2tm.game.behaviors.Selectable;
+import com.fundynamic.d2tm.game.entities.Entity;
+import com.fundynamic.d2tm.game.entities.Player;
+import com.fundynamic.d2tm.game.map.Cell;
+
+
+public class NormalMouse extends AbstractMouseBehavior {
+
+    public NormalMouse(Mouse mouse) {
+        super(mouse);
+        mouse.setMouseImage(Mouse.MouseImages.NORMAL, 0, 0);
+    }
+
+    @Override
+    public void leftClicked() {
+        Entity entity = hoveringOverSelectableEntity();
+        if (entity == null) return;
+
+        selectEntity(entity);
+
+        if (selectedEntityBelongsToControllingPlayer() && selectedEntityIsMovable()) {
+            mouse.setMouseBehavior(new MovableSelectedMouse(mouse));
+        }
+    }
+
+    protected void selectEntity(Entity entity) {
+        deselectCurrentlySelectedEntity();
+        mouse.setLastSelectedEntity(entity);
+        ((Selectable) entity).select();
+    }
+
+    protected Entity hoveringOverSelectableEntity() {
+        Cell hoverCell = mouse.getHoverCell();
+        if (hoverCell == null) return null;
+        Entity entity = hoverCell.getEntity();
+        if (entity == null) return null;
+        if (!entity.isSelectable()) return null;
+        return entity;
+    }
+
+    @Override
+    public void rightClicked() {
+        deselectCurrentlySelectedEntity();
+        if (selectedEntityBelongsToControllingPlayer()) {
+            mouse.setMouseBehavior(new NormalMouse(mouse));
+        }
+        mouse.setLastSelectedEntity(null);
+    }
+
+    protected void deselectCurrentlySelectedEntity() {
+        Entity lastSelectedEntity = mouse.getLastSelectedEntity();
+        if (lastSelectedEntity != null) {
+            if (lastSelectedEntity.isSelectable()) {
+                ((Selectable) lastSelectedEntity).deselect();
+            }
+        }
+        mouse.setMouseImage(Mouse.MouseImages.NORMAL, 0, 0);
+    }
+
+    @Override
+    public void mouseMovedToCell(Cell cell) {
+        if (cell == null) throw new IllegalArgumentException("argument cell may not be null");
+        mouse.setHoverCell(cell);
+        Entity entity = hoveringOverSelectableEntity();
+        if (entity != null && entity.belongsToPlayer(mouse.getControllingPlayer())) {
+            mouse.setMouseImage(Mouse.MouseImages.HOVER_OVER_SELECTABLE_ENTITY, 16, 16);
+        } else {
+            mouse.setMouseImage(Mouse.MouseImages.NORMAL, 0, 0);
+        }
+    }
+
+    protected boolean selectedEntityBelongsToControllingPlayer() {
+        Entity lastSelectedEntity = mouse.getLastSelectedEntity();
+        if (lastSelectedEntity == null) return false;
+        Player controllingPlayer = mouse.getControllingPlayer();
+        if (controllingPlayer == null) return false;
+        return lastSelectedEntity.getPlayer().equals(controllingPlayer);
+    }
+
+
+    protected boolean selectedEntityIsMovable() {
+        Entity lastSelectedEntity = mouse.getLastSelectedEntity();
+        return lastSelectedEntity.isMovable();
+    }
+
+}

src/main/java/com/fundynamic/d2tm/game/controls/PlacingStructureMouse.java

@@ -0,0 +1,49 @@
+package com.fundynamic.d2tm.game.controls;
+
+
+import com.fundynamic.d2tm.game.entities.EntityRepository;
+import com.fundynamic.d2tm.game.map.Cell;
+import com.fundynamic.d2tm.math.Random;
+import org.newdawn.slick.Color;
+import org.newdawn.slick.Graphics;
+
+public class PlacingStructureMouse extends AbstractMouseBehavior {
+
+    private final EntityRepository entityRepository;
+    private EntityRepository.EntityData entityToPlace;
+
+    public PlacingStructureMouse(Mouse mouse, EntityRepository entityRepository) {
+        super(mouse);
+        this.entityRepository = entityRepository;
+        selectRandomlySomethingToPlace();
+    }
+
+    @Override
+    public void leftClicked() {
+        Cell hoverCell = mouse.getHoverCell();
+        entityRepository.placeOnMap(hoverCell.getCoordinatesAsVector2D(), entityToPlace, mouse.getControllingPlayer());
+        selectRandomlySomethingToPlace();
+    }
+
+    @Override
+    public void rightClicked() {
+        mouse.setMouseBehavior(new NormalMouse(mouse));
+    }
+
+    @Override
+    public void mouseMovedToCell(Cell cell) {
+        mouse.setHoverCell(cell);
+    }
+
+    public void render(Graphics graphics, int x, int y) {
+        graphics.setColor(Color.green);
+        graphics.setLineWidth(1.1f);
+        graphics.drawRect(x, y, entityToPlace.width, entityToPlace.height);
+    }
+
+    private void selectRandomlySomethingToPlace() {
+        entityToPlace = entityRepository.getEntityData(EntityRepository.EntityType.STRUCTURE, Random.getRandomBetween(0, 2));
+        mouse.setMouseImage(entityToPlace.getFirstImage(), 16, 16);
+    }
+
+}