Add npcs

src/main/java/io/github/twhscs/game/App.java

@@ -12,6 +12,9 @@
 import org.jsfml.window.VideoMode;
 import org.jsfml.window.event.Event;
 
+import java.util.ArrayList;
+import java.util.List;
+
 class App {
     private final int TILE_SIZE = 32;
     private final float ZOOM = 0.5f;
@@ -21,6 +24,7 @@ class App {
     private final ResourceManager RESOURCE_MANAGER;
     private final Map MAP;
     private final Player PLAYER;
+    private final List<Entity> ENTITIES;
 
     private App() {
         WINDOW = new RenderWindow(new VideoMode(640, 480), "Game");
@@ -40,9 +44,15 @@ private App() {
         String[] soundBufferNames = {"collision", "interact_failure", "interact_success"};
         RESOURCE_MANAGER.loadSoundBuffers(soundBufferNames);
         PLAYER = new Player(RESOURCE_MANAGER.getTexture("ryuk"), GAME_VIEW, TILE_SIZE, 4, 2);
+        ENTITIES = new ArrayList<Entity>();
+        ENTITIES.add(
+                new NonPlayableCharacter(RESOURCE_MANAGER.getTexture("ryuk"), TILE_SIZE, 4, 2)
+        );
         MAP = new Map(100, 100, TILE_SIZE, ZOOM, 25, RESOURCE_MANAGER.getTexture("tiles"), WINDOW);
         MAP.setPlayer(PLAYER);
-
+        for (Entity e : ENTITIES) {
+            MAP.setEntity(e);
+        }
         // Start the main loop.
         run();
     }
@@ -119,6 +129,9 @@ private void processInput() {
                     GAME_VIEW.reset(new FloatRect(0.0f, 0.0f, size.x, size.y));
                     GAME_VIEW.zoom(ZOOM);
                     PLAYER.updateSprite();
+                    for (Entity e : ENTITIES) {
+                        e.updateSprite();
+                    }
                     break;
                 case KEY_PRESSED:
                     switch (event.asKeyEvent().key) {

src/main/java/io/github/twhscs/game/Entity.java

@@ -0,0 +1,49 @@
+package io.github.twhscs.game;
+
+import io.github.twhscs.game.util.Direction;
+import org.jsfml.graphics.*;
+import org.jsfml.system.Vector2f;
+import org.jsfml.system.Vector2i;
+
+abstract class Entity implements Drawable {
+    protected Sprite SPRITE;
+    protected Vector2i SPRITE_SIZE;
+    protected int TILE_SIZE;
+    protected Vector2f position;
+    protected Direction direction;
+    protected Map map;
+
+    Entity() {
+        SPRITE = new Sprite();
+        SPRITE_SIZE = new Vector2i(0,0);
+        TILE_SIZE = 0;
+    }
+
+    public Vector2f getPosition() {
+        return position;
+    }
+
+    public void setPosition(Vector2f position) {
+        this.position = position;
+    }
+
+    public void setMap(Map map) {
+        this.map = map;
+    }
+
+    public void update() {}
+
+    public void updateSprite() {}
+
+    public void draw(RenderTarget renderTarget, RenderStates renderStates) {
+        renderTarget.draw(SPRITE);
+    }
+
+    public String toString() {
+        return "Entity{" +
+                "SPRITE_SIZE=" + SPRITE_SIZE +
+                ", position=" + position +
+                ", direction=" + direction +
+                '}';
+    }
+}

src/main/java/io/github/twhscs/game/Map.java

@@ -4,9 +4,7 @@
 import org.jsfml.system.Vector2f;
 import org.jsfml.system.Vector2i;
 
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
 
 class Map implements Drawable {
     private final Vector2i DIMENSIONS;
@@ -19,6 +17,7 @@ class Map implements Drawable {
     private final int TOTAL_CHUNKS;
     private final int X_CHUNKS;
     private final VertexArray[] VERTEX_ARRAYS;
+    private final List<Entity> ENTITIES;
     private Player player;
 
 
@@ -37,10 +36,16 @@ class Map implements Drawable {
         // Calculate the total amount of chunks.
         TOTAL_CHUNKS = X_CHUNKS * yChunks;
         VERTEX_ARRAYS = new VertexArray[TOTAL_CHUNKS];
+        ENTITIES = new ArrayList<Entity>();
         // Load the tiles into the map.
         load();
     }
 
+    public void setEntity(Entity entity) {
+        ENTITIES.add(entity);
+        entity.setMap(this);
+    }
+
     public void setPlayer(Player player) {
         this.player = player;
         player.setMap(this);
@@ -87,8 +92,20 @@ private int positionToChunkID(Vector2f position) {
         return ((int) position.x / CHUNK_SIZE) + (((int) position.y / CHUNK_SIZE) * X_CHUNKS);
     }
 
+    public boolean isOccupiedPosition(Vector2f position) {
+        if (player != null && position.equals(player.getPosition())) {
+            return true;
+        }
+        for (Entity e : ENTITIES) {
+            if (position.equals(e.getPosition())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     public boolean isValidPosition(Vector2f position) {
-        return position.x >= 0.0f && position.y >= 0.0f && position.x < DIMENSIONS.x && position.y < DIMENSIONS.y;
+        return position.x >= 0.0f && position.y >= 0.0f && position.x < DIMENSIONS.x && position.y < DIMENSIONS.y && !isOccupiedPosition(position);
     }
 
     private void partition() {
@@ -152,8 +169,14 @@ private void partition() {
         }
     }
 
-    public void update() {
+    public void updateEntities() {
+        for (Entity e : ENTITIES) {
+            e.update();
+        }
+    }
 
+    public void update() {
+        updateEntities();
     }
 
 
@@ -190,5 +213,8 @@ public void draw(RenderTarget renderTarget, RenderStates renderStates) {
                 }
             }
         }
+        for (Entity e : ENTITIES) {
+            WINDOW.draw(e);
+        }
     }
 }

src/main/java/io/github/twhscs/game/NonPlayableCharacter.java

@@ -0,0 +1,134 @@
+package io.github.twhscs.game;
+
+import io.github.twhscs.game.util.Direction;
+import io.github.twhscs.game.util.Position;
+import org.jsfml.graphics.*;
+import org.jsfml.system.Vector2f;
+import org.jsfml.system.Vector2i;
+
+class NonPlayableCharacter extends Entity implements Drawable {
+    private final int ANIMATION_FRAMES;
+    private final int ANIMATION_SPEED;
+    private final float ANIMATION_STEP;
+    private int animationFrame;
+    private boolean animating;
+
+    NonPlayableCharacter(Texture npcTexture, int TILE_SIZE, int ANIMATION_FRAMES, int ANIMATION_SPEED) {
+        super.SPRITE = new Sprite(npcTexture);
+        super.SPRITE_SIZE = Vector2i.div(npcTexture.getSize(), ANIMATION_FRAMES);
+        super.TILE_SIZE = TILE_SIZE;
+        super.position = new Vector2f(0.0f, 0.0f);
+        super.direction = Direction.NORTH;
+        this.ANIMATION_FRAMES = ANIMATION_FRAMES;
+        this.ANIMATION_SPEED = ANIMATION_SPEED;
+        this.ANIMATION_STEP = 1.0f / (ANIMATION_FRAMES * ANIMATION_SPEED);
+        animationFrame = 0;
+        animating = false;
+        updateSprite();
+    }
+
+    @Override
+    public String toString() {
+        return "NonPlayableCharacter{" +
+                "SPRITE_SIZE=" + super.SPRITE_SIZE +
+                ", ANIMATION_FRAMES=" + ANIMATION_FRAMES +
+                ", ANIMATION_SPEED=" + ANIMATION_SPEED +
+                ", ANIMATION_STEP=" + ANIMATION_STEP +
+                ", position=" + super.position +
+                ", direction=" + super.direction +
+                ", animationFrame=" + animationFrame +
+                ", animating=" + animating +
+                '}';
+    }
+
+    @Override
+    public void updateSprite() {
+        // Calculate the sprite position by multiplying the map position by the tile size.
+        // Subtract half of the sprite width minus the tile size to center it horizontally.
+        // Subtract the sprite height minus the tile size to center it vertically.
+        Vector2f spritePosition = new Vector2f(position.x * TILE_SIZE - ((SPRITE_SIZE.x - TILE_SIZE) / 2.0f), position.y * TILE_SIZE - (SPRITE_SIZE.y - TILE_SIZE));
+        // Round the position to prevent graphical errors.
+        spritePosition = Position.round(spritePosition);
+        // Update the sprite's position.
+        SPRITE.setPosition(spritePosition);
+        // Apply the appropriate texture based on direction and animation.
+        SPRITE.setTextureRect(getTextureRect());
+    }
+
+    public void randomlyChooseMove() {
+        if ((int)(Math.random() * 25) == 1) {
+            this.move(Direction.getRandomCardinalDirection());
+        }
+    }
+
+    public void move(Direction direction) {
+        // TODO: Allow for faster movement. (Do not have to wait until current move is finished before initiating next move.)
+        // Only move the player if they are not already moving.
+        if (!animating) {
+            // Calculate the position to move towards.
+            Vector2f newPosition = Position.getRelativePosition(position, direction, 1.0f);
+            // Make sure the new position is valid.
+            if (map.isValidPosition(newPosition)) {
+                // If it is valid, update the direction and start moving..
+                super.direction = direction;
+                animating = true;
+            }
+        }
+    }
+
+    @Override
+    public void update() {
+        //This randomly chooses when and where to move
+        //We will hopefully replace this with path finding or something more advanced
+        randomlyChooseMove();
+        // Check if the player is moving.
+        if (animating) {
+            // Move the player by the animation step.
+            super.position = Position.getRelativePosition(position, direction, ANIMATION_STEP);
+            // Check if it is time to stop moving.
+            if (animationFrame + 1 >= ANIMATION_FRAMES * ANIMATION_SPEED) {
+                // Reset the animation frame and stop moving.
+                animationFrame = 0;
+                animating = false;
+                // Round the position to prevent float rounding errors.
+                super.position = Position.round(position);
+            } else {
+                // If it is not time to stop, keep going.
+                animationFrame++;
+            }
+            // Update the sprite.
+            updateSprite();
+        }
+    }
+
+    private IntRect getTextureRect() {
+        // Normalize the current frame based on the amount of actual frames.
+        int adjustedFrame = Math.round((animationFrame * ANIMATION_FRAMES) / (ANIMATION_FRAMES * ANIMATION_SPEED));
+        // Use math to calculate the player's current texture.
+        switch (super.direction) {
+            case NORTH:
+                return new IntRect(adjustedFrame * super.SPRITE_SIZE.x, 3 * super.SPRITE_SIZE.y, super.SPRITE_SIZE.x, super.SPRITE_SIZE.y);
+            case SOUTH:
+                return new IntRect(adjustedFrame * super.SPRITE_SIZE.x, 0, super.SPRITE_SIZE.x, super.SPRITE_SIZE.y);
+            case WEST:
+                return new IntRect(adjustedFrame * super.SPRITE_SIZE.x, super.SPRITE_SIZE.y, super.SPRITE_SIZE.x, super.SPRITE_SIZE.y);
+            case EAST:
+                return new IntRect(adjustedFrame * super.SPRITE_SIZE.x, 2 * super.SPRITE_SIZE.y, super.SPRITE_SIZE.x, super.SPRITE_SIZE.y);
+            default:
+                return new IntRect(0, 0, 0, 0);
+        }
+    }
+
+    public void interpolate(float positionBetweenUpdates) {
+        if (animating) {
+            // Multiply the animation step by the position between frames (0.0f - 1.0f).
+            float interpolationStep = ANIMATION_STEP * positionBetweenUpdates;
+            // Get the current position.
+            Vector2f currentPosition = super.position;
+            // Temporarily update the position with the interpolation step applied, update the sprite, then revert the position.
+            super.position = Position.getRelativePosition(super.position, super.direction, interpolationStep);
+            updateSprite();
+            super.position = currentPosition;
+        }
+    }
+}

src/main/java/io/github/twhscs/game/Player.java

@@ -30,7 +30,7 @@ class Player implements Drawable {
         this.ANIMATION_FRAMES = ANIMATION_FRAMES;
         this.ANIMATION_SPEED = ANIMATION_SPEED;
         // Calculate the animation step by taking the reciprocal of the frame count times speed.
-        ANIMATION_STEP = 1.0f / (ANIMATION_FRAMES * ANIMATION_SPEED);
+        this.ANIMATION_STEP = 1.0f / (ANIMATION_FRAMES * ANIMATION_SPEED);
         position = new Vector2f(0.0f, 0.0f);
         direction = Direction.NORTH;
         animationFrame = 0;

src/main/java/io/github/twhscs/game/util/Direction.java

@@ -1,5 +1,9 @@
 package io.github.twhscs.game.util;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 /**
  * Enumeration of the eight cardinal and ordinal directions.
  */
@@ -34,4 +38,20 @@ public static Direction getOppositeDirection(Direction direction) {
                 return null;
         }
     }
+
+    /**
+     * Gets a random direction.
+     * @return a random direction.
+     */
+    public static Direction getRandomDirection() {
+        return Direction.values()[(int)(Math.random() * 8)];
+    }
+
+    /**
+     * Gets a random cardinal direction.
+     * @return a random cardinal direction.
+     */
+    public static Direction getRandomCardinalDirection() {
+        return Direction.values()[(int)(Math.random() * 4)];
+    }
 }