def reclaim_board(request):
ip = request.META['REMOTE_ADDR']
game = get_game(site=get_current_site(request), create=False)
if game is not None:
Game.objects.filter(id=game.id).update(last_used=times.now())
bingo_board = _get_user_bingo_board(request)
if not bingo_board is None:
return redirect(reverse(bingo, kwargs={
'board_id': bingo_board.board_id}))
if request.POST:
reclaim_form = ReclaimForm(request.POST, game=game, prefix="reclaim")
if reclaim_form.is_valid():
bingo_board = reclaim_form.cleaned_data['bingo_board']
request.session['board_id'] = bingo_board.id
bingo_board.ip = ip
bingo_board.save()
return redirect(reverse(bingo, kwargs={'board_id':
bingo_board.board_id}))
else:
reclaim_form = ReclaimForm(prefix="reclaim")
create_form = CreateForm(prefix="create", game=game)
return render(request,
"bingo/reclaim_board.html", {
'reclaim_form': reclaim_form,
'create_form': create_form,
})
def reclaim_board(request):
ip = request.META['REMOTE_ADDR']
game = get_game(site=get_current_site(request), create=False)
if game is not None:
Game.objects.filter(id=game.id).update(last_used=times.now())
bingo_board = _get_user_bingo_board(request)
if not bingo_board is None:
return redirect(
reverse(bingo, kwargs={'board_id': bingo_board.board_id}))
if request.POST:
reclaim_form = ReclaimForm(request.POST, game=game, prefix="reclaim")
if reclaim_form.is_valid():
bingo_board = reclaim_form.cleaned_data['bingo_board']
request.session['board_id'] = bingo_board.id
bingo_board.ip = ip
bingo_board.save()
return redirect(
reverse(bingo, kwargs={'board_id': bingo_board.board_id}))
else:
reclaim_form = ReclaimForm(prefix="reclaim")
create_form = CreateForm(prefix="create", game=game)
return render(request, "bingo/reclaim_board.html", {
'reclaim_form': reclaim_form,
'create_form': create_form,
})
def main(request, reclaim_form=None, create_form=None):
game = get_game(site=get_current_site(request), create=False)
bingo_board = _get_user_bingo_board(request)
create_form = CreateForm(prefix="create", game=game)
reclaim_form = ReclaimForm(prefix="reclaim")
boards = BingoBoard.objects.filter(game=game)
old_games = Game.objects.filter(
site=get_current_site(request)
).exclude(
# games without any boards created
bingoboard=None
).exclude(
# games without game_id are hidden
game_id=None
).order_by("-created")
if game is not None:
old_games = old_games.exclude(id=game.id)
return render(request, "bingo/main.html", {
'my_board': bingo_board,
'create_form': create_form,
'reclaim_form': reclaim_form,
'boards': boards,
'current_game': game,
'old_games': old_games,
'can_start_game': not GAME_START_DISABLED,
})
def post(self):
game_id = self.get_argument('game_id')
game_password = self.get_argument('game_password')
username = self.get_argument('username')
session = Session()
try:
user = get_user(username)
game = get_game(game_id=game_id, game_password=game_password)
try:
usergame = get_usergame(user.id, game.id)
if usergame is not None:
response_dict = get_response_dict(True)
except NoResultFound:
if not game.started:
game.add_user(user)
response_dict = get_response_dict(True)
else:
response_dict = get_response_dict(False, 'Game has started; you cannot join.')
except Exception as e:
session.rollback()
response_dict = get_response_dict(False, e.message)
finally:
Session.remove()
self.finish(simplejson.dumps(response_dict))
def main(request, reclaim_form=None, create_form=None):
game = get_game(site=get_current_site(request), create=False)
bingo_board = _get_user_bingo_board(request)
create_form = CreateForm(prefix="create", game=game)
reclaim_form = ReclaimForm(prefix="reclaim")
boards = BingoBoard.objects.filter(game=game)
old_games = Game.objects.filter(site=get_current_site(request)).exclude(
# games without any boards created
bingoboard=None).exclude(
# games without game_id are hidden
game_id=None).order_by("-created")
if game is not None:
old_games = old_games.exclude(id=game.id)
return render(
request, "bingo/main.html", {
'my_board': bingo_board,
'create_form': create_form,
'reclaim_form': reclaim_form,
'boards': boards,
'current_game': game,
'old_games': old_games,
'can_start_game': not GAME_START_DISABLED,
})
def post(self):
shot_id = self.get_argument('shot_id')
username = self.get_argument('username')
shot_upheld = self.get_argument('shot_upheld')
claim = self.get_argument('claim', '')
try:
resolving_user = get_user(username=username)
shot = get_shot(shot_id)
game = get_game(shot.game_id)
session = Session()
mission = get_mission(game_id=game.id, assassin_id=shot.assassin_id, target_id=shot.target_id, completed_timestamp=None)
if shot_upheld == 'True':
if shot.target_id == resolving_user.id or resolving_user in game.game_masters:
shot.kill_upheld = True
game.mission_completed(mission, shot)
response_dict = get_response_dict(True)
else:
if shot.target_id == resolving_user.id:
dispute = Dispute(game.id, shot_id, claim)
session.add(dispute)
session.flush()
session.commit()
response_dict = get_response_dict(True)
elif resolving_user in game.game_masters:
shot.kill_upheld = False
response_dict = get_response_dict(True)
except Exception as e:
session.rollback()
response_dict = get_response_dict(False, e.message)
finally:
Session.remove()
self.finish(simplejson.dumps(response_dict))
def post(self):
username = self.get_argument('username')
game_id = self.get_argument('game_id')
dispute_id = self.get_argument('dispute_id')
shot_upheld = self.get_argument('dispute_upheld')
gm_decision_reason = self.get_argument('gm_decision_reason')
session = Session()
try:
dispute = session.query(Dispute).filter_by(id=dispute_id).one()
shot = session.query(Shot).filter_by(id=dispute.shot_id).one()
resolving_user = get_user(username=username)
game = get_game(game_id)
mission = get_mission(game_id=game_id, assassin_id=shot.assassin_id, target_id=shot.target_id, completed_timestamp=None)
if resolving_user in game.game_masters:
if shot_upheld == 'True':
game.mission_completed(mission)
dispute.shot_upheld = True
else:
dispute.shot_upheld = False
target_usergame = get_usergame(shot.target_id, game.id)
if target_usergame.alive == None:
target_usergame.alive = True
session.add(target_usergame)
dispute.gm_decision_reason = gm_decision_reason
session.add(dispute)
session.flush()
session.commit()
response_dict = get_response_dict(True)
else:
response_dict = get_response_dict(False, 'Only the game master can resolve a dispute')
except Exception, e:
session.rollback()
response_dict = get_response_dict(False, e.message)
def update_games(self, games):
for game_info in games:
game = get_game(self.year, self.week_number, game_info.number)
game.team1_actual_points = game_info.team1_score if game_info.team1_score != '' else -1
game.team2_actual_points = game_info.team2_score if game_info.team2_score != '' else -1
game.quarter = game_info.quarter
game.time_left = game_info.time_left
game_state = game_info.state
if game_state == "not_started":
game.game_state = NOT_STARTED
elif game_state == "in_progress":
game.game_state = IN_PROGRESS
elif game_state == "final":
game.game_state = FINAL
else:
raise AssertionError, "Unexpected game state value: %s" % (
game_state)
if game_state == "final":
game.winner = CalculateResults(None).get_pool_game_winner(game)
else:
game.winner = 0
game.save()
# TODO not entirely sure about this, but if the update games page gets submitted,
# change the Week.winner field to None since it will no longer be accurate
# if any scores were changed
week = get_week(self.year, self.week_number)
week.winner = None
week.save()
def create_board(request):
bingo_board = _get_user_bingo_board(request)
game = bingo_board.game if bingo_board is not None else None
user = request.user
if bingo_board:
Game.objects.filter(id=bingo_board.game.id).update(
last_used=times.now())
return redirect(reverse(bingo, kwargs={
'board_id': bingo_board.board_id}))
elif request.POST:
create_form = CreateForm(
request.POST,
prefix="create",
game=game)
if create_form.is_valid():
with transaction.atomic():
ip = request.META['REMOTE_ADDR']
password = create_form.cleaned_data.get('password')
game_description = create_form.cleaned_data.get(
'description', '')
game = get_game(
site=get_current_site(request),
description=game_description,
create=True)
Game.objects.filter(id=game.id).update(
last_used=times.now())
# if the user is logged in, associate the board with
# the user, and ignore the password
# (so no other user can claim the board)
user = user if user.is_authenticated() else None
if user:
password = None
bingo_board = BingoBoard(
game=game, user=user, ip=ip, password=password)
bingo_board.save()
if USE_SSE:
_publish_num_users(game.site.id, game.num_users(),
game.num_active_users())
return redirect(reverse(bingo, kwargs={
'board_id': bingo_board.board_id}))
else:
reclaim_form = ReclaimForm(prefix="reclaim")
return render(
request,
"bingo/reclaim_board.html",
{
'reclaim_form': reclaim_form,
'create_form': create_form,
}
)
else:
return redirect(reverse(main))
async def index(request):
current_ws = web.WebSocketResponse()
if not current_ws.can_prepare(request).ok:
return aiohttp_jinja2.render_template('index.html', request, {})
await current_ws.prepare(request)
game = get_game(request=request)
user = User(ws=current_ws)
game.connect(user=user)
opponent = game.get_opponent(user=user)
if opponent is not None:
# Если есть оппонент, то его необходимо уведомить о подключении другого игрока
opponent_message = {
'action': 'join',
'opponentSign': user.sign,
}
await opponent.ws.send_json(opponent_message)
user_message = {
'action': 'connect',
'sign': user.sign,
'game_id': game.id,
'opponentName': str(opponent) if opponent else None,
}
await user.ws.send_json(user_message)
async for msg in user.ws:
if opponent is None:
opponent = game.get_opponent(user=user)
if msg.type == web.WSMsgType.text and opponent is not None:
data = json.loads(msg.data)
if 'coordinates' in data:
i = int(data['coordinates']['i'])
j = int(data['coordinates']['j'])
if game.set_in_field(user, i, j):
await opponent.ws.send_json(data)
winner = game.get_winner()
if winner == user.sign:
await user.ws.send_json({'action': 'win'})
await opponent.ws.send_json({'action': 'lose'})
game.state = STATE.GAME_OVER
elif winner == opponent.sign:
await user.ws.send_json({'action': 'lose'})
await opponent.ws.send_json({'action': 'win'})
game.state = STATE.GAME_OVER
if opponent:
await opponent.ws.send_json({'action': 'disconnect'})
game.state = STATE.OPPONENT_DISCONNECTED
del user
return current_ws
def post(self):
game_id = self.get_argument('game_id')
session = Session()
try:
game = get_game(game_id)
game.start()
response_dict = get_response_dict(True)
except Exception as e:
session.rollback()
response_dict = get_response_dict(False, e.message)
Session.remove()
self.finish(simplejson.dumps(response_dict))
def create_board(request):
bingo_board = _get_user_bingo_board(request)
game = bingo_board.game if bingo_board is not None else None
user = request.user
if bingo_board:
Game.objects.filter(id=bingo_board.game.id).update(
last_used=times.now())
return redirect(
reverse(bingo, kwargs={'board_id': bingo_board.board_id}))
elif request.POST:
create_form = CreateForm(request.POST, prefix="create", game=game)
if create_form.is_valid():
with transaction.atomic():
ip = request.META['REMOTE_ADDR']
password = create_form.cleaned_data.get('password')
game_description = create_form.cleaned_data.get(
'description', '')
game = get_game(site=get_current_site(request),
description=game_description,
create=True)
Game.objects.filter(id=game.id).update(last_used=times.now())
# if the user is logged in, associate the board with
# the user, and ignore the password
# (so no other user can claim the board)
user = user if user.is_authenticated() else None
if user:
password = None
bingo_board = BingoBoard(game=game,
user=user,
ip=ip,
password=password)
bingo_board.save()
if USE_SSE:
_publish_num_users(game.site.id, game.num_users(),
game.num_active_users())
return redirect(
reverse(bingo, kwargs={'board_id': bingo_board.board_id}))
else:
reclaim_form = ReclaimForm(prefix="reclaim")
return render(request, "bingo/reclaim_board.html", {
'reclaim_form': reclaim_form,
'create_form': create_form,
})
else:
return redirect(reverse(main))
def _get_user_bingo_board(request):
bingo_board = None
game = get_game(site=get_current_site(request), create=False)
session_board_id = request.session.get('board_id', None)
user = request.user if request.user.is_authenticated() else None
ip = request.META['REMOTE_ADDR']
# try the board_id in the session
if not session_board_id is None:
try:
bingo_board = BingoBoard.objects.get(id=session_board_id,
game=game)
bingo_board.ip = ip
except BingoBoard.DoesNotExist, e:
pass
# double board_id?
except BingoBoard.MultipleObjectsReturned:
pass
def _get_user_bingo_board(request):
bingo_board = None
game = get_game(site=get_current_site(request), create=False)
session_board_id = request.session.get('board_id', None)
user = request.user if request.user.is_authenticated() else None
ip = request.META['REMOTE_ADDR']
# try the board_id in the session
if not session_board_id is None:
try:
bingo_board = BingoBoard.objects.get(id=session_board_id,
game=game)
bingo_board.ip = ip
except BingoBoard.DoesNotExist, e:
pass
# double board_id?
except BingoBoard.MultipleObjectsReturned:
pass
def post(self):
username = self.get_argument('username')
game_id = self.get_argument('game_id')
shot_picture = None
target_username = self.get_argument('target_username')
mission_id = self.get_argument('mission_id', None)
session = Session()
try:
target_user = get_user(username=target_username)
assassin_user = get_user(username=username)
game = get_game(game_id)
mission = get_mission(game_id=game_id, assassin_username=username, target_id=target_user.id)
picture_binary = self.request.files['shot_picture'][0]['body']
shot_picture_url = imgur.upload(file_body=picture_binary)
player_shooting_target = Shot(assassin_id=assassin_user.id, \
target_id=target_user.id, \
game_id=game_id, \
shot_picture=shot_picture_url)
session.add(player_shooting_target)
session.flush()
session.commit()
target_usergame = get_usergame(user_id=target_user.id, game_id=game_id)
if player_shooting_target.is_valid():
target_usergame.alive = None # mark them as shot
target_usergame.pending_shot = player_shooting_target.id
session.add(target_usergame)
session.flush()
session.commit()
response_dict = get_response_dict(True)
else:
if target_usergame.alive is None:
response_dict = get_response_dict(False, "Shot invalid. Your target was previously shot, and the kill needs to be confirmed by him/her or the game master")
else:
response_dict = get_response_dict(False, "Shot invalid. If this was your target in this game, maybe they had a body double or you need to wait?")
except Exception as e:
session.rollback()
response_dict = get_response_dict(False, e.message)
finally:
Session.remove()
self.finish(simplejson.dumps(response_dict))
def post(self):
logger = logging.getLogger('DisablePowerup')
session = Session()
try:
game_id = self.get_argument('game_id')
username = self.get_argument('username')
power_id = self.get_argument('powerup_id')
user = get_user(username)
ug = get_usergame(user.id, game_id)
if(ug.is_game_master):
game = get_game(game_id)
game.disable_powerup(user.id, power_id)
session.commit()
result_dict = get_response_dict(True)
else:
raise Exception("You are not a Game Master for the given game_id")
except Exception, e:
logger.exception(e)
session.rollback()
result_dict = get_response_dict(False, e.message)