def test_call_riichi(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.init_game()
manager.init_round()
client = clients[0]
self.assertEqual(manager.riichi_sticks, 0)
self.assertEqual(client.player.scores, 25000)
self.assertEqual(client.player.in_riichi, False)
manager.call_riichi(client)
self.assertEqual(manager.riichi_sticks, 1)
self.assertEqual(client.player.scores, 24000)
self.assertEqual(client.player.in_riichi, True)
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.init_game()
manager.init_round()
manager.call_riichi(clients[0])
self.assertEqual(clients[0].player.in_riichi, True)
self.assertEqual(clients[1].player.in_riichi, False)
self.assertEqual(clients[2].player.in_riichi, False)
self.assertEqual(clients[3].player.in_riichi, False)
for client in clients:
client.player.in_riichi = False
manager.call_riichi(clients[1])
self.assertEqual(clients[0].player.in_riichi, False)
self.assertEqual(clients[1].player.in_riichi, True)
self.assertEqual(clients[2].player.in_riichi, False)
self.assertEqual(clients[3].player.in_riichi, False)
for client in clients:
client.player.in_riichi = False
manager.call_riichi(clients[2])
self.assertEqual(clients[0].player.in_riichi, False)
self.assertEqual(clients[1].player.in_riichi, False)
self.assertEqual(clients[2].player.in_riichi, True)
self.assertEqual(clients[3].player.in_riichi, False)
for client in clients:
client.player.in_riichi = False
manager.call_riichi(clients[3])
self.assertEqual(clients[0].player.in_riichi, False)
self.assertEqual(clients[1].player.in_riichi, False)
self.assertEqual(clients[2].player.in_riichi, False)
self.assertEqual(clients[3].player.in_riichi, True)
def setUp(self):
self.case1 = GameManager(number_of_players=2,
sequence='RYGPBRYGBRPOP',
deck='R, B, GG, Y, P, B, P, RR')
self.case2 = GameManager(number_of_players=2,
sequence='​RYGRYB',
deck='R, YY, G, G, B')
self.case3 = GameManager(number_of_players=3,
sequence='QQQQQQQQQ',
deck='Q, QQ, Q, Q, QQ, Q')
def test_init_dealer(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.set_dealer(0)
manager.init_round()
self.assertTrue(manager.clients[0].player.is_dealer)
self.assertFalse(manager.clients[1].player.is_dealer)
self.assertFalse(manager.clients[2].player.is_dealer)
self.assertFalse(manager.clients[3].player.is_dealer)
manager.set_dealer(1)
manager.init_round()
self.assertTrue(manager.clients[1].player.is_dealer)
self.assertFalse(manager.clients[0].player.is_dealer)
self.assertFalse(manager.clients[2].player.is_dealer)
self.assertFalse(manager.clients[3].player.is_dealer)
manager.set_dealer(2)
manager.init_round()
self.assertTrue(manager.clients[2].player.is_dealer)
self.assertFalse(manager.clients[0].player.is_dealer)
self.assertFalse(manager.clients[1].player.is_dealer)
self.assertFalse(manager.clients[3].player.is_dealer)
manager.set_dealer(3)
manager.init_round()
self.assertTrue(manager.clients[3].player.is_dealer)
self.assertFalse(manager.clients[0].player.is_dealer)
self.assertFalse(manager.clients[1].player.is_dealer)
self.assertFalse(manager.clients[2].player.is_dealer)
def post(self, request):
"""Check form data, and send the result if form is valid"""
form = GameForm(request.POST)
context = {'form': form}
if form.is_valid():
# Initialize instance of game
game = GameManager(number_of_players=form.cleaned_data.get(
'number_of_players', 0),
sequence=form.cleaned_data.get('board', ''),
deck=form.cleaned_data.get('deck', ''))
game_result = game.result()
# Save game data at database
self.model.objects.create(
players=form.cleaned_data.get('number_of_players', None),
squares=form.cleaned_data.get('number_of_squares', None),
cards=form.cleaned_data.get('number_of_cards', None),
sequence=form.cleaned_data.get('board', None),
deck=form.cleaned_data.get('deck', None),
result=game_result)
# Send result of game to client side
context['result'] = game_result
else:
context['error'] = 'Form is not valid!'
return render(request, self.template_name, context)
def test_scores_calculations_after_retake(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.init_game()
manager.init_round()
manager.process_the_end_of_the_round(None, None, None, None, False)
self.assertEqual(clients[0].player.scores, 25000)
self.assertEqual(clients[1].player.scores, 25000)
self.assertEqual(clients[2].player.scores, 25000)
self.assertEqual(clients[3].player.scores, 25000)
clients[0].player.in_tempai = True
manager.process_the_end_of_the_round(None, None, None, None, False)
self.assertEqual(clients[0].player.scores, 28000)
self.assertEqual(clients[1].player.scores, 24000)
self.assertEqual(clients[2].player.scores, 24000)
self.assertEqual(clients[3].player.scores, 24000)
for client in clients:
client.player.scores = 25000
clients[0].player.in_tempai = True
clients[1].player.in_tempai = True
manager.process_the_end_of_the_round(None, None, None, None, False)
self.assertEqual(clients[0].player.scores, 26500)
self.assertEqual(clients[1].player.scores, 26500)
self.assertEqual(clients[2].player.scores, 23500)
self.assertEqual(clients[3].player.scores, 23500)
for client in clients:
client.player.scores = 25000
clients[0].player.in_tempai = True
clients[1].player.in_tempai = True
clients[2].player.in_tempai = True
manager.process_the_end_of_the_round(None, None, None, None, False)
self.assertEqual(clients[0].player.scores, 26000)
self.assertEqual(clients[1].player.scores, 26000)
self.assertEqual(clients[2].player.scores, 26000)
self.assertEqual(clients[3].player.scores, 22000)
for client in clients:
client.player.scores = 25000
clients[0].player.in_tempai = True
clients[1].player.in_tempai = True
clients[2].player.in_tempai = True
clients[3].player.in_tempai = True
manager.process_the_end_of_the_round(None, None, None, None, False)
self.assertEqual(clients[0].player.scores, 25000)
self.assertEqual(clients[1].player.scores, 25000)
self.assertEqual(clients[2].player.scores, 25000)
self.assertEqual(clients[3].player.scores, 25000)
def test_is_game_end_by_negative_scores(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.set_dealer(0)
manager.init_round()
winner = clients[0]
loser = clients[1]
loser.player.scores = 500
result = manager.process_the_end_of_the_round(list(range(0, 14)), 0,
winner, loser, False)
self.assertEqual(loser.player.scores, -500)
self.assertEqual(result['is_game_end'], True)
def test_win_by_tsumo_and_scores_calculation(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.init_game()
manager.init_round()
manager.riichi_sticks = 1
winner = clients[0]
manager.process_the_end_of_the_round(list(range(0, 14)), 0, winner,
None, True)
self.assertEqual(winner.player.scores, 26900)
self.assertEqual(clients[1].player.scores, 24700)
self.assertEqual(clients[2].player.scores, 24700)
self.assertEqual(clients[3].player.scores, 24700)
def test_play_round_with_retake(self):
game.game_manager.shuffle_seed = lambda: 0.01
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.init_game()
manager.set_dealer(3)
manager.init_round()
result = manager.play_round()
self.assertEqual(manager.round_number, 1)
self.assertEqual(result['is_tsumo'], False)
self.assertEqual(result['is_game_end'], False)
self.assertEqual(result['winner'], None)
self.assertEqual(result['loser'], None)
def execute(self):
player1 = Player(Alliance.RED, PlayerType.HUMAN, name="Dia")
player2 = Player(Alliance.YELLOW, PlayerType.COMPUTER)
SelectDifficultyCommand().execute()
gm = GameManager(player1, player2)
care_taker = Caretaker(gm)
winner = None
while not gm.game_over and not gm.draw:
self.__print_format_table(gm)
move = gm.state.next_player.get_move
if isinstance(move, str):
UndoCommand(gm, care_taker).execute()
care_taker.backup()
winner = self.__handle_move(move, gm, care_taker)
self.__print_format_game_over(gm, winner)
def test_init_round(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.init_game()
manager.init_round()
self.assertEqual(len(manager.dead_wall), 14)
self.assertEqual(len(manager.dora_indicators), 1)
self.assertIsNotNone(manager.current_client)
self.assertEqual(manager.round_number, 0)
self.assertEqual(manager.honba_sticks, 0)
self.assertEqual(manager.riichi_sticks, 0)
self.assertEqual([i.player.scores for i in manager.clients],
[25000, 25000, 25000, 25000])
for client in clients:
self.assertEqual(len(client.player.tiles), 13)
self.assertEqual(len(manager.tiles), 70)
def test_win_by_ron_and_scores_calculation(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.init_game()
manager.init_round()
winner = clients[0]
loser = clients[1]
# only 1000 hand
manager.process_the_end_of_the_round(list(range(0, 14)), 0, winner,
loser, False)
self.assertEqual(winner.player.scores, 26000)
self.assertEqual(loser.player.scores, 24000)
winner.player.scores = 25000
winner.player.dealer_seat = 1
loser.player.scores = 25000
manager.riichi_sticks = 2
manager.honba_sticks = 2
manager.process_the_end_of_the_round(list(range(0, 14)), 0, winner,
loser, False)
self.assertEqual(winner.player.scores, 28600)
self.assertEqual(loser.player.scores, 23400)
self.assertEqual(manager.riichi_sticks, 0)
self.assertEqual(manager.honba_sticks, 0)
winner.player.scores = 25000
winner.player.dealer_seat = 0
loser.player.scores = 25000
manager.honba_sticks = 2
# if dealer won we need to increment honba sticks
manager.process_the_end_of_the_round(list(range(0, 14)), 0, winner,
loser, False)
self.assertEqual(winner.player.scores, 26600)
self.assertEqual(loser.player.scores, 23400)
self.assertEqual(manager.honba_sticks, 3)
def test_is_game_end_by_eight_winds(self):
clients = [Client() for _ in range(0, 4)]
current_dealer = 0
manager = GameManager(clients)
manager.init_game()
manager.set_dealer(current_dealer)
manager.init_round()
manager._unique_dealers = 1
for x in range(0, 7):
# to avoid honba
client = current_dealer == 0 and 1 or 0
result = manager.process_the_end_of_the_round(
list(range(0, 14)), 0, clients[client], None, True)
self.assertEqual(result['is_game_end'], False)
self.assertNotEqual(manager.dealer, current_dealer)
current_dealer = manager.dealer
result = manager.process_the_end_of_the_round(list(range(0, 14)), 0,
clients[0], None, True)
self.assertEqual(result['is_game_end'], True)
def test_init_scores_and_recalculate_position(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.init_game()
manager.set_dealer(3)
clients[0].player.scores = 24000
clients[1].player.scores = 23000
clients[2].player.scores = 22000
clients[3].player.scores = 21000
manager.recalculate_players_position()
self.assertEqual(clients[0].player.scores, 24000)
self.assertEqual(clients[0].player.position, 1)
self.assertEqual(clients[1].player.scores, 23000)
self.assertEqual(clients[1].player.position, 2)
self.assertEqual(clients[2].player.scores, 22000)
self.assertEqual(clients[2].player.position, 3)
self.assertEqual(clients[3].player.scores, 21000)
self.assertEqual(clients[3].player.position, 4)
clients[0].player.scores = 24000
clients[1].player.scores = 24000
clients[2].player.scores = 22000
clients[3].player.scores = 22000
manager.recalculate_players_position()
self.assertEqual(clients[0].player.scores, 24000)
self.assertEqual(clients[0].player.position, 1)
self.assertEqual(clients[1].player.scores, 24000)
self.assertEqual(clients[1].player.position, 2)
self.assertEqual(clients[2].player.scores, 22000)
self.assertEqual(clients[2].player.position, 3)
self.assertEqual(clients[3].player.scores, 22000)
self.assertEqual(clients[3].player.position, 4)
def test_change_dealer_after_end_of_the_round(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.set_dealer(0)
manager.init_round()
# retake. dealer is NOT in tempai, let's move a dealer position
manager.process_the_end_of_the_round(list(range(0, 14)), None, None,
None, False)
self.assertEqual(manager.dealer, 1)
# retake. dealer is in tempai, don't move a dealer position
clients[1].player.in_tempai = True
manager.process_the_end_of_the_round(list(range(0, 14)), 0, None, None,
False)
self.assertEqual(manager.dealer, 1)
# dealer win by ron, don't move a dealer position
manager.process_the_end_of_the_round(list(range(0, 14)), 0, None, None,
False)
self.assertEqual(manager.dealer, 1)
# dealer win by tsumo, don't move a dealer position
manager.process_the_end_of_the_round(list(range(0, 14)), 0, None, None,
False)
self.assertEqual(manager.dealer, 1)
# NOT dealer win by ron, let's move a dealer position
manager.process_the_end_of_the_round(list(range(0, 14)), 0, clients[3],
clients[2], False)
self.assertEqual(manager.dealer, 2)
# NOT dealer win by tsumo, let's move a dealer position
manager.process_the_end_of_the_round(list(range(0, 14)), 0, clients[1],
None, True)
self.assertEqual(manager.dealer, 3)
def test_retake_and_honba_increment(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.init_game()
manager.init_round()
# no one in tempai, so honba stick should be added
manager.process_the_end_of_the_round(None, None, None, None, False)
self.assertEqual(manager.honba_sticks, 1)
manager.honba_sticks = 0
manager.set_dealer(0)
clients[0].player.in_tempai = False
clients[1].player.in_tempai = True
# dealer NOT in tempai, no honba
manager.process_the_end_of_the_round(None, None, None, None, False)
self.assertEqual(manager.honba_sticks, 0)
clients[0].player.in_tempai = True
# dealer in tempai, so honba stick should be added
manager.process_the_end_of_the_round(None, None, None, None, False)
self.assertEqual(manager.honba_sticks, 1)
def mgr():
return GameManager()
from uuid import uuid4
from flask import Flask, render_template, session
from flask_socketio import SocketIO, send, emit
from api import GameServerAPI
from game.game_manager import GameManager
zombie_app: Flask = Flask(__name__)
zombie_app.config['SECRET_KEY'] = 'Ajdjeu234Jfjsd!lsd@#@33jA'
socketio = SocketIO(zombie_app, cors_allowed_origins='*')
api = GameServerAPI(GameManager(), session, emit, send, zombie_app.logger)
socketio.on_namespace(api)
@zombie_app.route('/')
def index():
return render_template('index.html')
if __name__ == '__main__':
socketio.run(zombie_app, debug=True, host='0.0.0.0')
def __init__(self):
'''Game module is top level class, handles game loop.'''
self.frame_time = int(10**3 / config['game']['fps']) # in msec
self.window = self.create_window()
self.manager = GameManager(self.window)
#! ./venv/bin/python3
from game.game_manager import GameManager
import logging
if __name__ == "__main__":
logger = logging.getLogger('game')
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(levelname)s:%(message)s')
ch.setFormatter(formatter)
logger.addHandler(ch)
logger.info('Starting the application...')
gm = GameManager()
gm.start()
def test_init_game(self):
clients = [Client() for _ in range(0, 4)]
manager = GameManager(clients)
manager.init_game()
self.assertTrue(manager.dealer in [0, 1, 2, 3])
def __init__(self, *args, **kwargs):
self._game_manager = GameManager()
self.room = None
self.players = []
def game(player_red, player_blue):
return GameManager(player_red, player_blue)
from datetime import datetime
from dateutil import parser as dateparser
from exception.game.game_not_found_error import GameNotFoundError
from exception.game.user_not_member_of_game_error import UserNotMemberOfGameError
from flask import (Blueprint, request, Response, jsonify)
from flask_login import login_required, current_user
from game.game_manager import GameManager
from portfolio.portfolio_manager import PortfolioManager
from models.game import Game
from utils.serialiser import serialise_properties
bp = Blueprint('games', __name__, url_prefix='/games')
game_manager = GameManager()
@bp.route('', methods=['GET'])
@login_required
def games():
user_id = current_user.get_id()
game_id = request.args.get('game_id')
if game_id:
try:
game = game_manager.get_game_for_user_by_id(user_id, game_id)
except GameNotFoundError as e:
return Response(response=e.message, status=404)
except UserNotMemberOfGameError as e:
return Response(response=e.message, status=403)