def _get_network():
game = get_game()
network = game.get_network()
network['goals'] = [ node_to_dict(g) for g in network['goals'] ]
network['policies'] = [ node_to_dict(p) for p in network['policies'] ]
network['generated'] = asctime()
return network
def player_fundings():
game = get_game()
fundings = []
for player in game.get_players():
fundings.append(player_to_funding_dict(game, player.id))
return fundings, 200
def get_player(player_id):
game = get_game()
player = game.get_player(player_id)
if player:
return player_to_dict(game, player), 200
else:
return "Player not found", 404
def buy_policy(player_id, offer):
game = get_game()
try:
buy = game.buy_policy(player_id, offer)
return buy, 200
except ValueError, e:
return str(e), 400
def get_funding(player_id):
game = get_game()
player = game.get_player(player_id)
funds = []
for policy_id,amount in game.get_policy_funding_for_player(player):
funds.append({'from_id':player_id, 'to_id': policy_id, 'amount': amount})
return funds, 200
def get_table(id):
game = get_game()
table = game.get_table(id)
if not table:
return "Table not found", 404
data = generate_table_data(table)
return data, 200
def update_network(network):
game = get_game()
game.update_network(network)
network = game.get_network()
network['goals'] = [ node_to_dict(g) for g in network['goals'] ]
network['policies'] = [ node_to_dict(p) for p in network['policies'] ]
return network, 200
def set_funding(player_id, funding = None):
game = get_game()
player = game.get_player(player_id)
try:
funding = [ (x['to_id'], x['amount']) for x in funding ]
game.set_policy_funding_for_player(player, funding)
return funding, 200
except ValueError:
return "Sum of funds exceeds max allowed", 400
def clear_table(id):
game = get_game()
table = game.get_table(id)
if not table:
return "Table not found", 404
game.clear_table(id)
return "table cleared", 200
def set_messages(messages):
game = get_game()
game.clear_messages()
for m in messages['budgets']:
ts = dateutil.parser.parse(m['time']).replace(tzinfo=None)
game.add_message(ts, "budget", m['message'])
for m in messages['events']:
ts = dateutil.parser.parse(m['time']).replace(tzinfo=None)
game.add_message(ts, "event", m['message'])
def claim_budget(player_id):
game = get_game()
try:
player = game.get_player(player_id)
if player is None:
return "Player not found", 404
player.claim_budget()
return "budget claimed", 200
except ValueError, e:
return str(e), 400
def do_tick():
t0 = time()
game = get_game()
t1 = time()
game.tick()
t2 = time()
msg = 'entire tick {:.2f}, get_game: {:.2f}'.format(t2-t1, t1-t0)
log.debug(msg)
return msg, 200
def require_api_key(f, *args, **kw):
key = request.headers.get('X-API-KEY')
if not key:
abort(401)
game = get_game()
mkey = "{}-client-key".format(key)
client_name = game.validate_api_key(key)
if not (key and client_name is not None):
abort(401)
return f(*args, **kw)
def get_policy_offer(player_id, policy_id, price=None):
game = get_game()
if price == None:
price = game.default_offer_price
try:
offer = game.offer_policy(player_id, policy_id, price)
if offer is None:
return "Player of policy not found", 404
return offer, 200
except ValueError, e:
return str(e), 400
def get_messages():
game = get_game()
budgets = []
events = []
for m in sorted(game.get_messages(), key=lambda x: x.timestamp):
data = message_to_dict(m)
if m.type == 'budget':
budgets.append(data)
elif m.type == 'event':
events.append(data)
return dict(budgets=budgets, events=events), 200
def create_player(player=None):
"""
Creates a new game player.
"""
game = get_game()
if player:
player = game.create_player(player['name'])
d = player_to_dict(game, player)
d['token'] = player.token
return d, 201
else:
return "error", 500
def require_user_key(f, *args, **kw):
key = request.headers.get('X-USER-KEY')
player_id = request.view_args['player_id']
mkey = "{}-player-token".format(player_id)
game = get_game()
player = game.get_player(player_id)
if not player:
abort(404)
if not (key and player.token == key):
abort(401)
return f(*args, **kw)
def _get_metadata():
game = get_game()
settings = game.settings
return {'game_year': settings.current_game_year,
'game_year_start': settings.current_game_year_start,
'next_game_year': settings.current_game_year+1 if settings.current_game_year else None,
'next_game_year_start': settings.next_game_year_start if settings.next_game_year_start else None,
'version': APP_VERSION,
'total_players_inflow': game.total_players_inflow,
'total_active_players_inflow': game.total_active_players_inflow,
'budget_per_cycle': settings.budget_per_cycle,
'max_spend_per_tick': settings.max_spend_per_tick,
}
def get_wallets(id):
game = get_game()
wallet = game.get_node(id).wallet
if not wallet:
return "No wallet found", 404
res = []
for player_id, amount in wallet.todict().items():
res.append({'owner': player_id,
'location': id,
'balance': float("{:.2f}".format(amount)),
})
return res, 200
def delete_player_table(player_id, table_id):
"""
Adds / Updates the table a player is on
"""
game = get_game()
p = game.get_player(player_id)
if not p:
return "Player not found", 404
t = game.get_table(table_id)
if not t:
return "Table not found", 404
game.remove_player_from_table(player_id, table_id)
return player_to_dict(game, p), 200
def _league_table():
game = get_game()
res = []
top = game.top_players()
for t in top:
if not t.goal_id:
continue
goal = game.get_goal(t.goal_id)
r = {'id': t.id,
'name': t.name,
'goal': goal.name,
'goal_contribution': "{:.2f}".format(game.goal_funded_by_player(t.id)),
'goal_total': "{:.2f}".format(goal.balance),
}
res.append(r)
return dict(rows=res)
def generate_table_data(table):
game = get_game()
name = table.name
players = tuple(table.players)
network = game.get_network(players)
nodes = {}
links = []
for player_id in players:
n = game.get_player(player_id)
nodes[n.id] = {'id': n.id,
'name': n.name,
'group': 8,
'resources': "{:.2f}".format(n.balance),
}
links.extend([edge_to_dict(e) for e in n.lower_edges])
for n in network['policies']:
data = node_to_dict2(n)
data['group'] = 9
nodes[n.id] = data
links.extend([edge_to_dict(e) for e in n.lower_edges])
for n in network['goals']:
data = node_to_dict2(n)
nodes[n.id] = data
links = [ l for l in links
if l['source'] in nodes
and l['target'] in nodes
]
network = {'nodes': nodes.values(), 'links': links}
players_dict = [ player_to_dict(game,game.get_player(p)) for p in players ]
return dict(id=table.id,
name=name,
players=players_dict,
network=network,
layout_checksum=edges_to_checksum(links),
)
def get_node(id):
game = get_game()
node = game.get_node(id)
if not node:
return "Node not found", 404
return node_to_dict(node), 200
def start_game(params):
game = get_game()
year = game.start(params['start_year'], params['end_year'], params['duration'], params['budget_per_player'])
game.do_replenish_budget()
return "game started, year {}".format(year), 200
def stop_game():
game = get_game()
year = game.stop()
return "game stopped at year {}".format(year), 200
def delete_table(id):
game = get_game()
if game.delete_table(id):
return "Table deleted", 200
else:
return "Table not found", 404
def create_table(table = None):
game = get_game()
table = game.create_table(table['name'])
return generate_table_data(table), 201
def create_network(network):
game = get_game()
game.clear_network()
game.create_network(network)
return _get_network(), 201
