def setUp(self):
self.state = State()
self.paris = InlandTerritory(1, 'Paris', 'France', [7])
self.london = CoastalTerritory(2, 'London', 'England', [3, 6], [3])
self.wales = CoastalTerritory(3, 'Wales', 'England', [2, 6], [2])
self.english_channel = SeaTerritory(6, 'English Channel', [2, 3])
self.brest = CoastalTerritory(7, 'Brest', 'France', [1, 6], [])
self.rome = CoastalTerritory(8, 'Rome', 'Italy', [9], [])
self.apulia = CoastalTerritory(9, 'Apulia', 'Italy', [8], [])
self.spain = CoastalTerritory(10, 'Spain', None, [11, 12, 13, 14],
[11, 12])
self.gascony = CoastalTerritory(11, 'Gascony', 'France', [10], [])
self.marseilles = CoastalTerritory(12, 'Marseilles', 'France', [10],
[10])
self.mid_atlantic = SeaTerritory(13, 'Mid Atlantic', [10])
self.gulf_of_lyon = SeaTerritory(14, 'Gulf of Lyon', [10])
self.spain_north_coast = NamedCoast(1, 'North Coast', self.spain,
[self.gascony, self.mid_atlantic])
self.spain_south_coast = NamedCoast(
2, 'South Coast', self.spain,
[self.marseilles, self.gulf_of_lyon, self.marseilles])
to_register = [
self.paris, self.london, self.wales, self.english_channel,
self.brest, self.rome, self.apulia, self.spain, self.gascony,
self.marseilles, self.mid_atlantic, self.gulf_of_lyon,
self.spain_north_coast, self.spain_south_coast
]
[self.state.register(o) for o in to_register]
def setUp(self):
self.state = State()
self.portugal = CoastalTerritory(11, 'Portugal', None, [], [])
self.spain = CoastalTerritory(10, 'Spain', None, [], [])
self.spain_south_coast = NamedCoast(2, 'South Coast', self.spain, [])
to_register = [self.spain, self.spain_south_coast]
[self.state.register(o) for o in to_register]
def test_register_piece_updates_territory(self):
state = State()
paris = InlandTerritory(1, 'paris', Nations.FRANCE, [])
army_paris = Army(0, Nations.FRANCE, paris)
state.register(paris)
state.register(army_paris)
self.assertEqual(paris.piece, army_paris)
def test_register_named_coast_updates_territory(self):
state = State()
spain = CoastalTerritory(1, 'spain', None, [], [])
spain_nc = NamedCoast(1, 'spain sc', spain, [])
state.register(spain)
state.register(spain_nc)
self.assertTrue(spain_nc in spain.named_coasts)
def test_order_exists(self):
state = State()
london = CoastalTerritory(1, 'London', 'England', [], [])
wales = CoastalTerritory(2, 'Wales', 'England', [], [])
army = Army('England', london)
london_move = Move('England', london, wales)
to_register = [london, wales, army, london_move]
[state.register(o) for o in to_register]
self.assertEqual(army.order, london_move)
def test_register_order_updates_piece_order(self):
state = State()
paris = InlandTerritory(1, 'paris', Nations.FRANCE, [])
army_paris = Army(0, Nations.FRANCE, paris)
hold = Hold(0, Nations.FRANCE, paris)
state.register(paris)
state.register(army_paris)
state.register(hold)
self.assertEqual(army_paris.order, hold)
self.assertEqual(hold.piece, army_paris)
def setUp(self):
self.state = State()
self.paris = InlandTerritory(1, 'Paris', 'France', [7])
self.london = CoastalTerritory(2, 'London', 'England', [3, 6], [3])
self.wales = CoastalTerritory(3, 'Wales', 'England', [2, 6], [2])
self.munich = InlandTerritory(4, 'Munich', 'Germany', [5])
self.silesia = InlandTerritory(5, 'Silesia', 'Germany', [4])
self.english_channel = SeaTerritory(6, 'English Channel', [2, 3])
self.brest = CoastalTerritory(7, 'Brest', 'France', [1, 6], [])
to_register = [self.paris, self.london, self.wales, self.munich,
self.silesia, self.english_channel, self.brest]
[self.state.register(o) for o in to_register]
def test_piece(self):
state = State()
london = CoastalTerritory(1, 'London', 'England', [], [])
wales = CoastalTerritory(2, 'Wales', 'England', [], [])
army = Army('England', london)
london_hold = Hold('England', london)
wales_hold = Hold('England', wales)
to_register = [london, wales, army, london_hold, wales_hold]
[state.register(o) for o in to_register]
self.assertEqual(london_hold.piece, army)
self.assertIsNone(wales_hold.piece)
def test_register_territory_updates_neighbours(self):
state = State()
paris = InlandTerritory(1, 'paris', Nations.FRANCE, [2, 3])
burgundy = InlandTerritory(2, 'burgundy', Nations.FRANCE, [1, 3])
gascony = InlandTerritory(3, 'gascony', Nations.FRANCE, [1, 2])
state.register(paris)
state.register(burgundy)
state.register(gascony)
self.assertTrue(paris in burgundy.neighbours)
self.assertTrue(paris in gascony.neighbours)
self.assertTrue(burgundy in paris.neighbours)
self.assertTrue(burgundy in gascony.neighbours)
self.assertTrue(gascony in paris.neighbours)
self.assertTrue(gascony in burgundy.neighbours)
def test_register_territory_updates_shared_coasts(self):
state = State()
rome = CoastalTerritory(1, 'rome', Nations.ITALY, [2, 4], [2, 3])
naples = CoastalTerritory(2, 'naples', Nations.ITALY, [1], [1])
tuscany = CoastalTerritory(3, 'tuscany', Nations.ITALY, [1, 4], [1])
venice = CoastalTerritory(4, 'venice', Nations.ITALY, [1, 3], [])
state.register(rome)
state.register(naples)
state.register(tuscany)
state.register(venice)
self.assertTrue(all([t in rome.neighbours for t in [naples, venice]]))
self.assertEqual({rome}, naples.neighbours)
self.assertTrue(all([t in tuscany.neighbours for t in [rome, venice]]))
self.assertTrue(all([t in venice.neighbours for t in [rome, tuscany]]))
self.assertEqual(rome.shared_coasts, {naples, tuscany})
self.assertEqual(naples.shared_coasts, {rome})
self.assertEqual(tuscany.shared_coasts, {rome})
self.assertEqual(venice.shared_coasts, set())
def setUp(self):
self.state = State()
self.territories = Territories()
self.named_coasts = NamedCoasts(self.territories)
self.state = register_all(self.state, self.territories,
self.named_coasts)
def setUp(self):
self.state = State()
def setUp(self):
self.state = State(Season.SPRING, Phase.ORDER, 1900)
def setUp(self):
self.state = State()
self.territories = Territories()
self.state = register_all(self.state, self.territories, [])
def process_game_state(data):
territory_map = {}
named_coast_map = {}
# Marshall data into expected format and validate
validated_data = TurnSchema().load(data)
season = validated_data['season']
phase = validated_data['phase']
year = validated_data['year']
# Instantiate `State` for this turn
state = State(season, phase, year)
# Initialise territory instances and register each to state. Add to
# territory map
for territory_data in validated_data['territories']:
territory_type = territory_data.pop('type')
territory_class = territory_type_dict[territory_type]
territory = territory_class(state, **territory_data)
territory_map[territory_data['id']] = territory
# Initialise named coasts - grab parent from territory map
for named_coast_data in validated_data['named_coasts']:
named_coast_data['parent'] = territory_map[named_coast_data['parent']]
named_coast = NamedCoast(state, **named_coast_data)
named_coast_map[named_coast.id] = named_coast
# Initialise orders - grab source, target, aux, target_coast from maps
for order_data in validated_data['orders']:
order_type = order_data.pop('type')
order_class = order_type_dict[order_type]
for arg_name in ['source', 'target', 'aux']:
territory_id = order_data[arg_name]
if territory_id:
order_data[arg_name] = territory_map[territory_id]
target_coast_id = order_data['target_coast']
if target_coast_id:
order_data['target_coast'] = named_coast_map[target_coast_id]
order_class(state, **order_data)
# Initialise pieces - grab source, target, aux, target_coast from maps
for piece_data in validated_data['pieces']:
piece_type = piece_data.pop('type')
piece_class = piece_type_dict[piece_type]
for arg_name in ['territory', 'attacker_territory']:
territory_id = piece_data[arg_name]
if territory_id:
piece_data[arg_name] = territory_map[territory_id]
named_coast_id = piece_data['named_coast']
if named_coast_id:
piece_data['named_coast'] = named_coast_map[named_coast_id]
piece_class(state, **piece_data)
# Initialise nation instances and register each to state
for nation_data in validated_data['nations']:
Nation(state, **nation_data)
# Process game state
process(state)
# Serialize processed game state and return
processed_data = TurnSchema().dump(state)
return processed_data
