def becomes_satellite(G, player, nation):
del G.diplomacy.neutrals[nation] # no longer neutral
# no longer armed
if G.nations.status[nation].is_armed:
G.nations.status[nation].is_armed = 0
faction = G.players[player]
if nation in G.diplomacy.influence:
inf = G.diplomacy.influence[nation]
if inf.faction != player:
#do this only if control was NOT in player's hands
#see 2.4: a Control marker of that Faction is placed on its Capital.
decrement_influence(G, nation, inf.value)
pop, res = compute_tracks(G.nations.territories[nation], G.tiles)
G.players[inf.faction].trans.resources -= pop
G.players[inf.faction].trans.resources -= res
G.logger.write(
'{} loses {} influence in {} (losing POP={}, RES={})'.format(inf.faction, inf.value, nation, pop, res))
faction.tracks.POP += pop
faction.tracks.RES += res
G.logger.write('{} gains POP={}, RES={}'.format(player, pop, res))
else:
#TODO: hier muss auch influence setzen!
pop, res = compute_tracks(G.nations.territories[nation], G.tiles)
faction.tracks.POP += pop
faction.tracks.RES += res
G.logger.write('{} gains POP={}, RES={}'.format(player, pop, res))
G.nations.groups[G.nations.designations[nation]].remove(nation)
G.nations.designations[nation] = player
G.nations.groups[player].add(nation)
for tilename in G.nations.territories[nation]:
tile = G.tiles[tilename]
free = True
for uid in tile.units:
unit = G.objects.table[uid]
if G.nations.designations[unit.nationality] != player:
free = False
break
if free:
faction.territory.add(tilename)
tile.owner = player
G.objects.updated[tilename] = tile
# faction.territory.update(G.nations.territories[nation])
G.logger.write('{} takes control of {}'.format(player, nation))
def new_year_phase(G):
# increment year
G.game.year += 1
G.logger.write('Start of {}'.format(G.game.year))
# recompute tracks
for player, faction in G.players.items():
faction.tracks.POP, faction.tracks.RES = compute_tracks(
faction.territory, G.tiles)
# victory check
vps = count_victory_points(G)
for player, vp in vps.items():
if vp >= G.game.victory.economic:
G.logger.write('{} has won the Economic Victory'.format(player))
raise NotImplementedError
# shuffle discard piles
shuffle(G.cards.action)
shuffle(G.cards.investment)
# peace dividends
for player, faction in G.players.items():
if not faction.stats.at_war and not faction.stats.aggressed:
val = G.game.peace_dividends.pop()
faction.stats.peace_dividends.append(val)
G.logger.write('{} draws a peace dividend'.format(player))
G.logger.write('- you receive {} victory points'.format(val),
player=player)
# choose turn order
G.game.turn_order = G.game.turn_order_options[random.randint(1, 6)]
G.logger.write('Turn order: {}'.format(', '.join(G.game.turn_order)))
def load_players_and_minors(G):
player_setup = load('config/faction_setup.yml')
capitals = load('config/capitals.yml')
G.nations = tdict()
territories = tdict()
designations = tdict()
minor_designation = 'Minor'
for tile in G.tiles.values():
if 'alligence' in tile:
designations[tile.alligence] = minor_designation
if tile.alligence not in territories:
territories[tile.alligence] = tset()
territories[tile.alligence].add(tile._id)
designations['USA'] = 'Major'
G.nations.designations = designations
G.nations.territories = territories
G.nations.capitals = capitals
for nation, tilename in capitals.items():
G.tiles[tilename].capital = True
G.nations.groups = tdict()
# load factions/players
players = tdict()
groups = tset(player_setup.keys())
rivals = tdict()
for g in groups:
gps = groups.copy()
gps.remove(g)
rivals[g] = tset(gps)
for name, config in player_setup.items():
faction = tdict()
faction.stats = tdict()
faction.stats.handlimit = config.Handlimit
faction.stats.factory_all_costs = config.FactoryCost
faction.stats.factory_idx = 0
faction.stats.factory_cost = faction.stats.factory_all_costs[
faction.stats.factory_idx]
faction.stats.emergency_command = config.EmergencyCommand
faction.stats.rivals = rivals[name]
faction.stats.DoW = tdict({r: False for r in rivals[name]})
faction.stats.at_war_with = tdict({r: False for r in rivals[name]})
faction.stats.at_war = False
faction.stats.aggressed = False
faction.stats.peace_dividends = tlist()
faction.stats.enable_USA = 'enable_USA' in config
faction.stats.enable_Winter = 'enable_Winter' in config
faction.cities = tdict()
faction.cities.MainCapital = config.MainCapital
faction.cities.SubCapitals = config.SubCapitals
faction.members = tdict()
for nation, info in config.members.items():
faction.members[nation] = tset([nation])
if info.type == 'Great_Power':
faction.stats.great_power = nation
if 'Colonies' in info:
faction.members[nation].update(info.Colonies)
full_cast = tset()
for members in faction.members.values():
full_cast.update(members)
for member in full_cast:
G.nations.designations[member] = name
faction.homeland = tdict(
{member: tset()
for member in faction.members.keys()})
faction.territory = tset()
for tile_name, tile in G.tiles.items():
if 'alligence' not in tile:
continue
if tile.alligence in faction.members: # homeland
faction.homeland[tile.alligence].add(tile_name)
if tile.alligence in full_cast:
faction.territory.add(tile_name)
tile.owner = name
faction.tracks = tdict()
pop, res = compute_tracks(faction.territory, G.tiles)
faction.tracks.POP = pop
faction.tracks.RES = res
faction.tracks.IND = config.initial_ind
faction.units = tdict()
faction.hand = tset() # for cards
faction.technologies = tset()
faction.secret_vault = tset()
faction.influence = tset()
faction.diplomacy = tdict()
faction.diplomacy.associates = tset()
faction.diplomacy.protectorates = tset()
faction.diplomacy.satellites = tset()
faction.diplomacy.violations = tset()
players[name] = faction
G.players = players
# load minors/diplomacy
minors = tdict()
majors = tdict()
status = tdict()
for name, team in G.nations.designations.items():
if team not in G.nations.groups:
G.nations.groups[team] = tset()
G.nations.groups[team].add(name)
if team in {minor_designation, 'Major'}:
status[name] = tdict()
status[name].is_armed = False
status[name].units = tdict()
if team == minor_designation: # only minors
minor = tdict()
minor.faction = None
minor.value = 0
minors[name] = minor
if team == 'Major': # only includes neutral majors
major = tdict()
major.faction = None
major.value = 0
majors[name] = major
G.diplomacy = tdict()
G.diplomacy.minors = minors
G.diplomacy.majors = majors
G.diplomacy.neutrals = minors.copy()
G.diplomacy.neutrals.update(majors)
G.diplomacy.influence = tdict()
G.nations.status = status
def government_post_phase(G, player=None, action=None):
if len(G.temp.move_to_post) and action is not None:
action, = action
if action == 'accept':
G.temp.move_to_post[player] = False
elif action in G.players[player].hand:
discard_cards(G, action)
elif action in G.players[player].secret_vault:
reveal_tech(G, player, action)
else:
# G.temp.move_to_post[player] = False
#deactivate removing influence!!!
decrement_influence(G, action)
action = None
code = encode_post_gov_actions(G)
if len(code):
return code
# diplomacy resolution (check for control, discard diplomacy_cards), handsize, update tracks
# resolve diplomacy
discard_cards(G, *G.temp.diplomacy_cards)
del G.temp.diplomacy_cards
for nation, (fname, val) in G.temp.diplomacy.items():
for _ in range(val):
increment_influence(G, fname, nation)
del G.temp.diplomacy
# check for control
new_sats = tdict()
for nation, dipl in G.diplomacy.neutrals.items():
if nation not in G.diplomacy.influence:
if dipl.faction is None:
continue
else:
faction = G.players[dipl.faction]
faction.diplomacy[diplvl[dipl.value]].remove(nation)
pop, res = compute_tracks(G.nations.territories[nation],
G.tiles)
faction.tracks.POP -= pop
faction.tracks.RES -= res
G.logger.write(
'{} lost influence over {} (losing POP={} RES={})'.format(
dipl.faction, nation, pop, res))
dipl.value = 0
dipl.faction = None
else:
inf = G.diplomacy.influence[nation]
val = min(inf.value, 3)
gainer = None
loser = None
if nation == 'USA': # handle USA separately
if dipl.faction is None:
if G.players[inf.faction].stats.enable_USA:
gainer = inf.faction
elif dipl.faction == inf.faction:
if G.players[
dipl.
faction].stats.enable_USA and dipl.value != val:
G.players[dipl.faction].diplomacy[diplvl[
dipl.value]].remove(nation)
else:
if G.players[dipl.faction].stats.enable_USA:
loser = dipl.faction
G.players[dipl.faction].diplomacy[diplvl[
dipl.value]].remove(nation)
if G.players[inf.faction].stats.enable_USA:
gainer = inf.faction
else:
if dipl.faction is None:
gainer = inf.faction
elif dipl.faction != inf.faction:
loser = dipl.faction
gainer = inf.faction
G.players[dipl.faction].diplomacy[diplvl[
dipl.value]].remove(nation)
elif dipl.value == val: # no change required
continue
else: # value has changed
#G.players[inf.faction].diplomacy[diplvl[dipl.value]].remove(dipl.faction) #@@@@
G.players[inf.faction].diplomacy[diplvl[
dipl.value]].remove(nation)
faction = G.players[inf.faction]
faction.diplomacy[diplvl[val]].add(nation)
dipl.faction = inf.faction
dipl.value = val
if val >= 3:
new_sats[nation] = inf.faction
# update tracks
tmsg = ''
if gainer is not None or loser is not None:
pop, res = compute_tracks(G.nations.territories[nation],
G.tiles)
if gainer is not None:
G.players[gainer].tracks.POP += pop
G.players[gainer].tracks.RES += res
tmsg += ' ({} gains POP={}, RES={})'.format(
gainer, pop, res)
if loser is not None:
G.players[loser].tracks.POP -= pop
G.players[loser].tracks.RES -= res
tmsg += ' (lost by {})'.format(loser)
if nation == 'USA' and not faction.stats.enable_USA:
G.logger.write('{} has {} influence in the USA'.format(
inf.faction, inf.value))
else:
dname = dipname[val]
G.logger.write('{} becomes {} of {}{}'.format(
nation, dname, inf.faction, tmsg))
G.temp.new_sats = new_sats
if len(new_sats): # plan a satellite phase to place garrison troops
add_next_phase(G, 'Satellite')
raise PhaseComplete
def government_post_phase(G, player=None, action=None):
if len(G.temp.move_to_post) and action is not None:
action, = action
if action == 'accept':
G.temp.move_to_post[player] = False
elif action in G.players[player].hand:
discard_cards(G, action)
elif action in G.players[player].secret_vault:
reveal_tech(G, player, action)
else:
decrement_influence(G, action)
action = None
code = encode_post_gov_actions(G)
if len(code):
return code
# diplomacy resolution (check for control, discard diplomacy_cards), handsize, update tracks
# resolve diplomacy
if 'diplomacy' in G.temp:
discard_cards(G, *G.temp.diplomacy_cards)
del G.temp.diplomacy_cards
for nation, (fname, val) in G.temp.diplomacy.items():
for _ in range(val):
increment_influence(G, fname, nation)
del G.temp.diplomacy
# check for control
new_sats = tdict()
for nation, dipl in G.diplomacy.neutrals.items():
if nation not in G.diplomacy.influence:
if dipl.faction is None:
continue
else:
faction = G.players[dipl.faction]
faction.diplomacy[diplvl[dipl.value]].remove(nation)
pop, res = compute_tracks(G.nations.territories[nation], G.tiles)
faction.tracks.POP -= pop
faction.tracks.RES -= res
G.logger.write('{} lost influence over {} (losing POP={} RES={})'.format(dipl.faction, nation, pop, res))
dipl.value = 0
dipl.faction = None
else:
inf = G.diplomacy.influence[nation]
val = min(inf.value, 3)
gainer = None
loser = None
if nation == 'USA': # handle USA separately
if dipl.faction is None:
if G.players[inf.faction].stats.enable_USA:
gainer = inf.faction
elif dipl.faction == inf.faction:
if G.players[dipl.faction].stats.enable_USA and dipl.value != val:
G.players[dipl.faction].diplomacy[diplvl[dipl.value]].remove(nation)
else:
if G.players[dipl.faction].stats.enable_USA:
loser = dipl.faction
G.players[dipl.faction].diplomacy[diplvl[dipl.value]].remove(nation)
if G.players[inf.faction].stats.enable_USA:
gainer = inf.faction
else:
val = min(inf.value, 3) # cap influence at 3
if dipl.faction is None:
gainer = inf.faction
elif dipl.faction != inf.faction:
loser = dipl.faction
gainer = inf.faction
G.players[dipl.faction].diplomacy[diplvl[dipl.value]].remove(nation)
elif dipl.value == val: # no change required
continue
else: # value has changed
G.players[inf.faction].diplomacy[diplvl[dipl.value]].remove(dipl.faction)
faction = G.players[inf.faction]
faction.diplomacy[diplvl[inf.value]].add(dipl.faction)
dipl.faction = inf.faction
dipl.value = inf.value
if inf.value == 3:
new_sats[nation] = inf.faction
# update tracks
tmsg = ''
if gainer is not None or loser is not None:
pop, res = compute_tracks(G.nations.territories[nation], G.tiles)
if gainer is not None:
G.players[gainer].tracks.POP += pop
G.players[gainer].tracks.RES += res
tmsg += ' ({} gains POP={}, RES={})'.format(gainer, pop, res)
if loser is not None:
G.players[loser].tracks.POP -= pop
G.players[loser].tracks.RES -= res
tmsg += ' (lost by {})'.format(loser)
dname = dipname[inf.value]
G.logger.write('{} becomes {} of {}{}'.format(nation, dname, inf.faction, tmsg))
if 'USA' in new_sats:
name = new_sats['USA']
del new_sats['USA']
USA_becomes_satellite(G, name)
sat_units = tdict()
for nation, fname in new_sats.items():
becomes_satellite(G, nation)
for tilename in G.nations.territories[nation]:
tile = G.tiles[tilename]
if 'muster' in tile:
if fname not in sat_units:
sat_units[fname] = tdict()
sat_units[fname][tilename] = tile.muster
G.temp.sat_units = sat_units
# place garrison in new satellites
if action is not None:
unit = adict()
unit.tile, unit.type = action
unit.nationality = G.players[player].stats.great_power
unit.cv = G.temp.sat_units[player][unit.tile]
add_unit(G, unit)
del G.temp.sat_units[player][unit.tile]
if len(G.temp.sat_units[player]) == 0:
del G.temp.sat_units[player]
if len(G.temp.sat_units):
return encode_sat_units(G)
raise PhaseComplete
def violation_of_neutrality(G, declarer, nation): # including world reaction and placing armed minor units
assert nation in G.diplomacy.neutrals, '{} is no longer neutral'.format(nation)
G.players[declarer].stats.aggressed = True
G.logger.write('{} has violated the neutrality of {}'.format(declarer, nation))
# world reaction
reaction = G.tiles[G.nations.capitals[nation]].muster
rivals = G.players[declarer].stats.rivals
G.logger.write('{} draw {} cards for world reaction'.format(' and '.join(rivals), reaction)) #@@@
for rival in rivals:
draw_cards(G, 'action', rival, reaction)
# remove influence
if nation == 'USA':
assert declarer not in {'West', 'USSR'}, 'West/USSR cannot violate the neutrality of the USA'
if 'USA' in G.diplomacy.influence:
inf = G.diplomacy.influence['USA']
del G.diplomacy.influence['USA']
del G.objects.table[inf._id]
G.objects.removed[inf._id] = inf
G.logger.write('{} loses {} influence in the USA'.format(inf.faction, inf.value))
# USA becomes a West satellite
USA_becomes_satellite(G, 'West')
if not G.players[declarer].stats.at_war_with['West']:
declaration_of_war(G, declarer, 'West')
return
G.players[declarer].diplomacy.violations.add(nation)
if nation in G.diplomacy.influence:
inf = G.diplomacy.influence[nation]
if inf.faction != declarer and inf.value == 2 and not G.players[declarer].stats.at_war_with[inf.faction]:
G.logger.write('Since {} was a protectorate of {}, {}\' protection takes effect'.format(
nation, inf.faction, inf.faction))
declaration_of_war(G, declarer, inf.faction)
# nation should now become a satellite of inf.faction - including placing units
sats = tdict()
sats[nation] = inf.faction
G.temp.new_sats = sats
raise NotImplementedError
# raise PhaseInterrupt('Satellite') # TODO: no hard interrupt, may be in the middle of evaluating movement
lvl = diplvl[inf.value]
G.players[inf.faction].diplomacy[lvl].remove(nation)
decrement_influence(G, nation, inf.value)
pop, res = compute_tracks(G.nations.territories[nation], G.tiles)
G.players[inf.faction].tracks.POP -= pop
G.players[inf.faction].tracks.RES -= res
G.logger.write('{} loses {} influence in {} (losing POP={}, RES={})'.format(inf.faction, inf.value, nation, pop,
res))
convert_to_armed_minor(G, nation) #$$