177 lines
6.2 KiB

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from card import COLORS, SPECIALS
from card import RED, BLUE, GREEN, YELLOW
from card import GREY_ID
from random import choice, random
import logging
logger = logging.getLogger('card')
def color_from_str(string):
"""Decodes a Card object from a string"""
# Actuall it should't be "in special"
if string not in SPECIALS:
color, value = string.split('_')
del value
return color
def cards_sum(deck):
"""How many cards do we have in each color?"""
# r, b, g, y
card_count = {RED: 0, BLUE: 0, GREEN: 0, YELLOW: 0}
for card in deck:
c = color_from_str(card)
if c in card_count:
card_count[c] += 1
return card_count
def color_choice(deck, greydeck):
"""Now that we are doing a color choice, which color should we choose?"""
full_deck = deck + greydeck
sum = cards_sum(full_deck)
chosen_color = None
chosen_number = 0
for color in (RED, BLUE, GREEN, YELLOW):
if chosen_number <= sum[color]:
chosen_number = sum[color]
chosen_color = color
if chosen_number == 0 or chosen_color is None:
chosen_color = choice((RED, BLUE, GREEN, YELLOW))
return chosen_color
def randchance(chance=0.5):
""" make simple random choice
chance can be any number between 0,1
if chance > random():
return True
return False
class Game():
def __init__(self):
self.deck = list()
self.greydeck = list()
self.old_deck = list()
self.old_greydeck = list()
self.special = list()
self.functional = list()
# functional = draw, call_bluff, pass
# call_bluff > draw
self.choose_color = list()
self.joined = None #may be None or a a list of group entity
self.is_playing = False
self.anti_cheat = ''
self.delay = None
def join_game(self, group):
if self.joined is None:
self.joined = list()
if group in self.joined:
return True
def leave_game(self, group):
if self.joined:
except ValueError:
returnValue = False
returnValue = True
if (self.joined is not None) and (not self.joined):
self.joined = None
return returnValue
def start_game(self):
self.is_playing = True
def stop_game(self):
self.is_playing = False
# delay is set in
#self.delay = None
def rotate_deck(self):
"""Memorize deck for for 1 round in case of color choose"""
if len(self.choose_color):
# when choosing color, the bot cannot get any ordinary card. (deck and greydeck are all empty)
if len(self.deck) != 0 or len(self.greydeck) != 0:
logger.critical('Unexpected behavior: there\'s cards in deck while choosing color.')
self.old_deck = self.deck
self.old_greydeck = self.greydeck
def clear_deck(self, rotate=False):
if not rotate:
self.old_deck = list()
self.old_greydeck = list()
self.deck = list()
self.greydeck = list()
self.special = list()
self.functional = list()
self.choose_color = list()
self.anti_cheat = ''
def print_cards(self):
""" print all of my cards
returns a string that is printable
note that currently the bot just ignores unplayable special cards
if len(self.choose_color):
return str(self.choose_color + self.old_deck + ["[u]" + s for s in self.old_greydeck] + self.special + self.functional)
return str(self.deck + ["[u]" + s for s in self.greydeck] + self.special + self.functional)
def add_grey_card(self, set_id, card_id):
"""get grey_cards from set_id + card_id, and add them"""
grey_card = GREY_ID.get(int(set_id), {}).get(int(card_id), None)
if grey_card:
else:'Can\'t get any card from the given id {}'.format(card_id))
def add_card(self, result_id, anti_cheat):
"""add card to deck, refer to the code of unobot for more info"""
self.anti_cheat = anti_cheat
if result_id in ('hand', 'gameinfo', 'nogame'):
elif result_id.startswith('mode_'):
elif len(result_id) == 36:
elif result_id == 'call_bluff':
elif result_id == 'draw':
elif result_id == 'pass':
elif result_id in COLORS:
elif result_id in SPECIALS:
def play_card(self):
''' The bot plays its card.
The deck is refreshed every round,
currently the bot is unable to know its previously played cards.
# in case we are choosing color
if len(self.choose_color):
return color_choice(self.old_deck, self.old_greydeck)
# play ordinary cards
# and always take special cards into account
elif len(self.deck):
if len(self.special) and randchance(0.1):
return choice(self.special)
return choice(self.deck)
# if we don't have any ordinary cards to play
# maybe there's a plus four?
elif len(self.special):
return choice(self.special)
elif len(self.functional):
# or maybe there's a pass?
if 'pass' in self.functional:
return 'pass'
# still no? call his bluff!
if 'call_bluff' in self.functional and randchance(0.05):
return 'call_bluff'
# what is left? probably draw(
return choice(self.functional)