pacman-contribution-graph 1.0.14 → 2.0.0

package/src/game.ts

@@ -1,231 +0,0 @@
-import { Canvas } from './canvas';
-import { DELTA_TIME, GHOST_NAMES, GRID_HEIGHT, GRID_WIDTH, MONTHS, PACMAN_DEATH_DURATION } from './constants';
-import { GhostsMovement } from './movement/ghosts-movement';
-import { PacmanMovement } from './movement/pacman-movement';
-import { MusicPlayer, Sound } from './music-player';
-import { SVG } from './svg';
-import { StoreType } from './types';
-
-const initializeGrid = (store: StoreType) => {
-	store.pacman.points = 0;
-	store.pacman.totalPoints = 0;
-	store.grid = Array.from({ length: GRID_WIDTH }, () => Array.from({ length: GRID_HEIGHT }, () => ({ commitsCount: 0, intensity: 0 })));
-	store.monthLabels = Array(GRID_WIDTH).fill('');
-	let maxCommits = 1;
-
-	const now = new Date();
-	const startOfCurrentWeek = new Date(now);
-	startOfCurrentWeek.setDate(now.getDate() - now.getDay());
-
-	store.contributions.forEach((contribution) => {
-		const contributionDate = new Date(contribution.date);
-		const dayOfWeek = contributionDate.getDay();
-		const weeksAgo = Math.floor((+startOfCurrentWeek - +contributionDate) / (1000 * 60 * 60 * 24 * 7));
-
-		if (weeksAgo >= 0 && weeksAgo < GRID_WIDTH && dayOfWeek >= 0 && dayOfWeek < GRID_HEIGHT) {
-			store.grid[GRID_WIDTH - 1 - weeksAgo][dayOfWeek] = { commitsCount: contribution.count, intensity: 0 };
-			if (contribution.count > maxCommits) maxCommits = contribution.count;
-		}
-	});
-
-	for (let x = 0; x < GRID_WIDTH; x++) {
-		for (let y = 0; y < GRID_HEIGHT; y++) {
-			if (store.grid[x][y].commitsCount > 0) {
-				store.grid[x][y].intensity = store.grid[x][y].commitsCount / maxCommits;
-			}
-		}
-	}
-
-	for (let x = 0; x < GRID_WIDTH; x++) {
-		const weeksAgo = GRID_WIDTH - 1 - x;
-		const columnDate = new Date(startOfCurrentWeek);
-		columnDate.setDate(columnDate.getDate() - weeksAgo * 7);
-		store.monthLabels[x] = MONTHS[columnDate.getMonth()];
-	}
-};
-
-const placePacman = (store: StoreType) => {
-	store.pacman = {
-		x: 0,
-		y: 0,
-		direction: 'right',
-		points: 0,
-		totalPoints: 0,
-		deadRemainingDuration: 0,
-		powerupRemainingDuration: 0,
-		recentPositions: []
-	};
-	if (store.config.outputFormat == 'canvas') Canvas.drawPacman(store);
-};
-
-const placeGhosts = (store: StoreType) => {
-	store.ghosts = [];
-	// Center gjosts in mid grid
-	store.ghosts.push({ x: 23, y: 3, name: GHOST_NAMES[0], scared: false, target: undefined });
-	store.ghosts.push({ x: 24, y: 3, name: GHOST_NAMES[1], scared: false, target: undefined });
-	store.ghosts.push({ x: 27, y: 3, name: GHOST_NAMES[2], scared: false, target: undefined });
-	store.ghosts.push({ x: 28, y: 3, name: GHOST_NAMES[3], scared: false, target: undefined });
-	if (store.config.outputFormat == 'canvas') Canvas.drawGhosts(store);
-};
-
-const stopGame = async (store: StoreType) => {
-	clearInterval(store.gameInterval);
-};
-
-const startGame = async (store: StoreType) => {
-	if (store.config.outputFormat == 'canvas') {
-		store.config.canvas = store.config.canvas;
-		Canvas.resizeCanvas(store);
-		Canvas.listenToSoundController(store);
-	}
-
-	store.frameCount = 0;
-	store.ghosts.forEach((ghost) => (ghost.scared = false));
-
-	initializeGrid(store);
-	if (store.config.outputFormat == 'canvas') Canvas.drawGrid(store);
-
-	if (store.config.outputFormat == 'canvas') {
-		if (!store.config.enableSounds) {
-			MusicPlayer.getInstance().mute();
-		}
-		await MusicPlayer.getInstance().preloadSounds();
-		MusicPlayer.getInstance().startDefaultSound();
-		await MusicPlayer.getInstance().play(Sound.BEGINNING);
-	}
-
-	const remainingCells = () => store.grid.some((row) => row.some((cell) => cell.intensity > 0));
-	if (remainingCells()) {
-		placePacman(store);
-		placeGhosts(store);
-	}
-
-	if (store.config.outputFormat == 'svg') {
-		while (remainingCells()) {
-			await updateGame(store);
-		}
-		// One more time to generate svg
-		await updateGame(store);
-	} else {
-		clearInterval(store.gameInterval);
-		store.gameInterval = setInterval(async () => await updateGame(store), DELTA_TIME);
-	}
-};
-
-const updateGame = async (store: StoreType) => {
-	store.frameCount++;
-	if (store.frameCount % store.config.gameSpeed !== 0) {
-		store.gameHistory.push({
-			pacman: { ...store.pacman },
-			ghosts: store.ghosts.map((ghost) => ({ ...ghost })),
-			grid: store.grid.map((row) => [...row.map((col) => col.intensity)])
-		});
-		return;
-	}
-
-	if (store.pacman.deadRemainingDuration) {
-		store.pacman.deadRemainingDuration--;
-		if (!store.pacman.deadRemainingDuration) {
-			// IT'S ALIVE!
-			placeGhosts(store);
-			if (store.config.outputFormat == 'canvas')
-				MusicPlayer.getInstance()
-					.play(Sound.GAME_OVER)
-					.then(() => MusicPlayer.getInstance().startDefaultSound());
-		}
-	}
-
-	if (store.pacman.powerupRemainingDuration) {
-		store.pacman.powerupRemainingDuration--;
-		if (!store.pacman.powerupRemainingDuration) {
-			store.ghosts.forEach((ghost) => (ghost.scared = false));
-			store.pacman.points = 0;
-		}
-	}
-
-	const remainingCells = store.grid.some((row) => row.some((cell) => cell.intensity > 0));
-	if (!remainingCells) {
-		if (store.config.outputFormat == 'canvas') {
-			clearInterval(store.gameInterval);
-			if (store.config.outputFormat == 'canvas') {
-				Canvas.renderGameOver(store);
-				MusicPlayer.getInstance()
-					.play(Sound.BEGINNING)
-					.then(() => MusicPlayer.getInstance().stopDefaultSound());
-			}
-		}
-
-		if (store.config.outputFormat == 'svg') {
-			const animatedSVG = SVG.generateAnimatedSVG(store);
-			store.config.svgCallback(animatedSVG);
-		}
-
-		store.config.gameOverCallback();
-		return;
-	}
-
-	PacmanMovement.movePacman(store);
-	checkCollisions(store);
-	if (!store.pacman.deadRemainingDuration) {
-		GhostsMovement.moveGhosts(store);
-		checkCollisions(store);
-	}
-
-	store.pacmanMouthOpen = !store.pacmanMouthOpen;
-
-	store.gameHistory.push({
-		pacman: { ...store.pacman },
-		ghosts: store.ghosts.map((ghost) => ({ ...ghost })),
-		grid: store.grid.map((row) => [...row.map((col) => col.intensity)])
-	});
-
-	if (store.config.outputFormat == 'canvas') Canvas.drawGrid(store);
-	if (store.config.outputFormat == 'canvas') Canvas.drawPacman(store);
-	if (store.config.outputFormat == 'canvas') Canvas.drawGhosts(store);
-	if (store.config.outputFormat == 'canvas') Canvas.drawSoundController(store);
-};
-
-const checkCollisions = (store: StoreType) => {
-	if (store.pacman.deadRemainingDuration) return;
-
-	store.ghosts.forEach((ghost, index) => {
-		if (ghost.x === store.pacman.x && ghost.y === store.pacman.y) {
-			if (store.pacman.powerupRemainingDuration && ghost.scared) {
-				respawnGhost(store, index);
-				store.pacman.points += 10;
-				if (store.config.outputFormat == 'canvas') {
-					MusicPlayer.getInstance().play(Sound.EAT_GHOST);
-				}
-			} else {
-				store.pacman.points = 0;
-				store.pacman.powerupRemainingDuration = 0;
-				store.pacman.deadRemainingDuration = PACMAN_DEATH_DURATION;
-				if (store.config.outputFormat == 'canvas') {
-					MusicPlayer.getInstance()
-						.play(Sound.GAME_OVER)
-						.then(() => MusicPlayer.getInstance().stopDefaultSound());
-				}
-			}
-		}
-	});
-};
-
-const respawnGhost = (store: StoreType, ghostIndex: number) => {
-	let x, y;
-	do {
-		x = Math.floor(Math.random() * GRID_WIDTH);
-		y = Math.floor(Math.random() * GRID_HEIGHT);
-	} while ((Math.abs(x - store.pacman.x) <= 2 && Math.abs(y - store.pacman.y) <= 2) || store.grid[x][y].intensity === 0);
-	store.ghosts[ghostIndex] = {
-		x,
-		y,
-		name: GHOST_NAMES[ghostIndex % GHOST_NAMES.length],
-		scared: false,
-		target: undefined
-	};
-};
-
-export const Game = {
-	startGame,
-	stopGame
-};

package/src/grid.ts

@@ -1,127 +0,0 @@
-import { GRID_HEIGHT, GRID_WIDTH, setWall } from './constants';
-
-const setSymmetricWall = (x: number, y: number, direction: 'horizontal' | 'vertical', sym: '' | 'x' | 'y' | 'xy', lineId: string) => {
-	if (direction == 'horizontal') {
-		setWall(x, y, 'horizontal', lineId);
-		if (sym == 'x') {
-			setWall(GRID_WIDTH - x - 1, y, 'horizontal', lineId);
-		} else if (sym == 'y') {
-			setWall(x, GRID_HEIGHT - y, 'horizontal', lineId);
-		} else if (sym == 'xy') {
-			setWall(GRID_WIDTH - x - 1, y, 'horizontal', lineId);
-			setWall(x, GRID_HEIGHT - y, 'horizontal', lineId);
-			setWall(GRID_WIDTH - x - 1, GRID_HEIGHT - y, 'horizontal', lineId);
-		}
-	} else {
-		setWall(x, y, 'vertical', lineId);
-		if (sym == 'x') {
-			setWall(GRID_WIDTH - x, y, 'vertical', lineId);
-		} else if (sym == 'y') {
-			setWall(x, GRID_HEIGHT - y - 1, 'vertical', lineId);
-		} else if (sym == 'xy') {
-			setWall(GRID_WIDTH - x, y, 'vertical', lineId);
-			setWall(x, GRID_HEIGHT - y - 1, 'vertical', lineId);
-			setWall(GRID_WIDTH - x, GRID_HEIGHT - y - 1, 'vertical', lineId);
-		}
-	}
-};
-
-const buildWalls = () => {
-	// Left and right wings
-	// L1
-	setSymmetricWall(0, 2, 'horizontal', 'xy', 'L1');
-	setSymmetricWall(1, 2, 'horizontal', 'xy', 'L1');
-	// L2
-	setSymmetricWall(4, 0, 'vertical', 'x', 'L2');
-	setSymmetricWall(4, 1, 'vertical', 'x', 'L2');
-	setSymmetricWall(4, 2, 'vertical', 'x', 'L2');
-	setSymmetricWall(4, 3, 'vertical', 'x', 'L2');
-	setSymmetricWall(4, 4, 'vertical', 'x', 'L2');
-	// L3
-	setSymmetricWall(3, 3, 'horizontal', 'x', 'L3');
-	setSymmetricWall(2, 3, 'horizontal', 'x', 'L3');
-	// L4
-	setSymmetricWall(4, 5, 'horizontal', 'x', 'L4');
-	// L5
-	setSymmetricWall(6, 4, 'vertical', 'x', 'L5');
-	setSymmetricWall(6, 3, 'vertical', 'x', 'L5');
-	setSymmetricWall(6, 2, 'vertical', 'x', 'L5');
-	// L6
-	setSymmetricWall(6, 2, 'horizontal', 'x', 'L6');
-	setSymmetricWall(7, 2, 'horizontal', 'x', 'L6');
-	setSymmetricWall(8, 2, 'horizontal', 'x', 'L6');
-	setSymmetricWall(9, 2, 'horizontal', 'x', 'L6');
-	// L7
-	setSymmetricWall(13, 2, 'horizontal', 'xy', 'L7');
-	setSymmetricWall(14, 2, 'horizontal', 'xy', 'L7');
-	setSymmetricWall(15, 2, 'horizontal', 'xy', 'L7');
-	setSymmetricWall(16, 2, 'horizontal', 'xy', 'L7');
-	setSymmetricWall(17, 2, 'horizontal', 'xy', 'L7');
-	setSymmetricWall(18, 2, 'horizontal', 'xy', 'L7');
-	// L8
-	setSymmetricWall(16, 2, 'vertical', 'xy', 'L8');
-	// L9
-	setSymmetricWall(8, 1, 'horizontal', 'x', 'L9');
-	setSymmetricWall(9, 1, 'horizontal', 'x', 'L9');
-	setSymmetricWall(10, 1, 'horizontal', 'x', 'L9');
-	setSymmetricWall(11, 1, 'horizontal', 'x', 'L9');
-	// L10
-	setSymmetricWall(12, 1, 'vertical', 'x', 'L10');
-	setSymmetricWall(12, 3, 'vertical', 'x', 'L10');
-	// L11
-	setSymmetricWall(11, 4, 'horizontal', 'x', 'L11');
-	setSymmetricWall(10, 4, 'horizontal', 'x', 'L11');
-	setSymmetricWall(9, 4, 'horizontal', 'x', 'L11');
-	setSymmetricWall(8, 4, 'horizontal', 'x', 'L11');
-	// L12
-	setSymmetricWall(8, 4, 'vertical', 'x', 'L12');
-	setSymmetricWall(8, 5, 'vertical', 'x', 'L12');
-	setSymmetricWall(8, 6, 'vertical', 'x', 'L12');
-	// L13
-	setSymmetricWall(23, 2, 'horizontal', 'x', 'L13');
-	setSymmetricWall(24, 2, 'horizontal', 'x', 'L13');
-	setSymmetricWall(23, 4, 'horizontal', 'x', 'L13');
-	setSymmetricWall(24, 4, 'horizontal', 'x', 'L13');
-	setSymmetricWall(25, 4, 'horizontal', 'x', 'L13');
-	// L14
-	setSymmetricWall(23, 2, 'vertical', 'x', 'L14');
-	setSymmetricWall(23, 3, 'vertical', 'x', 'L14');
-	// L15
-	setSymmetricWall(26, 4, 'vertical', 'x', 'L15');
-	setSymmetricWall(26, 5, 'vertical', 'x', 'L15');
-	// L16
-	setSymmetricWall(23, 6, 'horizontal', 'x', 'L16');
-	setSymmetricWall(24, 6, 'horizontal', 'x', 'L16');
-	setSymmetricWall(25, 6, 'horizontal', 'x', 'L16');
-	// L17
-	setSymmetricWall(26, 0, 'vertical', 'x', 'L17');
-	// L18
-	setSymmetricWall(24, 1, 'vertical', 'x', 'L18');
-	setSymmetricWall(23, 1, 'horizontal', 'x', 'L18');
-	setSymmetricWall(22, 1, 'horizontal', 'x', 'L18');
-	setSymmetricWall(21, 1, 'horizontal', 'x', 'L18');
-	setSymmetricWall(21, 1, 'vertical', 'x', 'L18');
-	setSymmetricWall(21, 2, 'vertical', 'x', 'L18');
-	setSymmetricWall(21, 3, 'vertical', 'x', 'L18');
-	setSymmetricWall(20, 4, 'horizontal', 'x', 'L18');
-	setSymmetricWall(19, 4, 'horizontal', 'x', 'L18');
-	setSymmetricWall(19, 3, 'vertical', 'x', 'L18');
-	setSymmetricWall(18, 3, 'horizontal', 'x', 'L18');
-	// L19
-	setSymmetricWall(22, 5, 'vertical', 'x', 'L19');
-	setSymmetricWall(21, 5, 'horizontal', 'x', 'L19');
-	setSymmetricWall(20, 5, 'horizontal', 'x', 'L19');
-	setSymmetricWall(20, 5, 'vertical', 'x', 'L19');
-	// L20
-	setSymmetricWall(1, 6, 'horizontal', 'x', 'L20');
-	setSymmetricWall(2, 6, 'horizontal', 'x', 'L20');
-	setSymmetricWall(3, 5, 'vertical', 'x', 'L20');
-	setSymmetricWall(3, 4, 'vertical', 'x', 'L20');
-	// L21
-	setSymmetricWall(5, 6, 'horizontal', 'x', 'L21');
-	setSymmetricWall(6, 6, 'horizontal', 'x', 'L21');
-};
-
-export const Grid = {
-	buildWalls
-};

package/src/index.ts

@@ -1,48 +0,0 @@
-import { Game } from './game';
-import { Grid } from './grid';
-import { Store } from './store';
-import { Config, StoreType } from './types';
-import { Utils } from './utils';
-
-export class PacmanRenderer {
-	store: StoreType;
-	conf: Config;
-
-	constructor(conf: Config) {
-		this.store = structuredClone(Store);
-		this.conf = { ...conf };
-		Grid.buildWalls();
-	}
-
-	public async start() {
-		const defaultConfing: Config = {
-			platform: 'github',
-			username: '',
-			canvas: undefined as unknown as HTMLCanvasElement,
-			outputFormat: 'svg',
-			svgCallback: (_: string) => {},
-			gameOverCallback: () => () => {},
-			gameTheme: 'github',
-			gameSpeed: 1,
-			enableSounds: false,
-			pointsIncreasedCallback: (_: number) => {}
-		};
-		this.store.config = { ...defaultConfing, ...this.conf };
-
-		switch (this.conf.platform) {
-			case 'gitlab':
-				this.store.contributions = await Utils.getGitlabContribution(this.store);
-				break;
-
-			case 'github':
-				this.store.contributions = await Utils.getGithubContribution(this.store);
-				break;
-		}
-
-		Game.startGame(this.store);
-	}
-
-	public stop() {
-		Game.stopGame(this.store);
-	}
-}

package/src/movement/ghosts-movement.ts

@@ -1,183 +0,0 @@
-import { GRID_HEIGHT, GRID_WIDTH } from '../constants';
-import { Ghost, Point2d, StoreType } from '../types';
-import { MovementUtils } from './movement-utils';
-
-const moveGhosts = (store: StoreType) => {
-	store.ghosts.forEach((ghost) => {
-		if (ghost.scared || Math.random() < 0.15) {
-			moveScaredGhost(ghost, store);
-		} else {
-			moveGhostWithPersonality(ghost, store);
-		}
-	});
-};
-
-// When scared, ghosts move randomly but with some intelligence
-const moveScaredGhost = (ghost: Ghost, store: StoreType) => {
-	if (!ghost.target || (ghost.x === ghost.target.x && ghost.y === ghost.target.y)) {
-		ghost.target = getRandomDestination(ghost.x, ghost.y);
-	}
-
-	const validMoves = MovementUtils.getValidMoves(ghost.x, ghost.y);
-	if (validMoves.length === 0) return;
-
-	// Move toward target but with some randomness to appear "scared"
-	const dx = ghost.target.x - ghost.x;
-	const dy = ghost.target.y - ghost.y;
-
-	// Filter moves that generally go toward the target
-	let possibleMoves = validMoves.filter((move) => {
-		const moveX = move[0];
-		const moveY = move[1];
-		return (dx > 0 && moveX > 0) || (dx < 0 && moveX < 0) || (dy > 0 && moveY > 0) || (dy < 0 && moveY < 0);
-	});
-
-	// If no valid moves toward target, use any valid move
-	if (possibleMoves.length === 0) {
-		possibleMoves = validMoves;
-	}
-
-	// Choose a random move from the possible moves
-	const [moveX, moveY] = possibleMoves[Math.floor(Math.random() * possibleMoves.length)];
-
-	// If Pacman has power-up, ghosts move slower
-	if (store.pacman.powerupRemainingDuration && Math.random() < 0.5) return;
-
-	ghost.x += moveX;
-	ghost.y += moveY;
-};
-
-// Move ghost according to its personality
-const moveGhostWithPersonality = (ghost: Ghost, store: StoreType) => {
-	const target = calculateGhostTarget(ghost, store);
-	ghost.target = target;
-
-	const nextMove = BFSTargetLocation(ghost.x, ghost.y, target.x, target.y);
-	if (nextMove) {
-		ghost.x = nextMove.x;
-		ghost.y = nextMove.y;
-	}
-};
-
-// Find the next position to move to using BFS
-const BFSTargetLocation = (startX: number, startY: number, targetX: number, targetY: number): Point2d | null => {
-	// If we're already at the target, no need to move
-	if (startX === targetX && startY === targetY) return null;
-
-	const queue: { x: number; y: number; path: Point2d[] }[] = [{ x: startX, y: startY, path: [] }];
-	const visited = new Set<string>();
-	visited.add(`${startX},${startY}`);
-
-	while (queue.length > 0) {
-		const current = queue.shift()!;
-		const { x, y, path } = current;
-
-		const validMoves = MovementUtils.getValidMoves(x, y);
-
-		for (const [dx, dy] of validMoves) {
-			const newX = x + dx;
-			const newY = y + dy;
-			const key = `${newX},${newY}`;
-
-			if (visited.has(key)) continue;
-			visited.add(key);
-
-			const newPath = [...path, { x: newX, y: newY }];
-
-			if (newX === targetX && newY === targetY) {
-				return newPath.length > 0 ? newPath[0] : null;
-			}
-
-			queue.push({ x: newX, y: newY, path: newPath });
-		}
-	}
-
-	// If no path found, no need to move
-	return null;
-};
-
-// Calculate ghost target based on personality
-const calculateGhostTarget = (ghost: Ghost, store: StoreType): Point2d => {
-	const { pacman } = store;
-	let pacDirection = [0, 0];
-	switch (ghost.name) {
-		case 'blinky': // Red ghost - directly targets Pacman
-			return { x: pacman.x, y: pacman.y };
-
-		case 'pinky': // Pink ghost - targets 4 spaces ahead of Pacman
-			pacDirection = getPacmanDirection(store);
-
-			const lookAhead = 4;
-			let fourAhead = {
-				x: pacman.x + pacDirection[0] * lookAhead,
-				y: pacman.y + pacDirection[1] * lookAhead
-			};
-
-			fourAhead.x = Math.min(Math.max(fourAhead.x, 0), GRID_WIDTH - 1);
-			fourAhead.y = Math.min(Math.max(fourAhead.y, 0), GRID_HEIGHT - 1);
-			return fourAhead;
-
-		case 'inky': // Blue ghost - complex targeting based on Blinky's position
-			const blinky = store.ghosts.find((g) => g.name === 'blinky');
-			pacDirection = getPacmanDirection(store);
-
-			// Target is 2 spaces ahead of Pacman
-			let twoAhead = {
-				x: pacman.x + pacDirection[0] * 2,
-				y: pacman.y + pacDirection[1] * 2
-			};
-
-			// Then double the vector from Blinky to that position
-			if (blinky) {
-				twoAhead = {
-					x: twoAhead.x + (twoAhead.x - blinky.x),
-					y: twoAhead.y + (twoAhead.y - blinky.y)
-				};
-			}
-			twoAhead.x = Math.min(Math.max(twoAhead.x, 0), GRID_WIDTH - 1);
-			twoAhead.y = Math.min(Math.max(twoAhead.y, 0), GRID_HEIGHT - 1);
-			return twoAhead;
-
-		case 'clyde': // Orange ghost - targets Pacman when far, runs away when close
-			const distanceToPacman = MovementUtils.calculateDistance(ghost.x, ghost.y, pacman.x, pacman.y);
-			if (distanceToPacman > 8) {
-				return { x: pacman.x, y: pacman.y };
-			} else {
-				return { x: 0, y: GRID_HEIGHT - 1 };
-			}
-
-		default:
-			// Default behavior targets Pacman directly
-			return { x: pacman.x, y: pacman.y };
-	}
-};
-
-const getPacmanDirection = (store: StoreType): [number, number] => {
-	switch (store.pacman.direction) {
-		case 'right':
-			return [1, 0];
-		case 'left':
-			return [-1, 0];
-		case 'up':
-			return [0, -1];
-		case 'down':
-			return [0, 1];
-		default:
-			return [0, 0];
-	}
-};
-
-// Get a random destination for scared ghosts
-const getRandomDestination = (x: number, y: number) => {
-	const maxDistance = 8;
-	const randomX = x + Math.floor(Math.random() * (2 * maxDistance + 1)) - maxDistance;
-	const randomY = y + Math.floor(Math.random() * (2 * maxDistance + 1)) - maxDistance;
-	return {
-		x: Math.max(0, Math.min(randomX, GRID_WIDTH - 1)),
-		y: Math.max(0, Math.min(randomY, GRID_HEIGHT - 1))
-	};
-};
-
-export const GhostsMovement = {
-	moveGhosts
-};

package/src/movement/movement-utils.ts

@@ -1,40 +0,0 @@
-import { GRID_HEIGHT, GRID_WIDTH, WALLS } from '../constants';
-
-// Check for walls and grid edges
-const getValidMoves = (x: number, y: number): [number, number][] => {
-	const directions: [number, number][] = [
-		[-1, 0], // left
-		[1, 0], // right
-		[0, -1], // up
-		[0, 1] // down
-	];
-	return directions.filter(([dx, dy]) => {
-		const newX = x + dx;
-		const newY = y + dy;
-
-		if (newX < 0 || newX >= GRID_WIDTH || newY < 0 || newY >= GRID_HEIGHT) {
-			return false;
-		}
-
-		if (dx === -1) {
-			return !WALLS.vertical[x][y].active;
-		} else if (dx === 1) {
-			return !WALLS.vertical[x + 1][y].active;
-		} else if (dy === -1) {
-			return !WALLS.horizontal[x][y].active;
-		} else if (dy === 1) {
-			return !WALLS.horizontal[x][y + 1].active;
-		}
-
-		return true;
-	});
-};
-
-const calculateDistance = (x1: number, y1: number, x2: number, y2: number): number => {
-	return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
-};
-
-export const MovementUtils = {
-	getValidMoves,
-	calculateDistance
-};