J1 Summary Project Review

Test.py

@@ -1 +1,17 @@
+import ctps
 import interface
+
+LOGFILE = "test.log"
+
+def log_to_file(message: str) -> None:
+    with open(LOGFILE, "a") as f:
+        f.write(message + "\n")
+
+interface.report = log_to_file
+
+commands = ['start', 'dungeon', 'kitchen']
+
+game = ctps.Game()
+game.setup()
+for choice in commands:
+    game.do_choice(choice)

battle.py

@@ -1,48 +1,44 @@
 import time
 
+import character
+import interface
+
+
 class Battle:
+
     def __init__(self, player, room):
         self.player = player
         self.room = room
-
 
     def battle_start(self):
-        if not self.room.all_enemies_defeated():
-            print("YOU FOUND ENEMIES!!!!")
-            i = 0
-            while not self.battle_over():
-                if i % 2 == 0:
-                    self.player_attack()
-                elif i % 2 == 1:
-                    self.enemy_attack()
-
-                i += 1
-                time.sleep(0.1)
-            print("Battle over!")
-        else:
-            print("All soldiers in the room have been defeated already!")
-
-    def player_attack(self):
-        source = self.player
-        target = self.room.get_enemies()[0]
-        source.attack(target)
-        print(f"You attacked the {target.get_type()}! {target.get_type()} health: {target.get_health()}")
-        if target.get_health() <= 0:
-            if target.get_type() == "Princess":
-                print("Princess is now unconcious! Time to escape!")
-            else:
-                print("Soldier defeated!")
-            self.room.remove_enemy()
         if self.room.all_enemies_defeated():
-            print("All soldiers in the room are defeated!")
+            interface.report("All soldiers in the room have been defeated already!")
+            return
+        interface.report("YOU FOUND ENEMIES!!!!")
+        while not self.battle_over():
+            attacker = self.player
+            defender = self.room.get_enemies()[0]
+            self.attack(attacker, defender)
+            if defender.isdead():
+                interface.report(interface.death_msg(defender.get_type()))
+                if attacker == self.player:
+                    self.room.remove_enemy()
+                    defender = self.room.get_enemies()[0]
+            attacker, defender = defender, attacker
+            time.sleep(0.1)
+        if self.room.all_enemies_defeated():
+            interface.report("All soldiers in the room are defeated!")
+        interface.report("Battle over!")
+
+    def attack(self, attacker, defender) -> None:
+        defender.receive_damage(attacker.damage)
+        interface.report(self.attack_report(attacker, defender))
 
-    def enemy_attack(self):
-        source = self.room.get_enemies()[0]
-        target = self.player
-        source.attack(target)
-        print(f"{source.get_type()} attacked you! Your health: {target.get_health()}")
-        # if target.get_health() <= 0:
-        #     print("You died! WEAK!")
+    def attack_report(self, attacker, defender) -> str:
+        if attacker.get_type() == "Player":
+            return f"You attacked the {defender.get_type()}! {defender.get_type()} health: {defender.get_health()}"
+        else:
+            return f"{attacker.get_type()} attacked you! Your health: {defender.get_health()}"
 
     def battle_over(self):
-        return self.player.get_health() <= 0 or self.room.all_enemies_defeated()
+        return self.player.isdead() or self.room.all_enemies_defeated()

character.py

@@ -1,52 +1,39 @@
-import random
-
 class Character:
 
-    def __init__(self, _type, health, damage = 0):
-        self._type = _type
+    def __init__(self, health, damage=0):
         self.health = health
         self.damage = damage
 
-
-    def attack(self, character):
-        """
-        Deal damage to another character object
-        """
-        character.receive_damage(self.damage)
-        # print("Die")
-
-    def receive_damage(self, damage):
+    def receive_damage(self, damage: int) -> None:
         """
         Remove health
         """
         self.health -= damage
         # print("Ouch")
 
-    def isdead(self):
+    def isdead(self) -> bool:
         """
         Returns status of character (dead or alive)
         """
         return self.health <= 0
 
-    def get_health(self):
+    def get_health(self) -> int:
         return self.health
 
-    def get_type(self):
-        return self._type
+    def get_type(self) -> str:
+        raise NotImplementedError
 
-class Player(Character):
 
-    def __init__(self, health, damage):
-        super().__init__("Player", health, damage)
+class Player(Character):
+    def get_type(self) -> str:
+        return "Player"
 
 
 class Soldier(Character):
+    def get_type(self) -> str:
+        return "Soldier"
 
-    def __init__(self, health):
-        super().__init__("Soldier", health)
-        self.damage = random.randint(2,7)
 
 class Princess(Character):
-
-    def __init__(self, health):
-        super().__init__("Princess", health)
+    def get_type(self) -> str:
+        return "Princess"

ctps.py

@@ -1,74 +1,77 @@
-import data, interface, battle
+import data
+import interface
+import battle
+
 
 class Game:
+
     def __init__(self):
-        self.interface = None #
         self.player = None
         self.princess = None
         self.rooms = []
         self.now = 0
 
     def setup(self):
-        self.interface = interface.Interface() #
         self.player = data.createPlayer()
         self.rooms = data.createRooms()
         self.princess = self.rooms[-1].get_enemies()[-1]
-        if self.interface.start_menu() == 'exit': #if interface.start_menu() == 'exit':
-            self.interface.exit_screen() #interface.exit_screen()
-            exit()
-
-    def isover(self):
+
+    def isover(self) -> bool:
+        if not self.player or not self.princess:
+            # Game has not been set up
+            return False
+        return self.player.isdead() or self.princess.isdead()
+
+    def end_game(self) -> None:
+        if not self.player or not self.princess:
+            # Game has not been set up
+            return
         if self.player.isdead():
-            self.interface.death_msg() #interface.death_msg()
-            return True
+            pass  # death msg already displayed in battle
         elif self.princess.isdead():
             if all([room.all_enemies_defeated() for room in self.rooms]):
-                self.interface.win_msg() #interface.win_msg()
+                interface.win_msg()
             else:
-                self.interface.caught_msg() #interface.caught_msg()
-            return True
-        return False
+                interface.caught_msg()
 
     def next_room(self):
         if self.now < len(self.rooms) - 1:
             self.now += 1
-            
+
     def prev_room(self):
         if self.now > 0:
             self.now -= 1
-    
+
     def get_now_room(self):
         return self.rooms[self.now]
 
     def get_now_room_name(self):
         return self.rooms[self.now].get_name()
-        
+
     def get_next_room_name(self):
         if self.now < len(self.rooms) - 1:
             return self.rooms[self.now + 1].get_name()
         else:
             return "WALL"
-    
+
     def get_prev_room_name(self):
         if self.now - 1 >= 0:
             return self.rooms[self.now - 1].get_name()
         else:
             return "WALL"
 
-    def get_choice(self):
-        "Dispalys and gets player choice. Display results afterwards"
-        choice = eval(f"self.interface.{self.get_now_room_name().lower()}_menu()") #choice = eval(f"interface.{self.get_now_room_name().lower()}_menu()")
-        print(choice+'\n')
+    def get_choice(self) -> str:
+        """Prompts player to make a choice."""
+        room_name = self.get_now_room_name().lower()
+        choice = interface.prompt_menu(room_name)
+        return choice
+
+    def do_choice(self, choice: str) -> None:
+        print("Your choice:", choice)
         if choice == 'Move to next room':
             self.next_room()
         elif choice == 'Move to previous room':
             self.prev_room()
         elif choice == 'Look around':
-
             combat = battle.Battle(self.player, self.get_now_room())
             combat.battle_start()
-
-        else:
-            print("Invalid choice")
-        print()
-

data.py

@@ -1,44 +1,38 @@
+import json
+import random
+
 import room
 import character
-import json
+
+with open('gamedata.json', 'r') as f:
+    gamedata = json.load(f)
 
 
 def createRooms() -> list[room.Room]:
-    """
-    Must follow order of room: Dungeon, Kitchen, Hall, Toilet, Bedroom
+    """Must follow order of room: Dungeon, Kitchen, Hall, Toilet, Bedroom
     Store Name & Number of enemies
     """
 
     list_of_rooms = []
-    room_name_enemy_num = {
-        "Dungeon": 3,
-        "Kitchen": 3,
-        "Hall": 3,
-        "Toilet": 3,
-        "Bedroom": 3
-    }
-    for name, num in room_name_enemy_num.items():
+    for name, roomdata in gamedata["room"].items():
+        # breakpoint()
         temp = room.Room(name)
-        for _ in range(num):
-            temp.add_enemy(character.Soldier(20))
+        for _ in range(roomdata["num_enemies"]):
+            temp.add_enemy(createSoldier())
         list_of_rooms.append(temp)
     temp.add_enemy(character.Princess(1))
 
     return list_of_rooms
 
-
-with open('data.json', 'r') as f:
-    char_data = json.load(f)
-
-
 def createPlayer() -> character.Player:
-    """
-
-    """
-    record = char_data["player"]
+    record = gamedata["player"]
     return character.Player(record["hp"], record["str"])
 
-
 def createPrincess() -> character.Princess:
-    record = char_data["princess"]
-    return character.Princess(record["hp"])
+    record = gamedata["princess"]
+    return character.Princess(record["hp"])
+
+def createSoldier() -> character.Soldier:
+    record = gamedata["soldier"]
+    min_str, max_str = record["str"]
+    return character.Soldier(record["hp"], random.randint(min_str, max_str))

gamedata.json

@@ -0,0 +1,22 @@
+{
+    "player": {
+        "hp": 300,
+        "str": 5,
+        "items": []
+    },
+    "princess": {
+        "hp": 20,
+        "str": 0
+    },
+    "soldier": {
+        "hp": 20,
+        "str": [2, 7]
+    },
+    "room": {
+        "Dungeon": {"num_enemies": 3},
+        "Kitchen": {"num_enemies": 3},
+        "Hall": {"num_enemies": 3},
+        "Toilet": {"num_enemies": 3},
+        "Bedroom": {"num_enemies": 3}
+    }
+}