def client_hit(data):
draw(identifier_to_steamid(data['identifier']), db.session.query(Game).filter(Game.player_steamid == identifier_to_steamid(data['identifier'])).one().deck_identifier, Status.visible)
socketio.emit('update_table', json.dumps(update_table(data['identifier'])), room=request.sid)
if isGameOver(identifier_to_steamid(data['identifier'])):
client_stand(data)
def join_multi():
if 'room_key' in request.form and request.form['room_key'] != '':
if table_handler.table_exist(request.form['room_key']):
print('valid room key')
if table_handler.isFull(
table_handler.identifier_to_id(request.form['room_key'])):
print('room is full')
else:
table_handler.join_table(
table_handler.identifier_to_id(request.form['room_key']),
identifier_to_steamid(request.cookies.get('identifier')))
print('Joined room')
return render_template(
'multiplayer/blackjack.html',
website_info=configuration_handler.load('website'))
else:
print('Invalid room key')
else:
print('Auto joining room')
table_handler.auto_join(
identifier_to_steamid(request.cookies.get('identifier')))
print('Joined room')
return render_template(
'multiplayer/blackjack.html',
website_info=configuration_handler.load('website'))
return redirect('/multi')
def client_connect(data):
print('Client has connected')
deck_identifier = db.session.query(Game).filter(Game.player_steamid == identifier_to_steamid(data['identifier'])).one().deck_identifier
draw(identifier_to_steamid(data['identifier']), deck_identifier,Status.visible)
draw(identifier_to_steamid(data['identifier']), deck_identifier,Status.hidden)
draw(get_cpu_identifier(data['identifier']), deck_identifier, Status.visible)
draw(get_cpu_identifier(data['identifier']), deck_identifier, Status.hidden)
socketio.emit('update_table', json.dumps(update_table(data['identifier'])), room=request.sid)
if isGameOver(identifier_to_steamid(data['identifier'])):
client_stand(data)
def isIngame(identifier):
if db.session.query(Active_player).filter(
Active_player.steamid == identifier_to_steamid(
identifier)).count():
return True
return False
def update_table(identifier):
steamid = identifier_to_steamid(identifier)
table = get_current_table(steamid)
player_objects = []
for player in db.session.query(Active_player).filter(
Active_player.table_id == table.id).all():
player_obj = {
'name': steamid_to_name(player.steamid),
'status_string': player.status_string,
'cards': [],
'bet': player.bet
}
for card in db.session.query(Active_card).filter(
Active_card.owner == player.steamid):
if card.status == Status.hidden:
player_obj['cards'].append('green_back')
else:
player_obj['cards'].append(
db.session.query(Card).filter(
Card.id == card.card_identifier).one().image_name)
player_objects.append(player_obj)
emit_to_table(
get_current_table(steamid).id, 'update_table',
json.dumps(player_objects))
def double_bet(identifier):
game = db.session.query(Game).filter(
Game.player_steamid == identifier_to_steamid(identifier)).one()
remove_balance(identifier, game.bet)
game.bet = game.bet * 2
db.session.commit()
def isIngame(identifier):
print('Validating identifier ' + identifier)
if db.session.query(Game).filter(
Game.player_steamid == identifier_to_steamid(identifier)).count():
return True
else:
return False
def round_action(identifier):
steamid = identifier_to_steamid(identifier)
if get_turn(get_current_table(steamid).id) == None:
if db.session.query(Active_player).filter(
Active_player.steamid == steamid).filter(
Active_player.bet != None).count():
print('All bets completed')
table = get_current_table(steamid)
table.player_turn = 0
db.session.commit()
round_action(identifier)
else:
print('Sending bet option')
for player in db.session.query(Active_player).filter(
Active_player.table_id == get_current_table(
steamid).id).filter(Active_player.bet == None).all():
send_options(player.steamid, options.bet)
elif round_over(get_current_table(steamid).id):
print('Round over')
finish_round(get_current_table(steamid).id)
elif db.session.query(Active_player).filter(
Active_player.table_id == get_current_table(steamid).id).filter(
Active_player.has_played == False).filter(
Active_player.status == Player_status.active).count():
print('Sending play requests to players')
players = db.session.query(Active_player).filter(
Active_player.table_id == get_current_table(steamid).id).filter(
Active_player.has_played == False).all()
send_options(players[0].steamid, options.play)
elif db.session.query(Active_player).filter(
Active_player.table_id == get_current_table(steamid).id).filter(
Active_player.has_played == True).filter(
Active_player.status == Player_status.active).count():
print('All players have played')
for player in db.session.query(Active_player).filter(
Active_player.table_id == get_current_table(steamid).id
).filter(Active_player.has_played == True).all():
player.has_played = False
db.session.commit()
table = get_current_table(steamid)
table.player_turn += 1
db.session.commit()
else:
print('No action required')
update_table(identifier)
def client_connect(data):
player = db.session.query(Active_player).filter(
Active_player.steamid == identifier_to_steamid(data['identifier'])
).filter(Active_player.session_id == None).one()
player.session_id = request.sid
db.session.commit()
print('Client has connected to table')
round_handler.round_action(data['identifier'])
if table_handler.get_turn(
table_handler.get_current_table(
identifier_to_steamid(data['identifier'])).id) != None:
socketio.emit('client_message',
json.dumps({'message': 'Wait till next round'}),
room=request.sid)
def client_doubledown(data):
if doubledown_valid(data['identifier']):
if sufficent_funds(data['identifier'], current_bet(data['identifier'])):
draw(identifier_to_steamid(data['identifier']), db.session.query(Game).filter(Game.player_steamid == identifier_to_steamid(data['identifier'])).one().deck_identifier, Status.hidden)
double_bet(data['identifier'])
socketio.emit('update_table', json.dumps(update_table(data['identifier'])), room=request.sid)
client_stand(data)
else:
socketio.emit('error', {'message': 'insufficent funds'}, room=request.sid)
def client_action(data):
if data['action'] == 'bet':
response = table_handler.validate_bet(data['identifier'],
int(data['amount']))
print(response)
if response == 'Bet placed':
socketio.emit('action_confirmed', room=request.sid)
socketio.emit('client_message',
json.dumps({'message': response}),
room=request.sid)
elif data['action'] == 'hit':
draw(
identifier_to_steamid(data['identifier']),
table_handler.get_current_table(
identifier_to_steamid(data['identifier'])).deck_identifier,
Status.visible)
round_handler.round_action(data['identifier'])
def update_table(identifier):
steamid = identifier_to_steamid(identifier)
game = db.session.query(Game).filter(Game.player_steamid == steamid).one()
player_hand = db.session.query(Active_card).filter(
Active_card.owner == steamid).all()
cpu_hand = db.session.query(Active_card).filter(
Active_card.owner == game.cpu_hand_identifier).all()
print('Got hands')
table_data = {
'player_cards': [],
'cpu_cards': [],
'doubledown':
doubledown_valid(steamid),
'bet':
db.session.query(Game).filter(Game.player_steamid == steamid).one().bet
}
print('Got doubledown and bet status')
for card in player_hand:
card_data = {
'image':
db.session.query(Card).filter(
Card.id == card.card_identifier).one().image_name
}
table_data['player_cards'].append(card_data)
print('Got player images')
for card in cpu_hand:
if card.status == Status.visible:
image_name = db.session.query(Card).filter(
Card.id == card.card_identifier).one().image_name
else:
image_name = 'red_back'
card_data = {'image': image_name}
table_data['cpu_cards'].append(card_data)
print('Got cpu images')
print(table_data)
return table_data
def finish_game(identifier):
steamid = identifier_to_steamid(identifier)
game_data = {'player_cards': [], 'cpu_cards': []}
for card in db.session.query(Active_card).filter(
Active_card.owner == steamid).all():
card_data = {
'image':
db.session.query(Card).filter(
Card.id == card.card_identifier).one().image_name
}
game_data['player_cards'].append(card_data)
for card in db.session.query(Active_card).filter(
Active_card.owner == db.session.query(Game).filter(
Game.player_steamid ==
steamid).one().cpu_hand_identifier).all():
card_data = {
'image':
db.session.query(Card).filter(
Card.id == card.card_identifier).one().image_name
}
game_data['cpu_cards'].append(card_data)
game_state = get_game_state(steamid)
if game_state == Game_state.player_busted:
game_data['result'] = 'You busted'
elif game_state == Game_state.cpu_busted:
game_data['result'] = 'Cpu busted'
elif game_state == Game_state.cpu_blackjack:
game_data['result'] = 'Cpu got blackjack'
elif game_state == Game_state.player_blackjack:
game_data['result'] = 'You got blackjack'
elif game_state == Game_state.cpu_lead:
game_data['result'] = 'Cpu won by points'
elif game_state == Game_state.player_lead:
game_data['result'] = 'You won by points'
elif game_state == Game_state.draw:
game_data['result'] = 'Draw'
remove_user_from_active_games(steamid)
return game_data
def init_game(identifier, bet):
steamid = identifier_to_steamid(identifier)
remove_user_from_active_games(steamid)
cpu_hand_identifier = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for _ in range(45))
remove_balance(identifier, bet)
print('Removed bet amount from user')
db.session.add(Game(steamid, bet, cpu_hand_identifier))
db.session.commit()
print('Init game + commited to database')
return db.session.query(Game).filter(
Game.player_steamid == steamid).one().deck_identifier
def validate_bet(identifier, amount):
steamid = identifier_to_steamid(identifier)
if get_turn(
db.session.query(Active_player).filter(
Active_player.steamid == steamid).one().table_id) == None:
if balance_handler.sufficent_funds(identifier, amount):
if db.session.query(Active_player).filter(
Active_player.steamid == steamid).one().bet == None:
balance_handler.remove_balance(identifier, amount)
player = db.session.query(Active_player).filter(
Active_player.steamid == steamid).one()
player.bet = amount
player.status_string = 'Betted ' + str(amount) + '$'
player.has_played = True
player.status = Player_status.active
db.session.commit()
return 'Bet placed'
return 'You have already placed bet'
return 'Insufficent funds'
return 'Bets not allowed atm'
def client_stand(data):
simulate_cpu(identifier_to_steamid(data['identifier']), request.sid)
payout_bet(identifier_to_steamid(data['identifier']))
socketio.emit('game_finished', json.dumps(finish_game(data['identifier'])), room=request.sid)
def get_cpu_identifier(identifier):
return db.session.query(Game).filter(
Game.player_steamid == identifier_to_steamid(
identifier)).one().cpu_hand_identifier
