def load_map(G, tiles='config/tiles.yml', borders='config/borders.yml'):
tiles = load(tiles)
borders = load(borders)
for b in borders:
n1, n2 = b.tile1, b.tile2
t = b.type
if 'borders' not in tiles[n1]:
tiles[n1].borders = tdict()
tiles[n1].borders[n2] = t
if 'borders' not in tiles[n2]:
tiles[n2].borders = tdict()
tiles[n2].borders[n1] = t
G.tiles = tdict({name: idict(tile) for name, tile in tiles.items()})
for name, tile in G.tiles.items():
tile.__dict__['_id'] = name
# tile.name = name
tile.units = tset()
if tile.type not in {'Sea', 'Ocean', 'Strait'}:
for neighbor in tile.borders.keys():
if G.tiles[neighbor].type == 'Sea' or G.tiles[
neighbor].type == 'Ocean':
tile.type = 'Coast'
break
# add tile to game objects
tile.obj_type = 'tile'
tile.visible = tset({'Axis', 'West', 'USSR'})
G.objects.table[name] = tile
def convert_from_saveable(data):
if data is None:
return None
if isinstance(data, (str, int, float)):
try:
return int(data)
except:
pass
return data
if isinstance(data, dict):
if len(data) == 1:
key, val = next(iter(data.items()))
if 'set' == key:
return tset(convert_from_saveable(el) for el in val)
if 'xset' == key:
return xset(convert_from_saveable(el) for el in val)
if 'tuple' == key:
return tuple(convert_from_saveable(el) for el in val)
if '_object_' == key[:8]:
typ = eval(key[8:])
obj = typ()
obj.load_state(val)
return obj
if '_id' in data:
return idict({convert_from_saveable(k): convert_from_saveable(v) for k, v in data.items()})
return tdict({convert_from_saveable(k): convert_from_saveable(v) for k, v in data.items()})
if isinstance(data, list):
return tlist(convert_from_saveable(el) for el in data)
try:
return data.save_state()
except AttributeError:
raise Exception('Cannot save data of type: {}'.format(type(data)))
def increment_influence(G, player, nation): if nation not in G.diplomacy.influence: inf = idict() inf.value = 1 inf.nation = nation inf.faction = player inf.obj_type = 'influence' inf.visible = xset(G.players.keys()) G.players[player].influence.add(inf._id) G.diplomacy.influence[nation] = inf G.objects.table[inf._id] = inf G.objects.created[inf._id] = inf return inf = G.diplomacy.influence[nation] if player != inf.faction and inf.value == 1: del G.diplomacy.influence[nation] G.players[inf.faction].influence.remove(inf._id) del G.objects.table[inf._id] G.objects.removed[inf._id] = inf return delta = (-1) ** (player != inf.faction) inf.value += delta G.objects.updated[inf._id] = inf
def add_unit(G, unit): # tile, type, cv, nationality
unit = idict(unit.items())
unit.obj_type = 'unit'
if 'cv' not in unit: # by default add a cadre
unit.cv = 1
else:
assert 1 <= unit.cv <= 4, '{} is an invalid cv value: {}'.format(
unit.cv, unit)
player = G.nations.designations[unit.nationality]
#if player is 'Minor': #@@@
if player == 'Minor':
unit.visible = tset(G.players.keys())
#G.nations.status[unit.nationality][unit._id] = unit #@@@
G.nations.status[unit.nationality].units[unit._id] = unit
else:
unit.visible = tset({G.nations.designations[unit.nationality]})
# check/update reserves
reserves = G.units.reserves[unit.nationality]
if unit.type not in reserves or reserves[unit.type] == 0:
raise OutOfReservesError('{} has no more {}'.format(
unit.nationality, unit.type))
reserves[unit.type] -= 1
G.players[player].units[unit._id] = unit
tilename = unit.tile
tile = G.tiles[tilename]
# check for multiple fortresses
if unit.type == 'Fortress':
assert not (
tile.type == 'Sea' or tile.type == 'Ocean'
), 'Fortresses cannot be placed in the Sea/Ocean {}'.format(tilename)
for unit_id in tile.units:
assert G.objects.table[
unit_id].type != 'Fortress', 'There is already a Fortress in {}'.format(
G.objects.table[unit_id].tile)
# check convoy
check_for_convoy(unit, tile)
# add to sets
tile.units.add(unit._id)
G.objects.table[unit._id] = unit
G.objects.created[unit._id] = unit
G.objects.updated[tilename] = tile
return unit
def load_card_decks(G,
action_path='config/cards/action_cards.yml',
investment_path='config/cards/investment_cards.yml',
info_path='config/cards/card_info.yml'):
cinfo = load(info_path)
caction = load(action_path)
cinvest = load(investment_path)
action_cards = tdict()
action_cards.deck = tlist()
for ID, card in caction.items():
card = idict(card)
card.obj_type = 'action_card'
card.visible = tset()
card.__dict__['_id'] = 'action_{}'.format(ID)
action_cards.deck.append(card._id)
G.objects.table[card._id] = card
investment_cards = tdict()
investment_cards.deck = tlist()
for ID, card in cinvest.items():
card = idict(card)
card.obj_type = 'investment_card'
card.visible = tset()
card.__dict__['_id'] = 'invest_{}'.format(ID)
investment_cards.deck.append(card._id)
G.objects.table[card._id] = card
G.cards = tdict()
G.cards.action = action_cards
G.cards.action.discard_pile = tlist()
G.cards.investment = investment_cards
G.cards.investment.discard_pile = tlist()
G.cards.info = cinfo
shuffle(G.random, G.cards.investment)
shuffle(G.random, G.cards.action)
def load_gen_card_decks(
G,
card_config_path='config/card_stats.yml',
):
cc = load(card_config_path)
config = cc.action_cards
G.action_cards = adict()
card_list = []
dim = 2
num = sum(config.diplomacy.values()) // dim
for _ in range(10):
try:
picks = split_choices(G, list(config.diplomacy.items()), num, dim)
except ValueError:
pass
else:
break
wildcards = []
for name, info in config.wildcards.items():
for _ in range(info.count):
card = idict(info.items())
del card.count
card.name = name
wildcards.append(card)
G.random.shuffle(wildcards)
for season, info in config.seasons.items():
commands = sum([[k] * v for k, v in info.commands.items()], [])
G.random.shuffle(commands)
if len(info.priorities) > info.count:
priorities = G.random.choice(info.priorities,
info.count,
replace=False).tolist()
else:
priorities = info.priorities
assert len(priorities) == info.count
for _ in range(info.num_wildcards):
command, priority = commands.pop(), priorities.pop()
wildcard = wildcards.pop()
card = idict()
card.wildcard = wildcard
card.command_value = command
card.command_priority = priority
card.season = season
card_list.append(card)
for command, priority in zip(commands, priorities):
dpl1, dpl2 = picks.pop()
card = idict()
card.command_value = command
card.command_priority = priority
card.season = season
card.top_diplomacy = dpl1
card.bottom_diplomacy = dpl2
card_list.append(card)
G.action_cards.deck = card_list
config = cc.investment_cards
G.investment_cards = adict()
card_list = []
dim = 2
num = 0
techs = []
for name, info in config.technologies.items():
tech = adict(info.items())
count = info.count
del tech.count
num += count
tech.name = name
techs.append((tech, count))
for name, info in config.intelligence.items():
tech = adict(info.items())
count = info.count
del tech.count
num += count
tech.name = name
techs.append((tech, count))
num = num // dim
for _ in range(10):
try:
picks = split_choices(G, techs, num, dim)
except ValueError:
pass
else:
break
factories = sum([[k] * v for k, v in config.factory_levels.items()], [])
G.random.shuffle(factories)
for pick in picks:
tech1, tech2 = pick
card = idict()
card.top_technology = tech1
card.bottom_technology = tech2
card.factory_value = factories.pop()
card_list.append(card)
G.investment_cards.deck = card_list
G.action_cards.discard_pile = []
G.investment_cards.discard_pile = []
G.random.shuffle(G.investment_cards.deck)
G.random.shuffle(G.action_cards.deck)
