def add_player(self, user_id, first_name, message_id, silent=False):
if self.game_running:
return
if self.get_player_by_id(user_id) is None and len(
self.players) < self.MAX_PLAYERS:
self.logger.debug("Adding user '" + first_name + "' to players.")
player = Player(user_id, first_name, join_id=message_id)
self.players.append(player)
if silent:
return
# TODO When game is multiplayer then print current players?
keyboard = [[
InlineKeyboardButton(text=translate("start_game",
self.lang_id),
callback_data="start_game")
]]
reply_markup = InlineKeyboardMarkup(keyboard)
self.send_message(self.chat_id,
translate("playerJoined",
self.lang_id).format(first_name),
message_id=message_id,
reply_markup=reply_markup,
game_id=self.__game_id)
else:
self.send_message(
self.chat_id,
translate("alreadyJoined", self.lang_id).format(first_name))
self.logger.debug(
"User '{}' already in player list. Or max players reached".
format(first_name))
def start_game(self, message_id: int = None) -> None:
if self.game_running:
self.send_message(self.chat_id,
translate("alreadyAGame", self.lang_id))
return
if ((self.game_type == self.GROUP_CHAT
or self.game_type == self.MULTIPLAYER_GAME) and
len(self.players) > 1) or self.game_type == self.PRIVATE_CHAT:
self.game_running = True
for player in self.players:
add_game_played(player.user_id)
if self.game_type == self.GROUP_CHAT or self.game_type == self.MULTIPLAYER_GAME:
self.send_message(
self.chat_id,
translate("gameBegins", self.lang_id) + "\n" +
translate("gameBegins2", self.lang_id) + "\n\n" +
self.get_player_overview(),
game_id=self.__game_id)
self.dealers_turn()
self.give_player_one()
else:
self.send_message(self.chat_id,
translate("notEnoughPlayers", self.lang_id),
message_id=message_id,
game_id=self.__game_id)
def comment_cmd(bot, update, args):
user_id = update.message.from_user.id
chat_id = update.message.chat_id
first_name = update.message.from_user.first_name
last_name = update.message.from_user.last_name
username = update.message.from_user.username
db = DBwrapper.get_instance()
lang_id = db.get_lang_id(user_id)
state_handler = StateHandler.get_instance()
user = state_handler.get_user(user_id)
if user.get_state() == UserState.IDLE:
if len(args) > 1:
text = " ".join(args)
logger.debug("New comment! {}!".format(user_id))
bot.sendMessage(chat_id=chat_id, text=translate("userComment", lang_id))
for admin_id in db.get_admins():
bot.sendMessage(admin_id,
"New comment:\n\n{}\n\n{} | {} | {} | @{} | {}".format(text, user_id, first_name,
last_name, username,
lang_id))
user.set_state(UserState.IDLE)
else:
# The user just wrote "/comment" -> Ask him to send a message
logger.debug("Add {} to comment_list!".format(user_id))
keyboard = [[InlineKeyboardButton(text=translate("cancel", lang_id), callback_data="cancel_comment")]]
reply_markup = InlineKeyboardMarkup(keyboard)
bot.sendMessage(chat_id=chat_id, text=translate("sendCommentNow", lang_id), reply_markup=reply_markup)
user.set_state(UserState.COMMENTING)
def __init__(self, lang_id):
self.deck = self.create_deck()
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)
]
def cancel_cmd(bot, update):
user_id = update.effective_user.id
message_id = update.effective_message.message_id
callback_query_id = update.callback_query.id
chat_id = update.effective_chat.id
state_handler = StateHandler.get_instance()
user = state_handler.get_user(user_id)
if user.get_state() == UserState.COMMENTING:
db = DBwrapper.get_instance()
lang_id = db.get_lang_id(user_id)
user.set_state(UserState.IDLE)
bot.editMessageText(chat_id=chat_id, message_id=message_id, text=translate("cancelledMessage", lang_id))
bot.answerCallbackQuery(callback_query_id=callback_query_id, text=translate("cancelledMessage", lang_id))
def change_language(bot, update, lang_id):
bot.editMessageText(chat_id=update.callback_query.message.chat_id,
text=translate("langChanged", lang_id),
message_id=update.callback_query.message.message_id,
reply_markup=None)
db = DBwrapper.get_instance()
db.insert("languageID", lang_id, update.callback_query.from_user.id)
def get_player_overview(self,
show_points: bool = False,
dealer: bool = False) -> str:
"""Return the overview of all players in a game room"""
text = ""
if not self.game_running:
return text
for counter, user in enumerate(self.players):
if counter == self.current_player:
text += "▶️"
else:
text += "👤"
if show_points is True and (counter < self.current_player
or self.current_player == -1):
text += "{} - [{}]\n".format(user.first_name, user.cardvalue)
else:
text += (user.first_name + "\n")
if dealer is True:
text += ("🎩" + translate("dealerName", self.lang_id) + " - [" +
str(self.dealer.cardvalue) + "]")
return text
def start(bot, update):
text = translate("welcomeMsg")
bot.sendMessage(chat_id=update.message.chat_id,
message_id=update.message.message_id,
text=text,
parse_mode=ParseMode.HTML)
deleteMessage(bot, update)
def getUserKeyboard():
db = DBwrapper.get_instance()
usedNumbers = [x[0] for x in db.get_used_numbers()]
allNumbers = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 39,
40, 41
]
availableNumbers = [x for x in allNumbers if x not in usedNumbers]
buttons = list()
for userNumber in availableNumbers:
buttons.append(
InlineKeyboardButton(text=str(userNumber).zfill(2),
callback_data=str(userNumber)))
lastRowButton = [
InlineKeyboardButton(text=translate("cancelMsg"),
callback_data="cancel")
]
reply_mrk = InlineKeyboardMarkup(build_menu(buttons,
n_cols=4,
footer_buttons=lastRowButton),
one_time_keyboard=True)
return reply_mrk
def answer(bot, update):
sender_id = update.message.from_user.id
reply_to_message = update.message.reply_to_message
text = str(update.message.text[8:])
db = DBwrapper.get_instance()
if reply_to_message is None:
bot.sendMessage(sender_id,
text="⚠ You need to reply to the user's comment!")
return
try:
last_line = reply_to_message.text.split("\n")
ll_list = last_line[-1].split(" | ")
user_id = ll_list[0]
except ValueError:
return
if not re.match("[0-9]+", user_id):
bot.sendMessage(
sender_id,
"⚠ The user_id is not valid. Are you sure you replied to a user comment?"
)
return
answer_text = "{}\n\n{}".format(
translate("answerFromDev", db.get_lang_id(user_id)), text)
bot.sendMessage(chat_id=user_id, text=answer_text)
bot.sendMessage(chat_id=sender_id, text="Message sent!")
def change_language(bot, update, lang_id):
logger.info("Language changed to '{}' for user {}".format(
lang_id, update.effective_user.id))
bot.editMessageText(chat_id=update.callback_query.message.chat_id,
text=translate("langChanged", lang_id),
message_id=update.callback_query.message.message_id,
reply_markup=None)
db = DBwrapper.get_instance()
db.insert("languageID", lang_id, update.callback_query.from_user.id)
def addUser(bot, update):
text = translate("registerMsg")
keyboard = keyboards.getUserKeyboard()
bot.sendMessage(chat_id=update.message.chat_id,
message_id=update.message.message_id,
text=text,
parse_mode=ParseMode.HTML,
reply_markup=keyboard)
deleteMessage(bot, update)
def next_player(self):
if self.game_running:
if (self.current_player + 1) < len(self.players):
self.logger.debug("Next Player!")
self.current_player += 1
self.send_message(
self.chat_id,
translate("overview", self.lang_id) + "\n\n" +
self.get_player_overview(show_points=True) + "\n" +
translate("nextPlayer", self.lang_id).format(
self.players[self.current_player].first_name),
message_id=self.join_message_ids[self.current_player],
reply_markup=self.keyboard_running)
self.give_player_one()
else:
self.logger.debug("Dealer's turn")
self.current_player = -1
self.dealers_turn()
def dealers_turn(self):
if self.dealer.get_number_of_cards() < 2:
for i in range(2):
card = self.deck.pick_one_card()
cardvalue = self.deck.get_card_value(card)
self.dealer.give_card(card, cardvalue)
text = ""
if self.game_type == self.PRIVATE_CHAT:
text += translate("gameBegins", self.lang_id) + "\n"
text += "\n*" + translate(
"dealersCards", self.lang_id
) + "*\n\n" + self.deck.get_card_name(card) + ", | -- |"
self.send_message(self.chat_id,
text,
parse_mode="Markdown",
reply_markup=self.keyboard_running)
else:
output_text = translate("croupierDrew", self.lang_id) + "\n\n"
while self.dealer.get_cardvalue() <= 16:
card = self.deck.pick_one_card()
cardvalue = self.deck.get_card_value(card)
self.dealer.give_card(card, cardvalue)
i = 0
for card in self.dealer.cards:
if i == 0:
output_text += self.deck.get_card_name(card)
else:
output_text += " , " + self.deck.get_card_name(card)
i += 1
output_text += "\n\n" + translate("cardvalueDealer",
self.lang_id) + " " + str(
self.dealer.get_cardvalue())
self.send_message(self.chat_id,
output_text,
parse_mode="Markdown",
reply_markup=self.keyboard_running)
self.evaluation()
def language(bot, update):
lang_de_button = InlineKeyboardButton(text="Deutsch \U0001F1E9\U0001F1EA", callback_data="ch_lang_de")
lang_en_button = InlineKeyboardButton(text="Englisch \U0001F1FA\U0001F1F8", callback_data="ch_lang_en")
lang_nl_button = InlineKeyboardButton(text="Nederlands \U0001F1F3\U0001F1F1", callback_data="ch_lang_nl")
lang_eo_button = InlineKeyboardButton(text="Esperanto \U0001F30D", callback_data="ch_lang_eo")
lang_br_button = InlineKeyboardButton(text="Português \U0001F1E7\U0001F1F7", callback_data="ch_lang_br")
lang_es_button = InlineKeyboardButton(text="Español \U0001F1EA\U0001F1F8", callback_data="ch_lang_es")
lang_ru_button = InlineKeyboardButton(text="Русский \U0001F1F7\U0001F1FA", callback_data="ch_lang_ru")
lang_fa_button = InlineKeyboardButton(text="فارسی \U0001F1EE\U0001F1F7", callback_data="ch_lang_fa")
lang_keyboard = InlineKeyboardMarkup([[lang_de_button, lang_en_button], [lang_br_button, lang_ru_button, lang_nl_button], [lang_es_button, lang_eo_button, lang_fa_button]])
db = DBwrapper.get_instance()
if update.callback_query:
# TODO maybe text user in private instead of group!
lang_id = db.get_lang_id(update.callback_query.from_user.id)
bot.editMessageText(chat_id=update.callback_query.message.chat_id, text=translate("langSelect", lang_id), reply_markup=lang_keyboard, message_id=update.callback_query.message.message_id)
else:
lang_id = db.get_lang_id(update.message.from_user.id)
bot.sendMessage(chat_id=update.message.chat_id, text=translate("langSelect", lang_id), reply_markup=lang_keyboard, message_id=update.message.message_id)
def addAlertToUserProfile(bot, update):
user = update.effective_user
text = translate("alertMsg").format(user.username)
keyboard = keyboards.getProfileKeyboard()
bot.sendMessage(chat_id=update.message.chat_id,
message_id=update.message.message_id,
text=text,
parse_mode=ParseMode.HTML,
reply_markup=keyboard)
deleteMessage(bot, update)
def __init__(self,
chat_id: int,
user_id: int,
lang_id: str,
first_name: str,
game_handler: object,
message_id: int,
send_message: callable,
multiplayer: bool = None,
game_id: str = None):
# declare variables and set initial values
self.players = []
self.chat_id = chat_id
self.__game_id = game_id
self.lang_id = lang_id
self.deck = CardDeck(lang_id)
# TODO language of the cards & dealer cannot be changed
# TODO especially with new multiplayer important!
self.dealer = Dealer(translate("dealerName", lang_id), self.deck)
self.game_running = False
self.current_player = 0
self.game_handler = game_handler
self.send_message = send_message
self.logger = logging.getLogger(__name__)
if multiplayer:
self.game_type = self.MULTIPLAYER_GAME
chat_id = 0
elif chat_id >= 0:
self.game_type = self.PRIVATE_CHAT
else:
self.game_type = self.GROUP_CHAT
one_more_button = KeyboardButton(
translate("keyboardItemOneMore", lang_id))
no_more_button = KeyboardButton(
translate("keyboardItemNoMore", lang_id))
stop_button = KeyboardButton(translate("keyboardItemStop", lang_id))
self.keyboard_running = ReplyKeyboardMarkup(
keyboard=[[one_more_button, no_more_button], [stop_button]],
selective=True)
self.add_player(user_id, first_name, message_id, silent=True)
# Only send a "Please join the game" message, when it's a group chat
if self.game_type == self.GROUP_CHAT:
keyboard = [[
InlineKeyboardButton(text=translate("join",
self.lang_id).capitalize(),
callback_data="join_game")
]]
reply_markup = InlineKeyboardMarkup(keyboard)
send_message(chat_id,
translate("newRound", lang_id),
message_id=message_id,
reply_markup=reply_markup)
elif self.game_type == self.MULTIPLAYER_GAME:
pass
else:
self.start_game()
def dealers_turn(self):
if self.dealer.get_number_of_cards() < 2:
card = None
for _ in range(2):
card = self.deck.pick_one_card()
self.dealer.give_card(card)
text = ""
if self.game_type == self.PRIVATE_CHAT:
text += translate("gameBegins", self.lang_id) + "\n"
text += "\n*{}*\n\n{}, | -- |".format(
translate("dealersCards", self.lang_id), str(card))
self.send_message(self.chat_id,
text,
parse_mode="Markdown",
reply_markup=self.keyboard_running)
else:
output_text = translate("croupierDrew", self.lang_id) + "\n\n"
while self.dealer.cardvalue <= 16:
card = self.deck.pick_one_card()
self.dealer.give_card(card)
i = 0
for card in self.dealer.cards:
if i == 0:
output_text += str(card)
else:
output_text += " , " + str(card)
i += 1
output_text += "\n\n{} {}".format(
translate("cardvalueDealer", self.lang_id),
self.dealer.cardvalue)
self.send_message(self.chat_id,
output_text,
parse_mode="Markdown",
reply_markup=ReplyKeyboardRemove())
self.evaluation()
def help_cmd(bot, update):
# Explains commands to user
db = DBwrapper.get_instance()
lang_id = db.get_lang_id(update.message.from_user.id)
start_description = translate("start_description", lang_id)
stop_description = translate("stop_description", lang_id)
help_description = translate("help_description", lang_id)
language_description = translate("language_description", lang_id)
stats_description = translate("stats_description", lang_id)
hide_description = translate("hide_description", lang_id)
text = "/start - {}\n" \
"/stop - {}\n" \
"/help - {}\n" \
"/language - {}\n" \
"/stats - {}\n" \
"/hide - {}" \
.format(start_description,
stop_description,
help_description,
language_description,
stats_description,
hide_description
)
update.message.reply_text(text)
def start_game(self, message_id=None):
if (self.game_type == self.GROUP_CHAT and
len(self.players) >= 2) or self.game_type == self.PRIVATE_CHAT:
if not self.game_running:
self.game_running = True
for player in self.players:
add_game_played(player.user_id)
if self.game_type == self.GROUP_CHAT:
self.send_message(
self.chat_id,
translate("gameBegins", self.lang_id) + "\n" +
translate("gameBegins2", self.lang_id) + "\n\n" +
self.get_player_overview())
self.dealers_turn()
self.give_player_one()
else:
self.send_message(self.chat_id,
translate("notEnoughPlayers", self.lang_id),
message_id=message_id)
def __init__(self, chat_id, user_id, lang_id, first_name, game_handler,
message_id, send_message):
# declare variables and set initial values
self.players = []
self.join_message_ids = []
self.chat_id = chat_id
self.lang_id = lang_id
self.deck = CardDeck(
lang_id) # TODO language of the cards & dealer cannot be changed
self.dealer = Dealer(translate("dealerName", lang_id), self.deck)
self.game_running = False
self.current_player = 0
self.game_handler = game_handler
self.send_message = send_message
self.logger = logging.getLogger(__name__)
if chat_id >= 0:
self.game_type = self.PRIVATE_CHAT
else:
self.game_type = self.GROUP_CHAT
one_more_button = KeyboardButton(
translate("keyboardItemOneMore", lang_id))
no_more_button = KeyboardButton(
translate("keyboardItemNoMore", lang_id))
stop_button = KeyboardButton(translate("keyboardItemStop", lang_id))
self.keyboard_running = ReplyKeyboardMarkup(
keyboard=[[one_more_button, no_more_button], [stop_button]],
selective=True)
self.add_player(user_id, first_name, message_id, silent=True)
# Only send a "Please join the game" message, when it's a group chat
if self.game_type == self.GROUP_CHAT:
send_message(
chat_id, translate("newRound", lang_id),
message_id=message_id) # keyboard=self.keyboard_not_running
else:
self.start_game()
def getRegisteredUsers(bot, update):
db = DBwrapper.get_instance()
userList = db.get_all_users()
header = translate("userListMsg1")
footer = translate("userListMsg3")
formatedUserList = []
for user in userList:
formatedUserList.append(
translate("userListMsg2").format(f'{user[5]:02}', user[4]))
finalString = header + "\n\n"
finalString += '\n'.join(formatedUserList)
finalString += "\n\n" + footer
bot.sendMessage(
chat_id=update.message.chat_id,
message_id=update.message.message_id,
text=finalString,
parse_mode=ParseMode.HTML,
)
deleteMessage(bot, update)
def getProfileKeyboard():
stringList = [
translate("alertMsg1"),
translate("alertMsg2"),
translate("alertMsg3"),
translate("alertMsg4")
]
buttons = list()
for index, value in enumerate(stringList):
buttons.append(InlineKeyboardButton(text=value, callback_data=index))
lastRowButton = [
InlineKeyboardButton(text=translate("cancelMsg"),
callback_data="cancel")
]
reply_mrk = InlineKeyboardMarkup(build_menu(buttons,
n_cols=1,
footer_buttons=lastRowButton),
one_time_keyboard=True)
return reply_mrk
def game_commands(bot, update):
if update.message is None:
logger.warning(
"game_commands error happened again! Update: {}".format(update))
text = update.effective_message.text
chat_id = update.effective_message.chat_id
user = update.effective_user
user_id = user.id
first_name = user.first_name
last_name = user.last_name
username = user.username
db = DBwrapper.get_instance()
lang_id = db.get_lang_id(user_id)
state_handler = StateHandler.get_instance()
user = state_handler.get_user(user_id)
if user.get_state() == UserState.COMMENTING:
# User wants to comment!
bot.sendMessage(chat_id, text=translate("userComment", lang_id))
for admin_id in db.get_admins():
admin_message = "New comment:\n\n{}\n\n{} | {} | {} | @{} | {}".format(
text, user_id, first_name, last_name, username, lang_id)
bot.sendMessage(admin_id, text=admin_message)
user.set_state(UserState.IDLE)
return
if not db.is_user_saved(user_id):
logger.info("New user - {}".format(user_id))
db.add_user(user_id, "en", first_name, last_name, username)
if chat_id > 0:
# ask user for language if it's a private chat:
language_cmd(bot, update)
return
# check if user already has got a game (in the same chat):
# TODO multiplayer games
game = game_handler.get_game_by_chatid(chat_id)
if game is not None:
logger.debug(
"Game already existing. Forwarding text '{}' to game".format(text))
game.analyze_message(update)
def add_player(self, user_id, first_name, message_id, silent=None):
if not self.game_running:
if self.get_index_by_user_id(user_id) == -1 and len(
self.players) <= self.MAX_PLAYERS:
self.logger.debug("Adding user '" + first_name +
"' to players.")
player = Player(user_id, first_name, self.deck)
self.players.append(player)
self.join_message_ids.append(message_id)
if silent is None or silent is False:
self.send_message(
self.chat_id,
translate("playerJoined",
self.lang_id).format(first_name),
message_id=message_id)
else:
self.logger.debug("User '" + first_name +
"' already in player list.")
def analyze_message(self, update):
"""Commands for a game are forwarded to the specific game's 'analyze_message' method"""
text = update.message.text
user_id = update.message.from_user.id
first_name = update.message.from_user.first_name
message_id = update.message.message_id
# Remove leading slash from command
if text.startswith("/"):
command = str(text[1:]).lower()
else:
command = text.lower()
# TODO following "or self.game_type == self.MULTIPLAYER_GAME" is not neccessary
if self.game_type == self.GROUP_CHAT or self.game_type == self.MULTIPLAYER_GAME:
if command.startswith(translate("join", self.lang_id)):
self.add_player(user_id, first_name, message_id)
elif command.startswith(translate("startCmd", self.lang_id)):
self.start_game()
if self.game_running:
if command.startswith(translate("oneMore", self.lang_id)):
if self.current_player is None or self.current_player < 0:
return
if user_id == self.players[self.current_player].user_id:
self.give_player_one()
else:
self.send_message(
self.chat_id,
translate("notYourTurn",
self.lang_id).format(first_name),
game_id=self.__game_id)
elif command.startswith(translate("noMore", self.lang_id)):
if self.current_player is None or self.current_player < 0:
return
if user_id == self.players[self.current_player].user_id:
self.logger.debug("User doesn't want another card")
self.next_player()
elif command.startswith(translate("stopCmd", self.lang_id)):
if user_id == self.players[0].user_id:
self.send_message(self.chat_id,
translate("gameEnded", self.lang_id),
game_id=self.__game_id)
self.game_handler.gl_remove(self.chat_id)
def showUserProfile(bot, update):
query = update.callback_query
if query.data == "cancel":
deleteMessage(bot, update)
else:
user = query.from_user
try:
db = DBwrapper.get_instance()
userProfiles = db.get_user_profile()
except Exception as ex:
logger.error(
"showUserProfile - An error has occurred while getting an user profile!",
ex)
else:
text = translate("registryConfirmationMsg")
bot.edit_message_text(text=text.format(user.username, query.data),
parse_mode=ParseMode.HTML,
chat_id=query.message.chat_id,
message_id=query.message.message_id)
def saveAlertToUserProfile(bot, update):
query = update.callback_query
if query.data == "cancel":
deleteMessage(bot, update)
else:
user = query.from_user
try:
db = DBwrapper.get_instance()
db.add_user_profile(user.id, query.data)
except Exception as ex:
logger.error(
"saveAlertToUserProfile - An error has occurred while saving a profile!",
ex)
else:
text = translate("alertConfirmationMsg").fomat(user.username)
bot.edit_message_text(text=text,
parse_mode=ParseMode.HTML,
chat_id=query.message.chat_id,
message_id=query.message.message_id)
def confirmNewUser(bot, update):
query = update.callback_query
if query.data == "cancel":
deleteMessage(bot, update)
else:
user = query.from_user
try:
db = DBwrapper.get_instance()
db.add_user(user.id, user.first_name, user.last_name,
user.username, query.data, user.language_code)
except Exception as ex:
logger.error(
"confirmNewUser - An error has occurred while adding an user!",
ex)
else:
text = translate("registryConfirmationMsg").format(
user.username, query.data)
bot.edit_message_text(text=text,
parse_mode=ParseMode.HTML,
chat_id=query.message.chat_id,
message_id=query.message.message_id)
def get_player_overview(self,
show_points=False,
text="",
i=0,
dealer=False):
if self.game_running:
for user in self.players:
if i == self.current_player:
text += "▶️"
else:
text += "👤"
if show_points is True and (i < self.current_player
or self.current_player == -1):
text += (user.first_name + " - [" +
str(self.players[i].cardvalue) + "]\n")
else:
text += (user.first_name + "\n")
i += 1
if dealer is True:
text += ("🎩" + translate("dealerName", self.lang_id) + " - [" +
str(self.dealer.get_cardvalue()) + "]")
return text
else:
return ""
