def test_move_from_liverpool_to_london(self): piece = models.Piece.objects.create( game=self.game, type=PieceType.ARMY, nation=self.england, ) liverpool = models.Territory.objects.get(id='standard-liverpool') london = models.Territory.objects.get(id='standard-london') models.PieceState.objects.create( piece=piece, territory=liverpool, turn=self.turn, ) order = models.Order.objects.create( nation=self.england, source=liverpool, target=london, turn=self.turn, type=OrderType.MOVE, ) process_turn(self.turn) order.refresh_from_db() self.assertTrue(order.illegal) self.assertEqual(order.illegal_code, ArmyMovesToAdjacentTerritoryNotConvoy.code) self.assertEqual(order.illegal_verbose, ArmyMovesToAdjacentTerritoryNotConvoy.message)
def update(self, instance, validated_data): """ Set nation's `orders_finalized` field. Process game if turn is ready. """ instance.orders_finalized = not (instance.orders_finalized) instance.save() if instance.turn.ready_to_process: process_turn(instance.turn) return instance
def handle(self, *args, **options): slug = options['game'] self.noinput = options['no_input'] dry_run = options['dry_run'] try: game = models.Game.objects.get(slug=slug) except models.Game.DoesNotExist: raise CommandError( 'Could not find a game with the slug "{}"'.format(slug)) if game.status != GameStatus.ACTIVE: raise CommandError('Cannot advance turn on an inactive game') turn = game.get_current_turn() if turn.game.status != GameStatus.ACTIVE: raise CommandError('Cannot restore turn if game is not active.') if not turn.ready_to_process: self.stdout.write('Not all nations have finalized their orders\n') self.prompt() result = process_turn(turn, dry_run) if dry_run: pretty_output = json.dumps(result, sort_keys=True, indent=4) self.stdout.write(pretty_output)
def test_disband(self): self.turn.phase = Phase.BUILD self.turn.save() piece = models.Piece.objects.create( game=self.game, type=PieceType.ARMY, nation=self.russia, ) piece_state = models.PieceState.objects.create( piece=piece, territory=self.st_petersburg, turn=self.turn, must_retreat=True, ) order_st_petersburg = models.Order.objects.create( nation=self.russia, source=self.st_petersburg, turn=self.turn, type=OrderType.DISBAND, ) new_turn = process_turn(self.turn) order_st_petersburg.refresh_from_db() piece.refresh_from_db() piece_state.refresh_from_db() self.assertEqual(order_st_petersburg.outcome, OutcomeType.SUCCEEDS) self.assertTrue(piece.turn_disbanded, self.turn) self.assertEqual(new_turn.piecestates.count(), 0)
def test_no_order_removes_piece(self): self.turn.phase = Phase.RETREAT self.turn.save() st_petersburg_state = models.TerritoryState.objects.get( territory=self.st_petersburg) st_petersburg_state.contested = True st_petersburg_state.save() piece = models.Piece.objects.create( game=self.game, type=PieceType.ARMY, nation=self.russia, ) piece_state = models.PieceState.objects.create( piece=piece, territory=self.norway, turn=self.turn, must_retreat=True, ) new_turn = process_turn(self.turn) piece.refresh_from_db() piece_state.refresh_from_db() self.assertTrue(piece_state.destroyed) self.assertTrue(piece.turn_destroyed, self.turn) self.assertEqual(new_turn.piecestates.count(), 0)
def test_contested_retreat_removes_piece(self): self.turn.phase = Phase.RETREAT self.turn.save() st_petersburg_state = models.TerritoryState.objects.get( territory=self.st_petersburg) st_petersburg_state.contested = True st_petersburg_state.save() piece = models.Piece.objects.create( game=self.game, type=PieceType.ARMY, nation=self.russia, ) piece_state = models.PieceState.objects.create( piece=piece, territory=self.norway, turn=self.turn, must_retreat=True, ) order = models.Order.objects.create( nation=self.russia, source=self.norway, target=self.st_petersburg, turn=self.turn, type=OrderType.RETREAT, ) new_turn = process_turn(self.turn) order.refresh_from_db() piece.refresh_from_db() piece_state.refresh_from_db() self.assertTrue(order.illegal) self.assertEqual(order.outcome, OutcomeType.FAILS) self.assertTrue(piece_state.destroyed) self.assertTrue(piece.turn_destroyed, self.turn) self.assertEqual(new_turn.piecestates.count(), 0)
def test_turkey_does_not_take_bulgaria(self): self.turn.season = Season.FALL self.turn.save() piece = models.Piece.objects.create( game=self.game, type=PieceType.ARMY, nation=self.turkey, ) bulgaria = models.Territory.objects.get(id='standard-bulgaria') greece = models.Territory.objects.get(id='standard-greece') models.PieceState.objects.create( piece=piece, territory=bulgaria, turn=self.turn, ) order = models.Order.objects.create( nation=self.turkey, source=bulgaria, target=greece, turn=self.turn, type=OrderType.MOVE, ) new_turn = process_turn(self.turn) order.refresh_from_db() self.assertFalse(order.illegal) old_bulgaria_state = self.turn.territorystates.get(territory=bulgaria) new_bulgaria_state = new_turn.territorystates.get(territory=bulgaria) self.assertIsNone(old_bulgaria_state.captured_by) self.assertIsNone(new_bulgaria_state.controlled_by)
def test_basic_move(self): turn = models.Turn.objects.create( game=self.game, season=Season.SPRING, phase=Phase.ORDER, year=1900, ) france = models.Nation.objects.create( variant=self.variant, name='France', ) self.create_test_nation_state(nation=france, turn=turn, user=self.user) paris = models.Territory.objects.create( variant=self.variant, name='Paris', nationality=france, supply_center=True, type=TerritoryType.INLAND, ) models.TerritoryState.objects.create( territory=paris, turn=turn, controlled_by=france, ) picardy = models.Territory.objects.create( variant=self.variant, name='Picardy', nationality=france, type=TerritoryType.COASTAL, ) models.TerritoryState.objects.create( territory=picardy, turn=turn, controlled_by=france, ) army_paris = models.Piece.objects.create( game=self.game, nation=france, ) models.PieceState.objects.create( piece=army_paris, turn=turn, territory=paris, ) paris.neighbours.add(picardy) models.Order.objects.create( turn=turn, nation=france, type=OrderType.MOVE, source=paris, target=picardy, ) new_turn = process_turn(turn) self.assertEqual(new_turn.year, 1900) self.assertEqual(new_turn.phase, Phase.ORDER) self.assertEqual(new_turn.season, Season.FALL) piece_state = new_turn.piecestates.get() self.assertEqual(piece_state.territory, picardy)
def test_move_st_petersburg_north_coast_to_norway(self): piece = models.Piece.objects.create( game=self.game, type=PieceType.FLEET, nation=self.russia, ) models.PieceState.objects.create( named_coast=self.st_petersburg_north_coast, piece=piece, territory=self.st_petersburg, turn=self.turn, ) order = models.Order.objects.create( nation=self.russia, source=self.st_petersburg, target=self.norway, turn=self.turn, type=OrderType.MOVE, ) process_turn(self.turn) order.refresh_from_db() self.assertFalse(order.illegal)
def test_move_st_petersburg_south_coast_to_gulf_of_bothnia(self): piece = models.Piece.objects.create( game=self.game, type=PieceType.FLEET, nation=self.russia, ) gulf_of_bothnia = models.Territory.objects.get( id='standard-gulf-of-bothnia') models.PieceState.objects.create( named_coast=self.st_petersburg_south_coast, piece=piece, territory=self.st_petersburg, turn=self.turn, ) order = models.Order.objects.create( nation=self.russia, source=self.st_petersburg, target=gulf_of_bothnia, turn=self.turn, type=OrderType.MOVE, ) process_turn(self.turn) order.refresh_from_db() self.assertFalse(order.illegal)
def test_processed(self): new_turn = process_turn(self.turn) # Test turn self.assertEqual(new_turn.season, Season.FALL) self.assertEqual(new_turn.phase, Phase.ORDER) self.assertEqual(new_turn.year, 1901) self.assertEqual(new_turn.processed, False) self.assertEqual(new_turn.processed_at, None) self.assertEqual(new_turn.current_turn, True) # Test nation states for nation_state in new_turn.nationstates.all(): old_nation_state = self.turn.nationstates.get( nation=nation_state.nation) # All users have been copied over correctly self.assertEqual(nation_state.user, old_nation_state.user) # orders_finailzed set to False self.assertFalse(nation_state.orders_finalized)
def test_build_fleet_st_petersburg_north_coast(self): self.turn.season = Season.FALL self.turn.phase = Phase.BUILD self.turn.save() models.TerritoryState.objects.create( controlled_by=self.russia, territory=self.st_petersburg, turn=self.turn, ) order = models.Order.objects.create( nation=self.russia, source=self.st_petersburg, piece_type=PieceType.FLEET, target_coast=self.st_petersburg_north_coast, turn=self.turn, type=OrderType.BUILD, ) new_turn = process_turn(self.turn) order.refresh_from_db() self.assertFalse(order.illegal) new_turn.piecestates.get(territory=self.st_petersburg, named_coast=self.st_petersburg_north_coast, piece__nation=self.russia)
def test_bounce_occured(self): user = User.objects.create(username='******') variant = models.Variant.objects.create(name='standard') game = models.Game.objects.create( variant=variant, name='Test Game', description='Test Description', status=GameStatus.ACTIVE, num_players=7, created_by=user, ) turn = models.Turn.objects.create( game=game, season=Season.SPRING, phase=Phase.ORDER, year=1900, ) france = models.Nation.objects.create( variant=variant, name='France', ) self.create_test_nation_state(nation=france, turn=turn, user=user) paris = models.Territory.objects.create( variant=variant, name='Paris', nationality=france, supply_center=True, type=TerritoryType.INLAND, ) models.TerritoryState.objects.create( territory=paris, turn=turn, controlled_by=france, ) picardy = models.Territory.objects.create( variant=variant, name='Picardy', nationality=france, supply_center=False, type=TerritoryType.COASTAL, ) models.TerritoryState.objects.create( territory=picardy, turn=turn, controlled_by=france, ) burgundy = models.Territory.objects.create( variant=variant, name='Burgundy', nationality=france, supply_center=False, type=TerritoryType.COASTAL, ) burgundy_state = models.TerritoryState.objects.create( territory=burgundy, turn=turn, controlled_by=france, ) army_paris = models.Piece.objects.create( game=game, nation=france, ) models.PieceState.objects.create( piece=army_paris, turn=turn, territory=paris, ) army_picardy = models.Piece.objects.create( game=game, nation=france, ) models.PieceState.objects.create( piece=army_picardy, turn=turn, territory=picardy, ) paris_order = models.Order.objects.create( turn=turn, nation=france, type=OrderType.MOVE, source=paris, target=burgundy, ) picardy_order = models.Order.objects.create( turn=turn, nation=france, type=OrderType.MOVE, source=picardy, target=burgundy, ) paris.neighbours.add(picardy) picardy.neighbours.add(burgundy) paris.neighbours.add(burgundy) process_turn(turn) burgundy_state.refresh_from_db() paris_order.refresh_from_db() picardy_order.refresh_from_db() turn.refresh_from_db() self.assertTrue(turn.processed) self.assertTrue(burgundy_state.bounce_occurred) self.assertEqual(paris_order.outcome, OutcomeType.FAILS) self.assertEqual(picardy_order.outcome, OutcomeType.FAILS)
def test_process_turn(self): user = User.objects.create(username='******') variant = models.Variant.objects.create(name='standard') game = models.Game.objects.create( variant=variant, name='Test Game', description='Test Description', status=GameStatus.ACTIVE, num_players=7, created_by=user, ) turn = models.Turn.objects.create( game=game, season=Season.SPRING, phase=Phase.ORDER, year=1900, ) france = models.Nation.objects.create( variant=variant, name='France', ) self.create_test_nation_state(nation=france, turn=turn, user=user) paris = models.Territory.objects.create( variant=variant, name='Paris', nationality=france, supply_center=True, type=TerritoryType.INLAND, ) models.TerritoryState.objects.create( territory=paris, turn=turn, controlled_by=france, ) picardy = models.Territory.objects.create( variant=variant, name='Picardy', nationality=france, type=TerritoryType.COASTAL, ) models.TerritoryState.objects.create( territory=picardy, turn=turn, controlled_by=france, ) army_paris = models.Piece.objects.create( game=game, nation=france, ) models.PieceState.objects.create( piece=army_paris, turn=turn, territory=paris, ) paris.neighbours.add(picardy) order = models.Order.objects.create( turn=turn, nation=france, type=OrderType.MOVE, source=paris, target=picardy, ) from core.serializers import TurnSerializer game_state_dict = TurnSerializer(turn).data expected_keys = [ 'orders', 'territories', 'named_coasts', 'pieces', 'phase', 'variant' ] self.assertTrue( all([e in game_state_dict.keys() for e in expected_keys])) self.assertEqual(len(game_state_dict['territories']), 2) self.assertEqual(len(game_state_dict['pieces']), 1) self.assertEqual(len(game_state_dict['named_coasts']), 0) self.assertEqual(game_state_dict['variant'], 'standard') process_turn(turn) turn.refresh_from_db() self.assertTrue(turn.processed) order.refresh_from_db() self.assertEqual(order.outcome, OutcomeType.SUCCEEDS)
def test_retreat_rome_not_auto_destroy(self): self.turn.phase = Phase.ORDER self.turn.save() army_rome = self.turn.piecestates.create( piece=models.Piece.objects.create(game=self.game, nation=self.austria, type=PieceType.ARMY), territory=self.rome, ) self.turn.piecestates.create( piece=models.Piece.objects.create(game=self.game, nation=self.italy, type=PieceType.ARMY), territory=self.naples, ) self.turn.piecestates.create( piece=models.Piece.objects.create(game=self.game, nation=self.italy, type=PieceType.FLEET), territory=self.tyrrhenian_sea, ) self.turn.piecestates.create( piece=models.Piece.objects.create(game=self.game, nation=self.austria, type=PieceType.ARMY), territory=self.tuscany, ) self.turn.piecestates.create( piece=models.Piece.objects.create(game=self.game, nation=self.austria, type=PieceType.FLEET), territory=self.apulia, ) self.turn.piecestates.create( piece=models.Piece.objects.create(game=self.game, nation=self.austria, type=PieceType.FLEET), territory=self.venice, ) self.turn.orders.create( nation=self.austria, source=self.apulia, target=self.adriatic_sea, type=OrderType.MOVE, ) self.turn.orders.create( nation=self.austria, source=self.rome, type=OrderType.HOLD, ) self.turn.orders.create( nation=self.austria, source=self.venice, type=OrderType.HOLD, ) self.turn.orders.create( nation=self.italy, source=self.tuscany, target=self.piedmont, type=OrderType.MOVE, ) self.turn.orders.create( nation=self.italy, source=self.apulia, target=self.rome, type=OrderType.MOVE, ) self.turn.orders.create( nation=self.italy, source=self.tyrrhenian_sea, target=self.rome, aux=self.naples, type=OrderType.SUPPORT, ) process_turn(self.turn) army_rome.refresh_from_db() self.assertFalse(army_rome.destroyed) self.assertIsNone(army_rome.destroyed_message)