boardgame-core/tests/core/region.test.ts

import { describe, it, expect } from 'vitest';
import { createRegion, applyAlign, shuffle, moveToRegion, moveToRegionAll, removeFromRegion, type Region, type RegionAxis } from '@/core/region';
import { createRNG } from '@/utils/rng';
import { type Part } from '@/core/part';

describe('Region', () => {
    function createTestRegion(axes: RegionAxis[], parts: Part[]): { region: Region; parts: Record<string, Part> } {
        const partsMap: Record<string, Part> = {};
        for (const p of parts) {
            partsMap[p.id] = { ...p };
        }
        const region = createRegion('region1', axes);
        region.childIds = parts.map(p => p.id);
        region.partMap = Object.fromEntries(
            parts.map(p => [p.position.join(','), p.id])
        );
        return { region, parts: partsMap };
    }

    describe('applyAlign', () => {
        it('should do nothing with empty region', () => {
            const { region } = createTestRegion([{ name: 'x', min: 0, align: 'start' }], []);
            applyAlign(region, {});
            expect(region.childIds).toHaveLength(0);
        });

        it('should align parts to start on first axis', () => {
            const part1: Part = { id: 'p1', regionId: 'region1', position: [5, 10] };
            const part2: Part = { id: 'p2', regionId: 'region1', position: [7, 20] };
            const part3: Part = { id: 'p3', regionId: 'region1', position: [2, 30] };

            const { region, parts } = createTestRegion(
                [{ name: 'x', min: 0, align: 'start' }, { name: 'y' }],
                [part1, part2, part3]
            );

            applyAlign(region, parts);

            expect(parts[region.childIds[0]].position[0]).toBe(0);
            expect(parts[region.childIds[1]].position[0]).toBe(1);
            expect(parts[region.childIds[2]].position[0]).toBe(2);
            expect(parts[region.childIds[0]].position[1]).toBe(30);
            expect(parts[region.childIds[1]].position[1]).toBe(10);
            expect(parts[region.childIds[2]].position[1]).toBe(20);
        });

        it('should align parts to start with custom min', () => {
            const part1: Part = { id: 'p1', regionId: 'region1', position: [5, 100] };
            const part2: Part = { id: 'p2', regionId: 'region1', position: [7, 200] };

            const { region, parts } = createTestRegion(
                [{ name: 'x', min: 10, align: 'start' }, { name: 'y' }],
                [part1, part2]
            );

            applyAlign(region, parts);

            expect(parts[region.childIds[0]].position[0]).toBe(10);
            expect(parts[region.childIds[1]].position[0]).toBe(11);
            expect(parts[region.childIds[0]].position[1]).toBe(100);
            expect(parts[region.childIds[1]].position[1]).toBe(200);
        });

        it('should align parts to end on first axis', () => {
            const part1: Part = { id: 'p1', regionId: 'region1', position: [2, 50] };
            const part2: Part = { id: 'p2', regionId: 'region1', position: [4, 60] };
            const part3: Part = { id: 'p3', regionId: 'region1', position: [1, 70] };

            const { region, parts } = createTestRegion(
                [{ name: 'x', max: 10, align: 'end' }, { name: 'y' }],
                [part1, part2, part3]
            );

            applyAlign(region, parts);

            expect(parts[region.childIds[0]].position[0]).toBe(8);
            expect(parts[region.childIds[1]].position[0]).toBe(9);
            expect(parts[region.childIds[2]].position[0]).toBe(10);
        });

        it('should align parts to center on first axis', () => {
            const part1: Part = { id: 'p1', regionId: 'region1', position: [0, 5] };
            const part2: Part = { id: 'p2', regionId: 'region1', position: [1, 6] };
            const part3: Part = { id: 'p3', regionId: 'region1', position: [2, 7] };

            const { region, parts } = createTestRegion(
                [{ name: 'x', min: 0, max: 10, align: 'center' }, { name: 'y' }],
                [part1, part2, part3]
            );

            applyAlign(region, parts);

            expect(parts[region.childIds[0]].position[0]).toBe(4);
            expect(parts[region.childIds[1]].position[0]).toBe(5);
            expect(parts[region.childIds[2]].position[0]).toBe(6);
        });

        it('should handle even count center alignment', () => {
            const part1: Part = { id: 'p1', regionId: 'region1', position: [0, 10] };
            const part2: Part = { id: 'p2', regionId: 'region1', position: [1, 20] };

            const { region, parts } = createTestRegion(
                [{ name: 'x', min: 0, max: 10, align: 'center' }, { name: 'y' }],
                [part1, part2]
            );

            applyAlign(region, parts);

            expect(parts[region.childIds[0]].position[0]).toBe(4.5);
            expect(parts[region.childIds[1]].position[0]).toBe(5.5);
        });

        it('should sort children by position on current axis', () => {
            const part1: Part = { id: 'p1', regionId: 'region1', position: [5, 100] };
            const part2: Part = { id: 'p2', regionId: 'region1', position: [1, 200] };
            const part3: Part = { id: 'p3', regionId: 'region1', position: [3, 300] };

            const { region, parts } = createTestRegion(
                [{ name: 'x', min: 0, align: 'start' }, { name: 'y' }],
                [part1, part2, part3]
            );

            applyAlign(region, parts);

            expect(region.childIds[0]).toBe('p2');
            expect(region.childIds[1]).toBe('p3');
            expect(region.childIds[2]).toBe('p1');
        });

        it('should align on multiple axes', () => {
            const part1: Part = { id: 'p1', regionId: 'region1', position: [5, 10] };
            const part2: Part = { id: 'p2', regionId: 'region1', position: [7, 20] };
            const part3: Part = { id: 'p3', regionId: 'region1', position: [2, 30] };

            const { region, parts } = createTestRegion(
                [
                    { name: 'x', min: 0, align: 'start' },
                    { name: 'y', min: 0, align: 'start' }
                ],
                [part1, part2, part3]
            );

            applyAlign(region, parts);

            expect(region.childIds[0]).toBe('p3');
            expect(parts[region.childIds[0]].position).toEqual([0, 2]);

            expect(region.childIds[1]).toBe('p1');
            expect(parts[region.childIds[1]].position).toEqual([1, 0]);

            expect(region.childIds[2]).toBe('p2');
            expect(parts[region.childIds[2]].position).toEqual([2, 1]);
        });

        it('should align 4 elements on rectangle corners', () => {
            const part1: Part = { id: 'p1', regionId: 'region1', position: [0, 0] };
            const part2: Part = { id: 'p2', regionId: 'region1', position: [10, 0] };
            const part3: Part = { id: 'p3', regionId: 'region1', position: [10, 1] };
            const part4: Part = { id: 'p4', regionId: 'region1', position: [0, 1] };

            const { region, parts } = createTestRegion(
                [
                    { name: 'x', min: 0, max: 10, align: 'start' },
                    { name: 'y', min: 0, max: 10, align: 'start' }
                ],
                [part1, part2, part3, part4]
            );

            applyAlign(region, parts);

            expect(region.childIds[0]).toBe('p1');
            expect(parts[region.childIds[0]].position).toEqual([0, 0]);

            expect(region.childIds[1]).toBe('p4');
            expect(parts[region.childIds[1]].position).toEqual([0, 1]);

            expect(region.childIds[2]).toBe('p2');
            expect(parts[region.childIds[2]].position).toEqual([1, 0]);

            expect(region.childIds[3]).toBe('p3');
            expect(parts[region.childIds[3]].position).toEqual([1, 1]);
        });
    });

    describe('shuffle', () => {
        it('should do nothing with empty region', () => {
            const { region, parts } = createTestRegion([], []);
            const rng = createRNG(42);
            shuffle(region, parts, rng);
            expect(region.childIds).toHaveLength(0);
        });

        it('should do nothing with single part', () => {
            const part: Part = { id: 'p1', regionId: 'region1', position: [0, 0, 0] };
            const { region, parts } = createTestRegion([], [part]);
            const rng = createRNG(42);
            shuffle(region, parts, rng);
            expect(parts['p1'].position).toEqual([0, 0, 0]);
        });

        it('should shuffle positions of multiple parts', () => {
            const part1: Part = { id: 'p1', regionId: 'region1', position: [0, 100] };
            const part2: Part = { id: 'p2', regionId: 'region1', position: [1, 200] };
            const part3: Part = { id: 'p3', regionId: 'region1', position: [2, 300] };

            const { region, parts } = createTestRegion([], [part1, part2, part3]);
            const rng = createRNG(42);

            const originalPositions = region.childIds.map(id => [...parts[id].position]);
            shuffle(region, parts, rng);

            const newPositions = region.childIds.map(id => parts[id].position);

            originalPositions.forEach(origPos => {
                const found = newPositions.some(newPos =>
                    newPos[0] === origPos[0] && newPos[1] === origPos[1]
                );
                expect(found).toBe(true);
            });
        });

        it('should be deterministic with same seed', () => {
            const createPartsForTest = (): Part[] => [
                { id: 'p1', regionId: 'region1', position: [0, 10] },
                { id: 'p2', regionId: 'region1', position: [1, 20] },
                { id: 'p3', regionId: 'region1', position: [2, 30] },
            ];

            const setup1 = createTestRegion([], createPartsForTest());
            const setup2 = createTestRegion([], createPartsForTest());

            const rng1 = createRNG(42);
            const rng2 = createRNG(42);

            shuffle(setup1.region, setup1.parts, rng1);
            shuffle(setup2.region, setup2.parts, rng2);

            const positions1 = setup1.region.childIds.map(id => setup1.parts[id].position);
            const positions2 = setup2.region.childIds.map(id => setup2.parts[id].position);

            expect(positions1).toEqual(positions2);
        });

        it('should produce different results with different seeds', () => {
            const createPartsForTest = (): Part[] => [
                { id: 'p1', regionId: 'region1', position: [0, 10] },
                { id: 'p2', regionId: 'region1', position: [1, 20] },
                { id: 'p3', regionId: 'region1', position: [2, 30] },
                { id: 'p4', regionId: 'region1', position: [3, 40] },
                { id: 'p5', regionId: 'region1', position: [4, 50] },
            ];

            const results = new Set<string>();

            for (let seed = 1; seed <= 10; seed++) {
                const setup = createTestRegion([], createPartsForTest());
                const rng = createRNG(seed);
                shuffle(setup.region, setup.parts, rng);

                const positions = JSON.stringify(setup.region.childIds.map(id => setup.parts[id].position));
                results.add(positions);
            }

            expect(results.size).toBeGreaterThan(5);
        });
    });

    describe('moveToRegion', () => {
        it('should move a part from one region to another', () => {
            const sourceAxes: RegionAxis[] = [{ name: 'x', min: 0, max: 5 }];
            const targetAxes: RegionAxis[] = [{ name: 'x', min: 0, max: 5 }];
            const sourceRegion = createRegion('source', sourceAxes);
            const targetRegion = createRegion('target', targetAxes);

            const part: Part = { id: 'p1', regionId: 'source', position: [2] };
            const parts: Record<string, Part> = { p1: part };
            sourceRegion.childIds.push('p1');
            sourceRegion.partMap['2'] = 'p1';

            expect(sourceRegion.childIds).toHaveLength(1);
            expect(targetRegion.childIds).toHaveLength(0);
            expect(part.regionId).toBe('source');

            moveToRegion(part, sourceRegion, targetRegion, [0]);

            expect(sourceRegion.childIds).toHaveLength(0);
            expect(targetRegion.childIds).toHaveLength(1);
            expect(part.regionId).toBe('target');
            expect(part.position).toEqual([0]);
        });

        it('should keep existing position if no position provided', () => {
            const sourceRegion = createRegion('source', [{ name: 'x' }]);
            const targetRegion = createRegion('target', [{ name: 'x' }]);

            const part: Part = { id: 'p1', regionId: 'source', position: [3] };
            const parts: Record<string, Part> = { p1: part };
            sourceRegion.childIds.push('p1');
            sourceRegion.partMap['3'] = 'p1';

            moveToRegion(part, sourceRegion, targetRegion);

            expect(part.position).toEqual([3]);
        });
    });

    describe('moveToRegionAll', () => {
        it('should move multiple parts to a target region', () => {
            const sourceRegion = createRegion('source', [{ name: 'x' }]);
            const targetRegion = createRegion('target', [{ name: 'x' }]);

            const parts = {
                p1: { id: 'p1', regionId: 'source', position: [0] } as Part,
                p2: { id: 'p2', regionId: 'source', position: [1] } as Part,
                p3: { id: 'p3', regionId: 'source', position: [2] } as Part,
            };
            sourceRegion.childIds.push('p1', 'p2', 'p3');
            sourceRegion.partMap = { '0': 'p1', '1': 'p2', '2': 'p3' };

            moveToRegionAll([parts.p1, parts.p2, parts.p3], sourceRegion, targetRegion, [[0], [1], [2]]);

            expect(sourceRegion.childIds).toHaveLength(0);
            expect(targetRegion.childIds).toHaveLength(3);
            expect(parts.p1.position).toEqual([0]);
            expect(parts.p2.position).toEqual([1]);
            expect(parts.p3.position).toEqual([2]);
        });

        it('should keep existing positions if no positions provided', () => {
            const sourceRegion = createRegion('source', [{ name: 'x' }]);
            const targetRegion = createRegion('target', [{ name: 'x' }]);

            const parts = {
                p1: { id: 'p1', regionId: 'source', position: [5] } as Part,
                p2: { id: 'p2', regionId: 'source', position: [8] } as Part,
            };
            sourceRegion.childIds.push('p1', 'p2');
            sourceRegion.partMap = { '5': 'p1', '8': 'p2' };

            moveToRegionAll([parts.p1, parts.p2], sourceRegion, targetRegion);

            expect(parts.p1.position).toEqual([5]);
            expect(parts.p2.position).toEqual([8]);
        });
    });

    describe('removeFromRegion', () => {
        it('should remove a part from its region', () => {
            const region = createRegion('region1', [{ name: 'x' }]);

            const part: Part = { id: 'p1', regionId: 'region1', position: [2] };
            const parts: Record<string, Part> = { p1: part };
            region.childIds.push('p1');
            region.partMap['2'] = 'p1';

            expect(region.childIds).toHaveLength(1);

            removeFromRegion(part, region);

            expect(region.childIds).toHaveLength(0);
        });

        it('should leave other parts unaffected', () => {
            const region = createRegion('region1', [{ name: 'x' }]);

            const p1 = { id: 'p1', regionId: 'region1', position: [0] } as Part;
            const p2 = { id: 'p2', regionId: 'region1', position: [1] } as Part;
            const p3 = { id: 'p3', regionId: 'region1', position: [2] } as Part;
            region.childIds.push('p1', 'p2', 'p3');
            region.partMap = { '0': 'p1', '1': 'p2', '2': 'p3' };

            removeFromRegion(p2, region);

            expect(region.childIds).toHaveLength(2);
            expect(region.childIds).toEqual(['p1', 'p3']);
        });
    });
});