pacman-contribution-graph 1.0.0

package/src/canvas.ts

@@ -0,0 +1,200 @@
+import { CELL_SIZE, GAP_SIZE, GRID_HEIGHT, GRID_WIDTH, PACMAN_COLOR, PACMAN_COLOR_DEAD, PACMAN_COLOR_POWERUP } from './constants';
+import { MusicPlayer } from './music-player';
+import { Store } from './store';
+import { Utils } from './utils';
+
+const resizeCanvas = () => {
+	const canvasWidth = GRID_WIDTH * (CELL_SIZE + GAP_SIZE);
+	const canvasHeight = GRID_HEIGHT * (CELL_SIZE + GAP_SIZE) + 20; // Adding some space for months on top
+
+	Store.config.canvas.width = canvasWidth;
+	Store.config.canvas.height = canvasHeight;
+};
+
+const drawGrid = () => {
+	Store.config.canvas.getContext('2d')!.fillStyle = Utils.getCurrentTheme().gridBackground;
+	Store.config.canvas.getContext('2d')!.fillRect(0, 0, Store.config.canvas.width, Store.config.canvas.height);
+
+	for (let x = 0; x < GRID_HEIGHT; x++) {
+		for (let y = 0; y < GRID_WIDTH; y++) {
+			const intensity = Store.grid[x][y];
+			if (intensity > 0) {
+				const adjustedIntensity = intensity < 0.2 ? 0.3 : intensity;
+				const color = Utils.hexToRGBA(Utils.getCurrentTheme().contributionBoxColor, adjustedIntensity);
+				Store.config.canvas.getContext('2d')!.fillStyle = color;
+			} else {
+				Store.config.canvas.getContext('2d')!.fillStyle = Utils.getCurrentTheme().emptyContributionBoxColor;
+			}
+			Store.config.canvas.getContext('2d')!.beginPath();
+			Store.config.canvas
+				.getContext('2d')!
+				.roundRect(y * (CELL_SIZE + GAP_SIZE), x * (CELL_SIZE + GAP_SIZE) + 15, CELL_SIZE, CELL_SIZE, 5);
+			Store.config.canvas.getContext('2d')!.fill();
+		}
+	}
+
+	Store.config.canvas.getContext('2d')!.fillStyle = Utils.getCurrentTheme().textColor;
+	Store.config.canvas.getContext('2d')!.font = '10px Arial';
+	Store.config.canvas.getContext('2d')!.textAlign = 'center';
+
+	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;
+			Store.config.canvas.getContext('2d')!.fillText(Store.monthLabels[y], xPos, 10);
+			lastMonth = Store.monthLabels[y];
+		}
+	}
+};
+
+const drawPacman = () => {
+	const x = Store.pacman.y * (CELL_SIZE + GAP_SIZE) + CELL_SIZE / 2;
+	const y = Store.pacman.x * (CELL_SIZE + GAP_SIZE) + CELL_SIZE / 2 + 15;
+	const radius = CELL_SIZE / 2;
+
+	// Change Pac-Man's color to red if he's on power-up, dead, else yellow
+	if (Store.pacman.deadReaminingDuration) {
+		Store.config.canvas.getContext('2d')!.fillStyle = PACMAN_COLOR_DEAD;
+	} else if (Store.pacman.powerupReaminingDuration) {
+		Store.config.canvas.getContext('2d')!.fillStyle = PACMAN_COLOR_POWERUP;
+	} else {
+		Store.config.canvas.getContext('2d')!.fillStyle = PACMAN_COLOR;
+	}
+
+	const mouthAngle = Store.pacmanMouthOpen ? 0.35 * Math.PI : 0.1 * Math.PI;
+
+	let startAngle, endAngle;
+	switch (Store.pacman.direction) {
+		case 'up':
+			startAngle = 1.5 * Math.PI + mouthAngle;
+			endAngle = 1.5 * Math.PI - mouthAngle;
+			break;
+		case 'down':
+			startAngle = 0.5 * Math.PI + mouthAngle;
+			endAngle = 0.5 * Math.PI - mouthAngle;
+			break;
+		case 'left':
+			startAngle = Math.PI + mouthAngle;
+			endAngle = Math.PI - mouthAngle;
+			break;
+		case 'right':
+		default:
+			startAngle = 0 + mouthAngle;
+			endAngle = 2 * Math.PI - mouthAngle;
+			break;
+	}
+
+	Store.config.canvas.getContext('2d')!.beginPath();
+	Store.config.canvas.getContext('2d')!.arc(x, y, radius, startAngle, endAngle);
+	Store.config.canvas.getContext('2d')!.lineTo(x, y);
+	Store.config.canvas.getContext('2d')!.fill();
+};
+
+const drawGhosts = () => {
+	Store.ghosts.forEach((ghost) => {
+		const x = ghost.y * (CELL_SIZE + GAP_SIZE) + CELL_SIZE / 2;
+		const y = ghost.x * (CELL_SIZE + GAP_SIZE) + CELL_SIZE / 2 + 15;
+		const radius = CELL_SIZE / 2;
+
+		Store.config.canvas.getContext('2d')!.fillStyle = ghost.scared ? 'blue' : ghost.color;
+		Store.config.canvas.getContext('2d')!.beginPath();
+		Store.config.canvas.getContext('2d')!.arc(x, y, radius, 0, Math.PI);
+		Store.config.canvas.getContext('2d')!.rect(x - radius, y, radius * 2, radius);
+		Store.config.canvas.getContext('2d')!.fill();
+
+		Store.config.canvas.getContext('2d')!.fillStyle = 'white';
+		Store.config.canvas.getContext('2d')!.beginPath();
+		Store.config.canvas.getContext('2d')!.arc(x - radius / 3, y - radius / 3, radius / 4, 0, Math.PI * 2);
+		Store.config.canvas.getContext('2d')!.arc(x + radius / 3, y - radius / 3, radius / 4, 0, Math.PI * 2);
+		Store.config.canvas.getContext('2d')!.fill();
+
+		Store.config.canvas.getContext('2d')!.fillStyle = 'black';
+		Store.config.canvas.getContext('2d')!.beginPath();
+		Store.config.canvas.getContext('2d')!.arc(x - radius / 3, y - radius / 3, radius / 8, 0, Math.PI * 2);
+		Store.config.canvas.getContext('2d')!.arc(x + radius / 3, y - radius / 3, radius / 8, 0, Math.PI * 2);
+		Store.config.canvas.getContext('2d')!.fill();
+	});
+};
+
+const renderGameOver = () => {
+	Store.config.canvas.getContext('2d')!.fillStyle = 'black';
+	Store.config.canvas.getContext('2d')!.font = '20px Arial';
+	Store.config.canvas.getContext('2d')!.textAlign = 'center';
+	Store.config.canvas.getContext('2d')!.fillText('Game Over', Store.config.canvas.width / 2, Store.config.canvas.height / 2);
+};
+
+const drawSoundController = () => {
+	if (!Store.config.enableSounds) {
+		console.log('vvvv');
+		return;
+	}
+
+	const width = 30,
+		height = 30,
+		left = Store.config.canvas.width - width - 10,
+		top = 10;
+	Store.config.canvas.getContext('2d')!.fillStyle = `rgba(0, 0, 0, ${MusicPlayer.getInstance().isMuted ? 0.3 : 0.5})`;
+	Store.config.canvas.getContext('2d')!.beginPath();
+	Store.config.canvas.getContext('2d')!.moveTo(left + 10, top + 10);
+	Store.config.canvas.getContext('2d')!.lineTo(left + 20, top + 5);
+	Store.config.canvas.getContext('2d')!.lineTo(left + 20, top + 25);
+	Store.config.canvas.getContext('2d')!.lineTo(left + 10, top + 20);
+	Store.config.canvas.getContext('2d')!.closePath();
+	Store.config.canvas.getContext('2d')!.fill();
+
+	if (!MusicPlayer.getInstance().isMuted) {
+		Store.config.canvas.getContext('2d')!.strokeStyle = `rgba(0, 0, 0, 0.4)`;
+		Store.config.canvas.getContext('2d')!.lineWidth = 2;
+
+		// First wave
+		Store.config.canvas.getContext('2d')!.beginPath();
+		Store.config.canvas.getContext('2d')!.arc(left + 25, top + 15, 5, 0, Math.PI * 2);
+		Store.config.canvas.getContext('2d')!.stroke();
+
+		// Second wave
+		Store.config.canvas.getContext('2d')!.beginPath();
+		Store.config.canvas.getContext('2d')!.arc(left + 25, top + 15, 8, 0, Math.PI * 2);
+		Store.config.canvas.getContext('2d')!.stroke();
+	} else {
+		// Mute line
+		Store.config.canvas.getContext('2d')!.strokeStyle = 'rgba(255, 0, 0, 0.6)';
+		Store.config.canvas.getContext('2d')!.lineWidth = 3;
+		Store.config.canvas.getContext('2d')!.beginPath();
+		Store.config.canvas.getContext('2d')!.moveTo(left + 25, top + 5);
+		Store.config.canvas.getContext('2d')!.lineTo(left + 5, top + 25);
+		Store.config.canvas.getContext('2d')!.stroke();
+	}
+};
+
+const listenToSoundController = () => {
+	if (!Store.config.enableSounds) {
+		return;
+	}
+	Store.config.canvas.addEventListener('click', function (event) {
+		const rect = Store.config.canvas.getBoundingClientRect();
+		const x = event.clientX - rect.left,
+			y = event.clientY - rect.top;
+		const width = 30,
+			height = 30,
+			left = Store.config.canvas.width - width - 10,
+			top = 10;
+
+		if (x >= left && x <= left + this.width && y >= top && y <= top + this.height) {
+			if (MusicPlayer.getInstance().isMuted) {
+				MusicPlayer.getInstance().unmute();
+			} else {
+				MusicPlayer.getInstance().mute();
+			}
+		}
+	});
+};
+
+export const Canvas = {
+	resizeCanvas,
+	drawGrid,
+	drawPacman,
+	drawGhosts,
+	renderGameOver,
+	drawSoundController,
+	listenToSoundController
+};

package/src/constants.ts

@@ -0,0 +1,40 @@
+import { GameTheme, ThemeKeys } from './types';
+
+export const CELL_SIZE = 20;
+export const GAP_SIZE = 2;
+export const GRID_WIDTH = 52;
+export const GRID_HEIGHT = 7;
+export const PACMAN_COLOR = 'yellow';
+export const PACMAN_COLOR_POWERUP = 'red';
+export const PACMAN_COLOR_DEAD = '#80808064';
+export const GHOST_COLORS = ['red', 'pink', 'cyan', 'orange'];
+export const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+export const DELTA_TIME = 250;
+export const PACMAN_DEATH_DURATION = 10;
+export const PACMAN_POWERUP_DURATION = 15;
+export const GAME_THEMES: { [key in ThemeKeys]: GameTheme } = {
+	github: {
+		textColor: '#586069',
+		gridBackground: '#ffffff',
+		contributionBoxColor: '#9be9a8',
+		emptyContributionBoxColor: '#ebedf0'
+	},
+	'github-dark': {
+		textColor: '#8b949e',
+		gridBackground: '#0d1117',
+		contributionBoxColor: '#26a641',
+		emptyContributionBoxColor: '#161b22'
+	},
+	gitlab: {
+		textColor: '#626167',
+		gridBackground: '#ffffff',
+		contributionBoxColor: '#7992f5',
+		emptyContributionBoxColor: '#ececef'
+	},
+	'gitlab-dark': {
+		textColor: '#999999',
+		gridBackground: '#1f1f1f',
+		contributionBoxColor: '#2e7db1',
+		emptyContributionBoxColor: '#2d2d2d'
+	}
+};

package/src/game.ts

@@ -0,0 +1,344 @@
+import { Canvas } from './canvas';
+import { DELTA_TIME, GHOST_COLORS, GRID_HEIGHT, GRID_WIDTH, MONTHS, PACMAN_DEATH_DURATION, PACMAN_POWERUP_DURATION } from './constants';
+import { MusicPlayer, Sound } from './music-player';
+import { Store } from './store';
+import { SVG } from './svg';
+
+const initializeGrid = () => {
+	Store.grid = Array.from({ length: GRID_HEIGHT }, () => Array.from({ length: GRID_WIDTH }, () => 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[dayOfWeek][GRID_WIDTH - 1 - weeksAgo] = contribution.count;
+			if (contribution.count > maxCommits) maxCommits = contribution.count;
+		}
+	});
+
+	for (let x = 0; x < GRID_HEIGHT; x++) {
+		for (let y = 0; y < GRID_WIDTH; y++) {
+			if (Store.grid[x][y] > 0) {
+				Store.grid[x][y] = Store.grid[x][y] / maxCommits;
+			}
+		}
+	}
+
+	for (let y = 0; y < GRID_WIDTH; y++) {
+		const weeksAgo = GRID_WIDTH - 1 - y;
+		const columnDate = new Date(startOfCurrentWeek);
+		columnDate.setDate(columnDate.getDate() - weeksAgo * 7);
+		Store.monthLabels[y] = MONTHS[columnDate.getMonth()];
+	}
+};
+
+const placePacman = () => {
+	let validCells = [];
+	for (let x = 0; x < GRID_HEIGHT; x++) {
+		for (let y = 0; y < GRID_WIDTH; y++) {
+			if (Store.grid[x][y] > 0) validCells.push({ x, y });
+		}
+	}
+	if (validCells.length > 0) {
+		const randomCell = validCells[Math.floor(Math.random() * validCells.length)];
+		Store.pacman = {
+			x: randomCell.x,
+			y: randomCell.y,
+			direction: 'right',
+			points: 0,
+			deadReaminingDuration: 0,
+			powerupReaminingDuration: 0
+		};
+	}
+	if (Store.config.outputFormat == 'canvas') Canvas.drawPacman();
+};
+
+const placeGhosts = () => {
+	Store.ghosts = [];
+	Store.scaredGhostsDestinations = [];
+	// Create 4 ghosts
+	for (let i = 0; i < 4; i++) {
+		const color = GHOST_COLORS[i % GHOST_COLORS.length];
+		let x, y;
+		do {
+			x = Math.floor(Math.random() * GRID_HEIGHT);
+			y = Math.floor(Math.random() * GRID_WIDTH);
+		} while (Store.grid[x][y] === 0);
+		Store.ghosts.push({ x, y, color, scared: false, target: undefined });
+		Store.scaredGhostsDestinations.push({ x: 0, y: 0 });
+	}
+	if (Store.config.outputFormat == 'canvas') Canvas.drawGhosts();
+};
+
+const startGame = async () => {
+	if (Store.config.outputFormat == 'canvas') {
+		Store.config.canvas = Store.config.canvas;
+		Canvas.resizeCanvas();
+		Canvas.listenToSoundController();
+	}
+
+	Store.frameCount = 0;
+	Store.ghosts.forEach((ghost) => (ghost.scared = false));
+
+	initializeGrid();
+	if (Store.config.outputFormat == 'canvas') Canvas.drawGrid();
+
+	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);
+	}
+
+	placePacman();
+	placeGhosts();
+
+	if (Store.config.outputFormat == 'svg') {
+		const remainingCells = () => Store.grid.some((row) => row.some((cell) => cell > 0));
+		while (remainingCells()) {
+			await updateGame();
+		}
+		// One more time to generate svg
+		await updateGame();
+	} else {
+		clearInterval(Store.gameInterval);
+		Store.gameInterval = setInterval(async () => await updateGame(), DELTA_TIME);
+	}
+};
+
+const updateGame = async () => {
+	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])
+		});
+		return;
+	}
+
+	if (Store.pacman.deadReaminingDuration) {
+		Store.pacman.deadReaminingDuration--;
+		if (!Store.pacman.deadReaminingDuration) {
+			// IT'S ALIVE!
+			if (Store.config.outputFormat == 'canvas')
+				MusicPlayer.getInstance()
+					.play(Sound.GAME_OVER)
+					.then(() => MusicPlayer.getInstance().startDefaultSound());
+		}
+	}
+
+	if (Store.pacman.powerupReaminingDuration) {
+		Store.pacman.powerupReaminingDuration--;
+		if (!Store.pacman.powerupReaminingDuration) {
+			Store.ghosts.forEach((ghost) => (ghost.scared = false));
+			Store.pacman.points = 0;
+		}
+	}
+
+	const remainingCells = Store.grid.some((row) => row.some((cell) => cell > 0));
+	if (!remainingCells) {
+		if (Store.config.outputFormat == 'canvas') {
+			clearInterval(Store.gameInterval);
+			if (Store.config.outputFormat == 'canvas') {
+				Canvas.renderGameOver();
+				MusicPlayer.getInstance()
+					.play(Sound.BEGINNING)
+					.then(() => MusicPlayer.getInstance().stopDefaultSound());
+			}
+		}
+
+		if (Store.config.outputFormat == 'svg') {
+			const animatedSVG = SVG.generateAnimatedSVG();
+			const svgBlob = new Blob([animatedSVG], {
+				type: 'image/svg+xml;charset=utf-8'
+			});
+			const svgUrl = URL.createObjectURL(svgBlob);
+			Store.config.svgCallback(svgUrl);
+		}
+
+		Store.config.gameOverCallback();
+		return;
+	}
+
+	movePacman();
+	moveGhosts();
+	checkCollisions();
+
+	Store.pacmanMouthOpen = !Store.pacmanMouthOpen;
+
+	Store.gameHistory.push({
+		pacman: { ...Store.pacman },
+		ghosts: Store.ghosts.map((ghost) => ({ ...ghost })),
+		grid: Store.grid.map((row) => [...row])
+	});
+
+	if (Store.config.outputFormat == 'canvas') Canvas.drawGrid();
+	if (Store.config.outputFormat == 'canvas') Canvas.drawPacman();
+	if (Store.config.outputFormat == 'canvas') Canvas.drawGhosts();
+	if (Store.config.outputFormat == 'canvas') Canvas.drawSoundController();
+};
+
+const movePacman = () => {
+	if (Store.pacman.deadReaminingDuration) {
+		return;
+	}
+	let targetCells: { x: number; y: number; distance: number }[] = [];
+
+	if (Store.pacman.powerupReaminingDuration) {
+		targetCells = Store.ghosts.map((ghost) => ({
+			x: ghost.x,
+			y: ghost.y,
+			distance: Infinity
+		}));
+	} else {
+		for (let x = 0; x < GRID_HEIGHT; x++) {
+			for (let y = 0; y < GRID_WIDTH; y++) {
+				if (Store.grid[x][y] > 0) targetCells.push({ x, y, distance: Infinity });
+			}
+		}
+	}
+
+	if (targetCells.length === 0) return;
+
+	const closest = targetCells.reduce(
+		(closest, cell) => {
+			const distance = Math.abs(cell.x - Store.pacman.x) + Math.abs(cell.y - Store.pacman.y);
+			return distance < closest.distance ? { ...cell, distance } : closest;
+		},
+		{ x: Store.pacman.x, y: Store.pacman.y, distance: Infinity }
+	);
+
+	const dx = closest.x - Store.pacman.x;
+	const dy = closest.y - Store.pacman.y;
+
+	if (Math.abs(dx) > Math.abs(dy)) {
+		Store.pacman.x += Math.sign(dx);
+		Store.pacman.direction = dx > 0 ? 'down' : 'up';
+	} else {
+		Store.pacman.y += Math.sign(dy);
+		Store.pacman.direction = dy > 0 ? 'right' : 'left';
+	}
+
+	if (Store.grid[Store.pacman.x][Store.pacman.y] > 0) {
+		Store.pacman.points += 1;
+		Store.grid[Store.pacman.x][Store.pacman.y] = 0;
+
+		if (Store.pacman.points >= 30) activatePowerUp();
+	}
+};
+
+const moveGhosts = () => {
+	Store.ghosts.forEach((ghost, index) => {
+		if (ghost.scared) {
+			if (!ghost.target) {
+				ghost.target = getRandomDestination(ghost.x, ghost.y);
+			}
+
+			const dx = ghost.target.x - ghost.x;
+			const dy = ghost.target.y - ghost.y;
+			const moveX = Math.abs(dx) > Math.abs(dy) ? Math.sign(dx) : 0;
+			const moveY = Math.abs(dy) >= Math.abs(dx) ? Math.sign(dy) : 0;
+
+			const newX = ghost.x + moveX;
+			const newY = ghost.y + moveY;
+
+			if (newX >= 0 && newX < GRID_HEIGHT && newY >= 0 && newY < GRID_WIDTH) {
+				ghost.x = newX;
+				ghost.y = newY;
+			}
+
+			if (ghost.x === ghost.target.x && ghost.y === ghost.target.y) {
+				ghost.target = getRandomDestination(ghost.x, ghost.y);
+			}
+		} else {
+			const directions = [
+				[-1, 0],
+				[1, 0],
+				[0, -1],
+				[0, 1]
+			];
+			const [dx, dy] = directions[Math.floor(Math.random() * directions.length)];
+
+			// If Pacman has the power-up, ghosts move slower (move every other frame)
+			if (Store.pacman.powerupReaminingDuration && Math.random() < 0.5) return;
+
+			const newX = ghost.x + dx;
+			const newY = ghost.y + dy;
+
+			if (newX >= 0 && newX < GRID_HEIGHT && newY >= 0 && newY < GRID_WIDTH) {
+				ghost.x = newX;
+				ghost.y = newY;
+			}
+		}
+	});
+};
+
+const getRandomDestination = (x: number, y: number) => {
+	const maxDistance = 10;
+	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_HEIGHT - 1)),
+		y: Math.max(0, Math.min(randomY, GRID_WIDTH - 1))
+	};
+};
+
+const checkCollisions = () => {
+	if (Store.pacman.deadReaminingDuration) return;
+
+	Store.ghosts.forEach((ghost, index) => {
+		if (ghost.x === Store.pacman.x && ghost.y === Store.pacman.y) {
+			if (Store.pacman.powerupReaminingDuration && ghost.scared) {
+				respawnGhost(index);
+				Store.pacman.points += 10;
+				if (Store.config.outputFormat == 'canvas') {
+					MusicPlayer.getInstance().play(Sound.EAT_GHOST);
+				}
+			} else {
+				Store.pacman.points = 0;
+				Store.pacman.powerupReaminingDuration = 0;
+				Store.pacman.deadReaminingDuration = PACMAN_DEATH_DURATION;
+				if (Store.config.outputFormat == 'canvas') {
+					MusicPlayer.getInstance()
+						.play(Sound.GAME_OVER)
+						.then(() => MusicPlayer.getInstance().stopDefaultSound());
+				}
+			}
+		}
+	});
+};
+
+const respawnGhost = (ghostIndex: number) => {
+	let x, y;
+	do {
+		x = Math.floor(Math.random() * GRID_HEIGHT);
+		y = Math.floor(Math.random() * GRID_WIDTH);
+	} while ((Math.abs(x - Store.pacman.x) <= 2 && Math.abs(y - Store.pacman.y) <= 2) || Store.grid[x][y] === 0);
+	Store.ghosts[ghostIndex] = {
+		x,
+		y,
+		color: GHOST_COLORS[ghostIndex % GHOST_COLORS.length],
+		scared: false,
+		target: undefined
+	};
+};
+
+const activatePowerUp = () => {
+	Store.pacman.powerupReaminingDuration = PACMAN_POWERUP_DURATION;
+	Store.ghosts.forEach((ghost) => (ghost.scared = true));
+};
+
+export const Game = {
+	startGame
+};

package/src/index.ts

@@ -0,0 +1,31 @@
+import { Game } from './game';
+import { Store } from './store';
+import { Config } from './types';
+import { Utils } from './utils';
+
+export const renderContributions = async (conf: Config) => {
+	const defaultConfing: Config = {
+		platform: 'github',
+		username: '',
+		canvas: undefined as unknown as HTMLCanvasElement,
+		outputFormat: 'svg',
+		svgCallback: (_: string) => {},
+		gameOverCallback: () => () => {},
+		gameTheme: 'github',
+		gameSpeed: 1,
+		enableSounds: true
+	};
+	Store.config = { ...defaultConfing, ...conf };
+
+	switch (conf.platform) {
+		case 'gitlab':
+			Store.contributions = await Utils.getGitlabContribution(conf.username);
+			break;
+
+		case 'github':
+			Store.contributions = await Utils.getGithubContribution(conf.username);
+			break;
+	}
+
+	Game.startGame();
+};