Merge pull request #57 from d-Rickyy-b/dev

Add new features and fixes

Author: devcarron

README.md

@@ -4,8 +4,8 @@
 
 This is the code for my Telegram Bot with which you can play the game Black Jack. You can find it here: https://telegram.me/BlackJackBot
 
-The main file, which needs to be executed is "main.py".
-You need to put your API-Token in the right place.
+The main file, which needs to be executed is 'main.py'.
+You need to put your API-Token in the right place in the main file.
 
 ## Other Software
 
@@ -15,10 +15,4 @@ The bot uses the [python-telegram-bot](https://python-telegram-bot.org/) framewo
 
 ## Database
 
-The bot uses a SQLite database. The database file is in the "database" directory. It is called 'users.db'.
-
-To set up the database, you need two tables:
-
-1) ```CREATE TABLE 'admins' ('userID'	INTEGER NOT NULL,	'first_name'	TEXT,	'username'	TEXT,	PRIMARY KEY('userID'));```
-
-2) ```CREATE TABLE 'users' ('userID'	INTEGER NOT NULL,	'languageID'	TEXT,	'first_name'	TEXT,	'last_name'	TEXT,	'username'	TEXT, 'gamesPlayed'	INTEGER,	'gamesWon'	INTEGER,	'gamesTie'	INTEGER,	'lastPlayed'	INTEGER,	PRIMARY KEY('userID'));```
+The bot uses a SQLite database. The database file is in the "database" directory. It is called 'users.db'. The database gets auto-generated, if it doesn't exist. Make sure the program has write access to the database directory.

database/db_wrapper.py

@@ -17,14 +17,15 @@ def __init__(self):
                 print("File '" + database_path + "' does not exist! Trying to create one.")
                 try:
                     self.create_database(database_path)
-                except:
+                except Exception:
                     print("An error has occurred while creating the database!")
 
             self.connection = sqlite3.connect(database_path)
             self.connection.text_factory = lambda x: str(x, 'utf-8', "ignore")
             self.cursor = self.connection.cursor()
 
-        def create_database(self, database_path: str) -> None:
+        @staticmethod
+        def create_database(database_path: str) -> None:
             # Create database file and add admin and users table to the database
             open(database_path, 'a').close()
 
@@ -62,16 +63,20 @@ def get_user(self, user_id: int) -> tuple:
                 return ()
 
         def get_recent_players(self):
-            oneDayInSecs = 60 * 60 * 24
-            currentTime = int(time())
-            self.cursor.execute("SELECT userID FROM users WHERE lastPlayed>=?;", [currentTime - oneDayInSecs])
+            one_day_in_secs = 60 * 60 * 24
+            current_time = int(time())
+            self.cursor.execute("SELECT userID FROM users WHERE lastPlayed>=?;", [current_time - one_day_in_secs])
 
             return self.cursor.fetchall()
 
         def get_played_games(self, user_id: int) -> int:
             self.cursor.execute("SELECT gamesPlayed FROM users WHERE userID=?;", [str(user_id)])
 
             result = self.cursor.fetchone()
+
+            if not result:
+                return 0
+
             if len(result) > 0:
                 return int(result[0])
             else:

game/blackJack.py game/blackJackGame.pygame/blackJack.py renamed to game/blackJackGame.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+
+class Card(object):
+    symbols = ["♥", "♦", "♣", "♠"]
+    value_int = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]
+
+    @property
+    def symbol(self):
+        return self.symbols[self.card_id // 13]
+
+    @property
+    def value(self):
+        return self.value_int[self.card_id % 13]
+
+    @property
+    def face(self):
+        return self.value_str[self.card_id % 13]
+
+    def __str__(self):
+        return "|{} {}|".format(self.symbol, self.face)
+
+    def __init__(self, card_id: int, value_str: list) -> None:
+        self.card_id = card_id
+        self.value_str = value_str

game/card.py

@@ -1,35 +1,28 @@
 # -*- coding: utf-8 -*-
 
+from random import shuffle
+
+from game.card import Card
 from lang.language import translate
 
 __author__ = 'Rico'
 
 
 class CardDeck(object):
-    symbols = ["♥", "♦", "♣", "♠"]
-    valueInt = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]
-
     def create_deck(self) -> list:
-        from random import shuffle
-        deck = list(range(1, 52))
-        shuffle(deck)
-        return deck[:]
+        deck = []
 
-    def pick_one_card(self) -> int:
-        card = self.deck[0]
-        self.deck.pop(0)
-        return card
+        for card_id in range(1, 52):
+            deck.append(Card(card_id, self.value_str))
 
-    def get_card_name(self, card: int) -> str:
-        symbol = self.symbols[card // 13]
-        value = self.value_str[card % 13]
-        card_name = "|" + symbol + " " + value + "|"
-        return card_name
+        shuffle(deck)
+        return deck[:]
 
-    def get_card_value(self, card: int) -> int:
-        return self.valueInt[card % 13]
+    def pick_one_card(self) -> Card:
+        return self.deck.pop(0)
 
     def __init__(self, lang_id: str) -> None:
-        self.deck = self.create_deck()
+        self.lang_id = lang_id
         self.value_str = [translate("ace", lang_id), "2", "3", "4", "5", "6", "7", "8", "9", "10",
                           translate("jack", lang_id), translate("queen", lang_id), translate("king", lang_id)]
+        self.deck = self.create_deck()

game/deck.py

@@ -1,51 +1,50 @@
 # -*- coding: utf-8 -*-
 
+from game.card import Card
+
 __author__ = 'Rico'
 
 
 class Player(object):
-    def give_card(self, card, value):
+    def give_card(self, card: Card):
         self.cards.append(card)
 
-        if value == 1 and self.cardvalue <= 10:
-            value = 11
+        if card.value == 11 and self.__cardvalue <= 10:
             self.give_ace()
+        elif card.value == 11 and (self.__cardvalue + 11) > 21:
+            self.__cardvalue += 1
+            return
 
-        self.cardvalue += value
-        self.number_of_cards += 1
+        self.__cardvalue += card.value
 
     def give_ace(self):
         self.has_ace = True
 
     def remove_ace(self):
         self.has_ace = False
-        self.cardvalue -= 10
-
-    def has21(self):
-        return self.cardvalue == 21
-
-    def has_busted(self):
-        return self.cardvalue > 21
+        self.__cardvalue -= 10
 
     def has_cards(self):
         return len(self.cards) > 0
 
     def get_cards_string(self):
         cards_string = ""
         for i, card in enumerate(self.cards):
-            cards_string += self.deck.get_card_name(card)
+            cards_string += str(card)
             if i + 1 < len(self.cards):
                 cards_string += ", "
         return cards_string
 
     def get_number_of_cards(self):
-        return self.number_of_cards
+        return len(self.cards)
 
-    def get_first_name(self):
-        return self.first_name
+    @property
+    def cardvalue(self):
+        return self.__cardvalue
 
-    def get_cardvalue(self):
-        return self.cardvalue
+    @property
+    def first_name(self):
+        return self.__first_name
 
     @property
     def user_id(self):
@@ -55,16 +54,15 @@ def user_id(self):
     def join_id(self):
         return self.__join_id
 
-    def get_lang_id(self):
-        return self.lang_id
+    @property
+    def lang_id(self):
+        return self.__lang_id
 
-    def __init__(self, user_id, first_name, deck, join_id, lang_id="en"):
+    def __init__(self, user_id, first_name, join_id, lang_id="en"):
         self.__user_id = user_id
-        self.first_name = first_name
+        self.__first_name = first_name
         self.__join_id = join_id
-        self.lang_id = lang_id
-        self.deck = deck
-        self.number_of_cards = 0
-        self.cardvalue = 0
+        self.__lang_id = lang_id
+        self.__cardvalue = 0
         self.has_ace = False
         self.cards = []

game/player.py

@@ -2,71 +2,88 @@
 
 import random
 import string
+from typing import Optional
+
+from game.blackJackGame import BlackJackGame
 
 __author__ = 'Rico'
 
 
-# game_handler handles the blackJack-game-objects. When a new object is created, it is saved in "GameList"
-# get_index_by_chatid returns the index of a running game in the list
+# game_handler handles the blackJack-game-objects. When a new game is created, it is saved in the "game_list"
 class GameHandler(object):
-    GameList = []  # List, where the running Games are stored in
-
-    def gl_create(self):
-        self.GameList = []
-
-    def gl_remove(self, chat_id):
-        index = self.get_index_by_chatid(chat_id)
-        if index is None:
-            return
-        if not index < 0:
-            self.GameList.pop(index)
-
-    def add_game(self, blackjackgame):
-        self.GameList.append(blackjackgame)
-
-    def get_index_by_chatid(self, chat_id):
-        for index, game in enumerate(self.GameList):
-            if game.chat_id == chat_id:
-                return index
-            else:
-                for player in game.players:
-                    if player.user_id == chat_id:
-                        return index
-
-        return None
-
-    def get_game_by_chatid(self, chat_id):
-        index = self.get_index_by_chatid(chat_id)
-        if index is None:
+    class __GameHandler(object):
+        def __init__(self):
+            self.game_list = []  # List, where the running Games are stored in
+            pass
+
+        def gl_create(self) -> None:
+            self.game_list = []
+
+        def gl_remove(self, chat_id: int) -> None:
+            index = self.get_index_by_chatid(chat_id)
+            if index is None:
+                return
+            if not index < 0:
+                self.game_list.pop(index)
+
+        def get_index_by_chatid(self, chat_id: int) -> Optional[int]:
+            for index, game in enumerate(self.game_list):
+                if game.chat_id == chat_id:
+                    return index
+                else:
+                    for player in game.players:
+                        if player.user_id == chat_id:
+                            return index
+
             return None
-        return self.GameList[index]
 
-    def get_game_by_index(self, index):
-        return self.GameList[index]
+        def add_game(self, blackjackgame: BlackJackGame) -> None:
+            self.game_list.append(blackjackgame)
 
-    def get_game_by_id(self, game_id):
-        if game_id is None:
-            return None
-        for game in self.GameList:
-            if game.get_game_id() == game_id:
-                return game
-        return None
+        def get_game_by_chatid(self, chat_id: int) -> Optional[BlackJackGame]:
+            index = self.get_index_by_chatid(chat_id)
+            if index is None:
+                return None
+            return self.game_list[index]
 
-    def generate_id(self):
-        game_id = ''.join(random.choice(string.digits + string.ascii_letters) for _ in range(8))
+        def get_game_by_index(self, index: int) -> BlackJackGame:
+            return self.game_list[index]
+
+        def get_game_by_id(self, game_id: int) -> Optional[BlackJackGame]:
+            if game_id is None:
+                return None
+            for game in self.game_list:
+                if game.game_id == game_id:
+                    return game
+            return None
 
-        while self.id_already_existing(game_id):
-            print("ID already existing: " + str(game_id))
+        def generate_id(self) -> str:
+            """Generates a random ID for a game"""
             game_id = ''.join(random.choice(string.digits + string.ascii_letters) for _ in range(8))
 
-        return game_id
+            while self.id_already_existing(game_id):
+                print("ID already existing: " + str(game_id))
+                game_id = ''.join(random.choice(string.digits + string.ascii_letters) for _ in range(8))
 
-    def id_already_existing(self, game_id):
-        for game in self.GameList:
-            if game.get_game_id() == game_id:
-                return True
+            return game_id
 
-        return False
+        def id_already_existing(self, game_id: str) -> bool:
+            """Checks if an ID is already existing in the list of games"""
+            for game in self.game_list:
+                if game.game_id == game_id:
+                    return True
+
+            return False
+
+    instance = None
 
     def __init__(self):
-        self.GameList = []
+        if not GameHandler.instance:
+            GameHandler.instance = GameHandler.__GameHandler()
+
+    @staticmethod
+    def get_instance() -> __GameHandler:
+        if not GameHandler.instance:
+            GameHandler.instance = GameHandler.__GameHandler()
+
+        return GameHandler.instance

gamehandler.py

@@ -14,10 +14,22 @@
 
 # translate returns the translation for a specific string
 def translate(string: str, language: str) -> str:
+    """Returns the translation in a specific language for a specific string"""
     if language in translations and string in translations[language]:
         return translations[language][string]
     elif language == "br":
         return translations["pt_BR"][string]
     elif "en" in translations and string in translations["en"]:
         return translations["en"][string]
     return string
+
+
+def translate_all(string: str) -> set:
+    """Returns all the translations of a specific string"""
+    strings = []
+    lang_list = ["de", "en", "nl", "eo", "br", "es", "ru", "fa"]
+
+    for lang in lang_list:
+        strings.append(translate(string, lang))
+
+    return set(strings)