boardgame-core/tests/samples/slay-the-spire-like/utils/shape-utils.test.ts

import { describe, it, expect } from 'vitest';
import { parseShapeString } from '@/samples/slay-the-spire-like/utils/parse-shape';
import {
    checkCollision,
    checkBoardCollision,
    checkBounds,
    validatePlacement,
    transformShape,
    getOccupiedCells,
    IDENTITY_TRANSFORM,
} from '@/samples/slay-the-spire-like/utils/shape-collision';

describe('parseShapeString', () => {
    it('should parse a single cell with o', () => {
        const result = parseShapeString('o');
        expect(result.grid).toEqual([[true]]);
        expect(result.width).toBe(1);
        expect(result.height).toBe(1);
        expect(result.count).toBe(1);
        expect(result.originX).toBe(0);
        expect(result.originY).toBe(0);
    });

    it('should parse a horizontal line', () => {
        const result = parseShapeString('oee');
        expect(result.width).toBe(3);
        expect(result.height).toBe(1);
        expect(result.count).toBe(3);
        expect(result.grid).toEqual([[true, true, true]]);
        expect(result.originX).toBe(0);
        expect(result.originY).toBe(0);
    });

    it('should parse a vertical line', () => {
        const result = parseShapeString('oss');
        expect(result.width).toBe(1);
        expect(result.height).toBe(3);
        expect(result.count).toBe(3);
        expect(result.grid).toEqual([[true], [true], [true]]);
        expect(result.originX).toBe(0);
        expect(result.originY).toBe(0);
    });

    it('should parse an L shape', () => {
        const result = parseShapeString('oes');
        expect(result.width).toBe(2);
        expect(result.height).toBe(2);
        expect(result.count).toBe(3);
        expect(result.grid).toEqual([
            [true, true],
            [false, true],
        ]);
    });

    it('should handle return command', () => {
        const result = parseShapeString('oeerww');
        expect(result.width).toBe(4);
        expect(result.height).toBe(1);
        expect(result.count).toBe(4);
        expect(result.grid).toEqual([[true, true, true, true]]);
    });

    it('should handle case insensitivity', () => {
        const resultLower = parseShapeString('oes');
        const resultUpper = parseShapeString('OES');
        expect(resultLower.grid).toEqual(resultUpper.grid);
        expect(resultLower.count).toBe(resultUpper.count);
    });

    it('should return empty grid for empty input', () => {
        const result = parseShapeString('');
        expect(result.grid).toEqual([[]]);
        expect(result.width).toBe(0);
        expect(result.height).toBe(1);
        expect(result.count).toBe(0);
    });

    it('should track origin correctly', () => {
        // eeso: e(1,0), e(2,0), s(2,1), o sets origin at (2,1)
        // After normalization: minX=1, minY=0, so originX = 2-1 = 1, originY = 1-0 = 1
        const result = parseShapeString('eeso');
        expect(result.originX).toBe(1);
        expect(result.originY).toBe(1);
    });

    it('should track origin at first o only', () => {
        const result = parseShapeString('oes');
        expect(result.originX).toBe(0);
        expect(result.originY).toBe(0);
    });

    it('should handle complex T shape', () => {
        // oewers: o(0,0), e(1,0), w(0,0), e(1,0), r->(0,0), s(0,1)
        // Filled: (0,0), (1,0), (0,1) - 3 cells
        const result = parseShapeString('oewers');
        expect(result.width).toBe(2);
        expect(result.height).toBe(2);
        expect(result.count).toBe(3);
        expect(result.grid).toEqual([
            [true, true],
            [true, false],
        ]);
    });
});

describe('shape-collision', () => {
    describe('getOccupiedCells', () => {
        it('should return cells for a single cell shape', () => {
            const shape = parseShapeString('o');
            const cells = getOccupiedCells(shape);
            expect(cells).toEqual([{ x: 0, y: 0 }]);
        });

        it('should return cells for a horizontal line', () => {
            const shape = parseShapeString('oe');
            const cells = getOccupiedCells(shape);
            expect(cells).toEqual([
                { x: 0, y: 0 },
                { x: 1, y: 0 },
            ]);
        });

        it('should return cells for an L shape', () => {
            const shape = parseShapeString('oes');
            const cells = getOccupiedCells(shape);
            expect(cells).toEqual([
                { x: 0, y: 0 },
                { x: 1, y: 0 },
                { x: 1, y: 1 },
            ]);
        });
    });

    describe('checkCollision', () => {
        it('should detect collision between overlapping shapes', () => {
            const shapeA = parseShapeString('o');
            const shapeB = parseShapeString('o');

            const result = checkCollision(
                shapeA,
                { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
                shapeB,
                { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } }
            );
            expect(result).toBe(true);
        });

        it('should not detect collision between non-overlapping shapes', () => {
            const shapeA = parseShapeString('o');
            const shapeB = parseShapeString('o');

            const result = checkCollision(
                shapeA,
                { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
                shapeB,
                { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } }
            );
            expect(result).toBe(false);
        });

        it('should detect collision with adjacent shapes', () => {
            const shapeA = parseShapeString('o');
            const shapeB = parseShapeString('o');

            const result = checkCollision(
                shapeA,
                { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
                shapeB,
                { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 0 } }
            );
            expect(result).toBe(false);
        });

        it('should detect collision with rotation', () => {
            const shapeA = parseShapeString('oe');
            const shapeB = parseShapeString('os');

            // shapeA is horizontal at (0,0)-(1,0)
            // shapeB rotated 90° becomes vertical at (0,0)-(0,1)
            // They should collide at (0,0)
            const result = checkCollision(
                shapeA,
                { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
                shapeB,
                { ...IDENTITY_TRANSFORM, rotation: 90, offset: { x: 0, y: 0 } }
            );
            expect(result).toBe(true);
        });
    });

    describe('checkBoardCollision', () => {
        it('should detect collision with occupied cells', () => {
            const shape = parseShapeString('oe');
            const occupied = new Set(['0,0', '1,0']);

            const result = checkBoardCollision(shape, IDENTITY_TRANSFORM, occupied);
            expect(result).toBe(true);
        });

        it('should not detect collision with empty board', () => {
            const shape = parseShapeString('oe');
            const occupied = new Set<string>();

            const result = checkBoardCollision(shape, IDENTITY_TRANSFORM, occupied);
            expect(result).toBe(false);
        });

        it('should detect collision after translation', () => {
            const shape = parseShapeString('oe');
            const occupied = new Set(['5,5', '6,5']);

            const result = checkBoardCollision(
                shape,
                { ...IDENTITY_TRANSFORM, offset: { x: 5, y: 5 } },
                occupied
            );
            expect(result).toBe(true);
        });
    });

    describe('checkBounds', () => {
        it('should return true for shape within bounds', () => {
            const shape = parseShapeString('oe');

            const result = checkBounds(shape, IDENTITY_TRANSFORM, 10, 10);
            expect(result).toBe(true);
        });

        it('should return false for shape outside bounds', () => {
            const shape = parseShapeString('oe');

            const result = checkBounds(
                shape,
                { ...IDENTITY_TRANSFORM, offset: { x: 9, y: 0 } },
                10,
                10
            );
            expect(result).toBe(false);
        });

        it('should return false for negative coordinates', () => {
            const shape = parseShapeString('oe');

            const result = checkBounds(
                shape,
                { ...IDENTITY_TRANSFORM, offset: { x: -1, y: 0 } },
                10,
                10
            );
            expect(result).toBe(false);
        });

        it('should return true for shape at boundary edge', () => {
            const shape = parseShapeString('o');

            const result = checkBounds(
                shape,
                { ...IDENTITY_TRANSFORM, offset: { x: 9, y: 9 } },
                10,
                10
            );
            expect(result).toBe(true);
        });
    });

    describe('validatePlacement', () => {
        it('should return valid for good placement', () => {
            const shape = parseShapeString('oe');
            const occupied = new Set<string>();

            const result = validatePlacement(shape, IDENTITY_TRANSFORM, 10, 10, occupied);
            expect(result).toEqual({ valid: true });
        });

        it('should return invalid for out of bounds', () => {
            const shape = parseShapeString('oe');
            const occupied = new Set<string>();

            const result = validatePlacement(
                shape,
                { ...IDENTITY_TRANSFORM, offset: { x: 9, y: 0 } },
                10,
                10,
                occupied
            );
            expect(result).toEqual({ valid: false, reason: '超出边界' });
        });

        it('should return invalid for collision', () => {
            const shape = parseShapeString('oe');
            const occupied = new Set(['0,0', '1,0']);

            const result = validatePlacement(shape, IDENTITY_TRANSFORM, 10, 10, occupied);
            expect(result).toEqual({ valid: false, reason: '与已有形状重叠' });
        });
    });

    describe('transformShape', () => {
        it('should apply translation correctly', () => {
            const shape = parseShapeString('o');
            const transform = { ...IDENTITY_TRANSFORM, offset: { x: 5, y: 3 } };

            const cells = transformShape(shape, transform);
            expect(cells).toEqual([{ x: 5, y: 3 }]);
        });

        it('should apply 90° rotation correctly', () => {
            const shape = parseShapeString('oe');
            const transform = { ...IDENTITY_TRANSFORM, rotation: 90 };

            const cells = transformShape(shape, transform);
            expect(cells).toEqual([
                { x: 0, y: 0 },
                { x: 0, y: -1 },
            ]);
        });

        it('should apply horizontal flip correctly', () => {
            const shape = parseShapeString('oe');
            const transform = { ...IDENTITY_TRANSFORM, flipX: true };

            const cells = transformShape(shape, transform);
            expect(cells).toEqual([
                { x: 1, y: 0 },
                { x: 0, y: 0 },
            ]);
        });

        it('should apply vertical flip correctly', () => {
            const shape = parseShapeString('os');
            const transform = { ...IDENTITY_TRANSFORM, flipY: true };

            const cells = transformShape(shape, transform);
            expect(cells).toEqual([
                { x: 0, y: 1 },
                { x: 0, y: 0 },
            ]);
        });

        it('should combine rotation and translation', () => {
            const shape = parseShapeString('os');
            const transform = {
                ...IDENTITY_TRANSFORM,
                rotation: 90,
                offset: { x: 10, y: 10 },
            };

            const cells = transformShape(shape, transform);
            expect(cells).toEqual([
                { x: 10, y: 10 },
                { x: 11, y: 10 },
            ]);
        });
    });
});