def test_is_game_over_tie(self): "A game board that is a tie is a game over." g = Game() g.board_state = [['X', 'O', 'X'], ['X', 'O', 'X'], ['O', 'X', 'O']] self.assertTrue(g.is_game_over())
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, "X XOOOXOX" if six.PY3 else "OOXOX OXX") self.assertEqual(game.is_game_over, "O")
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_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_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 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_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_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 " if six.PY3 else " X ") self.assertEqual(game.next_player, "O")
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 test_get_winner_rows(self): "Three in a row is a winner." for i in xrange(0, 3): g = Game() g.board_state[i][0] = g.board_state[i][1] = g.board_state[i][2] = 'X' self.assertEquals(g.get_winner(), 'X') g = Game() g.board_state[i][0] = g.board_state[i][1] = g.board_state[i][2] = 'O' self.assertEquals(g.get_winner(), 'O')
def test_get_winner_column(self): "Three in a column is a winner." for i in xrange(0, 3): g = Game() g.board_state[0][i] = g.board_state[1][i] = g.board_state[2][i] = 'X' self.assertEquals(g.get_winner(), 'X') g = Game() g.board_state[0][i] = g.board_state[1][i] = g.board_state[2][i] = 'O' self.assertEquals(g.get_winner(), 'O')
def accept(self, accepted): wait = GameRequest.check_last_time(self.requester) if wait: return wait self.accepted = accepted self.accept_time = timezone.now() if accepted: Game.create([self.requestee, self.requester], game_conf=self.game_config) self.save()
def test_add_user_to_game(self): game, _ = Game.create_new_game(self.aMap.id, self.user) # Perform the join logic _, players_json, player_id = Game.add_user_to_game(game.id, self.joiner) # Check a bunch of conditions self.assertEqual(len(players_json), 3) self.assertEqual(players_json[0], "hosting_player") self.assertEqual(players_json[1], "joining_player")
def validate_rolls(self, rolls): """Make sure incoming rolls arrays are good""" # create a game object which won't be saved to the database # so we can check that our rolls list is valid test_game = Game(name="test_game", _rolls='[]') try: for roll in rolls: test_game.add_roll(roll) except: raise serializers.ValidationError("Rolls list was invald") return rolls
def test_get_winner_diagonal(self): "Three on a diagonal is a winner." g = Game() g.board_state = [['X', None, None], [None, 'X', None], [None, None, 'X']] self.assertEquals(g.get_winner(), 'X') g.board_state = [[None, None, 'O'], [None, 'O', None], ['O', None, None]] self.assertEquals(g.get_winner(), 'O')
def new_game(request): if request.is_ajax(): if request.method == 'POST': desc = request.POST['game_description'] if desc == '': desc = 'New Game' g = Game(description = desc) g.save() data = {'description': desc, 'id': g.id} html_str = Utils.game_info_template().substitute( game_id=g.id, description = desc, num_players = '0', max_players = g.max_players) data['html_str'] = html_str return HttpResponse(json.dumps(data))
def on_join(self): game_id = self.session['game_id'] user = self.session['user'] # Join the game_id room on the sockets side self.join(str(game_id)) # Add the user to the game on the database side game, players_json, player_id = Game.add_user_to_game(game_id, user) self.session['player_id'] = player_id # The host of the game is the person that created the game # WHICH HAPPENS TO BE player_id == 0 IN OUR IMPLEMENTATION # Perhaps we should fix this one day isHost = self.session['isHost'] = (player_id == 0) player_list = [v for v in players_json] # Send the new player information needed to join the map selfData = { 'isHost': isHost, 'map_id': game.map.id, 'player_list': player_list, 'player_id': player_id } self.emit('game_data', selfData) # Send all other players information needed to add the current # player to the game data = { 'username': user.username, 'timestamp': self.get_time(), 'player_id': self.session['player_id'] } self.emit_to_room(str(self.session['game_id']), 'join', data)
def setUp(self): server = MockSocketIOServer() self.environ = {} socket = MockSocket(server, {}) self.environ['socketio'] = socket self.ns = GameNamespace(self.environ, '/game') # Create mock objects for testing the socket self.ns.emit = MagicMock() self.ns.broadcast_to_room = MagicMock() self.ns.emit_to_room = MagicMock() self.ns.get_time = MagicMock(return_value=12242012) # Create a game with one user User.objects.create_user("hosting_player", "email", "password") self.user = authenticate(username="******", password="******") self.aMap = Map(creator=self.user, num_players=3, data="{}", map_name="Oogie Boogie") self.aMap.save() self.game, self.players_json = Game.create_new_game(self.aMap.id, self.user) self.ns.request = MockRequest() self.ns.request.user = self.user self.ns.request.META = { 'QUERY_STRING': 'id=' + str(self.game.id) }
def ajax_games(request): player = get_player(request) if player is None: return HttpResponseBadRequest('NO-PLAYER') json = simplejson.dumps(Game.get_dict_of_games(player)) return HttpResponse(json, mimetype='application/json')
def new(request): """ Create a new game and redirect to it """ game = Game.create_new(is_user_x=choice([True,False])) if game.is_user_x == False: game[1][1] = PLAYER_X # computer goes to the middle return HttpResponseRedirect(reverse('game.views.get', args=(game.id,)))
def join_random(request): games = Game.objects(players__ne=request.user.username, state='playing') games.where('this[~num_players] < this[~max_players]') games.order_by('next_ending').limit(1) for game in games: request.session['join_auto'] = game.pk return redirect('game.views.join', game.pk) else: return render(request, 'nogames.html')
def test_second_move(self): """ The AI should always try for the middle cell, but fallback to any corner if it is taken. """ g = Game() g.board_state[0][1] = 'O' perform_move(g) self.assertEquals(g.board_state[1][1], 'X') g = Game() g.board_state[1][1] = 'O' perform_move(g) corners = [ g.board_state[0][0], g.board_state[0][2], g.board_state[2][0], g.board_state[2][2] ] self.assertTrue('X' in set(corners))
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 process(self): account_1 = self.cleaned_data['player_1'] account_2 = self.cleaned_data['player_2'] score_1 = self.cleaned_data['score_1'] score_2 = self.cleaned_data['score_2'] if account_1.rank > account_2.rank: upset = True else: upset = False new_game = Game( winner=account_1, loser=account_2, winning_score=score_1, losing_score=score_2, upset=upset ) new_game.save()
def index(self): form = BallotForm(request.form) form.game.choices = [(str(Game.objects(name=x).first().id), x) for x in Game.objects.distinct('name')] if request.method == 'POST' and form.validate(): game = form.game.data ballot_type = form.ballot_type.data results = self.ballot(game, ballot_type) self._template_args['ballot_results'] = results self._template_args['round'] = self.round return self.render('ballot.html', form=form)
def test_ajax_lobby_games(self): User.objects.create_user('aaa', 'aaa', 'aaa') c = self.client login(c, 'aaa', 'aaa') s_resp = c.get(reverse('ajax_lobby_games')) resp_object = json.loads(s_resp.content) num = len(Game.get_games_in_state(Game.LOBBY)) self.assertEqual(len(resp_object), num)
def profile(request, username): profile = get_document_or_404(User, username=username) current = Game.objects(players=profile.username, state__in=('playing', 'voting')) current.order_by('next_ending') past = Game.objects(players=profile.username, state__in=('invalid', 'finished')).limit(10) past.order_by('-next_ending') prefs_form = None # if profile == request.user: # initial = PreferencesForm.initial_for(profile) # prefs_form = PreferencesForm(initial=initial) return render(request, 'profile.html', profile=profile, current=current, past=past, prefs_form=prefs_form)
def populateGameInfoObject(node): tmpObject= Game(); tmpObject.game_name=node.tag; tmpObject.cr_dt=timezone.now().date(); tmpObject.deleted_flag=False; tmpObject.cr_user='******' tmpObject.lst_dt=timezone.now().date(); tmpObject.lst_user='******' return tmpObject
def post(self, request): """ Create a new game """ form = GameForm(request.POST) if form.is_valid(): game, players_json = Game.create_new_game(form.cleaned_data["map_id"], request.user) # Render the context with our parameters. return redirect(reverse("game_view", kwargs={"gameid": game.id})) else: # Needs better error handling raise Http404
def connect(self): # Get connecting user self.user = self.scope["user"] # Get Users game self.game = Game.get_active_game(self.scope["user"]) # Assign channels self.room_name = str(self.game.id) if self.game is not None else "none" self.room_group_name = 'game_%s' % self.room_name if self.room_name == "none": # Player doesnt have active game, close connection self.close() # Join room group async_to_sync(self.channel_layer.group_add)( self.room_group_name, self.channel_name ) self.accept()
def post(self, request): form = RegisterForm(request.POST, request.FILES) if form.is_valid(): user = form.save() user.refresh_from_db( ) # load the profile instance created by the signal tmp_img = form.cleaned_data.get('image') if tmp_img is not None: user.profile.image = Game.resize_image(tmp_img, tmp_img.name, ImageSizeEnum.PROFILE) else: user.profile.image = form.cleaned_data.get('image') user.profile.description = form.cleaned_data.get('description') user.profile.nickname = form.cleaned_data.get('nickname') if form.cleaned_data.get('developer'): group = Group.objects.get(name='Developer') group.user_set.add(user) else: group = Group.objects.get(name='Player') group.user_set.add(user) user.is_active = False user.save() current_site = get_current_site(request) subject = 'Activate your account in GameHub' message = render_to_string( 'accounts/activation_email.html', { 'user': user, 'domain': current_site.domain, 'token': signing.dumps({'id': user.id}), 'expiry': settings.ACTIVATION_TIME }) user.email_user(subject, message) messages.add_message( request, messages.INFO, 'Activate your account with link in your email!') return redirect('accounts:login') else: return render(request, template_name='accounts/register.html', context={'form': form})
def dispatch(self, request, *args, **kwargs): # get the game by the id self.game = Game.get_game(kwargs['game_id']) user = get_user(request) # check to see if the game is open and available for this user # if this player is the creator, just return if self.game.p1 == user or self.game.p2 == user: return super(GameView, self).dispatch(request, *args, **kwargs) # if there is no opponent and the game is not yet completed, # set the opponent as this user if not self.game.p2 and self.game.winner == 0: self.game.p2 = user Cell.create_new_board(self.game.id, self.game.num_rows, self.game.num_cols, self.game.p1, self.game.p2) self.game.save() return super(GameView, self).dispatch(request, *args, **kwargs) else: messages.add_message(request, messages.ERROR, 'Sorry, the selected game is not available.') return redirect('/lobby/')
def setUp(self): logger.debug('StatisticsTest.setUp') dev_group = Group.objects.get(name='Developer') ply_group = Group.objects.get(name='Player') developer = User.objects.create(username='******') developer.save() dev_group.user_set.add(developer) users = [] for i in range(5): user = User.objects.create(username='******'.format(i)) user.save() ply_group.user_set.add(user) users.append(user) games = [] for i in range(3): game = Game.create(title='game{}'.format(i), url='http://foobar.fi', developer=developer, price=(i + 0.5)) game.save() games.append(game) for user in users[:3]: buy_game_for_user(user, games[0]) buy_game_for_user(user, games[1]) rate_game_for_user(user, games[0], 3) rate_game_for_user(user, games[1], 4) for user in users: buy_game_for_user(user, games[2]) rate_game_for_user(user, games[2], 3)
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 test_play_auto_human_computer(self): "At the start of the game, human starts." game = Game(player_x='human', player_o='game.players.RandomPlayer') game.play_auto() self.assertEqual(game.board, " ") self.assertEqual(game.next_player, "X")
import csv import os import django os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django-project-data.settings") django.setup() from game.models import Game f = open('steamstore_game.csv', 'r', encoding='utf-8') info = [] rdr = csv.reader(f) print(rdr) for row in rdr: name, developers, genres = row tuple = (name, developers, genres) info.append(tuple) f.close() instances = [] for (name, developers, genres) in info: instances.append(Game(title=name, developers=developers, genres=genres)) Game.objects.bulk_create(instances)
def add_game(self, host_id, players_amount): game = Game(players_amount=players_amount, host_id=host_id) game.save() Proxy().load() return game, self.status
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 get_all_games_for_session(session_id): return [game.as_dict() for game in Game.query(session_id)]
def test_cover_image_extension(self, name, cover_image, official_repository, errors_dict): game = Game(name=name, cover_image=cover_image, official_repository=official_repository) validation_test(game, errors_dict)
def create_game(request): data = request.data new_game = Game.create(data["first_player"], data["second_player"]) new_game.save() context_dict = GameView.get_game_context(new_game, request) return Response(data=context_dict, template_name=None)
def processNewGame(self, appid, changenum, api, payload): print('Start processing new game') # Passed payload of app data from Scout() req = payload # Set changenumber self.changenum = changenum # New Game Declaration for non relationship fields and non-multiple fields game = Game( appid=appid, name=req['apps'][0]['appinfo']['common']['name'], slug=slugify(req['apps'][0]['appinfo']['common']['name'], allow_unicode=True), release_state=req['apps'][0]['appinfo']['common'].get( 'releasestate', None), icon=req['apps'][0]['appinfo']['common'].get('icon', None), logo=req['apps'][0]['appinfo']['common'].get('logo', None), logo_small=req['apps'][0]['appinfo']['common'].get( 'logo_small', None), clienticon=req['apps'][0]['appinfo']['common'].get( 'clienticon', None), controller_support=req['apps'][0]['appinfo']['common'].get( 'controller_support', None), steam_release_date=self.epochToDateTime( req['apps'][0]['appinfo']['common'].get('steam_release_date')), metacritic_score=req['apps'][0]['appinfo']['common'].get( 'metacritic_score', None), metacritic_fullurl=req['apps'][0]['appinfo']['common'].get( 'metacritic_fullurl', None), ) game.save() # Boolean field creation in DB self.processBoolFields(req, game) # Int field creation in DB self.processIntFields(req, game) # Add price from steamAPI self.addPrice(game, api.priceRequest(game.appid)) # Add categories self.processCategories(req, game, api) # Add genres self.processGenres(req, game, api) # Add primary genre self.processPrimaryGenre(req, game, api) # Add languages self.processLanguages(req, game) # Add app type self.processAppType(req, game) # Add OS options self.processOsOptions(req, game) # Add Associations (dev, publisher) self.processAssociations(req, game) # Add changelog for app creation gamechange = GameChange(change_number=self.changenum, game=game, changelog=GameChange.changelog_builder( GameChange.ADD, game.appid, ), action=GameChange.ADD) gamechange.save() # Return the game after the app has been created in the DB return game
def testEmptyQuery(self): """Tests if an empty query returns all games in the database. """ qset = Game.search(None) self.assertEquals(len(qset), len(Game.objects.all()))
def valid_game(active=True, code=""): user = UserFactory() return Game(players_amount=4, host=user, active=active, code=code)
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 as_game(self): from game.models import Game return Game.initialize_from_dict(self.serialized_state)
def get_game(session_id, game_id): try: return Game.get(session_id, game_id).as_dict() except Game.DoesNotExist: return None
def test_when_3_users(api_client): users = [ AppUser( username="******", vk_id=2, score=20, first_name="Cat", last_name="Leo", photo_url="2.png", ), AppUser( username="******", vk_id=3, score=1, first_name="Dog", last_name="Cooper", photo_url="3.png", ), AppUser( username="******", vk_id=4, score=12, first_name="Puppet", last_name="Bella", photo_url="4.png", ), AppUser( username="******", vk_id=5, score=12, first_name="Fox", last_name="Cozy", photo_url="5.png", ), ] AppUser.objects.bulk_create(users) games = [ Game( player=AppUser.objects.get(vk_id=2), points=10, created_at=timezone.now(), ), Game( player=AppUser.objects.get(vk_id=2), points=20, created_at=timezone.now(), ), Game( player=AppUser.objects.get(vk_id=3), points=40, created_at=timezone.now(), ), Game( player=AppUser.objects.get(vk_id=2), points=30, created_at=timezone.now() - timedelta(days=32), ), Game( player=AppUser.objects.get(vk_id=4), points=2, created_at=timezone.now(), ), Game( player=AppUser.objects.get(vk_id=5), points=1, created_at=timezone.now(), ), Game( player=AppUser.objects.get(vk_id=5), points=1, created_at=timezone.now(), ), ] Game.objects.bulk_create(games) response = get_response(api_client) expected = [ { "first_name": "Dog", "id": AppUser.objects.get(vk_id=3).pk, "last_name": "Cooper", "photo_url": "3.png", "score": 40, }, { "first_name": "Cat", "id": AppUser.objects.get(vk_id=2).pk, "last_name": "Leo", "photo_url": "2.png", "score": 30, }, { "first_name": "Puppet", "id": AppUser.objects.get(vk_id=4).pk, "last_name": "Bella", "photo_url": "4.png", "score": 2, }, { "first_name": "Fox", "id": AppUser.objects.get(vk_id=5).pk, "last_name": "Cozy", "photo_url": "5.png", "score": 2, }, ] assert response.json() == expected
def wait_enemy(request): ''' функция обновления результатов''' if request.method == 'POST' and request.is_ajax(): try: person_id = request.session['person_id'] person = Person.objects.get(person_id=person_id) except Exception as err: print(err) return HttpResponse('Ожидаем соперника.да') else: if person.status == 'wait': try: #находим соперника enemy = Person.objects.filter(status='wait').exclude( person_id=person_id).order_by('-change_mode_date')[0] #создаем игру game = Game(person_step=person.person_id, status='go') game.save() #меняем статус на "игроков" person.status = 'gamer' person.game = game person.enemy = enemy person.save() enemy.status = 'gamer' enemy.game = game enemy.enemy = person enemy.save() #создаем модель выстрела для двух игроков enemy_position = Position.objects.get(person=enemy) person_position = Position.objects.get(person=person) person_shoot, person_created = Shoot.objects.get_or_create( person=person) person_shoot.enemy_big_ship = enemy_position.big_ship person_shoot.enemy_small_ship = enemy_position.small_ship person_shoot.save() enemy_shoot, enemy_created = Shoot.objects.get_or_create( person=enemy) enemy_shoot.enemy_big_ship = person_position.big_ship enemy_shoot.enemy_small_ship = person_position.small_ship enemy_shoot.save() return HttpResponse("Игра началась. Ваш ход.") except Exception as err: print(err) return HttpResponse('Ожидаем соперника...') #если статус "игрок" elif person.status == 'gamer': game = person.game if not game: #игра окончена, противник покинул игру is_my_step = 'true' message = "Противник покинул игру." shoots = ' ' game_is_active = 'false' data = { 'is_my_step': is_my_step, 'message': message, 'shoots': shoots, 'game_is_active': game_is_active } return HttpResponse(json.dumps(data)) #проверяем активна ли игра (ещё нет победителя) if not game.winner: #если шаг совпадает с person_id пользователя if game.person_step == person.person_id: is_my_step = 'true' message = "Твой ход, капитан." shoots = Shoot.objects.get( person=person.enemy).all_shoots game_is_active = 'true' data = { 'is_my_step': is_my_step, 'message': message, 'shoots': shoots, 'game_is_active': game_is_active } return HttpResponse(json.dumps(data)) else: try: #проверяем существует ли ещё противник и участвует ли он в той же игре is_enemy = Person.objects.get( person_id=game.person_step) if is_enemy.game != game: raise Exception except: is_my_step = 'false' message = "Противник покинул игру." shoots = Shoot.objects.get( person=person.enemy).all_shoots game_is_active = 'false' data = { 'is_my_step': is_my_step, 'message': message, 'shoots': shoots, 'game_is_active': game_is_active } return HttpResponse(json.dumps(data)) else: is_my_step = 'false' message = "Ходит противник." shoots = Shoot.objects.get( person=person.enemy).all_shoots game_is_active = 'true' data = { 'is_my_step': is_my_step, 'message': message, 'shoots': shoots, 'game_is_active': game_is_active } return HttpResponse(json.dumps(data)) else: #если игра окончена, отправляем соответствующее сообщение if game.winner == person.person_id: is_my_step = 'false' message = "Вы победили!" shoots = Shoot.objects.get( person=person.enemy).all_shoots game_is_active = 'false' data = { 'is_my_step': is_my_step, 'message': message, 'shoots': shoots, 'game_is_active': game_is_active } return HttpResponse(json.dumps(data)) else: is_my_step = 'false' message = "Вы проиграли." shoots = Shoot.objects.get( person=person.enemy).all_shoots game_is_active = 'false' data = { 'is_my_step': is_my_step, 'message': message, 'shoots': shoots, 'game_is_active': game_is_active } return HttpResponse(json.dumps(data))
def new_game(request): name = request.POST.get('name') game = Game.new(request.user, name) return HttpResponseRedirect(f'/game/game/{game.id}/')
def get_options(self, view): game_list = [(obj.name, obj.name) for obj in Game.objects()] return game_list
def gameroom(request): post_request = request.POST.copy() #Get our inputs from the post request. If they weren't provided, set the variable to None. avatar = int(post_request['avatar']) if 'avatar' in post_request else None player_name = post_request[ 'player_name'] if 'player_name' in post_request else None game_pin = post_request[ 'gamepintxt'] if 'gamepintxt' in post_request else None mode = request.POST['mode'] if 'mode' in request.POST else 'make' #If no avatar was selected, but one of the dev names was entered, set their avatar to the appropriate avatar. if avatar == None: if player_name == 'Azra': avatar = 4 elif player_name == 'Jackie': avatar = 5 elif player_name == 'Luke': avatar = 6 elif player_name == 'Yonatan': avatar = 7 #if there is missing/incorrect information, we need to redirect back to the loading page. Get all the errors we need to return, then return the context error_messages = [] if avatar == None: error_messages.append("Please select an avatar!") if player_name == None: error_messages.append("Please enter a name!") if game_pin == None: #if there is no game pin and the player is joining, tell them to enter a game pin. #if there is no game pin and the player is making a game, something went wrong, so tell them to try again (but don't bother if there are other errors anyway. Would seem confusing. if mode == 'join': error_messages.append("Please enter Game Pin!") elif error_messages == []: error_messages.append("Something went wrong. Please try again!") else: #if we do have a gamepin, and the mode is join, we have to see if the room exists. if mode == 'join' and len( Game.objects.filter(room_code=game_pin)) == 0: #if it doesn't, then tell them that error_messages.append("No room found with that pin!") # if we have errors, then get the landingpage again, load errors, and fill the info that was previously filled if len(error_messages) > 0: context = {"error_messages": error_messages} if player_name != None: context["player_name"] = player_name if avatar != None: context["avatar"] = avatar if game_pin != None: context["gamepintxt"] = game_pin context["mode"] = mode return render(request, 'game/creategame.html', context) #if mode is "make," then we are probably making a new game room. #It is possible that we would have mode "make" but a room already exists with the given pin. #Why? because the person who made the gameroom may have reloaded the page. this would send the same #post request, so we would act as though they are joining the game (try to add them as a player/rejoin as themself) game = None if mode == 'make' and len(Game.objects.filter(room_code=game_pin)) == 0: #set up the game using the game pin we have from the frontend game = Game(team_turn=random.randrange(2) + 1, room_code=game_pin) if game != None: print("game is not none") else: print("game is none") game.save() #make the board game.setup_default_grid(width=int(post_request['boardsize']), height=int(post_request['boardsize']), words_per_side=int( post_request['wordsperside'])) game.save() else: game = Game.objects.filter(room_code=game_pin)[0] game.save() #make a new player if there isn't currently a player with that name in the game. otherwise, check if the player is currently active; if they aren't then this player can take over their spot. if len(game.player_set.filter(name=player_name)) > 0: #someone exists with that name if game.player_set.filter( name=player_name)[0].connected and not mode == "make": #if they are currently connected, return back to landing page with appropriate error message. context = {"error_messages": ['Someone already has that name!']} if player_name != None: context["player_name"] = player_name if avatar != None: context["avatar"] = avatar if game_pin != None: context["gamepintxt"] = game_pin context["mode"] = mode return render(request, 'game/creategame.html', context) else: #they are not connected, so we can take over from them. player = game.player_set.filter(name=player_name)[0] else: #otherwise, no one exists with that name, so make a new player player = game.player_set.create(name=player_name, avatar_num=avatar) player.assign() player.save() #save our work on the game game.save() #now work on setup for the board and stuff rows = [] y = 0 while len(game.boardposition_set.filter(y=y)) > 0: rows.append(game.boardposition_set.filter(y=y)) y += 1 #get all the player names on both teams team_1_players_query_set = game.player_set.filter(team=1) team_1_players = [] for aplayer in team_1_players_query_set: team_1_players.append([aplayer.name, aplayer.avatar_num]) team_2_players_query_set = game.player_set.filter(team=2) team_2_players = [] for aplayer in team_2_players_query_set: team_2_players.append([aplayer.name, aplayer.avatar_num]) template = loader.get_template('game/gameroom.html') #send info to template context = { 'all_rows': rows, 'room_code': game.room_code, 'avatar_num': int(player.avatar_num), 'players_name': player.name, 'player_team': player.team, 'is_captain': player.captain, 'team_1_players': team_1_players, 'team_2_players': team_2_players, 'team_turn': game.team_turn, 'pk': player.pk, 'currentClue': game.current_clue, 'wordsLeft': game.words_left } return HttpResponse(template.render(context, request))
def apply(self, query, value): return query.filter(game__exact=Game.objects(name__exact=value).first().id)
def test_create_game(self): my_game = Game( name="Super game", ) self.assertEqual(my_game.name, "Super game")
def receive(self, text_data): text_data_json = json.loads(text_data) sender = self.user context = text_data_json["context"] if context == "request_reject": # Treat message as rejecting request rtype = text_data_json["type"] if rtype == "game" or rtype == "friend": req_id = text_data_json["request_id"] req_object = UserRequests.objects.filter(id=req_id).first() if req_object is None: self.send(text_data=json.dumps({"request_new_ack": "reject_missing"})) return if self.user_object != req_object.recipient: self.send(text_data=json.dumps({"request_new_ack": "reject_permission"})) return # Reject request req_object.answered = True req_object.answer = False req_object.save() # Notify sender and recipient self.send(text_data=json.dumps({"request_new_ack": "request_reject", "request_id": req_object.id})) # Notify sender that request was rejected target_group = "requests_user_" + str(req_object.sender.id) req_type = "" if req_object.type == "friend": req_type = "o přátelství" elif req_object.type == "game": req_type = "o hru" async_to_sync(self.channel_layer.group_send)( target_group, { "type": "request_notify_reject", "message": "Tvůj požadavek " + req_type + " s " + req_object.recipient.email + " byl odmítnut", "request_id": req_object.id, "rtype": "friend", } ) return # Route based on context if context == "request_accept": # Treat message as accepting request rtype = text_data_json["type"] if rtype == "game": req_id = text_data_json["request_id"] req_object = UserRequests.objects.filter(id=req_id).first() # Request doesnt exist if req_object is None: self.send(text_data=json.dumps({"request_new_ack": "accept_missing"})) return # Request is wrong type if req_object.type != "game": self.send(text_data=json.dumps({"request_new_ack": "wrong_type"})) return # Block user from accepting request that isnt for him if self.user_object != req_object.recipient: self.send(text_data=json.dumps({"request_new_ack": "accept_permission"})) return # Get online users user_activity_objects = OnlineUserActivity.get_user_activities(timedelta(minutes=3)) online = (user.user.id for user in user_activity_objects) # User is not online if not req_object.recipient.id in online: self.send(text_data=json.dumps({"request_new_ack": "not_online"})) return # Check if sender is in game sending = self.user_object if Game.has_active_game(sending): self.send(text_data=json.dumps({"request_new_ack": "already_game_self"})) return # Check if recipient is in game if Game.has_active_game(req_object.recipient): self.send(text_data=json.dumps({"request_new_ack": "already_game"})) return # Create game game_object = Game.create_game(req_object.sender, req_object.recipient) # Notify players target_recipient = "requests_user_" + str(game_object.player1.id) target_sender = "requests_user_" + str(game_object.player2.id) async_to_sync(self.channel_layer.group_send)( target_recipient, { "type": "request_notify_game", "request_new_ack": "game_start", "game_id": game_object.id, } ) async_to_sync(self.channel_layer.group_send)( target_sender, { "type": "request_notify_game", "request_new_ack": "game_start", "game_id": game_object.id, } ) ann = Announcements() ann.text = "Uživatelé " + str(game_object.player1.email) + " a " + str( game_object.player2.email) + " začali hru #" + str(game_object.id) + "." ann.save() return if rtype == "friend": req_id = text_data_json["request_id"] req_object = UserRequests.objects.filter(id=req_id).first() if req_object.type != "friend": self.send(text_data=json.dumps({"request_new_ack": "wrong_type"})) return if req_object is None: self.send(text_data=json.dumps({"request_new_ack": "accept_missing"})) return if self.user_object != req_object.sender and self.user_object != req_object.recipient: self.send(text_data=json.dumps({"request_new_ack": "accept_permission"})) return # Set request responded true and positive req_object.answered = True req_object.answer = True req_object.save() # Create friend friend = Friends() friend.user1 = req_object.sender friend.user2 = req_object.recipient friend.save() # Announcement create ann = Announcements() ann.text = "Uživatelé " + str(friend.user1.email) + " a " + str(friend.user2.email) + " se stali přáteli." ann.save() # Notify rejecter to delete his record self.send(text_data=json.dumps({"request_new_ack": "request_accept", "request_id": req_object.id})) return if context == "request_new": # Treat message as new request rtype = text_data_json["type"] # Further route based on type if rtype == "game": # Treat request as new game request # Acknowledge request self.send(text_data=json.dumps({"request_new_ack": "acknowledged"})) # Get recipient id = text_data_json["recipient"] recipient = User.objects.filter(id=id).first() target_group = "requests_user_" + str(recipient.id) # Check if user wants to play game with himself if recipient == self.user_object: self.send(text_data=json.dumps({"request_new_ack": "game_self"})) return # Get online users user_activity_objects = OnlineUserActivity.get_user_activities(timedelta(minutes=3)) online = (user.user.id for user in user_activity_objects) # User is not online if not recipient.id in online: self.send(text_data=json.dumps({"request_new_ack": "not_online"})) return # Check if recipient have pending request if UserRequests.has_pending_request(self.user_object, recipient, rtype): self.send(text_data=json.dumps({"request_new_ack": "already_pending"})) return other_side_requests = UserRequests.get_pending_request(recipient, self.user_object, rtype) # Check if sender is in game sending = self.user_object active_game_self = Game.get_active_game(sending) if active_game_self is not None: self.send(text_data=json.dumps({"request_new_ack": "already_game_self", "game_id": active_game_self.id})) return # Check if recipient is in game if Game.has_active_game(recipient): self.send(text_data=json.dumps({"request_new_ack": "already_game"})) return # Check pending request from other side if len(other_side_requests) > 0: request_object = other_side_requests[0] # Notify other user async_to_sync(self.channel_layer.group_send)( target_group, { "type": "request_notify_merged", "request_new_ack": "merged", "request_id": other_side_requests[0].id, "rtype": "game", } ) # Notify self self.send(text_data=json.dumps({ "request_new_ack": "merged", "request_id": request_object.id, })) # Set request responded true and positive request_object.answered = True request_object.answer = True request_object.save() # Create game game_object = Game.create_game(request_object.sender, request_object.recipient) # Notify players target_recipient = "requests_user_" + str(game_object.player1.id) target_sender = "requests_user_" + str(game_object.player2.id) async_to_sync(self.channel_layer.group_send)( target_recipient, { "type": "request_notify_game", "request_new_ack": "game_start", "game_id": game_object.id, } ) async_to_sync(self.channel_layer.group_send)( target_sender, { "type": "request_notify_game", "request_new_ack": "game_start", "game_id": game_object.id, } ) # Terminate rest of function return # Actually create Request in database request_text = "Uživatel " + self.user + " tě požádal o hru!" request = UserRequests.create_request(self.user_object, recipient, "game", request_text) # Send request to recipient async_to_sync(self.channel_layer.group_send)( target_group, { "type": "request_notify", "message": request_text, 'sender_name': self.user, "sender": self.user_id, "request_id": request.id, "rtype": "game", } ) return if rtype == "friend": # Treat request as new friend request # Acknowledge request self.send(text_data=json.dumps({"request_new_ack": "acknowledged"})) # Get recipient id = text_data_json["recipient"] recipient = User.objects.filter(id=id).first() target_group = "requests_user_" + str(recipient.id) # Check if user wants to friend himself if recipient == self.user_object: self.send(text_data=json.dumps({"request_new_ack": "friends_self"})) return # Check if users are already friends if Friends.are_friends(self.user_object, recipient): self.send(text_data=json.dumps({"request_new_ack": "already_friends"})) return # Check if recipient have pending request if UserRequests.has_pending_request(self.user_object, recipient, rtype): self.send(text_data=json.dumps({"request_new_ack": "already_pending"})) return other_side_requests = UserRequests.get_pending_request(recipient, self.user_object, rtype) # Check pending request from other side if len(other_side_requests) > 0: request_object = other_side_requests[0] # Notify other user async_to_sync(self.channel_layer.group_send)( target_group, { "type": "request_notify_merged", "request_new_ack": "merged", "request_id": other_side_requests[0].id, } ) # Notify self self.send(text_data=json.dumps({ "request_new_ack": "merged", "request_id": request_object.id, })) # Set request responded true and positive request_object.answered = True request_object.answer = True request_object.save() # Create friend friend = Friends() friend.user1 = self.user_object friend.user2 = recipient friend.save() ann = Announcements() ann.text = "Uživatelé " + str(friend.user1.email) + " a " + str( friend.user2.email) + " se stali přáteli." ann.save() # Terminate rest of function return # Actually create Request in database request_text = "Uživatel " + self.user + " tě požádal o přátelství!" request = UserRequests.create_request(self.user_object, recipient, "friend", request_text) # Send request to recipient async_to_sync(self.channel_layer.group_send)( target_group, { "type": "request_notify", "message": request_text, 'sender_name': self.user, "sender": self.user_id, "request_id": request.id, "rtype": "friend", } )
def __init__(self): self.board = Board() self.game = Game(AIPlayer(deep_blue_game_piece), Player(opponent_game_piece))
def setup_dynamo(): Game.create_table() Session.create_table() Participation.create_table()
def test_model_get_active_state(game: Game): assert game.get_active_state() is None
class BoardTest(TestCase): def setUp(self): # Create user user_data = { "username": "******", "email": "*****@*****.**", "password": "******", } self.user = User._default_manager.create_user(**user_data) self.user.save() board_data = {'name': 'boardcito', 'owner': self.user} self.board = Board(**board_data) self.board.save() room_data = { 'name': 'roomcito', 'board': self.board, 'game_has_started': False, 'owner': self.user, } self.room = Room(**room_data) self.room.save() self.game = Game(room=self.room) self.game.save() def test_create_board(self): board = Board.objects.create(owner=self.user, name="TestBoard") board.save() self.assertNotEqual(board, None) self.assertEqual(board.owner, self.user) self.assertEqual(board.name, "TestBoard") def test_create_hex(self): b = Board.objects.create(owner=self.user, name="Placeholder") h = Hexagon.objects.create(board=b, level=1, index=2, token=2, resource='brick') h.save() self.assertNotEqual(h, None) self.assertEqual(h.board, b) self.assertEqual(h.level, 1) self.assertEqual(h.index, 2) self.assertEqual(h.token, 2) self.assertEqual(h.resource, 'brick') def test_hex_list(self): hexagon = Hexagon.objects.create(board=self.board, level=0, index=0, token=1, resource="wool") hexagon.save() view = HexListViewSets.as_view({'get': 'list'}) factory = APIRequestFactory() request = factory.get('api/games/<int:game>/board/') response = view(request, game=self.game.id) hexes = self.board.hexagon_set.all() serializer = HexagonSerializer(hexes, many=True) result = {'hexes': serializer.data} self.assertEqual(response.data, result)