pacman-contribution-graph 1.0.14 → 2.0.0

package/src/movement/pacman-movement.ts

@@ -1,230 +0,0 @@
-import { GRID_HEIGHT, GRID_WIDTH, PACMAN_POWERUP_DURATION } from '../constants';
-import { Point2d, StoreType } from '../types';
-import { MovementUtils } from './movement-utils';
-
-const RECENT_POSITIONS_LIMIT = 5;
-
-const movePacman = (store: StoreType) => {
-	if (store.pacman.deadRemainingDuration) {
-		return;
-	}
-
-	const hasPowerup = !!store.pacman.powerupRemainingDuration;
-	const scaredGhosts = store.ghosts.filter((ghost) => ghost.scared);
-
-	let targetPosition: Point2d;
-
-	if (hasPowerup && scaredGhosts.length > 0) {
-		const ghostPosition = findClosestScaredGhost(store);
-		if (ghostPosition) {
-			targetPosition = ghostPosition;
-		} else {
-			targetPosition = findOptimalTarget(store);
-		}
-	} else if (store.pacman.target) {
-		if (store.pacman.target.x == store.pacman.x && store.pacman.target.y == store.pacman.y) {
-			targetPosition = findOptimalTarget(store);
-			store.pacman.target = { x: targetPosition?.x, y: targetPosition?.y };
-		} else {
-			targetPosition = store.pacman.target;
-		}
-	} else {
-		targetPosition = findOptimalTarget(store);
-		store.pacman.target = { x: targetPosition?.x, y: targetPosition?.y };
-	}
-
-	const nextPosition = calculateOptimalPath(store, targetPosition);
-
-	if (nextPosition) {
-		updatePacmanPosition(store, nextPosition);
-	} else {
-		makeDesperationMove(store);
-	}
-
-	checkAndEatPoint(store);
-};
-
-const findClosestScaredGhost = (store: StoreType) => {
-	const scaredGhosts = store.ghosts.filter((ghost) => ghost.scared);
-
-	if (scaredGhosts.length === 0) return null;
-
-	return scaredGhosts.reduce(
-		(closest, ghost) => {
-			const distance = MovementUtils.calculateDistance(ghost.x, ghost.y, store.pacman.x, store.pacman.y);
-			return distance < closest.distance ? { x: ghost.x, y: ghost.y, distance } : closest;
-		},
-		{ x: store.pacman.x, y: store.pacman.y, distance: Infinity }
-	);
-};
-
-const findOptimalTarget = (store: StoreType) => {
-	let pointCells: { x: number; y: number; value: number }[] = [];
-
-	for (let x = 0; x < GRID_WIDTH; x++) {
-		for (let y = 0; y < GRID_HEIGHT; y++) {
-			if (store.grid[x][y].intensity > 0) {
-				const distance = MovementUtils.calculateDistance(x, y, store.pacman.x, store.pacman.y);
-				const value = store.grid[x][y].intensity / (distance + 1);
-				pointCells.push({ x, y, value });
-			}
-		}
-	}
-
-	pointCells.sort((a, b) => b.value - a.value);
-	return pointCells[0];
-};
-
-const calculateOptimalPath = (store: StoreType, target: Point2d) => {
-	const queue: { x: number; y: number; path: Point2d[]; score: number }[] = [
-		{ x: store.pacman.x, y: store.pacman.y, path: [], score: 0 }
-	];
-	const visited = new Set<string>();
-	visited.add(`${store.pacman.x},${store.pacman.y}`);
-
-	const dangerMap = createDangerMap(store);
-
-	while (queue.length > 0) {
-		queue.sort((a, b) => b.score - a.score);
-		const current = queue.shift()!;
-		const { x, y, path } = current;
-
-		if (x === target.x && y === target.y) {
-			return path.length > 0 ? path[0] : null;
-		}
-
-		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)) {
-				const newPath = [...path, { x: newX, y: newY }];
-				const danger = dangerMap.get(key) || 0;
-				const pointValue = store.grid[newX][newY].intensity;
-				const distanceToTarget = MovementUtils.calculateDistance(newX, newY, target.x, target.y);
-
-				let revisitPenalty = 0;
-				if (store.pacman.recentPositions?.includes(key)) {
-					revisitPenalty += 100; // Penalize recently visited positions
-				}
-
-				queue.push({
-					x: newX,
-					y: newY,
-					path: newPath,
-					score: pointValue - danger - distanceToTarget / 10 - revisitPenalty
-				});
-				visited.add(key);
-			}
-		}
-	}
-
-	return null;
-};
-
-const createDangerMap = (store: StoreType) => {
-	const dangerMap = new Map<string, number>();
-	const hasPowerup = !!store.pacman.powerupRemainingDuration;
-
-	store.ghosts.forEach((ghost) => {
-		if (ghost.scared) return;
-
-		for (let dx = -5; dx <= 5; dx++) {
-			for (let dy = -5; dy <= 5; dy++) {
-				const x = ghost.x + dx;
-				const y = ghost.y + dy;
-
-				if (x >= 0 && x < GRID_WIDTH && y >= 0 && y < GRID_HEIGHT) {
-					const key = `${x},${y}`;
-					const distance = Math.abs(dx) + Math.abs(dy);
-					const dangerValue = 15 - distance;
-
-					if (dangerValue > 0) {
-						const currentDanger = dangerMap.get(key) || 0;
-						dangerMap.set(key, Math.max(currentDanger, dangerValue));
-					}
-				}
-			}
-		}
-	});
-
-	if (hasPowerup) {
-		for (const [key, value] of dangerMap.entries()) {
-			dangerMap.set(key, value / 5);
-		}
-	}
-
-	return dangerMap;
-};
-
-const makeDesperationMove = (store: StoreType) => {
-	const validMoves = MovementUtils.getValidMoves(store.pacman.x, store.pacman.y);
-
-	if (validMoves.length === 0) return;
-
-	const safestMove = validMoves.reduce(
-		(safest, [dx, dy]) => {
-			const newX = store.pacman.x + dx;
-			const newY = store.pacman.y + dy;
-
-			let minGhostDistance = Infinity;
-
-			store.ghosts.forEach((ghost) => {
-				if (!ghost.scared) {
-					const distance = MovementUtils.calculateDistance(ghost.x, ghost.y, newX, newY);
-					minGhostDistance = Math.min(minGhostDistance, distance);
-				}
-			});
-
-			return minGhostDistance > safest.distance ? { dx, dy, distance: minGhostDistance } : safest;
-		},
-		{ dx: 0, dy: 0, distance: -Infinity }
-	);
-
-	const newX = store.pacman.x + safestMove.dx;
-	const newY = store.pacman.y + safestMove.dy;
-
-	updatePacmanPosition(store, { x: newX, y: newY });
-};
-
-const updatePacmanPosition = (store: StoreType, position: Point2d) => {
-	store.pacman.recentPositions ||= [];
-	store.pacman.recentPositions.push(`${position.x},${position.y}`);
-	if (store.pacman.recentPositions.length > RECENT_POSITIONS_LIMIT) {
-		store.pacman.recentPositions.shift();
-	}
-
-	const dx = position.x - store.pacman.x;
-	const dy = position.y - store.pacman.y;
-
-	if (dx > 0) store.pacman.direction = 'right';
-	else if (dx < 0) store.pacman.direction = 'left';
-	else if (dy > 0) store.pacman.direction = 'down';
-	else if (dy < 0) store.pacman.direction = 'up';
-
-	store.pacman.x = position.x;
-	store.pacman.y = position.y;
-};
-
-const checkAndEatPoint = (store: StoreType) => {
-	if (store.grid[store.pacman.x][store.pacman.y].intensity > 0) {
-		store.pacman.totalPoints += store.grid[store.pacman.x][store.pacman.y].commitsCount;
-		store.pacman.points++;
-		store.config.pointsIncreasedCallback(store.pacman.totalPoints);
-		store.grid[store.pacman.x][store.pacman.y].intensity = 0;
-
-		if (store.pacman.points >= 10) activatePowerUp(store);
-	}
-};
-
-const activatePowerUp = (store: StoreType) => {
-	store.pacman.powerupRemainingDuration = PACMAN_POWERUP_DURATION;
-	store.ghosts.forEach((ghost) => (ghost.scared = true));
-};
-
-export const PacmanMovement = {
-	movePacman
-};

package/src/music-player.ts

@@ -1,119 +0,0 @@
-export enum Sound {
-	DEFAULT = 'https://cdn.jsdelivr.net/npm/pacman-contribution-graph/src/assets/sounds/pacman_chomp.wav',
-	BEGINNING = 'https://cdn.jsdelivr.net/npm/pacman-contribution-graph/src/assets/sounds/pacman_beginning.wav',
-	GAME_OVER = 'https://cdn.jsdelivr.net/npm/pacman-contribution-graph/src/assets/sounds/pacman_death.wav',
-	EAT_GHOST = 'https://cdn.jsdelivr.net/npm/pacman-contribution-graph/src/assets/sounds/pacman_eatghost.wav'
-}
-
-export class MusicPlayer {
-	private static instance: MusicPlayer;
-	private audioContext: AudioContext;
-	private sounds: Map<Sound, AudioBuffer> = new Map();
-	private currentSource: AudioBufferSourceNode | null = null;
-	private defaultSource: AudioBufferSourceNode | null = null;
-	public isMuted: boolean = false;
-
-	private constructor() {
-		this.audioContext = new AudioContext();
-	}
-
-	public static getInstance(): MusicPlayer {
-		if (!MusicPlayer.instance) {
-			MusicPlayer.instance = new MusicPlayer();
-		}
-		return MusicPlayer.instance;
-	}
-
-	public async preloadSounds(): Promise<void> {
-		for (const sound of Object.values(Sound)) {
-			const response = await fetch(sound);
-			const arrayBuffer = await response.arrayBuffer();
-			const audioBuffer = await this.audioContext.decodeAudioData(arrayBuffer);
-			this.sounds.set(sound as Sound, audioBuffer);
-		}
-	}
-
-	public async play(sound: Sound): Promise<void> {
-		if (this.isMuted) {
-			return;
-		}
-		if (this.currentSource) {
-			try {
-				this.currentSource.stop();
-			} catch (ex) {}
-		}
-
-		const buffer = this.sounds.get(sound);
-		if (!buffer) {
-			console.error(`Sound ${sound} not found`);
-			return;
-		}
-
-		this.currentSource = this.audioContext.createBufferSource();
-		this.currentSource.buffer = buffer;
-		this.currentSource.connect(this.audioContext.destination);
-
-		if (!this.isMuted) {
-			this.currentSource.start();
-		}
-
-		return new Promise((resolve) => {
-			this.currentSource!.onended = () => {
-				this.currentSource = null;
-				resolve();
-			};
-		});
-	}
-
-	public startDefaultSound(): void {
-		if (this.defaultSource) {
-			try {
-				this.defaultSource.stop();
-			} catch (ex) {}
-		}
-
-		const buffer = this.sounds.get(Sound.DEFAULT);
-		if (!buffer) {
-			console.error('Default sound not found');
-			return;
-		}
-
-		this.defaultSource = this.audioContext.createBufferSource();
-		this.defaultSource.buffer = buffer;
-		this.defaultSource.loop = true;
-		this.defaultSource.connect(this.audioContext.destination);
-
-		if (!this.isMuted) {
-			this.defaultSource.start();
-		}
-	}
-
-	public stopDefaultSound(): void {
-		if (this.defaultSource) {
-			try {
-				this.defaultSource.stop();
-			} catch (ex) {}
-			this.defaultSource = null;
-		}
-	}
-
-	public mute(): void {
-		this.isMuted = true;
-		if (this.currentSource) {
-			this.currentSource.disconnect();
-		}
-		if (this.defaultSource) {
-			this.defaultSource.disconnect();
-		}
-	}
-
-	public unmute(): void {
-		this.isMuted = false;
-		if (this.currentSource) {
-			this.currentSource.connect(this.audioContext.destination);
-		}
-		if (this.defaultSource) {
-			this.defaultSource.connect(this.audioContext.destination);
-		}
-	}
-}

package/src/store.ts

@@ -1,23 +0,0 @@
-import type { Config, StoreType } from './types';
-
-export const Store: StoreType = {
-	frameCount: 0,
-	contributions: [],
-	pacman: {
-		x: 0,
-		y: 0,
-		direction: 'right',
-		points: 0,
-		totalPoints: 0,
-		deadRemainingDuration: 0,
-		powerupRemainingDuration: 0,
-		recentPositions: []
-	},
-	ghosts: [],
-	grid: [],
-	monthLabels: [],
-	pacmanMouthOpen: true,
-	gameInterval: 0,
-	gameHistory: [],
-	config: undefined as unknown as Config
-};

package/src/svg.ts

@@ -1,254 +0,0 @@
-import {
-	CELL_SIZE,
-	DELTA_TIME,
-	GAP_SIZE,
-	GHOSTS,
-	GRID_HEIGHT,
-	GRID_WIDTH,
-	PACMAN_COLOR,
-	PACMAN_COLOR_DEAD,
-	PACMAN_COLOR_POWERUP,
-	WALLS
-} from './constants';
-import { AnimationData, StoreType } from './types';
-import { Utils } from './utils';
-
-const generateAnimatedSVG = (store: StoreType) => {
-	const svgWidth = GRID_WIDTH * (CELL_SIZE + GAP_SIZE);
-	const svgHeight = GRID_HEIGHT * (CELL_SIZE + GAP_SIZE) + 20;
-	let svg = `<svg width="${svgWidth}" height="${svgHeight}" xmlns="http://www.w3.org/2000/svg">`;
-	svg += `<desc>Generated with https://github.com/abozanona/pacman-contribution-graph on ${new Date()}</desc>`;
-	svg += `<rect width="100%" height="100%" fill="${Utils.getCurrentTheme(store).gridBackground}"/>`;
-
-	svg += generateGhostsPredefinition();
-
-	// Month labels
-	let lastMonth = '';
-	for (let y = 0; y < GRID_WIDTH; y++) {
-		if (store.monthLabels[y] !== lastMonth) {
-			const xPos = y * (CELL_SIZE + GAP_SIZE) + CELL_SIZE / 2;
-			svg += `<text x="${xPos}" y="10" text-anchor="middle" font-size="10" fill="${Utils.getCurrentTheme(store).textColor}">${store.monthLabels[y]}</text>`;
-			lastMonth = store.monthLabels[y];
-		}
-	}
-
-	// Grid
-	for (let x = 0; x < GRID_WIDTH; x++) {
-		for (let y = 0; y < GRID_HEIGHT; y++) {
-			const cellX = x * (CELL_SIZE + GAP_SIZE);
-			const cellY = y * (CELL_SIZE + GAP_SIZE) + 15;
-			const cellColorAnimation = generateChangingValuesAnimation(store, generateCellColorValues(store, x, y));
-			svg += `<rect id="c-${x}-${y}" x="${cellX}" y="${cellY}" width="${CELL_SIZE}" height="${CELL_SIZE}" rx="5" fill="${Utils.getCurrentTheme(store).emptyContributionBoxColor}">
-                <animate attributeName="fill" dur="${store.gameHistory.length * DELTA_TIME}ms" repeatCount="indefinite" 
-                    values="${cellColorAnimation.values}" 
-                    keyTimes="${cellColorAnimation.keyTimes}"/>
-            </rect>`;
-		}
-	}
-
-	// Walls
-	for (let x = 0; x < GRID_WIDTH; x++) {
-		for (let y = 0; y < GRID_HEIGHT; y++) {
-			if (WALLS.horizontal[x][y].active) {
-				svg += `<rect id="wh-${x}-${y}" x="${x * (CELL_SIZE + GAP_SIZE) - GAP_SIZE}" y="${y * (CELL_SIZE + GAP_SIZE) - GAP_SIZE + 15}" width="${CELL_SIZE + GAP_SIZE}" height="${GAP_SIZE}" rx="5" fill="${Utils.getCurrentTheme(store).wallColor}"></rect>`;
-			}
-			if (WALLS.vertical[x][y].active) {
-				svg += `<rect id="wv-${x}-${y}" x="${x * (CELL_SIZE + GAP_SIZE) - GAP_SIZE}" y="${y * (CELL_SIZE + GAP_SIZE) - GAP_SIZE + 15}" width="${GAP_SIZE}" height="${CELL_SIZE + GAP_SIZE}" rx="5" fill="${Utils.getCurrentTheme(store).wallColor}"></rect>`;
-			}
-		}
-	}
-
-	// Pacman
-	const pacmanColorAnimation = generateChangingValuesAnimation(store, generatePacManColors(store));
-	const pacmanPositionAnimation = generateChangingValuesAnimation(store, generatePacManPositions(store));
-	const pacmanRotationAnimation = generateChangingValuesAnimation(store, generatePacManRotations(store));
-	svg += `<path id="pacman" d="${generatePacManPath(0.55)}"
-        >
-		<animate attributeName="fill" dur="${store.gameHistory.length * DELTA_TIME}ms" repeatCount="indefinite"
-            keyTimes="${pacmanColorAnimation.keyTimes}"
-            values="${pacmanColorAnimation.values}"/>
-        <animateTransform attributeName="transform" type="translate" dur="${store.gameHistory.length * DELTA_TIME}ms" repeatCount="indefinite"
-            keyTimes="${pacmanPositionAnimation.keyTimes}"
-            values="${pacmanPositionAnimation.values}"
-            additive="sum"/>
-        <animateTransform attributeName="transform" type="rotate" dur="${store.gameHistory.length * DELTA_TIME}ms" repeatCount="indefinite"
-            keyTimes="${pacmanRotationAnimation.keyTimes}"
-            values="${pacmanRotationAnimation.values}"
-            additive="sum"/>
-        <animate attributeName="d" dur="0.5s" repeatCount="indefinite"
-            values="${generatePacManPath(0.55)};${generatePacManPath(0.05)};${generatePacManPath(0.55)}"/>
-    </path>`;
-
-	// Ghosts
-	store.ghosts.forEach((ghost, index) => {
-		const ghostPositionAnimation = generateChangingValuesAnimation(store, generateGhostPositions(store, index));
-		const ghostColorAnimation = generateChangingValuesAnimation(store, generateGhostColors(store, index));
-		svg += `<use id="ghost${index}" width="${CELL_SIZE}" height="${CELL_SIZE}" href="#ghost-${ghost.name}">
-            <animateTransform attributeName="transform" type="translate" dur="${store.gameHistory.length * DELTA_TIME}ms" repeatCount="indefinite"
-                keyTimes="${ghostPositionAnimation.keyTimes}"
-                values="${ghostPositionAnimation.values}"/>
-            <animate attributeName="href" dur="${store.gameHistory.length * DELTA_TIME}ms" repeatCount="indefinite"
-                keyTimes="${ghostColorAnimation.keyTimes}"
-                values="${ghostColorAnimation.values}"/>
-        </use>`;
-	});
-
-	svg += '</svg>';
-	return svg;
-};
-
-const generatePacManPath = (mouthAngle: number) => {
-	const radius = CELL_SIZE / 2;
-	const startAngle = mouthAngle;
-	const endAngle = 2 * Math.PI - mouthAngle;
-
-	return `M ${radius},${radius}
-            L ${radius + radius * Math.cos(startAngle)},${radius + radius * Math.sin(startAngle)}
-            A ${radius},${radius} 0 1,1 ${radius + radius * Math.cos(endAngle)},${radius + radius * Math.sin(endAngle)}
-            Z`;
-};
-
-const generatePacManPositions = (store: StoreType): string[] => {
-	return store.gameHistory.map((state) => {
-		const x = state.pacman.x * (CELL_SIZE + GAP_SIZE);
-		const y = state.pacman.y * (CELL_SIZE + GAP_SIZE) + 15;
-		return `${x},${y}`;
-	});
-};
-
-const generatePacManRotations = (store: StoreType): string[] => {
-	const pivit = CELL_SIZE / 2;
-	return store.gameHistory.map((state) => {
-		switch (state.pacman.direction) {
-			case 'right':
-				return `0 ${pivit} ${pivit}`;
-			case 'left':
-				return `180 ${pivit} ${pivit}`;
-			case 'up':
-				return `270 ${pivit} ${pivit}`;
-			case 'down':
-				return `90 ${pivit} ${pivit}`;
-			default:
-				return `0 ${pivit} ${pivit}`;
-		}
-	});
-};
-
-const generatePacManColors = (store: StoreType): string[] => {
-	return store.gameHistory.map((state) => {
-		if (state.pacman.deadRemainingDuration) {
-			return PACMAN_COLOR_DEAD;
-		} else if (state.pacman.powerupRemainingDuration) {
-			return PACMAN_COLOR_POWERUP;
-		} else {
-			return PACMAN_COLOR;
-		}
-	});
-};
-
-const generateCellColorValues = (store: StoreType, x: number, y: number): string[] => {
-	return store.gameHistory.map((state) => {
-		const intensity = state.grid[x][y];
-		if (intensity > 0) {
-			const adjustedIntensity = intensity < 0.2 ? 0.3 : intensity;
-			return Utils.hexToHexAlpha(Utils.getCurrentTheme(store).contributionBoxColor, adjustedIntensity);
-		} else {
-			return Utils.getCurrentTheme(store).emptyContributionBoxColor;
-		}
-	});
-};
-
-const generateGhostPositions = (store: StoreType, ghostIndex: number): string[] => {
-	return store.gameHistory.map((state) => {
-		const ghost = state.ghosts[ghostIndex];
-		const x = ghost.x * (CELL_SIZE + GAP_SIZE);
-		const y = ghost.y * (CELL_SIZE + GAP_SIZE) + 15;
-		return `${x},${y}`;
-	});
-};
-
-const generateGhostColors = (store: StoreType, ghostIndex: number): string[] => {
-	return store.gameHistory.map((state) => {
-		const ghost = state.ghosts[ghostIndex];
-		return '#' + (ghost.scared ? ghostShort('scared') : ghostShort(ghost.name));
-	});
-};
-
-const generateGhostsPredefinition = () => {
-	return `<defs>
-		<symbol id="${ghostShort('blinky')}" viewBox="0 0 100 100">
-            <image href="${GHOSTS['blinky'].imgDate}" width="100" height="100"/>
-		</symbol>
-		<symbol id="${ghostShort('clyde')}" viewBox="0 0 100 100">
-            <image href="${GHOSTS['clyde'].imgDate}" width="100" height="100"/>
-		</symbol>
-		<symbol id="${ghostShort('inky')}" viewBox="0 0 100 100">
-            <image href="${GHOSTS['inky'].imgDate}" width="100" height="100"/>
-		</symbol>
-		<symbol id="${ghostShort('pinky')}" viewBox="0 0 100 100">
-            <image href="${GHOSTS['pinky'].imgDate}" width="100" height="100"/>
-		</symbol>
-		<symbol id="${ghostShort('scared')}" viewBox="0 0 100 100">
-            <image href="${GHOSTS['scared'].imgDate}" width="100" height="100"/>
-		</symbol>
-	</defs>`;
-};
-
-const ghostShort = (ghostName: string): string => {
-	switch (ghostName) {
-		case 'blinky':
-			return 'gb';
-		case 'clyde':
-			return 'gc';
-		case 'inky':
-			return 'gi';
-		case 'pinky':
-			return 'gp';
-		case 'scared':
-			return 'gs';
-		default:
-			return ghostName;
-	}
-};
-
-const generateChangingValuesAnimation = (store: StoreType, changingValues: string[]): AnimationData => {
-	if (store.gameHistory.length !== changingValues.length) {
-		throw new Error('The length of changingValues must match the length of gameHistory');
-	}
-
-	const totalFrames = store.gameHistory.length;
-	let keyTimes: number[] = [];
-	let values: string[] = [];
-	let lastValue: string | null = null;
-	let lastIndex: number | null = null;
-
-	changingValues.forEach((currentValue, index) => {
-		if (currentValue !== lastValue) {
-			if (lastValue !== null && lastIndex !== null && index - 1 !== lastIndex) {
-				// Add a keyframe right before the value change
-				keyTimes.push(Number(((index - 0.000001) / (totalFrames - 1)).toFixed(6)));
-				values.push(lastValue);
-			}
-			// Add the new value keyframe
-			keyTimes.push(Number((index / (totalFrames - 1)).toFixed(6)));
-			values.push(currentValue);
-			lastValue = currentValue;
-			lastIndex = index;
-		}
-	});
-
-	// Ensure the last frame is always included
-	if (keyTimes[keyTimes.length - 1] !== 1) {
-		keyTimes.push(1);
-		values.push(lastValue!);
-	}
-
-	return {
-		keyTimes: keyTimes.join(';'),
-		values: values.join(';')
-	};
-};
-
-export const SVG = {
-	generateAnimatedSVG
-};

package/src/types.ts

@@ -1,78 +0,0 @@
-export type Point2d = {
-	x: number;
-	y: number;
-};
-
-export interface Pacman {
-	x: number;
-	y: number;
-	direction: 'right' | 'left' | 'up' | 'down';
-	points: number;
-	totalPoints: number;
-	deadRemainingDuration: number;
-	powerupRemainingDuration: number;
-	recentPositions: string[];
-	target?: Point2d;
-}
-
-export type GhostName = 'blinky' | 'clyde' | 'inky' | 'pinky';
-export interface Ghost {
-	x: number;
-	y: number;
-	name: GhostName;
-	scared: boolean;
-	target?: Point2d;
-}
-
-export interface Contribution {
-	date: Date;
-	count: number;
-}
-
-export interface StoreType {
-	frameCount: number;
-	contributions: Contribution[];
-	pacman: Pacman;
-	ghosts: Ghost[];
-	grid: { intensity: number; commitsCount: number }[][];
-	monthLabels: string[];
-	pacmanMouthOpen: boolean;
-	gameInterval: number;
-	gameHistory: {
-		pacman: Pacman;
-		ghosts: Ghost[];
-		grid: number[][];
-	}[];
-	config: Config;
-}
-
-export interface Config {
-	platform: 'github' | 'gitlab';
-	username: string;
-	canvas: HTMLCanvasElement;
-	outputFormat: 'canvas' | 'svg';
-	svgCallback: (blonUrl: string) => void;
-	gameOverCallback: () => void;
-	gameTheme: ThemeKeys;
-	gameSpeed: number;
-	enableSounds: boolean;
-	pointsIncreasedCallback: (pointsSum: number) => void;
-	githubSettings?: {
-		accessToken: string;
-	};
-}
-
-export type ThemeKeys = 'github' | 'github-dark' | 'gitlab' | 'gitlab-dark';
-
-export interface GameTheme {
-	textColor: string;
-	gridBackground: string;
-	contributionBoxColor: string;
-	emptyContributionBoxColor: string;
-	wallColor: string;
-}
-
-export interface AnimationData {
-	keyTimes: string;
-	values: string;
-}