def test_game_creation(self):
"""Test that Game instances are instantiated correctly."""
game = Game(players=4, turn=0)
self.assertTrue(isinstance(game, Game))
self.assertEqual(str(game), 'The game is not currently active.')
self.assertEqual(game.player_count(), 4)
game = Game(players=2, turn=2)
self.assertTrue(isinstance(game, Game))
self.assertEqual(str(game), 'It is Swindle_2\'s turn.')
self.assertEqual(game.player_count(), 2)
def test_next_game(self):
game = Game(name="test")
game.save()
game.create_next_game()
self.assertEqual("test 2", game.next_game.name)
game = game.next_game
game.create_next_game()
self.assertEqual("test 3", game.next_game.name)
long_name = ''.join([str(i % 10)for i in range(29)]) + 'a'
game = Game(name=long_name)
game.save()
game.create_next_game()
self.assertEqual(long_name[2:]+" 2", game.next_game.name)
def create_game(self, request, *args, **kwargs):
body = json.loads(request.body)
api_key = body.get('api_key')
allowed_users = body.get('allowed_users')
if not valid_user(request, api_key):
return self.create_response(request, {
'status': False,
'Message': 'Invalid Credentials'
})
else:
# Fetch quiz object for creator user
user_id = fetch_id(api_key)
quiz = Quiz.objects.get(created_by=user_id)
game = Game(quiz=quiz)
game.save()
for name in allowed_users:
user = Users.objects.get(name=name)
game.allowed_users.add(user)
# Returns the link to created Quiz
return self.create_response(
request, {
'status':
True,
'Message':
'Game created at - https://127.0.0.1:8000/api/v2/play/game/'
})
def new_game(request,pk):
if request.method=='GET':
player = Player.objects.get(pk=pk)
players = Player.objects.all()
genres = Genre.objects.all()
return render(request,'player/new_game.html',{'players':players,'genres':genres,'player':player})
else:
print '## Adding New Game ##'
game = Game(name = request.POST['name'],date = timezone.now(),active=False)
genres = request.POST.getlist('genres')
game.save()
for genre in genres:
game.genres.add(Genre.objects.get(pk=genre))
game.save()
print '## Saved Game ID: %s with name %s ##' % (game.id,game.name)
player = Player.objects.get(pk=pk)
PG = Player_Game(game = game, player = player, score = 0,accepted = True, declined = False)
print '## The first player in the game is %s with ID %s ##' % (player.name, player.id)
PG.save()
players = request.POST.getlist('players')
for p in players:
player = Player.objects.get(pk = int(p))
PG = Player_Game(game = game, player = player, score = 0, accepted = False, declined = False)
PG.save()
print '## Player %s with ID %s was invited to this game ##' % (player.name,player.id)
return HttpResponseRedirect("/player/%s/"%pk)
def test_init(self):
me = Player(123, "", 0, False, [])
others = [Player(222, "", 0, False, []), Player(111, "", 0, False, [])]
game = Game(0, 0, me.id, [me] + others, None, None, [])
self.assertEqual(me, game.me)
self.assertEqual(others, game.enemies)
def Questions(request):
if request.method == "GET":
cat_id = None,
num_quest = 1,
difficulty = None,
quest_type = 'multiple'
questions_raw = services.get_questions(cat_id, num_quest,
difficulty, quest_type)
if questions_raw['response_code'] != 0:
return JsonResponse({"error retriving questions":
"POST request required."}, status=400)
else:
questions_cln = []
for record in questions_raw['results']:
all_answers = record['incorrect_answers']
all_answers.append(record['correct_answer'])
# Rearrange potential answers in random order
all_answers = list(set(all_answers))
record['choice1'] = all_answers[0]
record['choice2'] = all_answers[1]
record['choice3'] = all_answers[2]
record['choice4'] = all_answers[3]
del record['incorrect_answers']
# decode text
record_cln = {k: pybase64.b64decode(v, validate=True)
.decode("utf-8") for k, v in record.items()}
# appened to a master list
questions_cln.append(record_cln)
# append historical data to the dataset
total_score = (Game.objects.aggregate(
Sum('score')))['score__sum']
total_quest = Game.objects.aggregate(
Sum('max_questions'))['max_questions__sum']
avg_score = round((total_score/total_quest), 2) \
if total_quest > 0 else 0
questions_cln[0]['avg_score'] = avg_score
num_games = Game.objects.count()
questions_cln[0]['num_games'] = num_games
return JsonResponse(questions_cln, safe=False)
elif request.method == "POST":
data = json.loads(request.body)
game = Game(score=data["score"], max_questions=data["max_questions"])
game.save()
return HttpResponse(status=204)
# Email must be via GET or PUT
else:
return JsonResponse({
"error": "GET or PUT request required."
}, status=400)
def create(request):
""" User will create games.
Keyword arguments:
request -
"""
if request.method == 'POST':
form = GameForm(request.POST)
if form.is_valid():
sport = Sport.objects.get(sport=form.cleaned_data['sport'])
#player = Player.objects.get(user=request.user) # unused var
game = Game()
game.sport = sport
game.owner = request.user
game.start_date_and_time = datetime.combine(
form.cleaned_data['start_date'],
form.cleaned_data['start_time'])
game.address = form.cleaned_data['address']
game.minimum_players = form.cleaned_data['minimum_players']
game.restrictions = form.cleaned_data['restrictions']
game.active = True
if request.POST['lng'] and request.POST['lat']:
game.longitude = request.POST['lng']
game.latitude = request.POST['lat']
game.save()
return HttpResponseRedirect('/game/%s/' % game.id)
else:
form = GameForm()
return render(request, 'create.html', {'form': form})
def new_game(request, session_id):
form = NewGame()
# Форма по созданию игры
if request.method == 'POST':
form = NewGame(request.POST)
if form.is_valid() and form['number'].value():
if not Player.objects.filter(player_id=session_id):
Player(player_id=session_id).save()
Game(game_id=session_id, number=form['number'].value()).save()
PlayerGameInfo(player_id=Player.objects.filter(
player_id=session_id).values('id')[0]['id'],
game_id=Game.objects.order_by('-id').filter(
game_id=session_id).values('id')[0]['id'],
is_owner=True).save()
return redirect('game_created',
game_id=Game.objects.order_by('-id').filter(
game_id=session_id).values('id')[0]['id'])
return render(
request,
'new_game.html',
{
'form': form,
},
)
def test_play_second(self):
"The second play is O"
game = Game(board="X ")
game.play(1)
self.assertEqual(game.board, "XO ")
self.assertEqual(game.next_player, "X")
def test_play_error_square_taken(self):
"You can't play a square that is taken."
game = Game(board="XOX ")
with self.assertRaises(ValueError):
game.play(1)
game.play(2)
def test_play_first(self):
"X always goes first"
game = Game()
game.play(0)
self.assertEqual(game.board, "X ")
self.assertEqual(game.next_player, "O")
def test_cover_image_extension(self, name, cover_image, version,
official_repository, errors_dict):
game = Game(name=name,
cover_image=cover_image,
version=version,
official_repository=official_repository)
validation_test(game, errors_dict)
def _add_game(self, number=1):
for i in range(number):
game = Game()
game.name = 'name%d' % (i)
game.description = 'description%d' % (i)
game.url = 'https://notexisturl%d.fi' % (i)
game.save()
def create(self, validated_data):
player_1 = Player.objects.get(name=validated_data['player_1']['name'])
player_2 = Player.objects.get(name=validated_data['player_2']['name'])
# Now we must create the game between the two players
game = Game(player_1=player_1, player_2=player_2)
game.save()
return game
def game(request):
"""
receive a player name in a POST to create a new game
return the newly created game object
"""
if request.method == 'POST': #create a new game
game = Game()
code = game.new_game()
playername = request.data['player_name']
player = Player(name=playername)
player.join_game(code)
game_serializer = GameSerializer(game)
player_serializer = PlayerSerializer(player)
#return a json object containing both the game and the player's object
return Response({
'game': game_serializer.data,
'player': player_serializer.data
})
elif request.method == 'GET': #retrieve info for an existing game
if 'access_code' in request.query_params:
game = Game.objects.get(
access_code=request.query_params['access_code'])
serializer = GameSerializer(game)
return Response(serializer.data)
else:
return Response()
def test_update_game_calls_send_actions(self):
cells = [
Cell(0, 5, 10, Vec2(0, 0), Vec2(1, 1)),
Cell(1, 5, 10, Vec2(0, 0), Vec2(1, 1)),
Cell(2, 5, 10, Vec2(0, 0), Vec2(1, 1))
]
player = Player(0, "", 10, True, cells)
game = Game(0, 0, 0, [player], Resources([], [], []), Map(0, 0), [])
cells[0].target = Vec2(2, 2)
cells[0].burst()
cells[1].split()
cells[1].trade(3)
class MockApi:
def send_actions(self, game_id, actions):
self.actions = actions
api = MockApi()
update_game(api, game, lambda x: None)
self.assertEqual(len(api.actions), 2)
self.assertTrue(api.actions[0].target.almost_equals(Vec2(2, 2)))
self.assertTrue(api.actions[0].burst)
self.assertTrue(api.actions[1].split)
self.assertEqual(3, api.actions[1].trade)
def test_play_auto_computer_human(self):
"At the start of the game, computer starts."
random.seed(0)
game = Game(player_o='human', player_x='game.players.RandomPlayer')
game.play_auto()
self.assertEqual(game.board, " X ")
self.assertEqual(game.next_player, "O")
def test_play_error_index(self):
"You can't pass in an invalid index."
game = Game()
with self.assertRaises(IndexError):
game.play(-1)
game.play(9)
game.play(10)
def test_play_auto_computer_to_computer(self):
"Two computers playing against themselves."
random.seed(0)
game = Game(player_o='game.players.RandomPlayer',
player_x='game.players.RandomPlayer')
game.play_auto()
self.assertEqual(game.board, "OOXOX OXX")
self.assertEqual(game.is_game_over, 'O')
def _add_game(self, team_arr, stage, i, faker):
game_teams = [team_arr[i], team_arr[i + 1]]
winning_team = [random.choice(game_teams)]
loose_team = list(set(game_teams).symmetric_difference(set(winning_team)))[0]
game = Game(winner=winning_team[0], stage=stage, host_date=faker.date(), looser=loose_team)
game.save()
game.teams.set(game_teams)
return winning_team
def start_db(room):
game = Game(room_id=room.id, started=room.started)
for p in room.players:
user = User.query.filter_by(username=p.name).first()
game.players.append(user)
db.session.add(game)
db.session.commit()
return
def setUp(self):
self.new = Game(name="newgame")
self.new.save()
self.perfect = Game(name="perfect")
self.perfect._rolls = ("[10, 10, 10, 10, 10, 10,"
" 10, 10, 10, 10, 10, 10]")
self.perfect.save()
self.incomplete = Game(name="incomplete")
self.incomplete._rolls = ("[10, 3, 4, 5, 5, 10, 2, 4, 0, 0]")
self.incomplete.save()
self.regular = Game(name="regular")
self.regular._rolls = ("[5, 4, 6, 4, 10, 2, 3, 1, 4,"
" 4, 0, 7, 2, 8, 0, 10, 2, 3]")
self.regular.save()
def test_create_game(self):
game = mixer.blend(Game)
Game().create_game(game.winner_id, game.round, game.team1_id,
game.team2_id, game.is_final)
new_game = Game.objects.filter(winner=game.winner,
team1=game.team1,
is_final=game.is_final).first()
assert game.is_final == new_game.is_final
assert game.winner == new_game.winner
def _add_game(self, number=1):
for i in range(number):
game = Game()
game.owner = self.user
game.name = 'name%d' % (i)
game.description = 'description%d' % (i)
game.url = 'https://notexisturl%d.fi' % (i)
game.price = Decimal("1." + str(i))
game.save()
def test_random(self):
"Basic testing."
random.seed(0) # For testing
game = Game()
p1 = RandomPlayer()
game.play(p1.play(game))
self.assertEqual(game.board, " X " if six.PY3 else " X ")
def save(self, user):
newgame = Game(title=self.cleaned_data["gametitle"],
current_round=1,
max_rounds=self.cleaned_data["max_rounds"],
player1=user,
open=True,
finished=False,
player1wins=0,
player2wins=0)
newgame.save()
def create_game(name):
"""Create game and it's decks"""
game = Game(name=name)
game.save()
deck = Deck(game=game)
deck.save()
deck.fill_deck()
Discard(game=game).save()
return game
def start(self):
c = int(self.count / 10)
for i in range(c):
t1 = Team(
name='team_{}'.format(i),
games=self.count,
)
t2 = Team(
name='team_{}'.format(i),
games=self.count,
)
t1.save(using='db1')
t2.save(using='db2')
for j in range(10):
u = User(username='******'.format(j + 10 * i),
email='ivan@ivan{}.ru'.format(j + 10 * i))
u.set_password('ivan123')
u.first_name = 'ivan{}'.format(j + 10 * i)
u.last_name = 'ivanov{}'.format(j + 10 * i)
ran_db = random.randint(1, 2)
u.id = int(get_pk() + str(ran_db))
print(u.id)
u.save(using='db' + str(ran_db))
if ran_db == 1:
tu = UserTeam(
user=u,
team=t1,
)
else:
tu = UserTeam(
user=u,
team=t2,
)
tu.save(using='db' + str(ran_db))
cc = int(self.count / 100)
for i in range(cc):
t = Turn(name='turn{}'.format(i))
t.save(using='db1')
t.save(using='db2')
for j in range(10):
m = Match(name='match{}'.format(j + 10 * i), turn_id=t.id)
m.save(using='db1')
m.save(using='db2')
for l in range(10):
g = Game(name='game___{}'.format(l + 10 * j + 100 * i),
match_id=m.id)
ran_db = random.randint(1, 2)
g.id = int(get_pk() + str(ran_db))
g.save(using='db' + str(ran_db))
tm = Team.objects.using('db' + str(ran_db)).filter(
name='team_{}'.format(j + 10 * i))[0]
gt = GameTeam(game=g, team=tm)
gt.save(using='db' + str(ran_db))
def codetosetmanually(self):
from game.models import Game
from django.contrib.auth.models import User
user = User.objects.get(pk=1)
p = Game(owner=user,
name='No Game',
description='desc',
url="http://url.fi",
price=2.30,
available=True)
p.save()
def post(cls, request, game_id=None):
game = request.data
challenges = request.data['challenges']
if game_id:
g = get_object_or_404(Game, pk=game_id)
else:
g = Game()
for k, v in game.items():
if k in ['pk', 'challenges', 'author', 'options']:
continue
setattr(g, k, v)
g.author = request.user
g.add_extra('options', game.get('options', []))
g.save()
pkch = {}
for ch in challenges:
pk = ch['pk']
if pk < 0:
# negative pk will create the challenge
c = Challenge()
else:
c = Challenge.objects.get(pk=pk)
for k, v in ch.items():
if k in ['pk', 'game', 'options', 'child_challenges', 'depends']:
continue
setattr(c, k, v)
c.add_extra('options', ch.get('options', []))
c.save()
g.challenges.add(c)
g.save()
pkch[pk] = c
for ch in challenges:
c = pkch[ch['pk']]
# child challenges
c.child_challenges.clear()
for cc in ch.get('child_challenges', []):
c.child_challenges.add(pkch[cc['pk']])
# depends
c.depends.clear()
for dep in ch.get('depends', []):
c.depends.add(pkch[dep['pk']])
c.save()
return Response({'status': 'ok'})
