OpenFrontIO/tests/GameImpl.test.ts

import {GameImpl, PlayerImpl} from '../src/core/GameImpl';
import {EventBus} from '../src/core/EventBus';
import {Game, Cell, MutablePlayer, PlayerInfo, TerrainMap, TerrainTypes, Tile} from '../src/core/Game';

describe('borderTilesWith', () => {
    let game: GameImpl;
    let player1: PlayerImpl;
    let player2: PlayerImpl;
    let terrainMap: TerrainMap;

    beforeEach(() => {
        // Create a 5x5 terrain map
        terrainMap = {
            terrain: jest.fn().mockReturnValue(TerrainTypes.Land),
            width: jest.fn().mockReturnValue(5),
            height: jest.fn().mockReturnValue(5)
        };
        const eventBus = new EventBus();
        game = new GameImpl(terrainMap, eventBus);
        player1 = game.addPlayer(new PlayerInfo('Player 1', false)) as PlayerImpl;
        player2 = game.addPlayer(new PlayerInfo('Player 2', false)) as PlayerImpl;
    });

    test('should return an empty set when players have no bordering tiles', () => {
        const borderTiles = player1.borderTilesWith(player2);
        expect(borderTiles.size).toBe(0);
    });

    test('should return correct border tiles when players are adjacent', () => {
        game.conquer(player1, new Cell(0, 0));
        game.conquer(player2, new Cell(1, 0));

        const borderTilesP1 = player1.borderTilesWith(player2);
        const borderTilesP2 = player2.borderTilesWith(player1);

        expect(borderTilesP1.size).toBe(1);
        expect(borderTilesP2.size).toBe(1);

        const p1BorderTile = Array.from(borderTilesP1)[0];
        const p2BorderTile = Array.from(borderTilesP2)[0];

        expect(p1BorderTile.cell()).toEqual(new Cell(0, 0));
        expect(p2BorderTile.cell()).toEqual(new Cell(1, 0));
    });

    test('should update border tiles when a new tile is conquered', () => {
        game.conquer(player1, new Cell(0, 0));
        game.conquer(player2, new Cell(2, 0));

        expect(player1.borderTilesWith(player2).size).toBe(0);

        game.conquer(player2, new Cell(1, 0));

        const borderTiles = player1.borderTilesWith(player2);
        expect(borderTiles.size).toBe(1);
        expect(Array.from(borderTiles)[0].cell()).toEqual(new Cell(0, 0));
    });

    test('should handle multiple border tiles correctly', () => {
        game.conquer(player1, new Cell(0, 0));
        game.conquer(player1, new Cell(0, 1));
        game.conquer(player2, new Cell(1, 0));
        game.conquer(player2, new Cell(1, 1));

        const borderTiles = player1.borderTilesWith(player2);
        expect(borderTiles.size).toBe(2);

        const borderCells = Array.from(borderTiles).map(tile => tile.cell());
        expect(borderCells).toEqual(expect.arrayContaining([new Cell(0, 0), new Cell(0, 1)]));
    });

    test('should update border tiles when a tile changes ownership', () => {
        game.conquer(player1, new Cell(0, 0));
        game.conquer(player1, new Cell(1, 0));
        game.conquer(player2, new Cell(2, 0));

        expect(player1.borderTilesWith(player2).size).toBe(1);

        game.conquer(player2, new Cell(1, 0));

        const borderTilesP1 = player1.borderTilesWith(player2);
        const borderTilesP2 = player2.borderTilesWith(player1);

        expect(borderTilesP1.size).toBe(1);
        expect(borderTilesP2.size).toBe(1);

        expect(Array.from(borderTilesP1)[0].cell()).toEqual(new Cell(0, 0));
        expect(Array.from(borderTilesP2).map(t => t.cell())).toEqual(
            expect.arrayContaining([new Cell(1, 0)])
        );
    });

    test('should handle border tiles with TerraNullius', () => {
        game.conquer(player1, new Cell(0, 0));

        const borderWithTerraNullius = player1.borderTilesWith(game.terraNullius());
        expect(borderWithTerraNullius.size).toBe(1);

        const borderCells = Array.from(borderWithTerraNullius).map(tile => tile.cell());
        expect(borderCells).toEqual(expect.arrayContaining([new Cell(0, 0)]));
    });

    test('should not include diagonal tiles as borders', () => {
        game.conquer(player1, new Cell(0, 0));
        game.conquer(player2, new Cell(1, 1));

        expect(player1.borderTilesWith(player2).size).toBe(0);
        expect(player2.borderTilesWith(player1).size).toBe(0);
    });

    // test('should handle complex border scenarios', () => {
    //     // Create a more complex border scenario
    //     //   0 1 2 3 4
    //     // 0 1 1 2 2 2
    //     // 1 1 1 2 2 2
    //     // 2 1 1 1 2 2
    //     // 3 1 1 1 1 2
    //     // 4 1 1 1 1 1

    //     for (let y = 0; y < 5; y++) {
    //         for (let x = 0; x < 5; x++) {
    //             if (x + y < 6) {
    //                 game.conquer(player1, new Cell(x, y));
    //             } else {
    //                 game.conquer(player2, new Cell(x, y));
    //             }
    //         }
    //     }

    //     const borderTilesP1 = player1.borderTilesWith(player2);
    //     const borderTilesP2 = player2.borderTilesWith(player1);

    //     expect(borderTilesP1.size).toBe(5);
    //     expect(borderTilesP2.size).toBe(5);

    //     const expectedBorderP1 = [
    //         new Cell(2, 0),
    //         new Cell(2, 1),
    //         new Cell(3, 2),
    //         new Cell(3, 3),
    //         new Cell(4, 3)
    //     ];

    //     const expectedBorderP2 = [
    //         new Cell(2, 2),
    //         new Cell(3, 1),
    //         new Cell(3, 2),
    //         new Cell(4, 1),
    //         new Cell(4, 2)
    //     ];

    //     const actualBorderP1 = Array.from(borderTilesP1).map(t => t.cell());
    //     const actualBorderP2 = Array.from(borderTilesP2).map(t => t.cell());

    //     expect(actualBorderP1).toEqual(expect.arrayContaining(expectedBorderP1));
    //     expect(actualBorderP2).toEqual(expect.arrayContaining(expectedBorderP2));
    // });

    test('should handle border updates when a player loses all tiles', () => {
        game.conquer(player1, new Cell(0, 0));
        game.conquer(player2, new Cell(1, 0));

        expect(player1.borderTilesWith(player2).size).toBe(1);

        game.conquer(player1, new Cell(1, 0));  // Player 1 takes Player 2's only tile

        expect(player1.borderTilesWith(player2).size).toBe(0);
        expect(player2.borderTilesWith(player1).size).toBe(0);
    });
});