def register(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
#?All of them seem to be connected with [email protected] why????
#*Maybe it's because no one was logged in at this point???
#!NOW I KNOW WHY. IT WAS BECAUSE I WAS LOGGED IN WITH [email protected] AND THE USER NEVER CHANGED.
#*As proof, when I register when I am logged out, I runn into an attribute error at request.user.player.add
#!SINCE THIS IS THE CASE I NEED TO CREATE THE PLAYER IN HOME PAGE
if form.is_valid():
#*I think I can just redirect to login
#!I have to differentiate between what is done at registration vs login
n = form.cleaned_data['username']
p = Player(name=n, highscore=0)
p.save()
form.save()
return redirect("/login")
#*What I need to pass in the correct variables for register
form = RegistrationForm()
if request.user.is_authenticated:
u = Player.objects.filter(name=request.user.get_username())[0]
return render(request, "register/register.html", {
"user": u,
"logged_in": True,
"form": form
})
else:
return render(request, "register/register.html", {
"logged_in": False,
"form": form,
})
def register(request):
username = request.POST.get('username','')
password = request.POST.get('password','')
repassword = request.POST.get('repassword','')
email = request.POST.get('email','')
nickname = request.POST.get('nickname','')
if (username == ''):
errors = '请输入您的密码'
return render_to_response("index.html", {'message':'register','error2': errors}, context_instance=RequestContext(request))
try:
p = User.objects.get(username = username)
except User.DoesNotExist:
if (password != repassword):
errors = '两次输入密码不一致，请重新输入'
return render_to_response("index.html", {'message':'register','error2': errors}, context_instance=RequestContext(request))
if (len(password) < 6):
errors = '密码长度太短，请重新输入'
return render_to_response("index.html", {'message':'register','error2': errors}, context_instance=RequestContext(request))
if nickname == '':
errors = '请输入您的昵称'
return render_to_response("index.html", {'message':'register','error2': errors}, context_instance=RequestContext(request))
if email == '':
errors = '请输入您的邮箱'
return render_to_response("index.html", {'message':'register','error2': errors}, context_instance=RequestContext(request))
user = User.objects.create_user(username = username,email = email,password = password)
user.save()
player = Player(user = user, nickname = nickname, signature = '', integration = 0, num_games = 0, is_forbidden = 0, status = 1)
player.save()
user = user = auth.authenticate(username = username, password = password)
auth.login(request, user)
return HttpResponseRedirect('/gamehall')
else:
errors = '用户名已被注册'
return render_to_response("index.html", {'message':'register','error2': errors}, context_instance=RequestContext(request))
def test_next_game_state_2_players(self):
"""Change current game state to the next from the game path"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
player1 = Player(name=us1, state='check')
player1.save()
player2 = Player(name=us2, state='check')
player2.save()
table = Table(player1=player1, player2=player2)
# Act & Assertion
self.assertEqual(table.game_state, 'ready')
table.next_game_state()
self.assertEqual(table.game_state, 'small_blind')
table.next_game_state()
self.assertEqual(table.game_state, 'give_2')
table.next_game_state()
self.assertEqual(table.game_state, 'give_3')
table.next_game_state()
self.assertEqual(table.game_state, 'give_1')
table.next_game_state()
self.assertEqual(table.game_state, 'give_1_again')
table.next_game_state()
self.assertEqual(table.game_state, 'winner')
table.next_game_state()
# In this plase should be 'again' but self.start_game_again() call
# this table.next_game_state, so we jump to begin - 'ready' state
self.assertEqual(table.game_state, 'ready')
def create_player(user, game, players):
"""Create and return player.
only return player if he is already created
:param user: user who will be related to player
:param game: game what will be related to player
:return: Player object
"""
players = players.order_by('in_game_order')
player = players.filter(user=user).first()
if player is None:
player = Player(user=user,
name=user.username,
game=game,
chips=GameSerializer(game).data['starting_chips'],
is_in_game=True)
else:
player.is_in_game = True
# set player in_game_order
if len(players) < 1:
player.in_game_order = 1
else:
player.in_game_order = players.reverse()[0].in_game_order + 1
# update number of connected players
game.players_connected = len(players)
game.save()
player.save()
return player.id
def create_players(self, users):
"""Create a list of Player instances from a list of User
instances for testing."""
players = []
for i, user in enumerate(users):
player = Player(user=user, nickname=f'Swindle_{i}')
player.save()
players.append(player)
return players
def _create_game(nb_player=4, game_name='test'):
game = Game(name=game_name)
game.save()
user_names = ['Clément'] + ["bot_"+str(i) for i in range(nb_player-1)]
players = []
for user_name in user_names:
user = User(username=user_name)
user.save()
player = Player(user=user, game=game)
player.save()
players.append(player)
return game, players
def test_biggest_rate(self):
"""
Should return the biggest value from all players from
player.round_money field
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, round_money=1)
player1.save()
player2 = Player(name=us2, round_money=0)
player2.save()
player3 = Player(name=us3, round_money=99)
player3.save()
player4 = Player(name=us4, round_money=7)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='again')
# Act
result = table.biggest_rate()
# Assertion
self.assertEqual(result, 99)
def test_start_game_again(self):
"""Reset game and start them again with the same players"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='pass', round_money=1)
player1.save()
player2 = Player(name=us2, state='out', round_money=0)
player2.save()
player3 = Player(name=us3, state='check', round_money=99)
player3.save()
player4 = Player(name=us4, state='start', round_money=7)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='again')
# Act
table.start_game_again()
# Assertion
self.assertEqual(table.game_state, 'ready')
self.assertEqual(table.player1.state, 'start')
self.assertEqual(table.player2.state, 'start')
self.assertEqual(table.player3.state, 'start')
self.assertEqual(table.player4.state, 'start')
def populate_players(self, faker: Faker):
teams = Team.objects.all()
for team in teams:
for i in range(10):
player = Player(id=str(uuid.uuid4()),
first_name=faker.first_name(),
last_name=faker.last_name(),
date_of_birth=faker.date(),
country=faker.country(),
height=round(decimal.Decimal(random.randrange(20000)) / 100, 2),
weight=round(decimal.Decimal(random.randrange(20000)) / 100, 2),
team=team)
player.save()
msg.good("Players data successfully populated")
def test_check_players_have_cards(self):
"""Return False if at least one player have cards"""
# Arrange
cards1 = str(Card.new('As')) + ',' + str(Card.new('9s'))
cards2 = str(Card.new('Ah')) + ',' + str(Card.new('9h'))
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, cards=cards1)
player1.save()
player2 = Player(name=us2, cards=cards2)
player2.save()
player3 = Player(name=us3)
player3.save()
player4 = Player(name=us4)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
# Act
result = table.check_players_have_cards()
# Assertion
self.assertFalse(result)
table.remove_cards_from_players()
result2 = table.check_players_have_cards()
self.assertTrue(result2)
def test_all_players_round_money_to_zero(self):
"""Set round_money to zero for all players"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, round_money=-99)
player1.save()
player2 = Player(name=us2, round_money=0)
player2.save()
player3 = Player(name=us3, round_money=99)
player3.save()
player4 = Player(name=us4, round_money=9)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
# Act
table.all_players_round_money_to_zero()
# Assertion
self.assertEqual(table.player1.round_money, 0)
def __add_player(self, user_id, game_id, order):
player = Player(
user_id=user_id,
game_id=game_id,
balance=settings.DEFAULT_GAME_SETTINGS['start_money'],
jailed=0,
position=0,
active=True,
jail_free_card=False,
move=0,
order=order,
)
player.save()
Proxy().load()
return player
def create_game(request):
if Game.objects.filter(status=Game.UNINITIALIZED).count() > 100:
return HttpResponse('There is too many game at once', status=500)
elif Game.objects.exclude(id__in=Player.objects.all().values(
'game').distinct()).count() > 20:
return HttpResponse('Please, join empty room', status=500)
elif Game.objects.filter(id__in=Player.objects.filter(user=request.user).values('game')).\
filter(status=Game.UNINITIALIZED).count() > 5:
return HttpResponse(
'You are in too much room at once, please leave one', status=500)
game = Game(name=request.POST['name'])
game.save()
player = Player(user=request.user, game=game)
player.save()
return redirect('game_page', game_id=game.id)
def creategame(roomcode):
#take care of db-setup for new game
p = Player(name="guest", score=0, status="N")
p.save()
g = Game(roomcode=roomcode,
ruler=p,
time=TIME,
maxplayers=PLAYERS,
aiplayers=AI,
autoend=END,
autochallenge=CHALLENGE)
g.save()
p.roomcode = g
p.save()
return p.id
def index(request):
player = get_player(request)
if player is not None:
# Delete old player and game objects
if player.game and player == player.game.master:
player.game.delete()
player.delete()
del request.session['player_pk']
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
name = form.cleaned_data['player_name']
create_game = form.cleaned_data['create_game']
checkin = CheckIn()
checkin.save()
player = Player(name=name, rand_id=Player.generate_rand_id(), checkin=checkin)
if create_game:
checkin = CheckIn()
checkin.save()
bot = Bot()
bot.save()
game = Game(checkin=checkin, bot=bot)
game.save()
player.game = game
player.index = 1
player.save()
if create_game:
game.master = player
game.players.add(player)
game.save()
request.session['player_pk'] = player.pk
request.session['player_rand_id'] = player.rand_id
request.session['player_name'] = name
if create_game:
return redirect('/create-game')
else:
return redirect('/join-game')
else:
form = LoginForm(initial={'player_name': request.session.get('player_name', '')})
return render(request, 'game/index.html', {'form': form})
def test_give_to_pool(self):
"""Give money from player.money to table.pool"""
# Arrange
us1 = User(username='******')
us1.save()
player1 = Player(name=us1, money=50)
player1.save()
table = Table(player1=player1, pool=0)
# Act
table.give_to_pool(player1, 10)
# Assertion
self.assertEqual(table.pool, 10)
self.assertEqual(player1.money, 40)
def register(request):
if request.method == 'POST':
form = UserRegisterForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
messages.success(
request,
f'Your account has been created! You are now able to log in')
user = User.objects.get(username=username)
#user = User.objects.get(username = request.POST['user'])
#user.player_set.create(name = user.username) # set_create calismiyor
player = Player(name=username)
player.user = user
player.save()
return redirect('login')
else: #Create empty form
form = UserRegisterForm()
return render(request, 'users/register.html', {'form': form})
def test_dealer_button(self):
"""
Give dealer button to first player or next of previous gamer
Dealer is always awarded to the first player if the table.dealer field
is empty or to the next player inthe table.dealer field
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='start')
player1.save()
player2 = Player(name=us2, state='start')
player2.save()
player3 = Player(name=us3, state='start')
player3.save()
player4 = Player(name=us4, state='start')
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='start')
# Act & Assertion
table.dealer_button()
self.assertEqual(table.dealer, player1)
table.game_state = 'start'
table.dealer_button()
self.assertEqual(table.dealer, player2)
table.game_state = 'start'
table.dealer_button()
self.assertEqual(table.dealer, player3)
table.game_state = 'start'
table.dealer_button()
self.assertEqual(table.dealer, player4)
table.game_state = 'start'
table.dealer_button()
self.assertEqual(table.dealer, player1)
def test_start(self):
"""
Set 'start' state for table and available players in table
if number of players in this table is > 1
and state of game is 'ready'
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='check')
player1.save()
player2 = Player(name=us2, state='pass')
player2.save()
player3 = Player(name=us3, state='raise')
player3.save()
player4 = Player(name=us4, state='out')
player4.save()
table = Table(player1=player1)
# Assertions & Acts
# Only 1 player in table (table.start() should not working)
self.assertEqual(table.game_state, 'ready')
table.start()
self.assertNotEqual(table.game_state, 'start')
# 4 players in table (table.start() should works)
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
self.assertEqual(table.game_state, 'ready')
self.assertEqual(player1.state, 'check')
self.assertEqual(player2.state, 'pass')
self.assertEqual(player3.state, 'raise')
self.assertEqual(player4.state, 'out')
table.start()
self.assertEqual(table.game_state, 'start')
self.assertEqual(player1.state, 'start')
self.assertEqual(player2.state, 'start')
self.assertEqual(player3.state, 'start')
self.assertEqual(player4.state, 'start')
def authenticate(self, username=None, password=None):
try:
info = login(username, password)
except InformaticsApiInvalidPassword:
return None
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(
username=username,
password=password,
first_name=info['firstname'],
last_name=info['lastname'],
is_superuser=(username in ADMINS),
is_staff=(username in ADMINS),
)
user.save()
player = Player(
user=user,
ejudge_id=info['ejudge_id'],
)
player.save()
return user
def test_give_2(self):
"""
Give 2 cards to each active player if:
- game state = give 2
- each player have None cards
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='start')
player1.save()
player2 = Player(name=us2, state='start')
player2.save()
player3 = Player(name=us3, state='start')
player3.save()
player4 = Player(name=us4, state='out')
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='give_2')
table.fill_deck_by_all_cards()
# Act
table.give_2()
# Assertion
self.assertNotIn(player1.cards, table.deck)
self.assertNotIn(player2.cards, table.deck)
self.assertNotIn(player3.cards, table.deck)
self.assertEqual(player4.cards, None)
self.assertIsInstance(player1.cards, str)
self.assertIsInstance(player2.cards, str)
self.assertIsInstance(player3.cards, str)
self.assertEqual(table.game_state, 'give_2')
def test_take_big_blind(self):
"""
Take small blind from the next one from 'dealer player'
Big blind is always awarded if players in table > 1
- to the next player from the table.small_blind field
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='start')
player1.save()
player2 = Player(name=us2, state='start')
player2.save()
player3 = Player(name=us3, state='start')
player3.save()
player4 = Player(name=us4, state='start')
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='small_blind',
dealer=player1,
small_blind=player2)
# Act & Assertion
table.take_big_blind()
self.assertEqual(table.big_blind, player3)
table.game_state = 'small_blind'
table.dealer = player2
table.small_blind = player3
table.take_big_blind()
self.assertEqual(table.big_blind, player4)
def test_give_1_again(self):
"""
Give 1 card to the table if:
- game state = give 1 again
- on table is only 4 cards
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1)
player1.save()
player2 = Player(name=us2)
player2.save()
player3 = Player(name=us3)
player3.save()
player4 = Player(name=us4)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='give_3')
table.fill_deck_by_all_cards()
# Act
table.give_3()
table.next_game_state()
table.give_1()
table.next_game_state()
table.give_1_again()
# Assertion
self.assertNotIn(table.cards_on_table, table.deck)
self.assertIsInstance(table.cards_on_table, str)
self.assertEqual(table.game_state, 'give_1_again')
def test_the_winner(self):
"""Return winner in this table"""
# Arrange
cards1 = str(Card.new('2s')) + ',' + str(Card.new('3s'))
cards2 = str(Card.new('4h')) + ',' + str(Card.new('5d'))
cards3 = str(Card.new('6d')) + ',' + str(Card.new('7h'))
cards4 = str(Card.new('As')) + ',' + str(Card.new('Ks'))
cards_on_table = str(Card.new('Qs')) + ',' \
+ str(Card.new('Js')) + ','\
+ str(Card.new('Ts')) + ','\
+ str(Card.new('2d')) + ','\
+ str(Card.new('3d'))
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, cards=cards1, state='check')
player1.save()
player2 = Player(name=us2, cards=cards2, state='check')
player2.save()
player3 = Player(name=us3, cards=cards3, state='check')
player3.save()
player4 = Player(name=us4, cards=cards4, state='check')
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
cards_on_table=cards_on_table)
# Act
the_winner = table.the_winner()
#print(the_winner)
# Assertion
self.assertEqual(the_winner, player4)
def test_set_all_in_game_players_state(self):
"""
Pre: Create table with players with different states.
Output: True if players without 'pass' or 'out' state have changed to
'start' state.
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='pass')
player1.save()
player2 = Player(name=us2)
player2.save()
player3 = Player(name=us3, state='check')
player3.save()
player4 = Player(name=us4, state='start')
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
# Act
table.set_all_in_game_players_state('start')
# Assertion
self.assertEqual(table.player1.state, 'pass')
self.assertEqual(table.player2.state, 'out')
self.assertEqual(table.player3.state, 'start')
self.assertEqual(table.player4.state, 'start')
def test_remove_cards_from_players(self):
"""Remove all cards from all players"""
# Arrange
cards1 = str(Card.new('As')) + ',' + str(Card.new('9s'))
cards2 = str(Card.new('Ah')) + ',' + str(Card.new('9h'))
cards3 = str(Card.new('Ad')) + ',' + str(Card.new('9d'))
cards4 = str(Card.new('Ac')) + ',' + str(Card.new('9c'))
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, cards=cards1)
player1.save()
player2 = Player(name=us2, cards=cards2)
player2.save()
player3 = Player(name=us3, cards=cards3)
player3.save()
player4 = Player(name=us4, cards=cards4)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
# Act
table.remove_cards_from_players()
# Assertion
self.assertEqual(table.player1.cards, None)
self.assertEqual(table.player2.cards, None)
self.assertEqual(table.player3.cards, None)
self.assertEqual(table.player4.cards, None)
def test_set_all_available_players_state(self):
"""
Pre: Create table with players with 'out' state.
Output: True if all players have changed to 'start' state.
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1)
player1.save()
player2 = Player(name=us2)
player2.save()
player3 = Player(name=us3)
player3.save()
player4 = Player(name=us4)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
# Act
table.set_all_available_players_state('start')
# Assertion
self.assertEqual(table.player1.state, 'start')
self.assertEqual(table.player2.state, 'start')
self.assertEqual(table.player3.state, 'start')
self.assertEqual(table.player4.state, 'start')
def show_home(request):
player_id = request.session.get('player_id', 'new')
context = {}
if request.method == 'POST':
player_id = request.session.get('player_id', 'new')
if player_id == 'new':
return HttpResponse('Ошибка сессии')
game_id = request.session.get('game_id')
guess = int(request.POST.get('guess'))
current_game = Game.objects.get(pk=game_id)
current_player = Player.objects.get(pk=player_id)
number = current_game.number
context = {
'role': current_player.role,
'game': current_game,
'guess': guess
}
if guess == number:
current_game.solved = True
current_game.try_count += 1
current_game.save()
else:
current_game.try_count += 1
current_game.save()
elif isinstance(player_id, int):
# игрок уже есть в базе
current_player = Player.objects.get(pk=player_id)
current_game = current_player.games.all().last()
context = {'role': current_player.role, 'game': current_game}
else:
game_check = Game.objects.all().last()
if game_check and len(list(game_check.players.values())) == 1:
# игрок присоединяется к существующей игре в роли гостя
new_player = Player(role='GU')
new_player.save()
request.session['player_id'] = new_player.id
current_game = game_check
request.session['game_id'] = current_game.id
many_to_many = PlayerGameInfo(players=new_player,
games=current_game)
many_to_many.save()
context = {'role': new_player.role, 'game': current_game}
else:
# создаем новую игру и делаем текущего игрока хостом
new_player = Player(role='HO')
new_player.save()
request.session['player_id'] = new_player.id
number = random.randint(1, 10)
new_game = Game(number=number)
new_game.save()
many_to_many = PlayerGameInfo(players=new_player, games=new_game)
many_to_many.save()
request.session['game_id'] = new_game.id
context = {'role': new_player.role, 'game': new_game}
return render(request, 'home.html', context)
def receive(self, text_data):
text_data_json = json.loads(text_data)
message = text_data_json['message']
if message:
parsed_command = message.split(maxsplit=1)
command = parsed_command[0].lower()
try:
command_arguments = parsed_command[1:]
except IndexError:
command_arguments = []
if self.scope['user'].is_authenticated:
try:
return_message = getattr(self.engine,
command)(*command_arguments)
except AttributeError:
# engine has no attribute command
return_message = f"{command} is not a valid command! Type 'help' if you need."
elif command == 'login':
if len(message.split()) == 3:
username_to_login = message.split()[1]
plain_password_to_login = message.split()[2]
if len(User.objects.filter(
username=username_to_login)) == 1:
self.user = User.objects.get(
username=username_to_login)
dt = self.user.last_login
if django_pbkdf2_sha256.verify(plain_password_to_login,
self.user.password):
async_to_sync(auth_login)(self.scope,
user=self.user)
if dt:
return_message = (
f"Welcome back, {self.user}! \n"
f"You last logged in at {dt.strftime('%Y-%m-%d %H:%M')} (UTC)"
)
else:
return_message = (
f"Welcome to the MUD, {self.user}! \n"
f"Since it's your first time here, we'll guide you in your first steps."
)
async_to_sync(self.channel_layer.group_send)(
self.room_group_name, {
'type':
'global_message_login_required_not_me',
'message':
f"{self.user} is back to WilyWolves MUD!",
'sender_channel_name': self.channel_name
})
else:
return_message = "Wrong password! Please try 'login <username> <password> again."
else:
return_message = (
f"{username_to_login!r} is not a valid username. "
"If you are new here, please type 'new'")
else:
return_message = "To log in, please type 'login <username> <password>'."
elif command == 'new':
if len(message.split()) == 3:
username_to_create = message.split()[1]
password_to_create = message.split()[2]
hashed_password = make_password(password_to_create)
if len(User.objects.filter(
username=username_to_create)) == 0:
new_user = User(username=username_to_create,
password=hashed_password,
is_superuser=False,
is_staff=False)
new_user.save()
new_player = Player(user=new_user)
new_player.save()
return_message = (
f"User {username_to_create!r} successfully created! "
"Please type 'login' to start playing.")
else:
return_message = f"Someone is already using {username_to_create}"
else:
return_message = "To create a new user, please type 'new <username> <password>'."
else:
return_message = "You need to log in first. Please type 'login' or 'new'"
if return_message is not None:
self.send(text_data=json.dumps({'message': return_message}))
from game.models import Player
import cjson
with open('/game/static/game/json/players.json', 'r') as f:
for line in f:
data = cjson.decode(line)
p = Player(name=data['PLAYER_NAME'], gp=data['GP'], min=data['MIN'], tov=data['TOV'], reb=data['REB'],\
fg3a=data['FG3A'], efg=data['EFG_PCT'], ast=data['AST'], ast_tov=data['AST_TOV'], fg3m=data['FG3M'],\
oreb=data['OREB'], fgm=data['FGM'], pf=data['PF'], pts=data['PTS'], fga=data['FGA'], ts=data['TS_PCT'],\
stl=data['STL'], fta=data['FTA'], blk=data['BLK'], dreb=data['DREB'], ftm=data['FTM'], stl_tov=data['STL_TOV'],\
ft=data['FT_PCT'], fg=data['FG_PCT'], fg3=data['FG3_PCT'])
p.save()
def test_cannot_create_player_without_game(self):
my_player = Player(name="The winning team")
with self.assertRaises(IntegrityError):
my_player.save()
def test_make_turn(self):
"""That function is call in every game page overload"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='check', money=90)
player1.save()
player2 = Player(name=us2, state='check', money=90)
player2.save()
player3 = Player(name=us3, state='check', money=90)
player3.save()
player4 = Player(name=us4, state='check', money=90)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='ready')
# Acts & Assertions
table.start()
table.dealer_button()
self.assertEqual(table.game_state, 'dealer')
table.take_small_blind()
self.assertEqual(table.game_state, 'small_blind')
table.take_big_blind()
self.assertEqual(table.game_state, 'big_blind')
# All players must give to the pool the same value
table.give_to_pool(player1, 2)
table.give_to_pool(player2, 1)
table.give_to_pool(player4, 2)
table.fill_deck_by_all_cards()
table.set_all_in_game_players_state('check')
table.make_turn()
self.assertEqual(table.game_state, 'give_2')
self.assertEqual(player1.state, 'start')
self.assertEqual(player2.state, 'start')
self.assertEqual(player3.state, 'start')
self.assertEqual(player4.state, 'start')
table.set_all_in_game_players_state('check')
table.make_turn()
self.assertEqual(table.game_state, 'give_3')
self.assertEqual(player1.state, 'start')
self.assertEqual(player2.state, 'start')
self.assertEqual(player3.state, 'start')
self.assertEqual(player4.state, 'start')
table.set_all_in_game_players_state('check')
table.player1.state = 'pass'
table.make_turn()
self.assertEqual(table.game_state, 'give_1')
self.assertEqual(player1.state, 'pass')
self.assertEqual(player2.state, 'start')
self.assertEqual(player3.state, 'start')
self.assertEqual(player4.state, 'start')
table.set_all_in_game_players_state('check')
table.make_turn()
self.assertEqual(table.game_state, 'give_1_again')
self.assertEqual(player1.state, 'pass')
self.assertEqual(player2.state, 'start')
self.assertEqual(player3.state, 'start')
self.assertEqual(player4.state, 'start')
table.set_all_in_game_players_state('check')
table.player2.state = 'pass'
table.make_turn()
self.assertEqual(table.game_state, 'winner')
self.assertEqual(player1.state, 'pass')
self.assertEqual(player2.state, 'pass')
self.assertEqual(player3.state, 'start')
self.assertEqual(player4.state, 'start')
table.set_all_in_game_players_state('check')
table.make_turn()
self.assertEqual(table.game_state, 'ready')
self.assertEqual(player1.state, 'start')
self.assertEqual(player2.state, 'start')
self.assertEqual(player3.state, 'start')
self.assertEqual(player4.state, 'start')
table.set_all_in_game_players_state('check')
table.make_turn()
self.assertEqual(table.game_state, 'small_blind')
self.assertEqual(player1.state, 'start')
self.assertEqual(player2.state, 'start')
self.assertEqual(player3.state, 'start')
self.assertEqual(player4.state, 'start')
table.set_all_in_game_players_state('check')
table.make_turn()
self.assertEqual(table.game_state, 'big_blind')
self.assertEqual(player1.state, 'start')
self.assertEqual(player2.state, 'start')
self.assertEqual(player3.state, 'start')
self.assertEqual(player4.state, 'start')
