def create_game(request , data: schemas.GameCreateSchema):
game = models.Game(creator_id=request.auth,password=data.password)
try:
game.save()
except:
raise HttpError(422, "ERROR")
return game
def create_game(user_id: int, db: Session):
db_game = models.Game(
ran_num=json.dumps(random_number()),
owner_id=user_id,
)
db.add(db_game)
db.commit()
db.refresh(db_game)
return db_game
def make_game(): #rgb
buildings = make_possible_buildings()
(hexes, probabilities, robber_location) = make_hexes(buildings)
roads = make_possible_roads(buildings)
game = models.Game(settup_round = True, started=False,
buildings = buildings, hexes = hexes,
probabilities = probabilities, roads = roads,
robber_location= robber_location,
colors_left=POSSIBLE_COLORS)
db.session.add(game)
db.session.commit()
return game.id
def reveal(request):
params = json.loads(request.body)
player_hash = params['player_hash']
player_plaintext = params['player_plaintext']
m = hashlib.sha256()
m.update(player_plaintext.encode())
calculated_hash = m.hexdigest()
if calculated_hash == player_hash:
cr = models.CommitReveal.objects.get(player_hash=player_hash)
cr.player_plaintext = player_plaintext
cr.save()
m2 = hashlib.sha256()
m2.update((player_hash + cr.server_hash).encode())
salt = m2.hexdigest()[0:62]
solution = generate_solution()
models.Game(commit_reveal=cr, solution=solution, salt=salt).save()
saltedSoln = int(salt, 16) + solution
params = [
settings.NODE_BINARY, 'build/mastermind/src/pedersen.js',
str(saltedSoln)
]
output = subprocess.check_output(params,
cwd=os.path.join(
settings.BASE_DIR, '../'))
s = output.decode('utf-8').split('\n')
solnHash = s[0]
return json_response({
'server_plaintext': cr.server_plaintext,
'server_hash': cr.server_hash,
'player_plaintext': cr.player_plaintext,
'player_hash': cr.player_hash,
'salt': salt,
'solnHash': solnHash,
'solution': solution
})
else:
return json_bad_response('Invalid hash')
def end_round(form, dest):
day_index = game.get_day_index(current_user, models.Game)
current_par = game.get_current_parameters(current_user, models.Parameter)
current_demand = game.get_current_demand(current_user, models.Demand)
norder = int(form.input.data)
ndemand = int(current_demand.demand_new.split(',')[day_index - 1])
nsold = min(norder, ndemand)
nlost = max(0, ndemand - norder)
rev = round(nsold * round(float(current_par.retail_price), 2), 2)
cost = round(norder * round(float(current_par.wholesale_price), 2), 2)
profit = round(rev - cost, 2)
if day_index == 1:
total_profit = round(profit, 2)
else:
total_profit = round(
profit + models.Game.query.filter_by(
id=current_user.id,
day_index=day_index - 1).first().total_profit, 2)
# insert into db
current_game_rec = models.Game(session_code=current_user.session_code,
id=current_user.id,
pname=current_user.pname,
day_index=day_index,
norder=norder,
ndemand=ndemand,
nsold=nsold,
nlost=nlost,
rev=rev,
cost=cost,
profit=profit,
total_profit=total_profit)
db.session.add(current_game_rec)
db.session.commit()
return render_template(dest,
norder=norder,
ndemand=ndemand,
nsold=nsold,
nlost=nlost,
rev=rev,
cost=cost,
current_par=current_par,
profit=profit,
tot_profit=total_profit)
def create_game(game: Game):
new_game = models.Game(
name=game.name,
session_name=game.session_name,
need_money=GAMES[game.name].get("need_money", False),
can_give_cards=GAMES[game.name].get("can_give_cards", False),
hand_count=GAMES[game.name].get("hand_count", False))
new_game.save()
create_deck(new_game)
return {
"id":
new_game.id,
"name":
new_game.name,
"session_name":
new_game.session_name,
"players": [
player.serialize() for player in models.Player.select().where(
models.Player.game == new_game)
]
}