def card_move(data):
user = get_stable_user()
print('Client {}, event {}: {}'.format(get_stable_user(), 'CARD MOVE',
data))
g = hanabi_games[data['gameid']]
if data['place_id'] == "PLAY":
result = g.play_card(get_stable_user(),
g.card_from_id(data['card_id']))
elif data['place_id'] == "TRASH":
result = g.trash_card(get_stable_user(),
g.card_from_id(data['card_id']))
# At the moment, just have the clients request their own individual updates
emit("SHOULD REQUEST UPDATE", {}, broadcast=True, room=g.gameid)
def hanabi(player_num, gameid):
# Current_user now will be the same object as current_user, so we get user here
user = get_stable_user()
print("{} is requesting to join hanabi gameid {}".format(user, gameid))
gameid = str(gameid)
# If the game doesn't already exist, create it!
if not gameid in hanabi_games or hanabi_games[gameid].game_over:
hanabi_games[gameid] = HanabiGame(int(player_num), gameid)
print("Created gameid {}".format(gameid))
# See if we are already in the player list
game = hanabi_games[gameid]
print("The users in the game already are {}".format(game.players))
if user in game.players:
print("Player is returning")
# Otherwise, see if it can take more players
elif (len(game.players) < game.player_count):
print("Player is new")
index = len(game.players)
game.player_index[user] = index
game.players.append(user)
else:
return "The game {} already has {} players".format(gameid, game.player_count)
print("Taking {} player index".format(game.player_index[user])) #Put the user into the game room
return render_template(
'hanabi.html',
title='Hanabi Board',
socketio_namespace='/hanabi',
player_index=game.player_index[user],
player_count=game.player_count,
hand_size=game.hand_size,
letters=HanabiGame.letters,
gameid=gameid,
)
def music_game():
user = get_stable_user()
return render_template(
'music_game.html',
title='Music game prototype',
user_id=user.id,
user_name=user.username,
)
def send_message(data):
g = freeplay_games[data['gameid']]
player = g.get_player_from_session(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'SEND MESSAGE',
data))
g.add_message(player, data['text'])
g.send_messages()
g.time_of_last_update = time()
def clue_card(data):
print('Client {}, event {}: {}'.format(get_stable_user(), 'CARD CLUE',
data))
g = hanabi_games[data['gameid']]
g.give_clue(current_user, g.card_from_id(data['card_id']),
data['card_field'])
# At the moment, just have the clients request their own individual updates
emit("SHOULD REQUEST UPDATE", {}, broadcast=True, room=g.gameid)
def flip(data):
g = freeplay_games[data['gameid']]
player = g.get_player_from_session(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'flip', data))
if not g.confirm_or_destroy_id(data['obj_id']):
return False
obj = g.all_movables[data['obj_id']]
obj.flip()
g.time_of_last_update = time()
def deal(data):
g = freeplay_games[data['gameid']]
player = g.get_player_from_session(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'DEAL', data))
if not g.confirm_or_destroy_id(data['obj_id']):
return False
obj = g.all_movables[data['obj_id']]
obj.deal(int(data['how_many']), data['which_face'])
g.time_of_last_update = time()
def continue_move(data):
g = freeplay_games[data['gameid']]
player = g.get_player_from_session(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'CONTINUE MOVE',
data))
if not g.confirm_or_destroy_id(data['obj_id']):
return False
obj = g.all_movables[data['obj_id']]
obj.continue_move(player, data['position'])
g.time_of_last_update = time()
def stop_move(data):
g = freeplay_games[data['gameid']]
player = g.get_player_from_session(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'STOP MOVE',
data))
if not g.confirm_or_destroy_id(data['obj_id']):
return False
obj = g.all_movables[data['obj_id']]
privacy = data['privacy'] if 'privacy' in data else None
obj.stop_move(player, data['position'], privacy=privacy)
g.time_of_last_update = time()
def join(data):
print('Client {}: JOIN ROOM: {}'.format(get_stable_user(), data))
join_room(data['room'])
g = freeplay_games[data['room']]
# Add a welcome message
name = g.get_active_player_tag()
g.add_message(None, name + ' joined the game')
# Send the newly joined client all the stuff
g.send_update(keys=['all'], broadcast=False)
# Send everyone the new player list
g.send_update(keys=['players'])
def cold_waters():
if request.method == 'GET':
user = get_stable_user()
return render_template(
'cold_waters.html',
title='Play Cold Waters',
user_id=user.id,
user_name=user.username,
experimental=request.args.get('exp'),
)
elif request.method == 'POST':
user = get_stable_user()
print('request:', request)
controls_recording = json.loads(request.form.get('thing'))['controls_recording']
controls_array = controls_recording['controls_array'].encode()
print('controls_recording:', controls_recording)
score = ColdWatersScore(
user_id=user.id,
code_version=controls_recording['code_signature'],
hard=controls_recording['hard'],
seed=controls_recording['seed'],
score=controls_recording['score'],
controls_array=controls_array,
rng_integrity_check=controls_recording['rng_integrity_check']
)
db.session.add(score)
db.session.commit()
fetched_score = load_cold_waters_score(score.id)
print('Added the above recording to the DB')
print(fetched_score.controls_array == score.controls_array)
return json.dumps({
'name': user.username,
'code_version': fetched_score.code_version,
'hard': fetched_score.hard,
'seed': fetched_score.seed,
'score': fetched_score.score,
'controls_array': fetched_score.controls_array.decode(),
'rng_integrity_check': fetched_score.rng_integrity_check
});
def combine(data):
g = freeplay_games[data['gameid']]
player = g.get_player_from_session(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'COMBINE', data))
if not g.confirm_or_destroy_id(data['top_id']):
return False
if not g.confirm_or_destroy_id(data['bottom_id']):
return False
obj1 = g.all_movables[data['top_id']]
obj2 = g.all_movables[data['bottom_id']]
obj2.incorporate(obj1)
g.time_of_last_update = time()
def card_move(data):
g = blitz_games[data['gameid']]
player = g.get_blitz_player(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'CARD MOVE',
data))
if not data['card_id'] in g.all_cards:
print("No such card on the server side: {}".format(data['card_id']))
else:
card = g.all_cards[data['card_id']]
if data['deck']:
card.move_to(data['deck'])
else:
card.move_to(None, position=data['position'])
result = player.play_card(g.card_from_id(data['card_id']),
g.card_positions[data['card_pos']])
g.time_of_last_update = time()
def blitz(gameid):
player_num = int(request.args.get('num') or 2)
AI_num = request.args.get('AI') or 0
stock_size = request.args.get('stock') or 9
queue_size = request.args.get('queue') or (4 if player_num>2 else 5)
# Current_user now will be the same object as current_user, so we get user here
user = get_stable_user()
print("{} is requesting to join blitz gameid {}".format(user, gameid))
gameid = str(gameid)
# If the game doesn't already exist, create it!
if not gameid in blitz_games or blitz_games[gameid].game_over:
blitz_games[gameid] = BlitzGame(int(player_num), gameid, AI_num=AI_num, queue_size=queue_size, stock_size=stock_size)
print("Created gameid {}".format(gameid))
# See if we are already in the player list
game = blitz_games[gameid]
print("The users in the game already are {}".format([p.session_user for p in game.players]))
# Otherwise, see if it can take more players
index = -1
for i,p in enumerate(game.players):
if not p.session_user and not p.AI:
print("Player is new")
p.session_user = user
index = i
break
elif p.session_user == user:
index = i
print("Player is returning")
break
if index==-1:
return "The game {} already has {} players".format(gameid, game.player_count)
print("Taking {} player index".format(index)) #Put the user into the game room
return render_template(
'blitz.html',
title='Dutch Blitz',
socketio_namespace='/blitz',
player_index=index,
player_count=game.player_count,
queue_size=game.queue_size,
gameid=gameid,
)
def pco_set(data):
g = freeplay_games[data['gameid']]
player = g.get_player_from_session(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'PCO SET', data))
if not g.confirm_or_destroy_id(data['obj_id']):
return False
obj = g.all_movables[data['obj_id']]
obj.offset_per_dependent = [int(data['pco_x']), int(data['pco_y'])]
return_data = {
'movables_info': [{
'id': obj.id,
'offset_per_dependent': obj.offset_per_dependent
}]
}
socketio.emit('UPDATE',
return_data,
broadcast=True,
room=data['gameid'],
namespace='/freeplay')
g.time_of_last_update = time()
def destroy(data):
g = freeplay_games[data['gameid']]
player = g.get_player_from_session(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'DESTROY', data))
if not g.confirm_or_destroy_id(data['obj_id']):
return False
obj = g.all_movables[data['obj_id']]
# Add a message
name = g.get_active_player_tag()
obj_name = str(1 + len(obj.dependents)) + ' thing'
if (len(obj.dependents)):
obj_name += 's'
if obj.display_name:
obj_name = obj.display_name + ' [' + obj_name + ']'
g.add_message(None, name + ' deleted ' + obj_name)
g.send_messages()
# Really destroy the object and dependents
obj.destroy(destroy_dependents=True)
g.time_of_last_update = time()
def freeplay(game_name, gameid):
game_name = game_name.lower()
# Current_user now will be the same object as current_user, so we get user here
user = get_stable_user()
print("{} is requesting to join freeplay gameid {}".format(user, gameid))
gameid = str(game_name+'/'+gameid)
# If the game doesn't already exist, create it!
if not gameid in freeplay_games:
freeplay_games[gameid] = FreeplayGame(gameid, game_name)
print("Created gameid {}".format(gameid))
game = freeplay_games[gameid]
print("The users in the game already are {}".format([p.session_user for p in game.players]))
# See if we are already in the player list
# Otherwise, add to the end
# TODO change this
index = -1
for i,p in enumerate(game.players):
if not p.session_user:
print("Player is new")
p.session_user = user
index = i
break
elif p.session_user == user:
index = i
print("Player is returning")
break
if index==-1:
index = len(game.players)
player = game.add_player(user)
print("Taking {} player index".format(index)) #Put the user into the game room
return render_template(
'freeplay.html',
title='Free Play',
socketio_namespace='/freeplay',
player_index=index,
gameid=gameid,
)
def update_request(data):
print('Client {}: UPDATE REQUEST: {}'.format(get_stable_user(), data))
print('The games are {}'.format(freeplay_games))
g = freeplay_games[data['gameid']]
g.send_update(keys=['all'], broadcast=False)
g.time_of_last_update = time()
def card_move(data):
g = blitz_games[data['gameid']]
player = g.get_blitz_player(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'DEAL DECK',
data))
result = player.deal_deck()
