Merge branch 'collisions' into 'master'

Collisions

See merge request ynerant/dungeon-battle!9

dungeonbattle/entities/player.py

@@ -4,3 +4,15 @@ from ..interfaces import FightingEntity
 class Player(FightingEntity):
     maxhealth = 20
     strength = 5
+
+    def move_up(self) -> bool:
+        return self.check_move(self.y - 1, self.x, True)
+
+    def move_down(self) -> bool:
+        return self.check_move(self.y + 1, self.x, True)
+
+    def move_left(self) -> bool:
+        return self.check_move(self.y, self.x - 1, True)
+
+    def move_right(self) -> bool:
+        return self.check_move(self.y, self.x + 1, True)

dungeonbattle/game.py

@@ -1,5 +1,6 @@
 from typing import Any
 
+from .entities.player import Player
 from .interfaces import Map
 from .mapdisplay import MapDisplay
 from .settings import Settings
@@ -22,8 +23,8 @@ class Game:
         m = Map.load("example_map.txt")
         player = Player()
         self.player = player
-        player.y = 1
+        m.add_entity(player)
-        player.x = 6
+        player.move(1, 6)
         d = MapDisplay(m, player)
         while True:
             screen.clear()
@@ -42,21 +43,3 @@ class Game:
             self.player.move_left()
         if key == 'd' or key == 'KEY_RIGHT':
             self.player.move_right()
-
-
-class Player:
-    # FIXME Should be elsewhere, only useful to don't break the previous code
-    y: int = 0
-    x: int = 0
-
-    def move_up(self) -> None:
-        self.y -= 1
-
-    def move_down(self) -> None:
-        self.y += 1
-
-    def move_left(self) -> None:
-        self.x -= 1
-
-    def move_right(self) -> None:
-        self.x += 1

dungeonbattle/interfaces.py

@@ -11,12 +11,18 @@ class Map:
     height: int
     tiles: list
 
-    def __init__(self, width: int, height: int, tiles: list,
+    def __init__(self, width: int, height: int, tiles: list):
-                 entities: list = None):
         self.width = width
         self.height = height
         self.tiles = tiles
-        self.entities = entities or []
+        self.entities = []
+
+    def add_entity(self, entity: "Entity") -> None:
+        """
+        Register a new entity in the map.
+        """
+        self.entities.append(entity)
+        entity.map = self
 
     @staticmethod
     def load(filename: str):
@@ -39,7 +45,7 @@ class Map:
         tiles = [[Tile(c)
                   for x, c in enumerate(line)] for y, line in enumerate(lines)]
 
-        return Map(width, height, tiles, [])
+        return Map(width, height, tiles)
 
     def draw_string(self) -> str:
         """
@@ -68,11 +74,19 @@ class Tile(Enum):
 class Entity:
     y: int
     x: int
+    map: Map
 
     def __init__(self):
         self.y = 0
         self.x = 0
 
+    def check_move(self, y: int, x: int, move_if_possible: bool = False)\
+            -> bool:
+        tile = self.map.tiles[y][x]
+        if tile.can_walk() and move_if_possible:
+            self.move(y, x)
+        return tile.can_walk()
+
     def move(self, y: int, x: int) -> None:
         self.y = y
         self.x = x

dungeonbattle/mapdisplay.py

@@ -1,22 +1,21 @@
 #!/usr/bin/env python
 import curses
-from typing import Any
 
+from dungeonbattle.entities.player import Player
 from dungeonbattle.interfaces import Map
 
 
 class MapDisplay:
-    def __init__(self, m: Map, player: Any):
+    def __init__(self, m: Map, player: Player):
-        # TODO Type the player field with the good type
         self.map = m
         self.pad = curses.newpad(m.height, m.width + 1)
         self.player = player
 
     def update_pad(self) -> None:
         self.pad.addstr(0, 0, self.map.draw_string())
+        # TODO Not all entities should be a player
         for e in self.map.entities:
-            self.pad.addch(e.y, e.x, e.img)
+            self.pad.addstr(e.y, e.x, '🐿')
-        self.pad.addstr(self.player.getPosY(), self.player.getPosX(), '🐿')
 
     def display(self, y: int, x: int) -> None:
         deltay, deltax = (curses.LINES // 2) + 1, (curses.COLS // 2) + 1

dungeonbattle/tests/entities_test.py

@@ -59,8 +59,8 @@ class TestEntities(unittest.TestCase):
         """
         item = Bomb()
         squirrel = Squirrel()
-        self.map.entities.append(item)
+        self.map.add_entity(item)
-        self.map.entities.append(squirrel)
+        self.map.add_entity(squirrel)
         squirrel.health = 2
         squirrel.move(41, 42)
         item.act(self.map)
@@ -76,6 +76,22 @@ class TestEntities(unittest.TestCase):
         Test some random stuff with players.
         """
         player = Player()
+        self.map.add_entity(player)
+        player.move(1, 6)
         self.assertEqual(player.strength, 5)
         self.assertEqual(player.health, player.maxhealth)
         self.assertEqual(player.maxhealth, 20)
+
+        # Test movements and ensure that collisions are working
+        self.assertFalse(player.move_up())
+        self.assertTrue(player.move_left())
+        self.assertFalse(player.move_left())
+        for i in range(8):
+            self.assertTrue(player.move_down())
+        self.assertFalse(player.move_down())
+        self.assertTrue(player.move_right())
+        self.assertTrue(player.move_right())
+        self.assertTrue(player.move_right())
+        self.assertFalse(player.move_right())
+        self.assertTrue(player.move_down())
+        self.assertTrue(player.move_down())