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)
