Added gamemodes. New mode: Fast. (#44)

* Changes for possible bug

* New sanic mode wip

* More changes for fast mode, WIP

* Fast mode is playable (code is ugly tho)

* Fixed skip error

* Fixed fast mode error

* Bug fixing

* Possible fix for the /leave bug before the game starts

* Update README to include Codacy badge

* Fixing error prone code

* Removing code smells

* Removing more code smells

* How long can this go on? (More smells according to Codacy)

* Compile locale fixed for Linux. Small es_ES fix.

* Major refactoring

* Wild mode finished. Changed emojis for text in log.

* Removing test prints, back to emojis

* Code cleaning and fix for player time in fast mode

* Changing help to not override builtin function

* Decreased bot.py's complexity

* Default gamemode is now Fast. Added a bot configuration file

* back to random

* Moved logger to shared_vars

* Added MIN_FAST_TURN_TIME to config and fixed 'skipped 4 times' message

* Pull review changes

* More review changes

* Removing codacy badge linked to my account for pull request

* Fixed first special card issue, logger back to how it was (with just one logging init)

* Renamed gameplay config file to gameplay_config.py.
This commit is contained in:
Jarv 2017-11-27 17:59:19 +01:00 committed by Jannes Höke
parent 9a652011db
commit ea881cf520
19 changed files with 472 additions and 247 deletions

View file

@ -16,6 +16,8 @@ To run the bot yourself, you will need:
- Use `/setinline` and `/setinlinefeedback` with BotFather for your bot. - Use `/setinline` and `/setinlinefeedback` with BotFather for your bot.
- Install requirements (using a `virtualenv` is recommended): `pip install -r requirements.txt` - Install requirements (using a `virtualenv` is recommended): `pip install -r requirements.txt`
You can change some gameplay parameters like turn times, minimum amount of players and default gamemode in `gameplay_config.py`. Check the gamemodes available with the `/modes` command.
Then run the bot with `python3 bot.py`. Then run the bot with `python3 bot.py`.
Code documentation is minimal but there. Code documentation is minimal but there.

219
actions.py Normal file
View file

@ -0,0 +1,219 @@
import random
import logging
import card as c
from datetime import datetime
from telegram import Message, Chat
from gameplay_config import TIME_REMOVAL_AFTER_SKIP, MIN_FAST_TURN_TIME
from errors import DeckEmptyError, NotEnoughPlayersError
from internationalization import __, _
from shared_vars import gm, botan
from user_setting import UserSetting
from utils import send_async, display_name, game_is_running
logger = logging.getLogger(__name__)
class Countdown(object):
player = None
job_queue = None
def __init__(self, player, job_queue):
self.player = player
self.job_queue = job_queue
# TODO do_skip() could get executed in another thread (it can be a job), so it looks like it can't use game.translate?
def do_skip(bot, player, job_queue=None):
game = player.game
chat = game.chat
skipped_player = game.current_player
next_player = game.current_player.next
if skipped_player.waiting_time > 0:
skipped_player.anti_cheat += 1
skipped_player.waiting_time -= TIME_REMOVAL_AFTER_SKIP
if (skipped_player.waiting_time < 0):
skipped_player.waiting_time = 0
try:
skipped_player.draw()
except DeckEmptyError:
pass
n = skipped_player.waiting_time
send_async(bot, chat.id,
text="Waiting time to skip this player has "
"been reduced to {time} seconds.\n"
"Next player: {name}"
.format(time=n,
name=display_name(next_player.user))
)
logger.info("{player} was skipped!. "
.format(player=display_name(player.user)))
game.turn()
if job_queue:
start_player_countdown(bot, game, job_queue)
else:
try:
gm.leave_game(skipped_player.user, chat)
send_async(bot, chat.id,
text="{name1} ran out of time "
"and has been removed from the game!\n"
"Next player: {name2}"
.format(name1=display_name(skipped_player.user),
name2=display_name(next_player.user)))
logger.info("{player} was skipped!. "
.format(player=display_name(player.user)))
if job_queue:
start_player_countdown(bot, game, job_queue)
except NotEnoughPlayersError:
send_async(bot, chat.id,
text="{name} ran out of time "
"and has been removed from the game!\n"
"The game ended."
.format(name=display_name(skipped_player.user)))
gm.end_game(chat, skipped_player.user)
def do_play_card(bot, player, result_id):
"""Plays the selected card and sends an update to the group if needed"""
card = c.from_str(result_id)
player.play(card)
game = player.game
chat = game.chat
user = player.user
us = UserSetting.get(id=user.id)
if not us:
us = UserSetting(id=user.id)
if us.stats:
us.cards_played += 1
if game.choosing_color:
send_async(bot, chat.id, text=_("Please choose a color"))
if len(player.cards) == 1:
send_async(bot, chat.id, text="UNO!")
if len(player.cards) == 0:
send_async(bot, chat.id,
text=__("{name} won!", multi=game.translate)
.format(name=user.first_name))
if us.stats:
us.games_played += 1
if game.players_won is 0:
us.first_places += 1
game.players_won += 1
try:
gm.leave_game(user, chat)
except NotEnoughPlayersError:
send_async(bot, chat.id,
text=__("Game ended!", multi=game.translate))
us2 = UserSetting.get(id=game.current_player.user.id)
if us2 and us2.stats:
us2.games_played += 1
gm.end_game(chat, user)
if botan:
random_int = random.randrange(1, 999999999)
botan.track(Message(random_int, user, datetime.now(),
Chat(chat.id, 'group')),
'Played cards')
def do_draw(bot, player):
"""Does the drawing"""
game = player.game
draw_counter_before = game.draw_counter
try:
player.draw()
except DeckEmptyError:
send_async(bot, player.game.chat.id,
text=__("There are no more cards in the deck.",
multi=game.translate))
if (game.last_card.value == c.DRAW_TWO or
game.last_card.special == c.DRAW_FOUR) and \
draw_counter_before > 0:
game.turn()
def do_call_bluff(bot, player):
"""Handles the bluff calling"""
game = player.game
chat = game.chat
if player.prev.bluffing:
send_async(bot, chat.id,
text=__("Bluff called! Giving 4 cards to {name}",
multi=game.translate)
.format(name=player.prev.user.first_name))
try:
player.prev.draw()
except DeckEmptyError:
send_async(bot, player.game.chat.id,
text=__("There are no more cards in the deck.",
multi=game.translate))
else:
game.draw_counter += 2
send_async(bot, chat.id,
text=__("{name1} didn't bluff! Giving 6 cards to {name2}",
multi=game.translate)
.format(name1=player.prev.user.first_name,
name2=player.user.first_name))
try:
player.draw()
except DeckEmptyError:
send_async(bot, player.game.chat.id,
text=__("There are no more cards in the deck.",
multi=game.translate))
game.turn()
def start_player_countdown(bot, game, job_queue):
player = game.current_player
time = player.waiting_time
if time < MIN_FAST_TURN_TIME:
time = MIN_FAST_TURN_TIME
if game.mode == 'fast':
if game.job:
game.job.schedule_removal()
job = job_queue.run_once(
#lambda x,y: do_skip(bot, player),
skip_job,
time,
context=Countdown(player, job_queue)
)
logger.info("Started countdown for player: {player}. {time} seconds."
.format(player=display_name(player.user), time=time))
player.game.job = job
def skip_job(bot, job):
player = job.context.player
game = player.game
if game_is_running(game):
job_queue = job.context.job_queue
do_skip(bot, player, job_queue)

267
bot.py
View file

@ -19,39 +19,35 @@
import logging import logging
from datetime import datetime from datetime import datetime
from random import randint
from telegram import ParseMode, Message, Chat, InlineKeyboardMarkup, \ from telegram import ParseMode, InlineKeyboardMarkup, \
InlineKeyboardButton InlineKeyboardButton
from telegram.ext import InlineQueryHandler, ChosenInlineResultHandler, \ from telegram.ext import InlineQueryHandler, ChosenInlineResultHandler, \
CommandHandler, MessageHandler, Filters, CallbackQueryHandler CommandHandler, MessageHandler, Filters, CallbackQueryHandler
from telegram.ext.dispatcher import run_async from telegram.ext.dispatcher import run_async
from start_bot import start_bot
from results import (add_call_bluff, add_choose_color, add_draw, add_gameinfo,
add_no_game, add_not_started, add_other_cards, add_pass,
add_card)
from user_setting import UserSetting
from utils import display_name, get_admin_ids
import card as c import card as c
import settings
import simple_commands
from actions import do_skip, do_play_card, do_draw, do_call_bluff, start_player_countdown
from gameplay_config import WAITING_TIME, DEFAULT_GAMEMODE, MIN_PLAYERS
from errors import (NoGameInChatError, LobbyClosedError, AlreadyJoinedError, from errors import (NoGameInChatError, LobbyClosedError, AlreadyJoinedError,
NotEnoughPlayersError, DeckEmptyError) NotEnoughPlayersError, DeckEmptyError)
from utils import send_async, answer_async, error, TIMEOUT
from shared_vars import botan, gm, updater, dispatcher
from internationalization import _, __, user_locale, game_locales from internationalization import _, __, user_locale, game_locales
import simple_commands from results import (add_call_bluff, add_choose_color, add_draw, add_gameinfo,
import settings add_no_game, add_not_started, add_other_cards, add_pass,
add_card, add_mode_classic, add_mode_fast, add_mode_wild)
from shared_vars import botan, gm, updater, dispatcher
from simple_commands import help_handler
from start_bot import start_bot
from utils import display_name
from utils import send_async, answer_async, error, TIMEOUT, user_is_creator_or_admin, user_is_creator, game_is_running
from simple_commands import help
#import json
#with open("config.json","r") as f:
# config = json.loads(f.read())
#forbidden = config.get("black_list", None)
logging.basicConfig( logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO) level=logging.INFO
)
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@user_locale @user_locale
@ -76,7 +72,7 @@ def new_game(bot, update):
chat_id = update.message.chat_id chat_id = update.message.chat_id
if update.message.chat.type == 'private': if update.message.chat.type == 'private':
help(bot, update) help_handler(bot, update)
else: else:
@ -92,6 +88,7 @@ def new_game(bot, update):
game = gm.new_game(update.message.chat) game = gm.new_game(update.message.chat)
game.starter = update.message.from_user game.starter = update.message.from_user
game.owner.append(update.message.from_user.id) game.owner.append(update.message.from_user.id)
game.mode = DEFAULT_GAMEMODE
send_async(bot, chat_id, send_async(bot, chat_id,
text=_("Created a new game! Join the game with /join " text=_("Created a new game! Join the game with /join "
"and start the game with /start")) "and start the game with /start"))
@ -107,7 +104,7 @@ def kill_game(bot, update):
games = gm.chatid_games.get(chat.id) games = gm.chatid_games.get(chat.id)
if update.message.chat.type == 'private': if update.message.chat.type == 'private':
help(bot, update) help_handler(bot, update)
return return
if not games: if not games:
@ -117,7 +114,7 @@ def kill_game(bot, update):
game = games[-1] game = games[-1]
if user.id in game.owner or user.id in get_admin_ids(bot, chat.id): if user_is_creator_or_admin(user, game, bot, chat):
try: try:
gm.end_game(chat, user) gm.end_game(chat, user)
@ -141,7 +138,7 @@ def join_game(bot, update):
chat = update.message.chat chat = update.message.chat
if update.message.chat.type == 'private': if update.message.chat.type == 'private':
help(bot, update) help_handler(bot, update)
return return
try: try:
@ -204,11 +201,18 @@ def leave_game(bot, update):
send_async(bot, chat.id, text=__("Game ended!", multi=game.translate)) send_async(bot, chat.id, text=__("Game ended!", multi=game.translate))
else: else:
send_async(bot, chat.id, if game.started:
text=__("Okay. Next Player: {name}", send_async(bot, chat.id,
multi=game.translate).format( text=__("Okay. Next Player: {name}",
name=display_name(game.current_player.user)), multi=game.translate).format(
reply_to_message_id=update.message.message_id) name=display_name(game.current_player.user)),
reply_to_message_id=update.message.message_id)
else:
send_async(bot, chat.id,
text=__("{name} left the game before it started.",
multi=game.translate).format(
name=display_name(user)),
reply_to_message_id=update.message.message_id)
def select_game(bot, update): def select_game(bot, update):
@ -275,7 +279,7 @@ def status_update(bot, update):
@game_locales @game_locales
@user_locale @user_locale
def start_game(bot, update, args): def start_game(bot, update, args, job_queue):
"""Handler for the /start command""" """Handler for the /start command"""
if update.message.chat.type != 'private': if update.message.chat.type != 'private':
@ -292,14 +296,17 @@ def start_game(bot, update, args):
if game.started: if game.started:
send_async(bot, chat.id, text=_("The game has already started")) send_async(bot, chat.id, text=_("The game has already started"))
elif len(game.players) < 2: elif len(game.players) < MIN_PLAYERS:
send_async(bot, chat.id, send_async(bot, chat.id,
text=_("At least two players must /join the game " text=__("At least {minplayers} players must /join the game "
"before you can start it")) "before you can start it").format(minplayers=MIN_PLAYERS))
else: else:
game.play_card(game.last_card) # Starting a game
game.started = True game.start()
for player in game.players:
player.draw_first_hand()
first_message = ( first_message = (
__("First player: {name}\n" __("First player: {name}\n"
@ -321,6 +328,7 @@ def start_game(bot, update, args):
timeout=TIMEOUT) timeout=TIMEOUT)
send_first() send_first()
start_player_countdown(bot, game, job_queue)
elif len(args) and args[0] == 'select': elif len(args) and args[0] == 'select':
players = gm.userid_players[update.message.from_user.id] players = gm.userid_players[update.message.from_user.id]
@ -342,7 +350,7 @@ def start_game(bot, update, args):
reply_markup=InlineKeyboardMarkup(groups)) reply_markup=InlineKeyboardMarkup(groups))
else: else:
help(bot, update) help_handler(bot, update)
@user_locale @user_locale
@ -472,13 +480,14 @@ def skip_player(bot, update):
game = player.game game = player.game
skipped_player = game.current_player skipped_player = game.current_player
next_player = game.current_player.next
started = skipped_player.turn_started started = skipped_player.turn_started
now = datetime.now() now = datetime.now()
delta = (now - started).seconds delta = (now - started).seconds
if delta < skipped_player.waiting_time: # You can't skip if the current player still has time left
# You can skip yourself even if you have time left (you'll still draw)
if delta < skipped_player.waiting_time and player != skipped_player:
n = skipped_player.waiting_time - delta n = skipped_player.waiting_time - delta
send_async(bot, chat.id, send_async(bot, chat.id,
text=_("Please wait {time} second", text=_("Please wait {time} second",
@ -486,47 +495,8 @@ def skip_player(bot, update):
n) n)
.format(time=n), .format(time=n),
reply_to_message_id=update.message.message_id) reply_to_message_id=update.message.message_id)
elif skipped_player.waiting_time > 0:
skipped_player.anti_cheat += 1
skipped_player.waiting_time -= 30
try:
skipped_player.draw()
except DeckEmptyError:
pass
n = skipped_player.waiting_time
send_async(bot, chat.id,
text=__("Waiting time to skip this player has "
"been reduced to {time} second.\n"
"Next player: {name}",
"Waiting time to skip this player has "
"been reduced to {time} seconds.\n"
"Next player: {name}",
n,
multi=game.translate)
.format(time=n,
name=display_name(next_player.user)))
game.turn()
else: else:
try: do_skip(bot, player)
gm.leave_game(skipped_player.user, chat)
send_async(bot, chat.id,
text=__("{name1} was skipped four times in a row "
"and has been removed from the game.\n"
"Next player: {name2}", multi=game.translate)
.format(name1=display_name(skipped_player.user),
name2=display_name(next_player.user)))
except NotEnoughPlayersError:
send_async(bot, chat.id,
text=__("{name} was skipped four times in a row "
"and has been removed from the game.\n"
"The game ended.", multi=game.translate)
.format(name=display_name(skipped_player.user)))
gm.end_game(chat.id, skipped_player.user)
@game_locales @game_locales
@ -540,15 +510,25 @@ def reply_to_query(bot, update):
switch = None switch = None
try: try:
user_id = update.inline_query.from_user.id user = update.inline_query.from_user
user_id = user.id
players = gm.userid_players[user_id] players = gm.userid_players[user_id]
player = gm.userid_current[user_id] player = gm.userid_current[user_id]
game = player.game game = player.game
except KeyError: except KeyError:
add_no_game(results) add_no_game(results)
else: else:
# The game has not started.
# The creator may change the game mode, other users just get a "game has not started" message.
if not game.started: if not game.started:
add_not_started(results) if user_is_creator(user, game):
add_mode_classic(results)
add_mode_fast(results)
add_mode_wild(results)
else:
add_not_started(results)
elif user_id == game.current_player.user.id: elif user_id == game.current_player.user.id:
if game.choosing_color: if game.choosing_color:
@ -594,7 +574,7 @@ def reply_to_query(bot, update):
@game_locales @game_locales
@user_locale @user_locale
def process_result(bot, update): def process_result(bot, update, job_queue):
""" """
Handler for chosen inline results. Handler for chosen inline results.
Checks the players actions and acts accordingly. Checks the players actions and acts accordingly.
@ -616,6 +596,13 @@ def process_result(bot, update):
if result_id in ('hand', 'gameinfo', 'nogame'): if result_id in ('hand', 'gameinfo', 'nogame'):
return return
elif result_id.startswith('mode_'):
# First 5 characters are 'mode_', the rest is the gamemode.
mode = result_id[5:]
game.set_mode(mode)
logger.info("Gamemode changed to {mode}".format(mode = mode))
send_async(bot, chat.id, text=__("Gamemode changed to {mode}".format(mode = mode)))
return
elif len(result_id) == 36: # UUID result elif len(result_id) == 36: # UUID result
return return
elif int(anti_cheat) != last_anti_cheat: elif int(anti_cheat) != last_anti_cheat:
@ -637,134 +624,30 @@ def process_result(bot, update):
reset_waiting_time(bot, player) reset_waiting_time(bot, player)
do_play_card(bot, player, result_id) do_play_card(bot, player, result_id)
if game in gm.chatid_games.get(chat.id, list()): if game_is_running(game):
send_async(bot, chat.id, send_async(bot, chat.id,
text=__("Next player: {name}", multi=game.translate) text=__("Next player: {name}", multi=game.translate)
.format(name=display_name(game.current_player.user))) .format(name=display_name(game.current_player.user)))
start_player_countdown(bot, game, job_queue)
def reset_waiting_time(bot, player): def reset_waiting_time(bot, player):
"""Resets waiting time for a player and sends a notice to the group""" """Resets waiting time for a player and sends a notice to the group"""
chat = player.game.chat chat = player.game.chat
if player.waiting_time < 90: if player.waiting_time < WAITING_TIME:
player.waiting_time = 90 player.waiting_time = WAITING_TIME
send_async(bot, chat.id, send_async(bot, chat.id,
text=__("Waiting time for {name} has been reset to 90 " text=__("Waiting time for {name} has been reset to {time} "
"seconds", multi=player.game.translate) "seconds", multi=player.game.translate)
.format(name=display_name(player.user))) .format(name=display_name(player.user), time=WAITING_TIME))
def do_play_card(bot, player, result_id):
"""Plays the selected card and sends an update to the group if needed"""
card = c.from_str(result_id)
player.play(card)
game = player.game
chat = game.chat
user = player.user
us = UserSetting.get(id=user.id)
if not us:
us = UserSetting(id=user.id)
if us.stats:
us.cards_played += 1
if game.choosing_color:
send_async(bot, chat.id, text=_("Please choose a color"))
if len(player.cards) == 1:
send_async(bot, chat.id, text="UNO!")
if len(player.cards) == 0:
send_async(bot, chat.id,
text=__("{name} won!", multi=game.translate)
.format(name=user.first_name))
if us.stats:
us.games_played += 1
if game.players_won is 0:
us.first_places += 1
game.players_won += 1
try:
gm.leave_game(user, chat)
except NotEnoughPlayersError:
send_async(bot, chat.id,
text=__("Game ended!", multi=game.translate))
us2 = UserSetting.get(id=game.current_player.user.id)
if us2 and us2.stats:
us2.games_played += 1
gm.end_game(chat, user)
if botan:
botan.track(Message(randint(1, 1000000000), user, datetime.now(),
Chat(chat.id, 'group')),
'Played cards')
def do_draw(bot, player):
"""Does the drawing"""
game = player.game
draw_counter_before = game.draw_counter
try:
player.draw()
except DeckEmptyError:
send_async(bot, player.game.chat.id,
text=__("There are no more cards in the deck.",
multi=game.translate))
if (game.last_card.value == c.DRAW_TWO or
game.last_card.special == c.DRAW_FOUR) and \
draw_counter_before > 0:
game.turn()
def do_call_bluff(bot, player):
"""Handles the bluff calling"""
game = player.game
chat = game.chat
if player.prev.bluffing:
send_async(bot, chat.id,
text=__("Bluff called! Giving 4 cards to {name}",
multi=game.translate)
.format(name=player.prev.user.first_name))
try:
player.prev.draw()
except DeckEmptyError:
send_async(bot, player.game.chat.id,
text=__("There are no more cards in the deck.",
multi=game.translate))
else:
game.draw_counter += 2
send_async(bot, chat.id,
text=__("{name1} didn't bluff! Giving 6 cards to {name2}",
multi=game.translate)
.format(name1=player.prev.user.first_name,
name2=player.user.first_name))
try:
player.draw()
except DeckEmptyError:
send_async(bot, player.game.chat.id,
text=__("There are no more cards in the deck.",
multi=game.translate))
game.turn()
# Add all handlers to the dispatcher and run the bot # Add all handlers to the dispatcher and run the bot
dispatcher.add_handler(InlineQueryHandler(reply_to_query)) dispatcher.add_handler(InlineQueryHandler(reply_to_query))
dispatcher.add_handler(ChosenInlineResultHandler(process_result)) dispatcher.add_handler(ChosenInlineResultHandler(process_result, pass_job_queue=True))
dispatcher.add_handler(CallbackQueryHandler(select_game)) dispatcher.add_handler(CallbackQueryHandler(select_game))
dispatcher.add_handler(CommandHandler('start', start_game, pass_args=True)) dispatcher.add_handler(CommandHandler('start', start_game, pass_args=True, pass_job_queue=True))
dispatcher.add_handler(CommandHandler('new', new_game)) dispatcher.add_handler(CommandHandler('new', new_game))
dispatcher.add_handler(CommandHandler('kill', kill_game)) dispatcher.add_handler(CommandHandler('kill', kill_game))
dispatcher.add_handler(CommandHandler('join', join_game)) dispatcher.add_handler(CommandHandler('join', join_game))

View file

@ -52,6 +52,7 @@ SKIP = 'skip'
VALUES = (ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, DRAW_TWO, VALUES = (ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, DRAW_TWO,
REVERSE, SKIP) REVERSE, SKIP)
WILD_VALUES = (ONE, TWO, THREE, FOUR, FIVE, DRAW_TWO, REVERSE, SKIP)
# Special cards # Special cards
CHOOSE = 'colorchooser' CHOOSE = 'colorchooser'

View file

@ -18,7 +18,7 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>. # along with this program. If not, see <http://www.gnu.org/licenses/>.
from pony.orm import Database, db_session, Optional, Required, Set, PrimaryKey from pony.orm import Database
# Database singleton # Database singleton
db = Database() db = Database()

36
deck.py
View file

@ -34,18 +34,7 @@ class Deck(object):
self.graveyard = list() self.graveyard = list()
self.logger = logging.getLogger(__name__) self.logger = logging.getLogger(__name__)
# Fill deck
for color in c.COLORS:
for value in c.VALUES:
self.cards.append(Card(color, value))
if not value == c.ZERO:
self.cards.append(Card(color, value))
for special in c.SPECIALS * 4:
self.cards.append(Card(None, None, special=special))
self.logger.debug(self.cards) self.logger.debug(self.cards)
self.shuffle()
def shuffle(self): def shuffle(self):
"""Shuffles the deck""" """Shuffles the deck"""
@ -70,3 +59,28 @@ class Deck(object):
def dismiss(self, card): def dismiss(self, card):
"""Returns a card to the deck""" """Returns a card to the deck"""
self.graveyard.append(card) self.graveyard.append(card)
def _fill_classic_(self):
# Fill deck with the classic card set
self.cards.clear()
for color in c.COLORS:
for value in c.VALUES:
self.cards.append(Card(color, value))
if not value == c.ZERO:
self.cards.append(Card(color, value))
for special in c.SPECIALS:
for _ in range(4):
self.cards.append(Card(None, None, special=special))
self.shuffle()
def _fill_wild_(self):
# Fill deck with a wild card set
self.cards.clear()
for color in c.COLORS:
for value in c.WILD_VALUES:
for _ in range(4):
self.cards.append(Card(color, value))
for special in c.SPECIALS:
for _ in range(6):
self.cards.append(Card(None, None, special=special))
self.shuffle()

34
game.py
View file

@ -21,6 +21,8 @@
import logging import logging
import json import json
from datetime import datetime from datetime import datetime
from gameplay_config import DEFAULT_GAMEMODE
from deck import Deck from deck import Deck
import card as c import card as c
@ -33,6 +35,8 @@ class Game(object):
draw_counter = 0 draw_counter = 0
players_won = 0 players_won = 0
starter = None starter = None
mode = DEFAULT_GAMEMODE
job = None
with open("config.json","r") as f: with open("config.json","r") as f:
config = json.loads(f.read()) config = json.loads(f.read())
owner = config.get("admin_list", None) owner = config.get("admin_list", None)
@ -43,9 +47,7 @@ class Game(object):
self.chat = chat self.chat = chat
self.last_card = None self.last_card = None
while not self.last_card or self.last_card.special: self.deck = Deck()
self.deck = Deck()
self.last_card = self.deck.draw()
self.logger = logging.getLogger(__name__) self.logger = logging.getLogger(__name__)
@ -64,6 +66,18 @@ class Game(object):
itplayer = itplayer.next itplayer = itplayer.next
return players return players
def start(self):
if self.mode == None or self.mode != "wild":
self.deck._fill_classic_()
else:
self.deck._fill_wild_()
self._first_card_()
self.started = True
def set_mode(self, mode):
self.mode = mode
def reverse(self): def reverse(self):
"""Reverses the direction of game""" """Reverses the direction of game"""
self.reversed = not self.reversed self.reversed = not self.reversed
@ -76,6 +90,20 @@ class Game(object):
self.current_player.turn_started = datetime.now() self.current_player.turn_started = datetime.now()
self.choosing_color = False self.choosing_color = False
def _first_card_(self):
# In case that the player did not select a game mode
if not self.deck.cards:
self.set_mode(DEFAULT_GAMEMODE)
# The first card should not be a special card
while not self.last_card or self.last_card.special:
self.last_card = self.deck.draw()
# If the card drawn was special, return it to the deck and loop again
if self.last_card.special:
self.deck.dismiss(self.last_card)
self.play_card(self.last_card)
def play_card(self, card): def play_card(self, card):
""" """
Plays a card and triggers its effects. Plays a card and triggers its effects.

View file

@ -79,20 +79,22 @@ class GameManager(object):
for player in players: for player in players:
if player in game.players: if player in game.players:
raise AlreadyJoinedError() raise AlreadyJoinedError()
else:
try:
self.leave_game(user, chat)
except NoGameInChatError:
pass
except NotEnoughPlayersError:
self.end_game(chat, user)
if user.id not in self.userid_players: try:
self.userid_players[user.id] = list() self.leave_game(user, chat)
except NoGameInChatError:
pass
except NotEnoughPlayersError:
self.end_game(chat, user)
players = self.userid_players[user.id] if user.id not in self.userid_players:
self.userid_players[user.id] = list()
players = self.userid_players[user.id]
player = Player(game, user) player = Player(game, user)
if game.started:
player.draw_first_hand()
players.append(player) players.append(player)
self.userid_current[user.id] = player self.userid_current[user.id] = player
@ -113,8 +115,8 @@ class GameManager(object):
p.leave() p.leave()
return return
else:
raise NoGameInChatError raise NoGameInChatError
game = player.game game = player.game
@ -185,5 +187,4 @@ class GameManager(object):
for player in players: for player in players:
if player.game.chat.id == chat.id: if player.game.chat.id == chat.id:
return player return player
else: return None
return None

6
gameplay_config.py Normal file
View file

@ -0,0 +1,6 @@
# Current gamemodes: "classic", "fast", "wild"
DEFAULT_GAMEMODE = "fast"
WAITING_TIME = 120
TIME_REMOVAL_AFTER_SKIP = 20
MIN_FAST_TURN_TIME = 15
MIN_PLAYERS = 2

View file

@ -22,7 +22,7 @@ import gettext
from functools import wraps from functools import wraps
from locales import available_locales from locales import available_locales
from database import db_session from pony.orm import db_session
from user_setting import UserSetting from user_setting import UserSetting
from shared_vars import gm from shared_vars import gm
@ -102,7 +102,7 @@ def user_locale(func):
@wraps(func) @wraps(func)
@db_session @db_session
def wrapped(bot, update, *pargs, **kwargs): def wrapped(bot, update, *pargs, **kwargs):
user, chat = _user_chat_from_update(update) user = _user_chat_from_update(update)[0]
with db_session: with db_session:
us = UserSetting.get(id=user.id) us = UserSetting.get(id=user.id)

View file

@ -2,7 +2,7 @@
# This script compiles the unobot.po file for all languages. # This script compiles the unobot.po file for all languages.
function compile { function compile {
cd '.\'$1'\LC_MESSAGES\' cd './'$1'/LC_MESSAGES/'
msgfmt unobot.po -o unobot.mo msgfmt unobot.po -o unobot.mo
cd ../../ cd ../../
} }

View file

@ -173,9 +173,9 @@ msgid "The game has already started"
msgstr "La partida ya ha comenzado." msgstr "La partida ya ha comenzado."
#: bot.py:281 #: bot.py:281
msgid "At least two players must /join the game before you can start it" msgid "At least {minplayers} players must /join the game before you can start it"
msgstr "" msgstr ""
"Antes de iniciar la partida, al menos dos jugadores deben unirse usando /join." "Antes de iniciar la partida, al menos {minplayers} jugadores deben unirse usando /join."
#: bot.py:297 #: bot.py:297
#, python-format #, python-format
@ -289,8 +289,8 @@ msgstr "Siguiente Jugador: {name}."
#: bot.py:572 #: bot.py:572
#, python-format #, python-format
msgid "Waiting time for {name} has been reset to 90 seconds" msgid "Waiting time for {name} has been reset to {time} seconds"
msgstr "El tiempo de espera para {name} se ha reiniciado a 90 segundos" msgstr "El tiempo de espera para {name} se ha reiniciado a {time} segundos"
#: bot.py:585 #: bot.py:585
msgid "Please choose a color" msgid "Please choose a color"
@ -415,7 +415,7 @@ msgstr "¡Estadísticas borradas y deshabilitadas! "
#: settings.py:94 #: settings.py:94
msgid "Set locale!" msgid "Set locale!"
msgstr "¡Idioma seleccionada!" msgstr "¡Idioma seleccionado!"
#: simple_commands.py #: simple_commands.py
msgid "" msgid ""

View file

@ -23,6 +23,7 @@ from datetime import datetime
import card as c import card as c
from errors import DeckEmptyError from errors import DeckEmptyError
from gameplay_config import WAITING_TIME
class Player(object): class Player(object):
@ -39,15 +40,6 @@ class Player(object):
self.user = user self.user = user
self.logger = logging.getLogger(__name__) self.logger = logging.getLogger(__name__)
try:
for i in range(7):
self.cards.append(self.game.deck.draw())
except DeckEmptyError:
for card in self.cards:
self.game.deck.dismiss(card)
raise
# Check if this player is the first player in this game. # Check if this player is the first player in this game.
if game.current_player: if game.current_player:
self.next = game.current_player self.next = game.current_player
@ -63,7 +55,17 @@ class Player(object):
self.drew = False self.drew = False
self.anti_cheat = 0 self.anti_cheat = 0
self.turn_started = datetime.now() self.turn_started = datetime.now()
self.waiting_time = 90 self.waiting_time = WAITING_TIME
def draw_first_hand(self):
try:
for _ in range(7):
self.cards.append(self.game.deck.draw())
except DeckEmptyError:
for card in self.cards:
self.game.deck.dismiss(card)
raise
def leave(self): def leave(self):
"""Removes player from the game and closes the gap in the list""" """Removes player from the game and closes the gap in the list"""
@ -113,7 +115,7 @@ class Player(object):
_amount = self.game.draw_counter or 1 _amount = self.game.draw_counter or 1
try: try:
for i in range(_amount): for _ in range(_amount):
self.cards.append(self.game.deck.draw()) self.cards.append(self.game.deck.draw())
except DeckEmptyError: except DeckEmptyError:

View file

@ -94,6 +94,42 @@ def add_not_started(results):
) )
def add_mode_classic(results):
"""Change mode to classic"""
results.append(
InlineQueryResultArticle(
"mode_classic",
title=_("🎻 Classic mode"),
input_message_content=
InputTextMessageContent(_('Classic 🎻'))
)
)
def add_mode_fast(results):
"""Change mode to classic"""
results.append(
InlineQueryResultArticle(
"mode_fast",
title=_("🚀 Sanic mode"),
input_message_content=
InputTextMessageContent(_('Gotta go fast! 🚀'))
)
)
def add_mode_wild(results):
"""Change mode to classic"""
results.append(
InlineQueryResultArticle(
"mode_wild",
title=_("🐉 Wild mode"),
input_message_content=
InputTextMessageContent(_('Into the Wild~ 🐉'))
)
)
def add_draw(player, results): def add_draw(player, results):
"""Add option to draw""" """Add option to draw"""
n = player.game.draw_counter or 1 n = player.game.draw_counter or 1

View file

@ -18,12 +18,13 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>. # along with this program. If not, see <http://www.gnu.org/licenses/>.
import json import json
import logging
from telegram.ext import Updater from telegram.ext import Updater
from telegram.contrib.botan import Botan from telegram.contrib.botan import Botan
from game_manager import GameManager from game_manager import GameManager
from database import db from database import db
import user_setting # required to generate db mapping
db.bind('sqlite', 'uno.sqlite3', create_db=True) db.bind('sqlite', 'uno.sqlite3', create_db=True)
db.generate_mapping(create_tables=True) db.generate_mapping(create_tables=True)

View file

@ -70,14 +70,27 @@ attributions = ("Attributions:\n"
"Originals available on http://game-icons.net\n" "Originals available on http://game-icons.net\n"
"Icons edited by ɳick") "Icons edited by ɳick")
modes_explanation = ("This UNO bot has three game modes: Classic, Sanic and Wild.\n\n"
" 🎻 The Classic mode uses the conventional UNO deck and there is no auto skip.\n"
" 🚀 The Sanic mode uses the conventional UNO deck and the bot automatically skips a player if he/she takes too long to play its turn\n"
" 🐉 The Wild mode uses a deck with more special cards, less number variety and no auto skip.\n\n"
"To change the game mode, the GAME CREATOR has to type the bot nickname and a space, just like when playing a card, and all gamemode options should appear.")
@user_locale @user_locale
def help(bot, update): def help_handler(bot, update):
"""Handler for the /help command""" """Handler for the /help command"""
send_async(bot, update.message.chat_id, text=_(help_text), send_async(bot, update.message.chat_id, text=_(help_text),
parse_mode=ParseMode.HTML, disable_web_page_preview=True) parse_mode=ParseMode.HTML, disable_web_page_preview=True)
@user_locale
def modes(bot, update):
"""Handler for the /help command"""
send_async(bot, update.message.chat_id, text=_(modes_explanation),
parse_mode=ParseMode.HTML, disable_web_page_preview=True)
@user_locale @user_locale
def source(bot, update): def source(bot, update):
"""Handler for the /help command""" """Handler for the /help command"""
@ -131,7 +144,8 @@ def stats(bot, update):
def register(): def register():
dispatcher.add_handler(CommandHandler('help', help)) dispatcher.add_handler(CommandHandler('help', help_handler))
dispatcher.add_handler(CommandHandler('source', source)) dispatcher.add_handler(CommandHandler('source', source))
dispatcher.add_handler(CommandHandler('news', news)) dispatcher.add_handler(CommandHandler('news', news))
dispatcher.add_handler(CommandHandler('stats', stats)) dispatcher.add_handler(CommandHandler('stats', stats))
dispatcher.add_handler(CommandHandler('modes', modes))

View file

@ -74,7 +74,7 @@ class Test(unittest.TestCase):
*(self.user1, self.chat0)) *(self.user1, self.chat0))
def test_leave_game(self): def test_leave_game(self):
g0 = self.gm.new_game(self.chat0) self.gm.new_game(self.chat0)
self.gm.join_game(self.user0, self.chat0) self.gm.join_game(self.user0, self.chat0)
self.gm.join_game(self.user1, self.chat0) self.gm.join_game(self.user1, self.chat0)
@ -91,14 +91,14 @@ class Test(unittest.TestCase):
*(self.user0, self.chat0)) *(self.user0, self.chat0))
def test_end_game(self): def test_end_game(self):
g0 = self.gm.new_game(self.chat0) self.gm.new_game(self.chat0)
self.gm.join_game(self.user0, self.chat0) self.gm.join_game(self.user0, self.chat0)
self.gm.join_game(self.user1, self.chat0) self.gm.join_game(self.user1, self.chat0)
self.assertEqual(len(self.gm.userid_players[0]), 1) self.assertEqual(len(self.gm.userid_players[0]), 1)
g1 = self.gm.new_game(self.chat0) self.gm.new_game(self.chat0)
self.gm.join_game(self.user2, self.chat0) self.gm.join_game(self.user2, self.chat0)
self.gm.end_game(self.chat0, self.user0) self.gm.end_game(self.chat0, self.user0)

View file

@ -18,7 +18,8 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>. # along with this program. If not, see <http://www.gnu.org/licenses/>.
from database import db, Optional, Required, PrimaryKey, db_session from pony.orm import Optional, PrimaryKey
from database import db
class UserSetting(db.Entity): class UserSetting(db.Entity):

View file

@ -24,6 +24,7 @@ from telegram.ext.dispatcher import run_async
from internationalization import _, __ from internationalization import _, __
from mwt import MWT from mwt import MWT
from shared_vars import gm
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -105,6 +106,22 @@ def answer_async(bot, *args, **kwargs):
error(None, None, e) error(None, None, e)
def game_is_running(game):
return game in gm.chatid_games.get(game.chat.id, list())
def user_is_creator(user, game):
return user.id in game.owner
def user_is_admin(user, bot, chat):
return user.id in get_admin_ids(bot, chat.id)
def user_is_creator_or_admin(user, game, bot, chat):
return user_is_creator(user, game) or user_is_admin(user, bot, chat)
@MWT(timeout=60*60) @MWT(timeout=60*60)
def get_admin_ids(bot, chat_id): def get_admin_ids(bot, chat_id):
"""Returns a list of admin IDs for a given chat. Results are cached for 1 hour.""" """Returns a list of admin IDs for a given chat. Results are cached for 1 hour."""