def build_game_from_state_proto(state_proto):
""" Builds a game object from a state_proto """
game = Game(map_name=state_proto.map, rules=state_proto.rules)
game.set_current_phase(state_proto.name)
# Setting units
game.clear_units()
for power_name in state_proto.units:
game.set_units(power_name, list(state_proto.units[power_name].value))
# Setting centers
game.clear_centers()
for power_name in state_proto.centers:
game.set_centers(power_name,
list(state_proto.centers[power_name].value))
# Returning
return game
def state_dict_to_game_and_power(state_dict, country_id, max_phases=None):
""" Converts a game state from the dictionary format to an actual diplomacy.Game object with the related power.
:param state_dict: The game state in dictionary format from webdiplomacy.net
:param country_id: The country id we want to convert.
:param max_phases: Optional. If set, improve speed by only keeping the last 'x' phases to regenerate the game.
:return: A tuple of
1) None, None - on error or if the conversion is not possible, or game is invalid / not-started / done
2) game, power_name - on successful conversion
"""
if state_dict is None:
return None, None
req_fields = ('gameID', 'variantID', 'turn', 'phase', 'gameOver', 'phases', 'standoffs', 'occupiedFrom')
if [1 for field in req_fields if field not in state_dict]:
LOGGER.error('The required fields for state dict are %s. Cannot translate %s', req_fields, state_dict)
return None, None
# Extracting information
game_id = str(state_dict['gameID'])
map_id = int(state_dict['variantID'])
standoffs = state_dict['standoffs']
occupied_from = state_dict['occupiedFrom']
# Parsing all phases
state_dict_phases = state_dict.get('phases', [])
if max_phases is not None and isinstance(max_phases, int):
state_dict_phases = state_dict_phases[-1 * max_phases:]
all_phases = [process_phase_dict(phase_dict, map_id=map_id) for phase_dict in state_dict_phases]
# Building game - Replaying the last phases
game = Game(game_id=game_id, map_name=CACHE['ix_to_map'][map_id])
for phase_to_replay in all_phases[:-1]:
game.set_current_phase(phase_to_replay['name'])
# Units
game.clear_units()
for power_name, power_units in phase_to_replay['units'].items():
if power_name == 'GLOBAL':
continue
game.set_units(power_name, power_units)
# Centers
game.clear_centers()
for power_name, power_centers in phase_to_replay['centers'].items():
if power_name == 'GLOBAL':
continue
game.set_centers(power_name, power_centers)
# Orders
for power_name, power_orders in phase_to_replay['orders'].items():
if power_name == 'GLOBAL':
continue
game.set_orders(power_name, power_orders)
# Processing
game.process()
# Setting the current phase
current_phase = all_phases[-1]
game.set_current_phase(current_phase['name'])
# Units
game.clear_units()
for power_name, power_units in current_phase['units'].items():
if power_name == 'GLOBAL':
continue
game.set_units(power_name, power_units)
# Centers
game.clear_centers()
for power_name, power_centers in current_phase['centers'].items():
if power_name == 'GLOBAL':
continue
game.set_centers(power_name, power_centers)
# Setting retreat locs
if current_phase['name'][-1] == 'R':
invalid_retreat_locs = set()
attack_source = {}
# Loc is occupied
for power in game.powers.values():
for unit in power.units:
invalid_retreat_locs.add(unit[2:5])
# Loc was in standoff
if standoffs:
for loc_dict in standoffs:
_, loc = center_dict_to_str(loc_dict, map_id=map_id)
invalid_retreat_locs.add(loc[:3])
# Loc was attacked from
if occupied_from:
for loc_id, occupied_from_id in occupied_from.items():
loc_name = CACHE[map_id]['ix_to_loc'][int(loc_id)][:3]
from_loc_name = CACHE[map_id]['ix_to_loc'][int(occupied_from_id)][:3]
attack_source[loc_name] = from_loc_name
# Removing invalid retreat locs
for power in game.powers.values():
for retreat_unit in power.retreats:
power.retreats[retreat_unit] = [loc for loc in power.retreats[retreat_unit]
if loc[:3] not in invalid_retreat_locs
and loc[:3] != attack_source.get(retreat_unit[2:5], '')]
# Returning
power_name = CACHE[map_id]['ix_to_power'][country_id]
return game, power_name
def create_mask(board_state, phase, locs, board_dict):
'''
Given a board_state, produces a mask that only includes valid orders from loc,
based on their positions in get_order_vocabulary in state_space. Assumes playing on standard map
Args:
board_state - 81 x dilbo vector representing current board state as described in Figure 2
phase - string indicating phase of game (e.g. 'S1901M')
loc - list of strings representing locations (e.g. ['PAR', ... ])
Returns:
List of Masks for zeroing out invalid orders, length is the number of orders total
'''
# create instance of Game object based on board_state
game = Game(map_name='standard')
game.set_current_phase(phase)
game.clear_units()
power_units = {}
power_centers = {}
for loc_idx in range(len(board_state)):
loc_name = ORDERING[loc_idx]
loc_vec = board_state[loc_idx,:]
if "unit_type" in board_dict[loc_name].keys():
unit_type = board_dict[loc_name]["unit_type"]
else:
unit_type = None
if "unit_power" in board_dict[loc_name].keys():
unit_power = board_dict[loc_name]["unit_power"]
else:
unit_power = None
if "buildable" in board_dict[loc_name].keys():
buildable = board_dict[loc_name]["buildable"]
else:
buildable = None
if "removable" in board_dict[loc_name].keys():
removable = board_dict[loc_name]["removable"]
else:
removable = None
if "d_unit_type" in board_dict[loc_name].keys():
dislodged_unit_type = board_dict[loc_name]["d_unit_type"]
else:
dislodged_unit_type = None
if "d_unit_power" in board_dict[loc_name].keys():
dislodged_unit_power = board_dict[loc_name]["d_unit_power"]
else:
dislodged_unit_power = None
if "area_type" in board_dict[loc_name].keys():
area_type = board_dict[loc_name]["area_type"]
else:
area_type = None
if "supply_center_owner" in board_dict[loc_name].keys():
supply_center_owner = board_dict[loc_name]["supply_center_owner"]
else:
supply_center_owner = None
# # extract one hot vectors from encoding
# unit_type_one_hot = loc_vec[0:3]
# unit_power_one_hot = loc_vec[3:11]
# buildable = loc_vec[11]
# removable = loc_vec[12]
# dislodged_unit_type_one_hot = loc_vec[13:16]
# dislodged_unit_power_one_hot = loc_vec[16:24]
# area_type_one_hot = loc_vec[24:27]
# supply_center_owner_one_hot = loc_vec[27:35]
#
# # convert one hot vectors into indices, and index into unit types and powers
# unit_type = INV_UNIT_TYPE[np.argmax(unit_type_one_hot)]
# unit_power = INV_UNIT_POWER[np.argmax(unit_power_one_hot)]
# dislodged_unit_type = INV_UNIT_TYPE[np.argmax(dislodged_unit_type_one_hot)]
# dislodged_unit_power = INV_UNIT_POWER[np.argmax(dislodged_unit_power_one_hot)]
# supply_center_owner = INV_UNIT_POWER[np.argmax(supply_center_owner_one_hot)]
# add the unit and/or dislodged unit in this locatino to power_units dict
# likewise for supply center (if it exists). See set_units() documentation for how units are formatted
if unit_type != None:
if unit_power not in power_units:
power_units[unit_power] = []
power_units[unit_power].append('{} {}'.format(unit_type, loc_name))
if dislodged_unit_type != None:
if dislodged_unit_type not in power_units:
power_units[dislodged_unit_power] = []
power_units[dislodged_unit_power].append('*{} {}'.format(dislodged_unit_type, loc_name))
if supply_center_owner != None:
if supply_center_owner not in power_centers:
power_centers[supply_center_owner] = []
power_centers[supply_center_owner].append(loc_name)
# Setting units
game.clear_units()
for power_name in list(power_units.keys()):
game.set_units(power_name, power_units[power_name])
# Setting centers
game.clear_centers()
for power_name in list(power_centers.keys()):
game.set_centers(power_name, power_centers[power_name])
possible_orders = game.get_all_possible_orders()
masks = np.full((len(locs), ORDER_VOCABULARY_SIZE),-(10**15))
for i in range(len(locs)):
loc = locs[i]
# Needs to be negative infinity to mask softmax function.
# Negative infinity gives nan in loss, so using very large negative number instead
for order in possible_orders[loc]:
ix = state_space.order_to_ix(order)
masks[i,ix] = 0
return np.array(masks)
