Saving game state to the database

dnd-bot/dnd_bot/database/database_connection.py

@@ -1,5 +1,7 @@
 import os
-from psycopg2 import connect, ProgrammingError
+from sqlite3 import ProgrammingError
+
+from psycopg2 import connect
 
 
 class DatabaseConnection:
@@ -58,126 +60,41 @@ def execute_query(query: str):
         DatabaseConnection.connection.commit()
 
     @staticmethod
-    def add_game(token: str, id_host: int, game_state: str, campaign_name: str) -> int | None:
-        """start game and add game to database
-        :param token: lobby/game token (5 digit password)
-        :param id_host: discord id of host
-        :param game_state: string enum, initial value of added game is 'LOBBY'
-        :param campaign_name: campaign  name
-        :return:
-            on success: game id, on failure: None
-        """
-
-        DatabaseConnection.cursor.execute('INSERT INTO public."Game" (token, id_host, game_state, campaign_name) VALUES '
-                                          '(%s, %s, %s, %s)',
-                                          (token, id_host, game_state, campaign_name))
+    def add_to_db(query: str = "", parameters: tuple = None, element_name: str = "element") -> int | None:
+        DatabaseConnection.cursor.execute(query, parameters)
         DatabaseConnection.cursor.execute('SELECT LASTVAL()')
 
         try:
-            game_id = DatabaseConnection.cursor.fetchone()[0]
+            id = DatabaseConnection.cursor.fetchone()[0]
         except ProgrammingError as err:
-            print(f"db: error adding game {err}")
+            print(f"db: error adding {element_name} {err}")
             return None
 
         DatabaseConnection.connection.commit()
-        return game_id
-
-    @staticmethod
-    def start_game(id_game: int) -> None:
-        """starts game
-        :param id_game: database game id
-        """
-        DatabaseConnection.cursor.execute('UPDATE public."Game" SET game_state=(%s) WHERE id_game = (%s)',
-                                          ('ACTIVE', id_game))
-
-        DatabaseConnection.connection.commit()
+        return id
 
     @staticmethod
-    def add_user(id_game: int, discord_id: int) -> int | None:
-        """add user to a game
-        :param id_game: database game id
-        :param discord_id: user discord id
-        """
-
-        DatabaseConnection.cursor.execute('INSERT INTO public."User" (id_game, discord_id) VALUES (%s, %s)',
-                                          (id_game, discord_id))
-        DatabaseConnection.cursor.execute('SELECT LASTVAL()')
+    def get_object_from_db(query: str = '', parameters: tuple = None, element_name: str = '') -> tuple | None:
+        DatabaseConnection.cursor.execute(query, parameters)
+        obj = DatabaseConnection.cursor.fetchone()
 
-        try:
-            user_id = DatabaseConnection.cursor.fetchone()[0]
-        except ProgrammingError as err:
-            print(f"db: error adding user {err}")
+        if not obj:
+            print(f"db: error getting {element_name}")
             return None
 
         DatabaseConnection.connection.commit()
-        return user_id
+        return obj
 
     @staticmethod
-    def find_game_by_token(token: str) -> dict | None:
-        """find game by token/password
-        :param token: game token/password to find the game by
-        :return: on success: dictionary containing game data - it's keys: 'id game' - database game id, 'token' - game token, 'id_host' -
-        discord host id, 'id_campaign' - campaign id, 'game_state' - string enum, 'players' - list of players
-        """
-
-        DatabaseConnection.cursor.execute(f'SELECT * FROM public."Game" WHERE token = %s AND game_state != %s',
-                                          (token, 'FINISHED'))
-        game_tuple = DatabaseConnection.cursor.fetchone()
+    def get_multiple_objects_from_db(query: str = '', parameters: tuple = None, element_name: str = '') -> list | None:
+        """returns list of tuples representing a db object"""
+        DatabaseConnection.cursor.execute(query, parameters)
+        objs = DatabaseConnection.cursor.fetchall()
 
-        if not game_tuple:
+        if not objs:
+            print(f"db: error getting multiple {element_name}")
             return None
 
-        DatabaseConnection.cursor.execute(f'SELECT * FROM public."User" WHERE id_game = {game_tuple[0]}')
-        users_tuples = DatabaseConnection.cursor.fetchall()
-
-        users = [{'id_user': user_tuple[0], 'id_game': user_tuple[1], 'discord_id': user_tuple[2]}
-                 for user_tuple in users_tuples]
-
-        return {'id_game': game_tuple[0], 'token': game_tuple[1], 'id_host': game_tuple[2],
-                'id_campaign': game_tuple[3],
-                'game_state': game_tuple[4], 'players': users}
-
-    @staticmethod
-    def update_game_state(id_game: int, game_state: str) -> None:
-        """updates game state on the one provided
-        """
-        DatabaseConnection.cursor.execute('UPDATE public."Game" SET game_state = (%s) WHERE id_game = (%s)',
-                                          (game_state, id_game))
-
-        DatabaseConnection.connection.commit()
-
-    @staticmethod
-    def get_all_game_tokens():
-        """returns all tokens currently existing in the database
-        """
-        DatabaseConnection.cursor.execute(f'SELECT token FROM public."Game"')
-        tokens = DatabaseConnection.cursor.fetchall()
-        DatabaseConnection.connection.commit()
-
-        return [x[0] for x in tokens]
-
-    @staticmethod
-    def get_id_game_from_game_token(token: str) -> int | None:
-        """returns database game id based on the token, None if the query fails
-        """
-        DatabaseConnection.cursor.execute(f'SELECT id_game FROM public."Game" WHERE token = (%s)', (token,))
-        game_id = DatabaseConnection.cursor.fetchone()
         DatabaseConnection.connection.commit()
+        return objs
 
-        if not game_id:
-            return None
-
-        return game_id
-
-    @staticmethod
-    def get_game_token_from_id_game(id_game: int) -> str | None:
-        """returns game token based on database game id, None if the query fails
-        """
-        DatabaseConnection.cursor.execute(f'SELECT token FROM public."Game" WHERE id_game = (%s)', (id_game,))
-        game_token = DatabaseConnection.cursor.fetchone()
-        DatabaseConnection.connection.commit()
-
-        if not game_token:
-            return None
-
-        return game_token

dnd-bot/dnd_bot/database/database_creature.py

@@ -0,0 +1,37 @@
+from dnd_bot.database.database_connection import DatabaseConnection
+from dnd_bot.database.database_entity import DatabaseEntity
+from dnd_bot.logic.prototype.creature import Creature
+
+
+class DatabaseCreature:
+
+    @staticmethod
+    def add_creature(x: int = 0, y: int = 0, sprite: str = '', name: str = 'Creature', hp: int = 0, strength: int = 0,
+                     dexterity: int = 0, intelligence: int = 0, charisma: int = 0, perception: int = 0,
+                     initiative: int = 0, action_points: int = 0, level: int = 0, drop_money: int = 0,
+                     id_game: int = 1) -> int | None:
+        id_entity = DatabaseEntity.add_entity(name=name, x=x, y=y, sprite=sprite, id_game=id_game)
+        id_creature = DatabaseConnection.add_to_db('INSERT INTO public."Creature" (level, "HP", strength, dexterity, '
+                                                   'intelligence, charisma, perception, initiative, action_points, '
+                                                   'money, id_entity) VALUES'
+                                                   '(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)',
+                                                   (
+                                                       level, hp, strength, dexterity, intelligence,
+                                                       charisma, perception,
+                                                       initiative, action_points, drop_money, id_entity),
+                                                   "creature")
+        return id_creature
+
+    @staticmethod
+    def update_creature(id_creature: int = 0, level: int = 0, hp: int = 0, strength: int = 0, dexterity: int = 0,
+                        intelligence: int = 0, perception: int = 0, initiative: int = 0, action_points: int = 0,
+                        money: int = 0) -> None:
+        pass
+
+    @staticmethod
+    def get_creature(id_creature: int = 0) -> dict | None:
+        pass
+
+    @staticmethod
+    def get_creature_items(id_creature) -> list | None:
+        pass

dnd-bot/dnd_bot/database/database_dialog.py

@@ -0,0 +1,17 @@
+class DatabaseDialog:
+
+    @staticmethod
+    def add_dialog(id_speaker: int = 0, id_listener: int = 0, content: str = "", status: str = "") -> int | None:
+        pass
+
+    @staticmethod
+    def update_dialog(id_dialog: int, status: str = "") -> None:
+        pass
+
+    @staticmethod
+    def get_dialog(id_dialog: int = 0) -> dict | None:
+        pass
+
+    @staticmethod
+    def get_all_dialogs() -> list | None:
+        pass

dnd-bot/dnd_bot/database/database_entity.py

@@ -0,0 +1,21 @@
+from dnd_bot.database.database_connection import DatabaseConnection
+
+
+class DatabaseEntity:
+
+    @staticmethod
+    def add_entity(name: str = "", x: int = 0, y: int = 0, sprite=None, id_game: int = 1) -> int | None:
+        return DatabaseConnection.add_to_db('INSERT INTO public."Entity" (name, x, y, sprite, id_game) VALUES'
+                                            '(%s, %s, %s, %s, %s)', (name, x, y, sprite, id_game), "entity")
+
+    @staticmethod
+    def update_entity(id_entity: int = 0, x: int = 0, y: int = 0) -> None:
+        pass
+
+    @staticmethod
+    def get_entity(id_entity: int) -> dict | None:
+        pass
+
+    @staticmethod
+    def get_entity_skills(id_entity: int = 0) -> list | None:
+        pass

dnd-bot/dnd_bot/database/database_equipment.py

@@ -0,0 +1,15 @@
+class DatabaseEquipment:
+
+    @staticmethod
+    def add_equipment(helmet: int = -1, chest: int = -1, leg_armor: int = -1, boots: int = -1, left_hand=-1,
+                      right_hand: int = -1, accessory: int = -1) -> int | None:
+        pass
+
+    @staticmethod
+    def update_equipment(id_equipment: int = 0, helmet: int = -1, chest: int = -1, leg_armor: int = -1, boots: int = -1,
+                         left_hand: int = -1, right_hand: int = -1, accessory: int = -1) -> None:
+        pass
+
+    @staticmethod
+    def get_equipment(id_equipment: int = 0) -> dict | None:
+        pass

dnd-bot/dnd_bot/database/database_event.py

@@ -0,0 +1,14 @@
+class DatabaseEvent:
+
+    @staticmethod
+    def add_event(x: int = 0, y: int = 0, range: int = 0, status: str = "", content: str = "",
+                  id_game: int = 0) -> int | None:
+        pass
+
+    @staticmethod
+    def get_event(id_event) -> dict | None:
+        pass
+
+    @staticmethod
+    def get_all_events() -> list | None:
+        pass

dnd-bot/dnd_bot/database/database_game.py

@@ -0,0 +1,97 @@
+from sqlite3 import ProgrammingError
+
+from dnd_bot.database.database_connection import DatabaseConnection
+
+
+class DatabaseGame:
+
+    @staticmethod
+    def add_game(token: str, id_host: int, game_state: str, campaign_name: str) -> int | None:
+        """start game and add game to database
+        :param token: lobby/game token (5 digit password)
+        :param id_host: discord id of host
+        :param game_state: string enum, initial value of added game is 'LOBBY'
+        :param campaign_name: campaign  name
+        :return:
+            on success: game id, on failure: None
+        """
+        return DatabaseConnection.add_to_db('INSERT INTO public."Game" (token, id_host, game_state, campaign_name)'
+                                            'VALUES (%s, %s, %s, %s)', (token, id_host, game_state, campaign_name),
+                                            "game")
+
+    @staticmethod
+    def start_game(id_game: int) -> None:
+        """starts game
+        :param id_game: database game id
+        """
+        DatabaseGame.update_game_state(id_game, 'ACTIVE')
+
+    @staticmethod
+    def update_game_state(id_game: int, game_state: str) -> None:
+        """updates game state on the one provided
+        """
+        DatabaseConnection.cursor.execute('UPDATE public."Game" SET game_state = (%s) WHERE id_game = (%s)',
+                                          (game_state, id_game))
+
+        DatabaseConnection.connection.commit()
+
+    @staticmethod
+    def get_all_game_tokens():
+        """returns all tokens currently existing in the database
+        """
+        DatabaseConnection.cursor.execute(f'SELECT token FROM public."Game"')
+        tokens = DatabaseConnection.cursor.fetchall()
+        DatabaseConnection.connection.commit()
+
+        return [x[0] for x in tokens]
+
+    @staticmethod
+    def get_id_game_from_game_token(token: str) -> int | None:
+        """returns database game id based on the token, None if the query fails
+        """
+        DatabaseConnection.cursor.execute(f'SELECT id_game FROM public."Game" WHERE token = (%s)', (token,))
+        game_id = DatabaseConnection.cursor.fetchone()
+        DatabaseConnection.connection.commit()
+
+        if not game_id:
+            return None
+
+        return game_id
+
+    @staticmethod
+    def get_game_token_from_id_game(id_game: int) -> str | None:
+        """returns game token based on database game id, None if the query fails
+        """
+        DatabaseConnection.cursor.execute(f'SELECT token FROM public."Game" WHERE id_game = (%s)', (id_game,))
+        game_token = DatabaseConnection.cursor.fetchone()
+        DatabaseConnection.connection.commit()
+
+        if not game_token:
+            return None
+
+        return game_token
+
+    @staticmethod
+    def find_game_by_token(token: str) -> dict | None:
+        """find game by token/password
+        :param token: game token/password to find the game by
+        :return: on success: dictionary containing game data - it's keys: 'id game' - database game id, 'token' - game token, 'id_host' -
+        discord host id, 'id_campaign' - campaign id, 'game_state' - string enum, 'players' - list of players
+        """
+
+        DatabaseConnection.cursor.execute(f'SELECT * FROM public."Game" WHERE token = %s AND game_state != %s',
+                                          (token, 'FINISHED'))
+        game_tuple = DatabaseConnection.cursor.fetchone()
+
+        if not game_tuple:
+            return None
+
+        DatabaseConnection.cursor.execute(f'SELECT * FROM public."User" WHERE id_game = {game_tuple[0]}')
+        users_tuples = DatabaseConnection.cursor.fetchall()
+
+        users = [{'id_user': user_tuple[0], 'id_game': user_tuple[1], 'discord_id': user_tuple[2]}
+                 for user_tuple in users_tuples]
+
+        return {'id_game': game_tuple[0], 'token': game_tuple[1], 'id_host': game_tuple[2],
+                'id_campaign': game_tuple[3],
+                'game_state': game_tuple[4], 'players': users}

dnd-bot/dnd_bot/database/database_item.py

@@ -0,0 +1,16 @@
+class DatabaseItem:
+
+    @staticmethod
+    def add_item(name: str = "", hp: int = 0, strength: int = 0, dexterity: int = 0, intelligence: int = 0,
+                 charisma: int = 0, perception: int = 0, action_points: int = 0, effect: str = "",
+                 base_price: int = 0) -> int | None:
+        pass
+
+    @staticmethod
+    def get_item(id_item) -> dict | None:
+        pass
+
+    @staticmethod
+    def add_creature_item(id_creature: int = 0, id_item: int = 0, amount: int = 0) -> None:
+        pass
+