Improved most messages in spanish (#39 )

Update bot.py
2017-09-19 17:31:53 +02:00 · 2017-03-04 09:30:09 +08:00 · 2017-03-04 09:17:52 +08:00 · 2017-03-04 09:17:20 +08:00 · 2017-03-03 19:40:40 +08:00 · 2017-02-24 14:16:52 +08:00
150 changed files with 1434 additions and 2376 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,6 +1,3 @@
-# Config file
-config.json
-
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
--- a/AUTHORS.md
+++ b/AUTHORS.md
@ -7,8 +7,6 @@
 The following wonderful people contributed directly or indirectly to this project:

 - [imlonghao](https://github.com/imlonghao)
- [pan93412](https://github.com/pan93412)
 - [qubitnerd](https://github.com/qubitnerd)
- [SYHGroup](https://github.com/SYHGroup)

-Please add yourself here alphabetically when you submit your first pull request.
+Please add yourself here alphabetically when you submit your first pull request.
--- a/13
+++ b/13
@ -1,13 +0,0 @@
-[[source]]
-name = "pypi"
-url = "https://pypi.org/simple"
-verify_ssl = true
-
-[dev-packages]
-
-[packages]
-python-telegram-bot = "==8.1.1"
-pony = "*"
-
-[requires]
-python_version = "3.7"
--- a/Pipfile.lock
+++ b/Pipfile.lock
@ -1,49 +0,0 @@
-{
-    "_meta": {
-        "hash": {
-            "sha256": "de56c4d5f516205e99d141cd7d372f67b602b6f981306971c01ffe25a5abf5c6"
-        },
-        "pipfile-spec": 6,
-        "requires": {
-            "python_version": "3.7"
-        },
-        "sources": [
-            {
-                "name": "pypi",
-                "url": "https://pypi.org/simple",
-                "verify_ssl": true
-            }
-        ]
-    },
-    "default": {
-        "certifi": {
-            "hashes": [
-                "sha256:046832c04d4e752f37383b628bc601a7ea7211496b4638f6514d0e5b9acc4939",
-                "sha256:945e3ba63a0b9f577b1395204e13c3a231f9bc0223888be653286534e5873695"
-            ],
-            "version": "==2019.6.16"
-        },
-        "future": {
-            "hashes": [
-                "sha256:67045236dcfd6816dc439556d009594abf643e5eb48992e36beac09c2ca659b8"
-            ],
-            "version": "==0.17.1"
-        },
-        "pony": {
-            "hashes": [
-                "sha256:55bb9d4d12029d8c2bbbc7a284970e72225035db7e6370c0a15ec93d1886fe88"
-            ],
-            "index": "pypi",
-            "version": "==0.7.10"
-        },
-        "python-telegram-bot": {
-            "hashes": [
-                "sha256:238c4a88b09d93c52d413bcf7e7fe14dfeb02f5f9222ffe4cafd4bd3d55489a3",
-                "sha256:997983e5082dc6aa811bce3a6014731201fc64b0a9c02fdb26beac686029d94b"
-            ],
-            "index": "pypi",
-            "version": "==8.1.1"
-        }
-    },
-    "develop": {}
-}
--- a/README.md
+++ b/README.md
@ -2,23 +2,18 @@

 [![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](./LICENSE)

-Telegram Bot that allows you to play the popular card game UNO via inline queries. The bot currently runs as [@unobot](http://telegram.me/unobot).
+Telegram Bot that allows you to play the popular card game UNO via inline queries. The bot currently runs as [@unobot](http://telegram.me/unobot)

 To run the bot yourself, you will need: 
- Python (tested with 3.4+)
- The [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot) module
+- Python (tested with 3.4 and 3.5)
+- The [python-telegram-bot](https://github.com/python-telegram-bot/python-telegram-bot) module version 5.0.0
 - [Pony ORM](https://ponyorm.com/)

 ## Setup
- Get a bot token from [@BotFather](http://telegram.me/BotFather) and change configurations in `config.json`.
- Convert all language files from `.po` files to `.mo` by executing the bash script `compile.sh` located in the `locales` folder.
-  Another option is: `find . -maxdepth 2 -type d -name 'LC_MESSAGES' -exec bash -c 'msgfmt {}/unobot.po -o {}/unobot.mo' \;`.
- Use `/setinline` and `/setinlinefeedback` with BotFather for your bot.
- Install requirements (using a `virtualenv` is recommended): `pip install -r requirements.txt`
+- Get a bot token from [@BotFather](http://telegram.me/BotFather) and place it in `credentials.py`
+- Convert all language files from .po to .mo using `msgfmt unobot.po -o unobot.mo`
+- Use `/setinline` and `/setinlinefeedback` with BotFather for your bot

-You can change some gameplay parameters like turn times, minimum amount of players and default gamemode in `config.json`.
-Current gamemodes available: classic, fast and wild. Check the details 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
--- a/TRANSLATORS.md
+++ b/TRANSLATORS.md
@ -2,17 +2,15 @@

 The following awesome people contributed to this project by translating it:

-| Locale | Translators                                                                                                  |
-|--------|--------------------------------------------------------------------------------------------------------------|
-| de_DE  | [Jannes Höke](https://github.com/jh0ker)                                                                     |
-| es_ES  | [José.A Rojo](https://github.com/J4RV), [Ricardo Valverde Hernández](https://telegram.me/rivh1), Victor, Yuga|
-| id_ID  | [Erwin Guo](https://www.facebook.com/erwinfransiscus)                                                        |
-| it_IT  | Carola Mariano, ɳick                                                                                         |
-| pt_BR  | [João Rodrigo Couto de Oliveira](http://twitter.com/JoaoRodrigoJR)
-| tr_TR  | [Kasım Ağca](https://telegram.me/Holytotem)
-|
-| zh_CN  | [imlonghao](https://github.com/imlonghao)                                                                    |
-| zh_HK  | [Jed Cheng](https://www.facebook.com/profile.php?id=100002258388821)                                         |
-| zh_TW  | [Eugene Lam](https://www.facebook.com/eugenelam1118), [jimchen5209](https://www.youtube.com/user/jimchen5209), [pan93412](https://www.github.com/pan93412)|       
+| Locale | Translators                                                          |
+|--------|----------------------------------------------------------------------|
+| de_DE  | [Jannes Höke](https://github.com/jh0ker)                             |
+| es_ES  | [Ricardo Valverde Hernández](https://telegram.me/rivh1), Victor, Yuga|
+| id_ID  | [Erwin Guo](https://www.facebook.com/erwinfransiscus)                |
+| it_IT  | Carola Mariano, ɳick                                                 |
+| pt_BR  | [João Rodrigo Couto de Oliveira](http://twitter.com/JoaoRodrigoJR)   |
+| zh_CN  | [imlonghao](https://github.com/imlonghao)                            |
+| zh_HK  | [Jed Cheng](https://www.facebook.com/profile.php?id=100002258388821) |
+| zh_TW  | [Eugene Lam](https://www.facebook.com/eugenelam1118)                 |

-Please add yourself here alphabetically when you submit your first translation.
+Please add yourself here alphabetically when you submit your first translation.
--- a/actions.py
+++ b/actions.py
@ -1,213 +0,0 @@
-import random
-
-import logging
-
-import card as c
-from datetime import datetime
-
-from telegram import Message, Chat
-
-from config import TIME_REMOVAL_AFTER_SKIP, MIN_FAST_TURN_TIME
-from errors import DeckEmptyError, NotEnoughPlayersError
-from internationalization import __, _
-from shared_vars import gm
-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}", multi=game.translate)
-                   .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}", multi=game.translate)
-                       .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.", multi=game.translate)
-                       .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", multi=game.translate))
-
-    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)
-
-
-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)
--- a/bot.py
+++ b/bot.py
@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 #
 # Telegram bot to play UNO in group chats
-# Copyright (c) 2016 Jannes Höke <uno@jhoeke.de>
+# Copyright (c) 2016 - 2017 Jannes Höke <uno@jhoeke.de> and Karho Yau
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as
@ -17,43 +17,45 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.

+
 import logging
 from datetime import datetime
+from random import randint

-from telegram import ParseMode, InlineKeyboardMarkup, \
-    InlineKeyboardButton
+from telegram import ParseMode, Message, Chat, InlineKeyboardMarkup, \
+    InlineKeyboardButton, ReplyKeyboardMarkup, Emoji
 from telegram.ext import InlineQueryHandler, ChosenInlineResultHandler, \
-    CommandHandler, MessageHandler, Filters, CallbackQueryHandler
+    CommandHandler, MessageHandler, Filters, CallbackQueryHandler, RegexHandler
 from telegram.ext.dispatcher import run_async

-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 config import WAITING_TIME, DEFAULT_GAMEMODE, MIN_PLAYERS
-from errors import (NoGameInChatError, LobbyClosedError, AlreadyJoinedError,
-                    NotEnoughPlayersError, DeckEmptyError)
-from internationalization import _, __, user_locale, game_locales
+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, add_mode_classic, add_mode_fast, add_mode_wild)
-from shared_vars import gm, updater, dispatcher
-from simple_commands import help_handler
-from start_bot import start_bot
+                     add_card)
+from user_setting import UserSetting
 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
+import card as c
+from errors import (NoGameInChatError, LobbyClosedError, AlreadyJoinedError,
+                    NotEnoughPlayersError, DeckEmptyError, PlayerLeftError)
+from utils import send_async, answer_async, error, TIMEOUT
+from shared_vars import botan, gm, updater, dispatcher
+from internationalization import _, __, user_locale, game_locales
+import simple_commands
+import settings
+
+from simple_commands import help


 logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    level=logging.INFO
-)
+    level=logging.INFO)
 logger = logging.getLogger(__name__)

+
@user_locale
 def notify_me(bot, update):
    """Handler for /notify_me command, pm people for next game"""
-    chat_id = update.message.chat_id
+    chat_id = update.message.chat.id
    if update.message.chat.type == 'private':
        send_async(bot,
                   chat_id,
@ -62,6 +64,11 @@ def notify_me(bot, update):
    else:
        try:
            gm.remind_dict[chat_id].add(update.message.from_user.id)
+            send_async(bot,
+                       chat_id,
+                       text=_("You will be notified "
+                          "when a new game is started in {title}.").format(
+                                title=update.message.chat.title))
        except KeyError:
            gm.remind_dict[chat_id] = {update.message.from_user.id}

@ -69,66 +76,32 @@ def notify_me(bot, update):
@user_locale
 def new_game(bot, update):
    """Handler for the /new command"""
-    chat_id = update.message.chat_id
+    chat_id = update.message.chat.id

    if update.message.chat.type == 'private':
-        help_handler(bot, update)
+        help(bot, update)

    else:

        if update.message.chat_id in gm.remind_dict:
-            for user in gm.remind_dict[update.message.chat_id]:
+            for user in gm.remind_dict[chat_id]:
                send_async(bot,
                           user,
-                           text=_("A new game has been started in {title}").format(
+                           text=_("A new game has been started in {title}.").format(
                                title=update.message.chat.title))

-            del gm.remind_dict[update.message.chat_id]
+            del gm.remind_dict[chat_id]

        game = gm.new_game(update.message.chat)
-        game.starter = update.message.from_user
-        game.owner.append(update.message.from_user.id)
-        game.mode = DEFAULT_GAMEMODE
+        game.owner = update.message.from_user
        send_async(bot, chat_id,
-                   text=_("Created a new game! Join the game with /join "
+                   text=_("Created a new game! Wait for your friends "
                          "and start the game with /start"))
+        gm.join_game(update.message.from_user, update.message.chat)

+        if botan:
+            botan.track(update.message, 'New games')

-@user_locale
-def kill_game(bot, update):
-    """Handler for the /kill command"""
-    chat = update.message.chat
-    user = update.message.from_user
-    games = gm.chatid_games.get(chat.id)
-
-    if update.message.chat.type == 'private':
-        help_handler(bot, update)
-        return
-
-    if not games:
-            send_async(bot, chat.id,
-                       text=_("There is no running game in this chat."))
-            return
-
-    game = games[-1]
-
-    if user_is_creator_or_admin(user, game, bot, chat):
-
-        try:
-            gm.end_game(chat, user)
-            send_async(bot, chat.id, text=__("Game ended!", multi=game.translate))
-
-        except NoGameInChatError:
-            send_async(bot, chat.id,
-                       text=_("The game is not started yet. "
-                              "Join the game with /join and start the game with /start"),
-                       reply_to_message_id=update.message.message_id)
-
-    else:
-        send_async(bot, chat.id,
-                  text=_("Only the game creator ({name}) and admin can do that.")
-                  .format(name=game.starter.first_name),
-                  reply_to_message_id=update.message.message_id)

@user_locale
 def join_game(bot, update):
@ -136,7 +109,7 @@ def join_game(bot, update):
    chat = update.message.chat

    if update.message.chat.type == 'private':
-        help_handler(bot, update)
+        help(bot, update)
        return

    try:
@ -195,93 +168,16 @@ def leave_game(bot, update):
                   reply_to_message_id=update.message.message_id)

    except NotEnoughPlayersError:
-        gm.end_game(chat, user)
+        gm.end_game(user, chat)
        send_async(bot, chat.id, text=__("Game ended!", multi=game.translate))

    else:
-        if game.started:
-            send_async(bot, chat.id,
-                       text=__("Okay. Next Player: {name}",
-                               multi=game.translate).format(
-                           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)
-
-
-@user_locale
-def kick_player(bot, update):
-    """Handler for the /kick command"""
-
-    if update.message.chat.type == 'private':
-        help_handler(bot, update)
-        return
-
-    chat = update.message.chat
-    user = update.message.from_user
-
-    try:
-        game = gm.chatid_games[chat.id][-1]
-
-    except (KeyError, IndexError):
-            send_async(bot, chat.id,
-                   text=_("No game is running at the moment. "
-                          "Create a new game with /new"),
-                   reply_to_message_id=update.message.message_id)
-            return
-
-    if not game.started:
-        send_async(bot, chat.id,
-                   text=_("The game is not started yet. "
-                          "Join the game with /join and start the game with /start"),
-                   reply_to_message_id=update.message.message_id)
-        return
-
-    if user_is_creator_or_admin(user, game, bot, chat):
-
-        if update.message.reply_to_message:
-            kicked = update.message.reply_to_message.from_user
-
-            try:
-                gm.leave_game(kicked, chat)
-
-            except NoGameInChatError:
-                send_async(bot, chat.id, text=_("Player {name} is not found in the current game.".format(name=display_name(kicked))),
-                                reply_to_message_id=update.message.message_id)
-                return
-
-            except NotEnoughPlayersError:
-                gm.end_game(chat, user)
-                send_async(bot, chat.id,
-                                text=_("{0} was kicked by {1}".format(display_name(kicked), display_name(user))))
-                send_async(bot, chat.id, text=__("Game ended!", multi=game.translate))
-                return
-
-            send_async(bot, chat.id,
-                            text=_("{0} was kicked by {1}".format(display_name(kicked), display_name(user))))
-
-        else:
-            send_async(bot, chat.id,
-                text=_("Please reply to the person you want to kick and type /kick again."),
-                reply_to_message_id=update.message.message_id)
-            return
-
        send_async(bot, chat.id,
                   text=__("Okay. Next Player: {name}",
                           multi=game.translate).format(
                       name=display_name(game.current_player.user)),
                   reply_to_message_id=update.message.message_id)

-    else:
-        send_async(bot, chat.id,
-                  text=_("Only the game creator ({name}) and admin can do that.")
-                  .format(name=game.starter.first_name),
-                  reply_to_message_id=update.message.message_id)
-

 def select_game(bot, update):
    """Handler for callback queries to select the current game"""
@ -336,7 +232,7 @@ def status_update(bot, update):
        except NoGameInChatError:
            pass
        except NotEnoughPlayersError:
-            gm.end_game(chat, user)
+            gm.end_game(user, chat)
            send_async(bot, chat.id, text=__("Game ended!",
                                             multi=game.translate))
        else:
@ -347,7 +243,7 @@ def status_update(bot, update):

@game_locales
@user_locale
-def start_game(bot, update, args, job_queue):
+def start_game(bot, update, args):
    """Handler for the /start command"""

    if update.message.chat.type != 'private':
@ -364,18 +260,15 @@ def start_game(bot, update, args, job_queue):
        if game.started:
            send_async(bot, chat.id, text=_("The game has already started"))

-        elif len(game.players) < MIN_PLAYERS:
+        elif len(game.players) < 2:
            send_async(bot, chat.id,
-                       text=__("At least {minplayers} players must /join the game "
-                              "before you can start it").format(minplayers=MIN_PLAYERS))
+                       text=_("At least two players must /join the game "
+                              "before you can start it"))

        else:
-            # Starting a game
-            game.start()
+            game.play_card(game.last_card)
+            game.started = True

-            for player in game.players:
-                player.draw_first_hand()
-            choice = [[InlineKeyboardButton(text=_("Make your choice!"), switch_inline_query_current_chat='')]]
            first_message = (
                __("First player: {name}\n"
                   "Use /close to stop people from joining the game.\n"
@ -393,11 +286,9 @@ def start_game(bot, update, args, job_queue):

                bot.sendMessage(chat.id,
                                text=first_message,
-                                reply_markup=InlineKeyboardMarkup(choice),
                                timeout=TIMEOUT)

            send_first()
-            start_player_countdown(bot, game, job_queue)

    elif len(args) and args[0] == 'select':
        players = gm.userid_players[update.message.from_user.id]
@ -419,7 +310,7 @@ def start_game(bot, update, args, job_queue):
                   reply_markup=InlineKeyboardMarkup(groups))

    else:
-        help_handler(bot, update)
+        help(bot, update)


@user_locale
@ -436,7 +327,7 @@ def close_game(bot, update):

    game = games[-1]

-    if user.id in game.owner:
+    if game.owner.id == user.id:
        game.open = False
        send_async(bot, chat.id, text=_("Closed the lobby. "
                                        "No more players can join this game."))
@ -444,8 +335,8 @@ def close_game(bot, update):

    else:
        send_async(bot, chat.id,
-                   text=_("Only the game creator ({name}) and admin can do that.")
-                   .format(name=game.starter.first_name),
+                   text=_("Only the game creator ({name}) can do that.")
+                   .format(name=game.owner.first_name),
                   reply_to_message_id=update.message.message_id)
        return

@ -464,15 +355,15 @@ def open_game(bot, update):

    game = games[-1]

-    if user.id in game.owner:
+    if game.owner.id == user.id:
        game.open = True
        send_async(bot, chat.id, text=_("Opened the lobby. "
                                        "New players may /join the game."))
        return
    else:
        send_async(bot, chat.id,
-                   text=_("Only the game creator ({name}) and admin can do that.")
-                   .format(name=game.starter.first_name),
+                   text=_("Only the game creator ({name}) can do that")
+                   .format(name=game.owner.first_name),
                   reply_to_message_id=update.message.message_id)
        return

@ -491,7 +382,7 @@ def enable_translations(bot, update):

    game = games[-1]

-    if user.id in game.owner:
+    if game.owner.id == user.id:
        game.translate = True
        send_async(bot, chat.id, text=_("Enabled multi-translations. "
                                        "Disable with /disable_translations"))
@ -499,8 +390,8 @@ def enable_translations(bot, update):

    else:
        send_async(bot, chat.id,
-                   text=_("Only the game creator ({name}) and admin can do that.")
-                   .format(name=game.starter.first_name),
+                   text=_("Only the game creator ({name}) can do that")
+                   .format(name=game.owner.first_name),
                   reply_to_message_id=update.message.message_id)
        return

@ -519,7 +410,7 @@ def disable_translations(bot, update):

    game = games[-1]

-    if user.id in game.owner:
+    if game.owner.id == user.id:
        game.translate = False
        send_async(bot, chat.id, text=_("Disabled multi-translations. "
                                        "Enable them again with "
@ -528,12 +419,53 @@ def disable_translations(bot, update):

    else:
        send_async(bot, chat.id,
-                   text=_("Only the game creator ({name}) and admin can do that.")
-                   .format(name=game.starter.first_name),
+                   text=_("Only the game creator ({name}) can do that")
+                   .format(name=game.owner.first_name),
                   reply_to_message_id=update.message.message_id)
        return

+    
+@game_locales
+@user_locale
+def mode(bot, update):
+    """Handler for the /mode command"""
+    chat = update.message.chat
+    user = update.message.from_user
+    games = gm.chatid_games.get(chat.id)

+    if not games:
+        send_async(bot, chat.id,
+                   text=__("There is no running game in this chat."))
+        return
+
+    game = games[-1]
+    
+    if chat.type == 'private':
+        send_async(bot, chat.id,
+                   text=_("Please change the group mode in the public game group with "
+                          "the bot."))
+        return
+
+    if game.owner.id == user.id and not games.started:
+        kb = [["🎻 " + _("Original"), "🚴 " + _("Progressive UNO")]]
+        markup = ReplyKeyboardMarkup(kb, resize_keyboard=True, one_time_keyboard=True)
+        choice = send_async(bot, chat.id, text=_("Choose the game mode:"), reply_markup = markup)
+        if choice[0] == "🎻":
+            game.mode = 0
+            send_async(bot, chat.id, text=_("Original rules will be used."))
+        else if choice[0] == "🚴":
+            game.mode = 1
+            send_async(bot, chat.id, text=_("Progressive UNO rules will be used."))
+        return
+
+    else:
+        send_async(bot, chat.id,
+                   text=_("Only the game creator ({name}) can do that when the game does not start")
+                   .format(name=game.owner.first_name),
+                   reply_to_message_id=update.message.message_id)
+        return
+
+    
@game_locales
@user_locale
 def skip_player(bot, update):
@ -549,14 +481,13 @@ def skip_player(bot, update):

    game = player.game
    skipped_player = game.current_player
+    next_player = game.current_player.next

    started = skipped_player.turn_started
    now = datetime.now()
    delta = (now - started).seconds

-    # 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:
+    if delta < skipped_player.waiting_time:
        n = skipped_player.waiting_time - delta
        send_async(bot, chat.id,
                   text=_("Please wait {time} second",
@ -564,8 +495,52 @@ def skip_player(bot, update):
                          n)
                   .format(time=n),
                   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:
-        do_skip(bot, player)
+        try:
+            gm.leave_game(skipped_player.user, chat)
+            send_async(bot, chat.id,
+                       text=__("{name1} was skipped three 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 three 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)))
+
+            us2 = UserSetting.get(id=skipped_player.user.id)
+            if us2 and us2.stats:
+                us2.games_played += 1
+                
+            gm.end_game(skipped_player.user, chat)
+           


@game_locales
@ -579,25 +554,15 @@ def reply_to_query(bot, update):
    switch = None

    try:
-        user = update.inline_query.from_user
-        user_id = user.id
+        user_id = update.inline_query.from_user.id
        players = gm.userid_players[user_id]
        player = gm.userid_current[user_id]
        game = player.game
    except KeyError:
        add_no_game(results)
    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 user_is_creator(user, game):
-                add_mode_classic(results)
-                add_mode_fast(results)
-                add_mode_wild(results)
-            else:
-                add_not_started(results)
-
+            add_not_started(results)

        elif user_id == game.current_player.user.id:
            if game.choosing_color:
@ -643,7 +608,7 @@ def reply_to_query(bot, update):

@game_locales
@user_locale
-def process_result(bot, update, job_queue):
+def process_result(bot, update):
    """
    Handler for chosen inline results.
    Checks the players actions and acts accordingly.
@ -665,13 +630,6 @@ def process_result(bot, update, job_queue):

    if result_id in ('hand', 'gameinfo', 'nogame'):
        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
        return
    elif int(anti_cheat) != last_anti_cheat:
@ -688,44 +646,150 @@ def process_result(bot, update, job_queue):
    elif result_id == 'pass':
        game.turn()
    elif result_id in c.COLORS:
-        game.choose_color(result_id)
+        try:
+            game.choose_color(result_id)
+        except PlayerLeftError:
+            send_async(bot, chat.id,
+                       text=__("There are errors in choosing color. "
+                               "Color is now unchanged.", multi=game.translate))
+            game.turn()
    else:
        reset_waiting_time(bot, player)
        do_play_card(bot, player, result_id)

-    if game_is_running(game):
-        nextplayer_message = (
-            __("Next player: {name}", multi=game.translate)
-            .format(name=display_name(game.current_player.user)))
-        choice = [[InlineKeyboardButton(text=_("Make your choice!"), switch_inline_query_current_chat='')]]
+    if game in gm.chatid_games.get(chat.id, list()):
        send_async(bot, chat.id,
-                        text=nextplayer_message,
-                        reply_markup=InlineKeyboardMarkup(choice))
-        start_player_countdown(bot, game, job_queue)
+                   text=__("Next player: {name}", multi=game.translate)
+                   .format(name=display_name(game.current_player.user)))


 def reset_waiting_time(bot, player):
    """Resets waiting time for a player and sends a notice to the group"""
    chat = player.game.chat

-    if player.waiting_time < WAITING_TIME:
-        player.waiting_time = WAITING_TIME
+    if player.waiting_time < 60:
+        player.waiting_time = 60
        send_async(bot, chat.id,
-                   text=__("Waiting time for {name} has been reset to {time} "
+                   text=__("Waiting time for {name} has been reset to 60 "
                           "seconds", multi=player.game.translate)
-                   .format(name=display_name(player.user), time=WAITING_TIME))
+                   .format(name=display_name(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(user, chat)
+
+    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 {numbers} cards to {name}",
+                           multi=game.translate)
+                   .format(name=player.prev.user.first_name,
+                           numbers=game.draw_counter))
+
+        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 {numbers} cards to {name2}",
+                           multi=game.translate)
+                   .format(name1=player.prev.user.first_name,
+                           name2=player.user.first_name,
+                           numbers=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))
+
+    game.turn()


 # Add all handlers to the dispatcher and run the bot
 dispatcher.add_handler(InlineQueryHandler(reply_to_query))
-dispatcher.add_handler(ChosenInlineResultHandler(process_result, pass_job_queue=True))
+dispatcher.add_handler(ChosenInlineResultHandler(process_result))
 dispatcher.add_handler(CallbackQueryHandler(select_game))
-dispatcher.add_handler(CommandHandler('start', start_game, pass_args=True, pass_job_queue=True))
+dispatcher.add_handler(CommandHandler('start', start_game, pass_args=True))
 dispatcher.add_handler(CommandHandler('new', new_game))
-dispatcher.add_handler(CommandHandler('kill', kill_game))
 dispatcher.add_handler(CommandHandler('join', join_game))
 dispatcher.add_handler(CommandHandler('leave', leave_game))
-dispatcher.add_handler(CommandHandler('kick', kick_player))
 dispatcher.add_handler(CommandHandler('open', open_game))
 dispatcher.add_handler(CommandHandler('close', close_game))
 dispatcher.add_handler(CommandHandler('enable_translations',
@ -734,9 +798,11 @@ dispatcher.add_handler(CommandHandler('disable_translations',
                                      disable_translations))
 dispatcher.add_handler(CommandHandler('skip', skip_player))
 dispatcher.add_handler(CommandHandler('notify_me', notify_me))
+dispatcher.add_handler(CommandHandler('mode', mode))
+dispatcher.add_handler(RegexHandler('^(Original|Progressive UNO)$', mode, pass_groups=True))
 simple_commands.register()
 settings.register()
-dispatcher.add_handler(MessageHandler(Filters.status_update, status_update))
+dispatcher.add_handler(MessageHandler([Filters.status_update], status_update))
 dispatcher.add_error_handler(error)

 start_bot(updater)
--- a/card.py
+++ b/card.py
@ -18,6 +18,8 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.


+from telegram.emoji import Emoji
+
 # Colors
 RED = 'r'
 BLUE = 'b'
@ -28,10 +30,10 @@ BLACK = 'x'
 COLORS = (RED, BLUE, GREEN, YELLOW)

 COLOR_ICONS = {
-    RED: '❤️',
-    BLUE: '💙',
-    GREEN: '💚',
-    YELLOW: '💛',
+    RED: Emoji.HEAVY_BLACK_HEART,
+    BLUE: Emoji.BLUE_HEART,
+    GREEN: Emoji.GREEN_HEART,
+    YELLOW: Emoji.YELLOW_HEART,
    BLACK: '⬛️'
 }

@ -52,7 +54,6 @@ SKIP = 'skip'

 VALUES = (ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, DRAW_TWO,
          REVERSE, SKIP)
-WILD_VALUES = (ONE, TWO, THREE, FOUR, FIVE, DRAW_TWO, REVERSE, SKIP)

 # Special cards
 CHOOSE = 'colorchooser'
--- a/chat_setting.py
+++ b/chat_setting.py
@ -18,18 +18,4 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.


-import json
-
-with open("config.json","r") as f:
-    config = json.loads(f.read())
-
-TOKEN=config.get("token")
-WORKERS=config.get("workers", 32)
-ADMIN_LIST = config.get("admin_list", None)
-OPEN_LOBBY = config.get("open_lobby", True)
-ENABLE_TRANSLATIONS = config.get("enable_translations", False)
-DEFAULT_GAMEMODE = config.get("default_gamemode", "fast")
-WAITING_TIME = config.get("waiting_time", 120)
-TIME_REMOVAL_AFTER_SKIP = config.get("time_removal_after_skip", 20)
-MIN_FAST_TURN_TIME = config.get("min_fast_turn_time", 15)
-MIN_PLAYERS = config.get("min_players", 2)
+pass
--- a/config.json.example
+++ b/config.json.example
@ -1,12 +0,0 @@
-{
-    "token": "token_here",
-    "admin_list": [0],
-    "open_lobby": true,
-    "enable_translations": false,
-    "workers": 32,
-    "default_gamemode": "fast",
-    "waiting_time": 120,
-    "time_removal_after_skip": 20,
-    "min_fast_turn_time": 15,
-    "min_players": 2
-}
--- a/credentials.py
+++ b/credentials.py
@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+#
+# Telegram bot to play UNO in group chats
+# Copyright (c) 2016 Jannes Höke <uno@jhoeke.de>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+
+TOKEN = 'TOKEN'
+BOTAN_TOKEN = ''  # Optional: Add a botan.io token if you want bot statistics
--- a/database.py
+++ b/database.py
@ -18,7 +18,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.


-from pony.orm import Database
+from pony.orm import Database, db_session, Optional, Required, Set, PrimaryKey

 # Database singleton
 db = Database()
--- a/deck.py
+++ b/deck.py
@ -34,7 +34,18 @@ class Deck(object):
        self.graveyard = list()
        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.shuffle()

    def shuffle(self):
        """Shuffles the deck"""
@ -58,31 +69,4 @@ class Deck(object):

    def dismiss(self, card):
        """Returns a card to the deck"""
-        if card.special:
-            card.color = None
        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()
--- a/errors.py
+++ b/errors.py
@ -36,3 +36,7 @@ class NotEnoughPlayersError(Exception):

 class DeckEmptyError(Exception):
    pass
+
+
+class PlayerLeftError(Exception):
+    pass
--- a/game.py
+++ b/game.py
@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 #
 # Telegram bot to play UNO in group chats
-# Copyright (c) 2016 Jannes Höke <uno@jhoeke.de>
+# Copyright (c) 2016 - 2017 Jannes Höke <uno@jhoeke.de> and Karho Yau
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as
@ -19,32 +19,33 @@


 import logging
-from config import ADMIN_LIST, OPEN_LOBBY, DEFAULT_GAMEMODE, ENABLE_TRANSLATIONS
 from datetime import datetime

 from deck import Deck
 import card as c

+
 class Game(object):
    """ This class represents a game of UNO """
    current_player = None
    reversed = False
+    draw_counter = 0
    choosing_color = False
    started = False
-    draw_counter = 0
+    owner = None
+    open = True
+    translate = False
    players_won = 0
-    starter = None
-    mode = DEFAULT_GAMEMODE
-    job = None
-    owner = ADMIN_LIST
-    open = OPEN_LOBBY
-    translate = ENABLE_TRANSLATIONS
+    mode = 0

    def __init__(self, chat):
        self.chat = chat
        self.last_card = None
+        self.joined_before = set()

-        self.deck = Deck()
+        while not self.last_card or self.last_card.special:
+            self.deck = Deck()
+            self.last_card = self.deck.draw()

        self.logger = logging.getLogger(__name__)

@ -63,18 +64,6 @@ class Game(object):
            itplayer = itplayer.next
        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):
        """Reverses the direction of game"""
        self.reversed = not self.reversed
@ -87,20 +76,6 @@ class Game(object):
        self.current_player.turn_started = datetime.now()
        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):
        """
        Plays a card and triggers its effects.
--- a/game_manager.py
+++ b/game_manager.py
@ -19,6 +19,7 @@


 import logging
+import random

 from game import Game
 from player import Player
@ -77,26 +78,31 @@ class GameManager(object):
        # Don not re-add a player and remove the player from previous games in
        # this chat, if he is in one of them
        for player in players:
-            if player in game.players:
+            # Try to pervent someone win or leave then join again.
+            if player in game.players or user.id in game.joined_before: 
                raise AlreadyJoinedError()
+        else:
+            try:
+                self.leave_game(user, chat)
+            except NoGameInChatError:
+                pass
+            except NotEnoughPlayersError:
+                self.end_game(chat, user)

-        try:
-            self.leave_game(user, chat)
-        except NoGameInChatError:
-            pass
-        except NotEnoughPlayersError:
-            self.end_game(chat, user)
+                if user.id not in self.userid_players:
+                    self.userid_players[user.id] = list()

-            if user.id not in self.userid_players:
-                self.userid_players[user.id] = list()
-
-            players = self.userid_players[user.id]
+                players = self.userid_players[user.id]

        player = Player(game, user)
-        if game.started:
-            player.draw_first_hand()
-
-        players.append(player)
+        
+        # Randomize player position.
+        game.joined_before.append(user.id)
+        if len(players) > 2:
+          players.insert(random.randrange(len(players)), player)
+        else:
+          players.append(player)
+                       
        self.userid_current[user.id] = player

    def leave_game(self, user, chat):
@ -115,8 +121,8 @@ class GameManager(object):

                        p.leave()
                        return
-
-            raise NoGameInChatError
+            else:
+                raise NoGameInChatError

        game = player.game

@ -137,7 +143,7 @@ class GameManager(object):
                del self.userid_current[user.id]
                del self.userid_players[user.id]

-    def end_game(self, chat, user):
+    def end_game(self, user, chat):
        """
        End a game
        """
@ -187,4 +193,5 @@ class GameManager(object):
        for player in players:
            if player.game.chat.id == chat.id:
                return player
-        return None
+        else:
+            return None
--- a/genpot.sh
+++ b/genpot.sh
@ -1,12 +0,0 @@
-#!/usr/bin/bash
-
-currentVer='1.0'
-
-xgettext *.py -o ./locales/unobot.pot --foreign-user \
-  --package-name="uno_bot" \
-  --package-version="$currentVer" \
-  --msgid-bugs-address='uno@jhoeke.de' \
-  --keyword=__ \
-  --keyword=_ \
-  --keyword=_:1,2 \
-  --keyword=__:1,2
--- a/images/webp/b_0.webp
+++ b/images/webp/b_0.webp
--- a/images/webp/b_1.webp
+++ b/images/webp/b_1.webp
--- a/images/webp/b_2.webp
+++ b/images/webp/b_2.webp
--- a/images/webp/b_3.webp
+++ b/images/webp/b_3.webp
--- a/images/webp/b_4.webp
+++ b/images/webp/b_4.webp
--- a/images/webp/b_5.webp
+++ b/images/webp/b_5.webp
--- a/images/webp/b_6.webp
+++ b/images/webp/b_6.webp
--- a/images/webp/b_7.webp
+++ b/images/webp/b_7.webp
--- a/images/webp/b_8.webp
+++ b/images/webp/b_8.webp
--- a/images/webp/b_9.webp
+++ b/images/webp/b_9.webp
--- a/images/webp/b_draw.webp
+++ b/images/webp/b_draw.webp
--- a/images/webp/b_reverse.webp
+++ b/images/webp/b_reverse.webp
--- a/images/webp/b_skip.webp
+++ b/images/webp/b_skip.webp
--- a/images/webp/colorchooser.webp
+++ b/images/webp/colorchooser.webp
--- a/images/webp/draw_four.webp
+++ b/images/webp/draw_four.webp
--- a/images/webp/g_0.webp
+++ b/images/webp/g_0.webp
--- a/images/webp/g_1.webp
+++ b/images/webp/g_1.webp
--- a/images/webp/g_2.webp
+++ b/images/webp/g_2.webp
--- a/images/webp/g_3.webp
+++ b/images/webp/g_3.webp
--- a/images/webp/g_4.webp
+++ b/images/webp/g_4.webp
--- a/images/webp/g_5.webp
+++ b/images/webp/g_5.webp
--- a/images/webp/g_6.webp
+++ b/images/webp/g_6.webp
--- a/images/webp/g_7.webp
+++ b/images/webp/g_7.webp
--- a/images/webp/g_8.webp
+++ b/images/webp/g_8.webp
--- a/images/webp/g_9.webp
+++ b/images/webp/g_9.webp
--- a/images/webp/g_draw.webp
+++ b/images/webp/g_draw.webp
--- a/images/webp/g_reverse.webp
+++ b/images/webp/g_reverse.webp
--- a/images/webp/g_skip.webp
+++ b/images/webp/g_skip.webp
--- a/images/webp/option_bluff.webp
+++ b/images/webp/option_bluff.webp
--- a/images/webp/option_draw.webp
+++ b/images/webp/option_draw.webp
--- a/images/webp/option_draw_old.webp
+++ b/images/webp/option_draw_old.webp
--- a/images/webp/option_info.webp
+++ b/images/webp/option_info.webp
--- a/images/webp/option_pass.webp
+++ b/images/webp/option_pass.webp
--- a/images/webp/option_pass_old.webp
+++ b/images/webp/option_pass_old.webp
--- a/images/webp/r_0.webp
+++ b/images/webp/r_0.webp
--- a/images/webp/r_1.webp
+++ b/images/webp/r_1.webp
--- a/images/webp/r_2.webp
+++ b/images/webp/r_2.webp
--- a/images/webp/r_3.webp
+++ b/images/webp/r_3.webp
--- a/images/webp/r_4.webp
+++ b/images/webp/r_4.webp
--- a/images/webp/r_5.webp
+++ b/images/webp/r_5.webp
--- a/images/webp/r_6.webp
+++ b/images/webp/r_6.webp
--- a/images/webp/r_7.webp
+++ b/images/webp/r_7.webp
--- a/images/webp/r_8.webp
+++ b/images/webp/r_8.webp
--- a/images/webp/r_9.webp
+++ b/images/webp/r_9.webp
--- a/images/webp/r_draw.webp
+++ b/images/webp/r_draw.webp
--- a/images/webp/r_reverse.webp
+++ b/images/webp/r_reverse.webp
--- a/images/webp/r_skip.webp
+++ b/images/webp/r_skip.webp
--- a/images/webp/y_0.webp
+++ b/images/webp/y_0.webp
--- a/images/webp/y_1.webp
+++ b/images/webp/y_1.webp
--- a/images/webp/y_2.webp
+++ b/images/webp/y_2.webp
--- a/images/webp/y_3.webp
+++ b/images/webp/y_3.webp
--- a/images/webp/y_4.webp
+++ b/images/webp/y_4.webp
--- a/images/webp/y_5.webp
+++ b/images/webp/y_5.webp
--- a/images/webp/y_6.webp
+++ b/images/webp/y_6.webp
--- a/images/webp/y_7.webp
+++ b/images/webp/y_7.webp
--- a/images/webp/y_8.webp
+++ b/images/webp/y_8.webp
--- a/images/webp/y_9.webp
+++ b/images/webp/y_9.webp
--- a/images/webp/y_draw.webp
+++ b/images/webp/y_draw.webp
--- a/images/webp/y_reverse.webp
+++ b/images/webp/y_reverse.webp
--- a/images/webp/y_skip.webp
+++ b/images/webp/y_skip.webp
--- a/images/webp_lowsat/b_0.webp
+++ b/images/webp_lowsat/b_0.webp
--- a/images/webp_lowsat/b_1.webp
+++ b/images/webp_lowsat/b_1.webp
--- a/images/webp_lowsat/b_2.webp
+++ b/images/webp_lowsat/b_2.webp
--- a/images/webp_lowsat/b_3.webp
+++ b/images/webp_lowsat/b_3.webp
--- a/images/webp_lowsat/b_4.webp
+++ b/images/webp_lowsat/b_4.webp
--- a/images/webp_lowsat/b_5.webp
+++ b/images/webp_lowsat/b_5.webp
--- a/images/webp_lowsat/b_6.webp
+++ b/images/webp_lowsat/b_6.webp
--- a/images/webp_lowsat/b_7.webp
+++ b/images/webp_lowsat/b_7.webp
--- a/images/webp_lowsat/b_8.webp
+++ b/images/webp_lowsat/b_8.webp
--- a/images/webp_lowsat/b_9.webp
+++ b/images/webp_lowsat/b_9.webp
--- a/images/webp_lowsat/b_draw.webp
+++ b/images/webp_lowsat/b_draw.webp
--- a/images/webp_lowsat/b_reverse.webp
+++ b/images/webp_lowsat/b_reverse.webp
--- a/images/webp_lowsat/b_skip.webp
+++ b/images/webp_lowsat/b_skip.webp
--- a/images/webp_lowsat/colorchooser.webp
+++ b/images/webp_lowsat/colorchooser.webp
--- a/images/webp_lowsat/draw_four.webp
+++ b/images/webp_lowsat/draw_four.webp
--- a/images/webp_lowsat/g_0.webp
+++ b/images/webp_lowsat/g_0.webp
--- a/images/webp_lowsat/g_1.webp
+++ b/images/webp_lowsat/g_1.webp
--- a/images/webp_lowsat/g_2.webp
+++ b/images/webp_lowsat/g_2.webp
--- a/images/webp_lowsat/g_3.webp
+++ b/images/webp_lowsat/g_3.webp
--- a/images/webp_lowsat/g_4.webp
+++ b/images/webp_lowsat/g_4.webp
--- a/images/webp_lowsat/g_5.webp
+++ b/images/webp_lowsat/g_5.webp
--- a/images/webp_lowsat/g_6.webp
+++ b/images/webp_lowsat/g_6.webp
--- a/Show more
+++ b/Show more
Author	SHA1	Message	Date
Jarv	538c5b0ab6	Improved most messages in spanish (#39 )	2017-09-19 17:31:53 +02:00
Karho	14bd90ea92	Update bot.py	2017-03-04 09:30:09 +08:00
Karho	9dde74381e	Update bot.py Removing Typos	2017-03-04 09:17:52 +08:00
Karho	683d203984	Update bot.py Adding mode function	2017-03-04 09:17:20 +08:00
Karho	d8dfb438a3	Update game_manager.py Changing the function end_game order to (self, user, chat)	2017-03-03 19:40:40 +08:00
Karho	52296e6df8	Update player.py	2017-02-24 14:16:52 +08:00
Karho	4c386218b0	Update player.py Adding a new mode part in the function _card_playable.	2017-02-24 14:15:08 +08:00
Karho	393da434e8	Update game.py Adding a new option "mode"	2017-02-24 13:39:14 +08:00
Karho	fae55f758d	Merge pull request #30 from jh0ker/master Update README.md	2017-02-24 13:32:34 +08:00
Karho	92c07d12ad	Update bot.py Changing the function process_result on result_id in c.COLORS such that there is a try-except statement to prevent a deadlock in choosing colors.	2017-02-18 00:06:41 +08:00
Karho	bffd7fb1c3	Update errors.py Adding a new PlayerLeftError	2017-02-17 22:55:11 +08:00
Karho	69dc39bb56	Update player.py Correcting the code once again as the last commit.	2017-02-17 22:47:16 +08:00
Karho	75e3076285	Update player.py Reverting back to the original rule.	2017-02-17 22:05:24 +08:00
Karho	f2e7a14318	Update bot.py Adding the function notify_me more texts in else part. Adding the function new_game to make players create a new game and join the game with the same command. Changing the function reset_waiting_time to 60 seconds. Changing the function skip_player in the else part to include the stats part for skipped_player.	2017-02-17 19:35:56 +08:00
Karho	0114fe774d	Update game.py Using set()) instead of list in self.joined_before	2017-02-17 11:45:53 +08:00
Karho	615bb35359	Combining with "patch" branch (#29 ) * Update unobot.po * Update test_player.py * Update test_player.py * Update test_player.py * Update test_player.py * Update player.py * Update player.py * Update internationalization.py * Update internationalization.py * Update test_player.py * Update test_player.py * Update test_player.py * Update player.py * Update player.py * Update player.py * Update test_player.py * Update test_player.py * revert play 4 then 4 rule * Update test_player.py * Update player.py * Update player.py * Update player.py * Update game.py * Update game_manager.py * Update game_manager.py * Update game_manager.py * Update player.py * Update test_player.py * Update player.py * Update bot.py * Update credentials.py * Update credentials.py * Update bot.py * Update game.py * Update game_manager.py * Update game_manager.py * Update player.py	2017-02-16 18:43:44 +08:00