def create_rematch(hashid):
game = CricketGame.query.filter_by(hashid=hashid).first_or_404()
match_json = json.dumps({1: {1: cricket_leg_default.copy()}})
rematch = CricketGame(
player1=game.player1,
player2=game.player2,
bo_sets=game.bo_sets,
bo_legs=game.bo_legs,
two_clear_legs=game.two_clear_legs,
p1_sets=0,
p2_sets=0,
p1_legs=0,
p2_legs=0,
p1_score=0,
p2_score=0,
begin=datetime.utcnow(),
match_json=match_json,
status='started',
opponent_type=game.opponent_type,
public_challenge=False,
tournament=game.tournament,
score_input_delay=game.score_input_delay,
webcam=game.webcam,
jitsi_hashid=secrets.token_urlsafe(8)[:8],
variant='cricket',
)
rematch.p1_next_turn = True
if game.closest_to_bull_json:
closest_to_bull_json = json.dumps({1: [], 2: []})
rematch.closest_to_bull_json = closest_to_bull_json
rematch.closest_to_bull = True
db.session.add(rematch)
db.session.commit() # needed to get a game id for the hashid
rematch.set_hashid()
db.session.commit()
return rematch.hashid
def create(mode='x01', opponent_name=None, tournament_hashid=None):
if mode == 'x01':
form = prepare_x01_form(opponent_name, tournament_hashid)
else:
form = prepare_cricket_form(opponent_name, tournament_hashid)
webcam_query = WebcamSettings.query.filter_by(user=current_user.id).first()
if not webcam_query or not webcam_query.activated:
if form.webcam.data:
return redirect(url_for('game.webcam_consent'))
form.webcam.render_kw = {'disabled': 'disabled'}
if form.validate_on_submit():
player1 = current_user.id if current_user.is_authenticated else None
if player1 and form.opponent.data == 'local':
player2 = current_user.id
status = 'started'
elif player1 and form.opponent.data == 'online':
if form.opponent_name.data:
if form.public_challenge.data:
# Public challenge flag and player name specified is not allowed
flash(
gettext(
'Public challenges must be created without an opponent name.'
), 'danger')
return render_template('game/create_game.html',
form=form,
opponent_name=opponent_name,
title=lazy_gettext('Create Game'))
player2 = (User.query.with_entities(User.id).filter(
func.lower(User.username) == func.lower(
form.opponent_name.data)).first_or_404())
player2_settings = UserSettings.query.filter_by(
user=player2.id).first()
if player2_settings and not player2_settings.allow_challenges:
# player 2 does not allow challenge requests
flash(gettext('Player does not allow challenges'),
'danger')
return render_template('game/create_game.html',
form=form,
opponent_name=opponent_name,
title=lazy_gettext('Create Game'))
message = gettext('New challenge')
notification = Notification(user=player2,
message=message,
author=current_user.username,
type='challenge')
db.session.add(notification)
send_notification(form.opponent_name.data,
message,
current_user.username,
'challenge',
webcam=form.webcam.data)
else:
player2 = None
status = 'challenged'
else:
# computer as opponent
player2 = None
status = 'started'
if form.webcam.data:
if player2:
webcam_player2 = WebcamSettings.query.filter_by(
user=player2).first()
if not webcam_player2 or not webcam_player2.activated:
flash(
gettext(
'Player 2 does not have webcam games enabled.'),
'danger')
return render_template('game/create_game.html',
form=form,
opponent_name=opponent_name,
title=lazy_gettext('Create Game'))
else:
webcam_player2 = None
jitsi_hashid = secrets.token_urlsafe(8)[:8]
webcam_player1 = WebcamSettings.query.filter_by(
user=player1).first()
jitsi_public_server = webcam_player1.jitsi_public_server or (
webcam_player2 and webcam_player2.jitsi_public_server)
else:
jitsi_hashid = None
jitsi_public_server = False
tournament = form.tournament.data if form.tournament.data != '-' else None
try:
player2_id = player2.id
except AttributeError:
player2_id = player2
if mode == 'x01':
match_json = json.dumps({
1: {
1: {
1: {
'scores': [],
'double_missed': []
},
2: {
'scores': [],
'double_missed': []
}
}
}
})
game = Game(
player1=player1,
player2=player2_id,
type=form.type.data,
variant='x01',
bo_sets=form.bo_sets.data,
bo_legs=form.bo_legs.data,
two_clear_legs=form.two_clear_legs.data,
p1_sets=0,
p2_sets=0,
p1_legs=0,
p2_legs=0,
p1_score=int(form.type.data),
p2_score=int(form.type.data),
in_mode=form.in_mode.data,
out_mode=form.out_mode.data,
begin=datetime.utcnow(),
match_json=match_json,
status=status,
opponent_type=form.opponent.data,
public_challenge=form.public_challenge.data,
tournament=tournament,
score_input_delay=form.score_input_delay.data,
webcam=form.webcam.data,
jitsi_hashid=jitsi_hashid,
jitsi_public_server=jitsi_public_server,
)
elif mode == 'cricket':
match_json = json.dumps({
1: {
1: cricket_leg_default.copy(),
},
}, )
game = CricketGame(
player1=player1,
player2=player2_id,
variant='cricket',
bo_sets=form.bo_sets.data,
bo_legs=form.bo_legs.data,
two_clear_legs=form.two_clear_legs.data,
p1_sets=0,
p2_sets=0,
p1_legs=0,
p2_legs=0,
p1_score=0,
p2_score=0,
begin=datetime.utcnow(),
match_json=match_json,
status=status,
opponent_type=form.opponent.data,
public_challenge=form.public_challenge.data,
tournament=tournament,
score_input_delay=form.score_input_delay.data,
webcam=form.webcam.data,
jitsi_hashid=jitsi_hashid,
jitsi_public_server=jitsi_public_server,
)
else:
pass
# Preset saving
if form.save_preset.data:
if mode == 'x01':
save_x01_preset(form)
elif mode == 'cricket':
save_cricket_preset(form)
else:
pass
if game.opponent_type.startswith('computer'):
game.opponent_type += form.level.data
game.p1_next_turn = form.starter.data == 'me'
if form.starter.data == 'closest_to_bull':
game.p1_next_turn = True
closest_to_bull_json = json.dumps({1: [], 2: []})
game.closest_to_bull_json = closest_to_bull_json
game.closest_to_bull = True
db.session.add(game)
db.session.commit() # needed to get a game id for the hashid
game.set_hashid()
db.session.commit()
return redirect(url_for('game.start', hashid=game.hashid))
return render_template('game/create_game.html',
form=form,
opponent_name=opponent_name,
title=lazy_gettext('Create Game'))
def process_leg_win(player_dict, match_json, current_values):
# check if draws are possible
set_draw_possible = (player_dict['bo_sets'] % 2) == 0
leg_draw_possible = (player_dict['bo_legs'] % 2) == 0
# amount of legs/sets needed to win
legs_for_set = (player_dict['bo_legs'] /
2) + 1 if leg_draw_possible else math.ceil(
player_dict['bo_legs'] / 2)
sets_for_match = (player_dict['bo_sets'] /
2) + 1 if set_draw_possible else math.ceil(
player_dict['bo_sets'] / 2)
# leg count increase with check for set win
if player_dict['two_clear_legs']:
player_dict['p_legs'] += 1
else:
player_dict['p_legs'] = (player_dict['p_legs'] + 1) % legs_for_set
# reset score to default value
player_dict['p_score'] = 0
# check if player won set
if player_dict['p_legs'] == 0 or \
(player_dict['two_clear_legs'] and
player_dict['p_legs'] >= legs_for_set and
player_dict['p_legs'] >= player_dict['o_legs'] + 2):
player_dict['p_sets'] += 1
# check if player won match or match drawn
if player_dict['p_sets'] == sets_for_match or \
(set_draw_possible and (player_dict['p_sets'] == player_dict['o_sets'] == (player_dict['bo_sets'] / 2))):
# leg score is needed if best of 1 set
if player_dict[
'bo_sets'] == 1 and not player_dict['two_clear_legs']:
player_dict['p_legs'] = math.ceil(
(player_dict['bo_legs'] + 0.5) / 2)
player_dict['status'] = 'completed'
player_dict['p_score'] = 0 # end score 0 looks nicer
else: # match not over, new set
player_dict['p_legs'] = 0
player_dict['o_legs'] = 0
current_values['set'] = str(int(current_values['set']) + 1)
current_values['leg'] = '1'
match_json[current_values['set']] = {
current_values['leg']: cricket_leg_default.copy()
}
else: # no new set unless drawn
# check for drawn set
if leg_draw_possible and (player_dict['p_legs'] ==
player_dict['o_legs'] ==
(player_dict['bo_legs'] / 2)):
player_dict['p_sets'] += 1
player_dict['o_sets'] += 1
# check if a player won the match
if player_dict['p_sets'] == sets_for_match or player_dict[
'o_sets'] == sets_for_match:
player_dict['status'] = 'completed'
player_dict['p_score'] = 0
# check if match is drawn - redundant atm, could be merged with game win
elif set_draw_possible and (player_dict['p_sets'] ==
player_dict['o_sets'] ==
(player_dict['bo_sets'] / 2)):
player_dict['status'] = 'completed'
player_dict['p_score'] = 0
# no one won the match, new set
else:
player_dict['p_legs'] = 0
player_dict['o_legs'] = 0
current_values['set'] = str(
int(current_values['set']) +
2) # + 2 because both players won a set
current_values['leg'] = '1'
match_json[current_values['set']] = {
current_values['leg']: cricket_leg_default.copy()
}
else: # no draw, just new leg
current_values['leg'] = str(int(current_values['leg']) + 1)
match_json[current_values['set']][
current_values['leg']] = cricket_leg_default.copy()
return player_dict, match_json, current_values