diff options
Diffstat (limited to 'html/broughlike/broughlike.js')
| -rw-r--r-- | html/broughlike/broughlike.js | 923 |
1 files changed, 923 insertions, 0 deletions
diff --git a/html/broughlike/broughlike.js b/html/broughlike/broughlike.js new file mode 100644 index 0000000..7efa67d --- /dev/null +++ b/html/broughlike/broughlike.js @@ -0,0 +1,923 @@ +import { CONFIG, COLORS, CANVAS } from './config.js'; + +let highScore = localStorage.getItem('highScore') || 0; +const player = { + x: 0, + y: 0, + health: CONFIG.PLAYER_HEALTH, + score: 0, + damage: CONFIG.PLAYER_BASE_DAMAGE, + totalDamageDone: 0, + totalDamageTaken: 0, + cellsTraveled: 0, + killCount: 0, + itemsCollected: 0, +}; + +const exit = { x: Math.floor(Math.random() * CONFIG.GRID_SIZE), y: Math.floor(Math.random() * CONFIG.GRID_SIZE) }; +let walls = []; +let enemies = []; +let items = []; +let combatDots = {}; + +function isValidMove(newX, newY) { + return ( + newX >= 0 && newX < CONFIG.GRID_SIZE && + newY >= 0 && newY < CONFIG.GRID_SIZE && + !walls.some(wall => wall.x === newX && wall.y === newY) + ); +} + +function generateExit() { + let distance = 0; + do { + exit.x = Math.floor(Math.random() * CONFIG.GRID_SIZE); + exit.y = Math.floor(Math.random() * CONFIG.GRID_SIZE); + distance = Math.abs(exit.x - player.x) + Math.abs(exit.y - player.y); + } while (distance < 4); +} + +function generateEnemies() { + enemies = []; + // Generate between 0 and MAX_ENEMIES_ON_LEVEL enemies if the player's score is 4 or lower + // Generate between MIN_ENEMIES_ON_LEVEL and MAX_ENEMIES_ON_LEVEL enemies if the player's score is 5 or higher + const numEnemies = player.score > 4 + ? Math.floor(Math.random() * (CONFIG.MAX_ENEMIES_ON_LEVEL - CONFIG.MIN_ENEMIES_ON_LEVEL + 1)) + CONFIG.MIN_ENEMIES_ON_LEVEL + : Math.floor(Math.random() * (CONFIG.MAX_ENEMIES_ON_LEVEL + 1)); + for (let i = 0; i < numEnemies;) { + let enemyX, enemyY; + do { + enemyX = Math.floor(Math.random() * CONFIG.GRID_SIZE); + enemyY = Math.floor(Math.random() * CONFIG.GRID_SIZE); + } while ( + (enemyX === player.x && enemyY === player.y) || + (enemyX === exit.x && enemyY === exit.y) || + walls.some(wall => wall.x === enemyX && wall.y === enemyY) || + (Math.abs(enemyX - player.x) + Math.abs(enemyY - player.y) < 2) // Ensure enemy is at least 2 spaces away from player + ); + if (isReachable(player.x, player.y, enemyX, enemyY)) { + enemies.push({ + color: COLORS.enemy, + x: enemyX, + y: enemyY, + health: Math.floor(Math.random() * (CONFIG.MAX_ENEMY_HEALTH - CONFIG.MIN_ENEMY_HEALTH + 1)) + CONFIG.MIN_ENEMY_HEALTH + }); + i++; // Only increment i if the enemy is reachable and actually placed on the board, this avoids levels with fewer enemies than MIN_ENEMIES_ON_LEVEL + } + } + + // Generate a boss enemy every ENEMY_BOSS_OCCURRENCE levels + if (player.score % CONFIG.ENEMY_BOSS_OCCURRENCE === 0 && player.score > 0) { + let bossX, bossY; + do { + bossX = exit.x; // Boss enemies always appear at the exit + bossY = exit.y; // This ensures that they're not in little rooms that the player can't reach + } while ( + (Math.abs(bossX - player.x) + Math.abs(bossY - player.y) < 2) // Ensure boss is at least 2 spaces away from player + ); + if (isReachable(player.x, player.y, bossX, bossY)) { + enemies.push({ + isBoss: true, + color: COLORS.boss, + x: bossX, + y: bossY, + health: CONFIG.MAX_ENEMY_HEALTH + 2 + }); + } + } +} + +function generateWallsNaive() { + walls = []; + let numWalls = Math.floor(Math.random() * (CONFIG.WALLS_MAX - CONFIG.WALLS_MIN + 1)) + CONFIG.WALLS_MIN; + while (walls.length < numWalls) { + const wallX = Math.floor(Math.random() * CONFIG.GRID_SIZE); + const wallY = Math.floor(Math.random() * CONFIG.GRID_SIZE); + + if ( + (wallX === player.x && wallY === player.y) || // Check that a wall is not placed on the starting position + (wallX === exit.x && wallY === exit.y) || // Check that a wall is not placed on the exit + enemies.some(enemy => enemy.x === wallX && enemy.y === wallY) || // Check that a wall is not placed on any enemies + items.some(item => item.x === wallX && item.y === wallY) // Check that a wall is not placed on any items + ) continue; + + if (!walls.some(wall => wall.x === wallX && wall.y === wallY)) { + walls.push({ x: wallX, y: wallY }); + } + } + + if (!isReachable(player.x, player.y, exit.x, exit.y)) { + generateWallsNaive(); + } +} + +function generateWallsDrunkardsWalk() { + walls = []; + const numWalls = Math.floor(Math.random() * (CONFIG.WALLS_MAX - CONFIG.WALLS_MIN + 1)) + CONFIG.WALLS_MIN; + let wallX = Math.floor(Math.random() * CONFIG.GRID_SIZE); + let wallY = Math.floor(Math.random() * CONFIG.GRID_SIZE); + + while (walls.length < numWalls) { + if ( + (wallX !== player.x || wallY !== player.y) && // Check that a wall is not placed on the starting position + (wallX !== exit.x || wallY !== exit.y) && // Check that a wall is not placed on the exit + !enemies.some(enemy => enemy.x === wallX && enemy.y === wallY) && // Check that a wall is not placed on any enemies + !items.some(item => item.x === wallX && item.y === wallY) && // Check that a wall is not placed on any items + !walls.some(wall => wall.x === wallX && wall.y === wallY) // Check that a wall is not placed on an existing wall + ) { + walls.push({ x: wallX, y: wallY }); + } + + // Randomly move to a neighboring cell + const direction = Math.floor(Math.random() * 4); + switch (direction) { + case 0: wallX = Math.max(0, wallX - 1); break; // Move left + case 1: wallX = Math.min(CONFIG.GRID_SIZE - 1, wallX + 1); break; // Move right + case 2: wallY = Math.max(0, wallY - 1); break; // Move up + case 3: wallY = Math.min(CONFIG.GRID_SIZE - 1, wallY + 1); break; // Move down + } + } + + if (!isReachable(player.x, player.y, exit.x, exit.y)) { + generateWallsDrunkardsWalk(); + } +} + +function generateWallsCellularAutomata() { + walls = []; + const map = Array(CONFIG.GRID_SIZE).fill().map(() => Array(CONFIG.GRID_SIZE).fill(0)); + + // Initialize a map with random walls + for (let x = 0; x < CONFIG.GRID_SIZE; x++) { + for (let y = 0; y < CONFIG.GRID_SIZE; y++) { + if (Math.random() < 0.4) { + map[x][y] = 1; + } + } + } + + for (let i = 0; i < 4; i++) { + // Create a new map to store the next state of the cellular automata + const newMap = Array(CONFIG.GRID_SIZE).fill().map(() => Array(CONFIG.GRID_SIZE).fill(0)); + + // Iterate over each cell in the grid + for (let x = 0; x < CONFIG.GRID_SIZE; x++) { + for (let y = 0; y < CONFIG.GRID_SIZE; y++) { + // Count the number of neighboring walls + const neighbors = countNeighbors(map, x, y); + + if (map[x][y] === 1) { + // If the cell is a wall, it stays a wall if it has 4 or more neighbors + newMap[x][y] = neighbors >= 4 ? 1 : 0; + } else { + // If the cell is empty, it turn into a wall if it has 5 or more neighbors + newMap[x][y] = neighbors >= 5 ? 1 : 0; + } + } + } + + // Update the original map with the new state + map.forEach((row, x) => row.forEach((cell, y) => map[x][y] = newMap[x][y])); + } + + // Convert map to walls array + for (let x = 0; x < CONFIG.GRID_SIZE; x++) { + for (let y = 0; y < CONFIG.GRID_SIZE; y++) { + if (map[x][y] === 1 && + (x !== player.x || y !== player.y) && + (x !== exit.x || y !== exit.y) && + !enemies.some(enemy => enemy.x === x && enemy.y === y) && + !items.some(item => item.x === x && item.y === y)) { + walls.push({ x, y }); + } + } + } + + if (!isReachable(player.x, player.y, exit.x, exit.y)) { + generateWallsCellularAutomata(); + } +} + +function countNeighbors(map, x, y) { + let count = 0; + for (let dx = -1; dx <= 1; dx++) { + for (let dy = -1; dy <= 1; dy++) { + if (dx === 0 && dy === 0) continue; + const nx = x + dx; + const ny = y + dy; + if (nx >= 0 && nx < CONFIG.GRID_SIZE && ny >= 0 && ny < CONFIG.GRID_SIZE) { + count += map[nx][ny]; + } else { + count++; // Consider out-of-bounds bits as walls + } + } + } + return count; +} + +function generateWallsRSP() { + walls = []; + + function splitNode(x, y, width, height) { + const splitHorizontally = Math.random() > 0.5; + const max = (splitHorizontally ? height : width) - CONFIG.MIN_ROOM_SIZE; + + if (max <= CONFIG.MIN_ROOM_SIZE) return [{ x, y, width, height }]; + + const split = Math.floor(Math.random() * (max - CONFIG.MIN_ROOM_SIZE)) + CONFIG.MIN_ROOM_SIZE; + + if (splitHorizontally) { + return [ + ...splitNode(x, y, width, split), + ...splitNode(x, y + split, width, height - split) + ]; + } else { + return [ + ...splitNode(x, y, split, height), + ...splitNode(x + split, y, width - split, height) + ]; + } + } + + function createRoom(node) { + const roomWidth = Math.floor(Math.random() * (node.width - 1)) + 1; + const roomHeight = Math.floor(Math.random() * (node.height - 1)) + 1; + const roomX = node.x + Math.floor(Math.random() * (node.width - roomWidth)); + const roomY = node.y + Math.floor(Math.random() * (node.height - roomHeight)); + return { x: roomX, y: roomY, width: roomWidth, height: roomHeight }; + } + + const nodes = splitNode(0, 0, CONFIG.GRID_SIZE, CONFIG.GRID_SIZE); + const rooms = nodes.map(createRoom); + + rooms.forEach(room => { + for (let x = room.x; x < room.x + room.width; x++) { + for (let y = room.y; y < room.y + room.height; y++) { + if ( + (x !== player.x || y !== player.y) && + (x !== exit.x || y !== exit.y) && + !enemies.some(enemy => enemy.x === x && enemy.y === y) && + !items.some(item => item.x === x && item.y === y) + ) { + walls.push({ x, y }); + } + } + }}); + + if (!isReachable(player.x, player.y, exit.x, exit.y)) { + generateWallsRSP(); + } +} + +function generateWalls() { + const wallGenerators = [ + { name: 'RSP Tree', func: generateWallsRSP }, + { name: 'Naive', func: generateWallsNaive }, + { name: 'Cellular Automata', func: generateWallsCellularAutomata }, + { name: 'Drunkard\'s Walk', func: generateWallsDrunkardsWalk } + ]; + const randomIndex = Math.floor(Math.random() * wallGenerators.length); + const selectedGenerator = wallGenerators[randomIndex]; + console.log(`Wall generator: ${selectedGenerator.name}`); + selectedGenerator.func(); +} + +function generateItems() { + items = []; + const numItems = Math.floor(Math.random() * (CONFIG.ITEMS_MAX - CONFIG.ITEMS_MIN + 1)) + CONFIG.ITEMS_MIN; + for (let i = 0; i < numItems;) { + let itemX, itemY; + do { + itemX = Math.floor(Math.random() * CONFIG.GRID_SIZE); + itemY = Math.floor(Math.random() * CONFIG.GRID_SIZE); + } while ( + (itemX === player.x && itemY === player.y) || + (itemX === exit.x && itemY === exit.y) || + walls.some(wall => wall.x === itemX && wall.y === itemY) || + enemies.some(enemy => enemy.x === itemX && enemy.y === itemY) || + items.some(item => item.x === itemX && item.y === itemY) + ); + const itemType = Math.random() < 0.5 ? 'diamond' : 'pentagon'; // 50% chance for each type + if (isReachable(player.x, player.y, itemX, itemY)) + items.push({ x: itemX, y: itemY, type: itemType }); + i++; // Only increment i if the item is reachable and actually placed on the board, this avoids levels with fewer items than ITEMS_MIN + } +} + +// Checks to see if there's a path between any two points on the level +function isReachable(startX, startY, targetX, targetY) { + const visited = Array(CONFIG.GRID_SIZE).fill().map(() => Array(CONFIG.GRID_SIZE).fill(false)); // Initialize a 2D array of false values + function dfs(x, y) { + if (x < 0 || x >= CONFIG.GRID_SIZE || y < 0 || y >= CONFIG.GRID_SIZE) return false; // Are the coordinates in bounds? + if (visited[x][y]) return false; // Have we already visited this cell? + if (walls.some(wall => wall.x === x && wall.y === y)) return false; // Is there a wall here? + visited[x][y] = true; // Mark this cell as visited + if (x === targetX && y === targetY) return true; // Have we reached the target? + return dfs(x + 1, y) || dfs(x - 1, y) || dfs(x, y + 1) || dfs(x, y - 1); // Recursively check neighbors + } + return dfs(startX, startY); +} + +function drawGrid() { + CANVAS.ctx.clearRect(0, 0, CANVAS.canvas.width, CANVAS.canvas.height); + CANVAS.ctx.lineWidth = 2; + CANVAS.ctx.strokeStyle = COLORS.grid; + for (let row = 0; row < CONFIG.GRID_SIZE; row++) { + for (let col = 0; col < CONFIG.GRID_SIZE; col++) { + CANVAS.ctx.strokeRect(col * CANVAS.tileSize, row * CANVAS.tileSize, CANVAS.tileSize, CANVAS.tileSize); + } + } +} + +function drawExit() { + const x = exit.x * CANVAS.tileSize + CANVAS.tileSize / 2; + const y = exit.y * CANVAS.tileSize + CANVAS.tileSize / 2; + CANVAS.ctx.beginPath(); + CANVAS.ctx.moveTo(x, y - CANVAS.tileSize / 3); + CANVAS.ctx.lineTo(x + CANVAS.tileSize / 3, y + CANVAS.tileSize / 3); + CANVAS.ctx.lineTo(x - CANVAS.tileSize / 3, y + CANVAS.tileSize / 3); + CANVAS.ctx.closePath(); + CANVAS.ctx.fillStyle = COLORS.exit; + CANVAS.ctx.fill(); +} + +function drawWalls() { + CANVAS.ctx.fillStyle = COLORS.walls; + walls.forEach(wall => { + CANVAS.ctx.fillRect(wall.x * CANVAS.tileSize, wall.y * CANVAS.tileSize, CANVAS.tileSize, CANVAS.tileSize); + }); +} + +function drawItems() { + items.forEach(item => { + const x = item.x * CANVAS.tileSize + CANVAS.tileSize / 2; + const y = item.y * CANVAS.tileSize + CANVAS.tileSize / 2; + CANVAS.ctx.fillStyle = item.type === 'diamond' ? COLORS.diamond : COLORS.pentagon; + CANVAS.ctx.beginPath(); + if (item.type === 'diamond') { + CANVAS.ctx.moveTo(x, y - CANVAS.tileSize / 4); + CANVAS.ctx.lineTo(x + CANVAS.tileSize / 4, y); + CANVAS.ctx.lineTo(x, y + CANVAS.tileSize / 4); + CANVAS.ctx.lineTo(x - CANVAS.tileSize / 4, y); + } else { + const sides = 5; + const radius = CANVAS.tileSize / 4; + for (let i = 0; i < sides; i++) { + const angle = (i * 2 * Math.PI) / sides - Math.PI / 2; + const pointX = x + radius * Math.cos(angle); + const pointY = y + radius * Math.sin(angle); + if (i === 0) CANVAS.ctx.moveTo(pointX, pointY); + else CANVAS.ctx.lineTo(pointX, pointY); + } + } + CANVAS.ctx.closePath(); + CANVAS.ctx.fill(); + }); +} + +function drawCharacterBorder(x, y, radius, damageTaken) { + const dashLength = 5; + const gapLength = Math.max(1, damageTaken * 2); // More damage, larger gaps + + CANVAS.ctx.lineWidth = 2; + CANVAS.ctx.strokeStyle = '#2d2d2d'; + CANVAS.ctx.setLineDash([dashLength, gapLength]); + CANVAS.ctx.beginPath(); + CANVAS.ctx.arc(x, y, radius, 0, 2 * Math.PI); + CANVAS.ctx.stroke(); + CANVAS.ctx.setLineDash([]); // Reset to a solid line +} + +function drawEnemies() { + enemies.forEach(enemy => { + const x = enemy.x * CANVAS.tileSize + CANVAS.tileSize / 2; + const y = enemy.y * CANVAS.tileSize + CANVAS.tileSize / 2; + const opacity = enemy.health / CONFIG.MAX_ENEMY_HEALTH; // Opacity based on health + const radius = CANVAS.tileSize / 3; + const damageTaken = CONFIG.MAX_ENEMY_HEALTH - enemy.health; + + CANVAS.ctx.beginPath(); + CANVAS.ctx.arc(x, y, radius, 0, 2 * Math.PI); + CANVAS.ctx.fillStyle = `${enemy.color}${opacity})`; + CANVAS.ctx.fill(); + + drawCharacterBorder(x, y, radius, damageTaken); + }); +} + +function drawPlayer() { + const x = player.x * CANVAS.tileSize + CANVAS.tileSize / 2; + const y = player.y * CANVAS.tileSize + CANVAS.tileSize / 2; + const radius = CANVAS.tileSize / 3; + const playerOpacity = player.health / CONFIG.PLAYER_HEALTH; // Opacity based on health + CANVAS.ctx.beginPath(); + for (let i = 0; i < 6; i++) { + const angle = (Math.PI / 3) * i; + const hexX = x + radius * Math.cos(angle); + const hexY = y + radius * Math.sin(angle); + if (i === 0) { + CANVAS.ctx.moveTo(hexX, hexY); + } else { + CANVAS.ctx.lineTo(hexX, hexY); + } + } + CANVAS.ctx.closePath(); + CANVAS.ctx.fillStyle = `${COLORS.player}${playerOpacity})`; + CANVAS.ctx.fill(); + CANVAS.ctx.lineWidth = 2; + CANVAS.ctx.strokeStyle = '#2d2d2d'; + CANVAS.ctx.stroke(); +} + +function drawCombatDots() { + for (const key in combatDots) { + const [cellX, cellY] = key.split(',').map(Number); + const dots = combatDots[key]; + dots.forEach(dot => { + CANVAS.ctx.beginPath(); + CANVAS.ctx.arc(cellX * CANVAS.tileSize + dot.x, cellY * CANVAS.tileSize + dot.y, 2, 0, Math.PI * 2); + CANVAS.ctx.fillStyle = dot.color; + CANVAS.ctx.fill(); + CANVAS.ctx.closePath(); + }); + } +} + +function handleItemCollection() { + const collectedItem = items.find(item => item.x === player.x && item.y === player.y); + if (collectedItem) { + player.itemsCollected++; + if (collectedItem.type === 'diamond') { + player.damage += 3; + console.log("Collected diamond! +3 damage on this level."); + } else if (collectedItem.type === 'pentagon') { + const healAmount = Math.floor(Math.random() * 2) + 1; + player.health = Math.min(player.health + healAmount, CONFIG.PLAYER_MAX_HEALTH); + console.log("Collected pentagon! Healed " + healAmount + " health."); + } + items = items.filter(item => item !== collectedItem); // Remove collected item + } +} + +function addCombatDots(x, y, color) { + const cellsToFill = [ + [x, y], // Center + [x - 1, y], // Left + [x + 1, y], // Right + [x, y - 1], // Up + [x, y + 1], // Down + [x - 1, y - 1], // Top-left + [x + 1, y - 1], // Top-right + [x - 1, y + 1], // Bottom-left + [x + 1, y + 1] // Bottom-right + ]; + + cellsToFill.forEach(([cellX, cellY]) => { + if (cellX >= 0 && cellX < CONFIG.GRID_SIZE && cellY >= 0 && cellY < CONFIG.GRID_SIZE) { + const key = `${cellX},${cellY}`; + if (!combatDots[key]) { + combatDots[key] = []; + } + for (let i = 0; i < CONFIG.DOTS_PER_HIT; i++) { + combatDots[key].push({ + x: Math.random() * CANVAS.tileSize, + y: Math.random() * CANVAS.tileSize, + color: color + }); + } + } + }); +} + +function movePlayer(dx, dy) { + const newX = player.x + dx; + const newY = player.y + dy; + if (isValidMove(newX, newY) && !enemies.some(enemy => enemy.x === newX && enemy.y === newY)) { + if (newX !== player.x || newY !== player.y) player.cellsTraveled++; + player.x = newX; + player.y = newY; + handleItemCollection(); // Did the player collect an item? + checkPlayerAtExit(); // Did the player get to the exit after moving? + } else { + // If an enemy is in the target cell, player stays put and does combat + const enemyInTargetCell = enemies.find(enemy => enemy.x === newX && enemy.y === newY); + if (enemyInTargetCell) { + handleDamage(player, enemyInTargetCell); + } + } + moveEnemies(); + render(); +} + +function moveEnemies() { + enemies.forEach(enemy => { + const distanceToPlayer = Math.abs(enemy.x - player.x) + Math.abs(enemy.y - player.y); + const distanceToExit = Math.abs(enemy.x - exit.x) + Math.abs(enemy.y - exit.y); // FIXME: necessary? + + // If the enemy is closer to the exit than the player, move towards the exit + // Bosses are more aggressive about chasing the player + const target = distanceToPlayer <= (enemy.isBoss ? CONFIG.ENEMY_CHASE_DISTANCE + 2 : CONFIG.ENEMY_CHASE_DISTANCE) ? player : exit; + const path = findPath(enemy, target); + + if (path.length > 1) { + const nextStep = path[1]; + const enemyInNextStep = enemies.find(e => e.x === nextStep.x && e.y === nextStep.y); + + // Is the next step occupied by an enemy? + if (!enemyInNextStep && !(nextStep.x === player.x && nextStep.y === player.y)) { + // Move to the next place + enemy.x = nextStep.x; + enemy.y = nextStep.y; + } else if (nextStep.x === player.x && nextStep.y === player.y) { + // If the player is in the next step, stay put and do combat + handleDamage(player, enemy); + } + } + }); +} + +function findPath(start, goal) { + const queue = [{ x: start.x, y: start.y, path: [] }]; + const visited = new Set(); + visited.add(`${start.x},${start.y}`); + + while (queue.length > 0) { + const { x, y, path } = queue.shift(); + const newPath = [...path, { x, y }]; + + if (x === goal.x && y === goal.y) { + return newPath; + } + + const directions = [ + { dx: 1, dy: 0 }, + { dx: -1, dy: 0 }, + { dx: 0, dy: 1 }, + { dx: 0, dy: -1 } + ]; + + directions.forEach(({ dx, dy }) => { + const newX = x + dx; + const newY = y + dy; + const key = `${newX},${newY}`; + + // Check if the new position is within the level and if it is passable + if ( + newX >= 0 && newX < CONFIG.GRID_SIZE && + newY >= 0 && newY < CONFIG.GRID_SIZE && + // Have we already been here? + !visited.has(key) && + // Is it a wall? + !walls.some(wall => wall.x === newX && wall.y === newY) && + // Is there an enemy already there? + !enemies.some(enemy => enemy.x === newX && enemy.y === newY) + ) { + queue.push({ x: newX, y: newY, path: newPath }); + visited.add(key); + } + }); + } + + return []; +} + +let combatAnimationEnabled = localStorage.getItem('combatAnimationEnabled'); +if (combatAnimationEnabled === null) { + combatAnimationEnabled = true; // default to on...is that a good idea? + localStorage.setItem('combatAnimationEnabled', combatAnimationEnabled); +} else { + combatAnimationEnabled = combatAnimationEnabled === 'true'; +} +document.getElementById('toggleShake').textContent = combatAnimationEnabled ? 'Turn Shake Off' : 'Turn Shake On'; + +function toggleShake() { + combatAnimationEnabled = !combatAnimationEnabled; + localStorage.setItem('combatAnimationEnabled', combatAnimationEnabled); + document.getElementById('toggleShake').textContent = combatAnimationEnabled ? 'Turn Shake Off' : 'Turn Shake On'; +} + +function combatAnimation() { + const canvas = document.getElementById('gameCanvas'); + canvas.classList.add('shake'); + canvas.addEventListener('animationend', () => { + canvas.classList.remove('shake'); + }, { once: true }); +} + +function handleDamage(player, enemy) { + const enemyMisses = Math.random() < 0.5; // 50% chance the enemy misses you + const cellX = player.x; + const cellY = player.y; + + if (!enemyMisses) { + player.health--; + player.totalDamageTaken++; + addCombatDots(cellX, cellY, COLORS.combatDotPlayer); // Add dots for player damage + console.log("Enemy hit! Player health: " + player.health); + } else { + console.log("Enemy missed!"); + } + + enemy.health = enemy.health - player.damage; + player.totalDamageDone++; + addCombatDots(cellX, cellY, enemy.isBoss ? COLORS.combatDotBoss : COLORS.combatDotEnemy); // Add dots for enemy damage + console.log("Player hit! Enemy health: " + enemy.health); + + if (combatAnimationEnabled) { + combatAnimation(); // Trigger the shake animation + } + + if (enemy.health <= 0) { + player.killCount++; + enemies = enemies.filter(e => e !== enemy); + if (enemy.isBoss) { + // Defeating a boss restores 3 player health + player.health = Math.min(player.health + 3, CONFIG.PLAYER_MAX_HEALTH); + console.log("Defeated a boss! Healed " + 3 + " health. Player health " + player.health); + } else if (Math.random() < 0.25) { + player.health = Math.min(player.health + 1, CONFIG.PLAYER_MAX_HEALTH); + } + } + + if (player.health <= 0) { + if (player.score > highScore) { + highScore = player.score; + localStorage.setItem('highScore', highScore); + } + alert(`Score: ${player.score}\nDistance Traveled: ${player.cellsTraveled}\nTotal Damage Dealt: ${player.totalDamageDone}\nTotal Damage Received: ${player.totalDamageTaken}\nCircles Vanquished: ${player.killCount}\n\nHigh Score: ${highScore}`); + resetGame(); + } +} + +function resetGame() { + const canvas = document.getElementById('gameCanvas'); + if (canvas.classList.contains('shake')) { + canvas.classList.remove('shake'); + } + player.health = CONFIG.PLAYER_HEALTH; + player.damage = CONFIG.PLAYER_BASE_DAMAGE; + player.bonusDamageTurns = 0; + player.totalDamageDone = 0; + player.totalDamageTaken = 0; + player.cellsTraveled = 0; + player.score = 0; + player.killCount = 0; + player.itemsCollected = 0; + player.x = 0; + player.y = 0; + combatDots = {}; + generateExit(); + generateWalls(); + generateEnemies(); + generateItems(); + render(); +} + +function checkPlayerAtExit() { + if (player.x === exit.x && player.y === exit.y) { + player.score += 1; + player.damage = CONFIG.PLAYER_BASE_DAMAGE; + console.groupCollapsed("Level complete! " + player.score); + console.log("Score: " + player.score); + console.log("Current health: " + player.health); + console.log("Distance Traveled: " + player.cellsTraveled); + console.log("Total Damage Dealt: " + player.totalDamageDone); + console.log("Total Damage Received: " + player.totalDamageTaken); + console.log("Circles Vanquished: " + player.killCount); + console.log("Items Collected: " + player.itemsCollected); + console.log("High Score: " + highScore); + console.groupEnd(); + combatDots = {}; + generateExit(); + generateWalls(); + generateEnemies(); + generateItems(); + render(); + } +} + +function render() { + drawGrid(); + drawPlayer(); + drawExit(); + drawItems(); + drawEnemies(); + drawWalls(); + drawCombatDots(); +} + +const directionMap = { + ArrowUp: [0, -1], + ArrowDown: [0, 1], + ArrowLeft: [-1, 0], + ArrowRight: [1, 0], + w: [0, -1], + s: [0, 1], + a: [-1, 0], + d: [1, 0], + h: [-1, 0], + j: [0, 1], + k: [0, -1], + l: [1, 0] +}; + +document.addEventListener('keydown', (e) => { + const direction = directionMap[e.key]; + if (direction) { + movePlayer(...direction); + checkPlayerAtExit(); + render(); + } +}); + +let touchStartX = 0; +let touchStartY = 0; + +CANVAS.canvas.addEventListener('touchstart', (e) => { + e.preventDefault(); // Prevent scrolling on touchstart + touchStartX = e.touches[0].clientX; + touchStartY = e.touches[0].clientY; +}); + +CANVAS.canvas.addEventListener('touchend', (e) => { + e.preventDefault(); // Prevent scrolling on touchend + const touchEndX = e.changedTouches[0].clientX; + const touchEndY = e.changedTouches[0].clientY; + const dx = touchEndX - touchStartX; + const dy = touchEndY - touchStartY; + + if (Math.abs(dx) > Math.abs(dy)) { + // Horizontal swipe + if (dx > 0) { + movePlayer(1, 0); // Swipe right + } else { + movePlayer(-1, 0); // Swipe left + } + } else { + // Vertical swipe + if (dy > 0) { + movePlayer(0, 1); // Swipe down + } else { + movePlayer(0, -1); // Swipe up + } + } + + render(); +}, { passive: false }); // TIL you can use passive set to false to help make preventDefault actually work? Feels like superstition + +const resizeCanvas = () => { + const rect = CANVAS.canvas.getBoundingClientRect(); + CANVAS.canvas.width = rect.width; + CANVAS.canvas.height = rect.height; + CANVAS.tileSize = CANVAS.updateTileSize(); // Update tile size based on canvas dimensions + render(); +}; + +window.addEventListener('resize', resizeCanvas); +resizeCanvas(); + +// Initial level setup +generateExit(); +generateWalls(); +generateEnemies(); +generateItems(); +render(); + + + + + + +let AUTO_PLAY = false; +let autoPlayInterval = null; + +function autoPlay() { + let lastPosition = { x: player.x, y: player.y }; + let stuckCounter = 0; + + const playerAtExit = () => player.x === exit.x && player.y === exit.y; + + const checkIfStuck = () => { + if (lastPosition.x === player.x && lastPosition.y === player.y) { + stuckCounter++; + } else { + stuckCounter = 0; + lastPosition = { x: player.x, y: player.y }; + } + return stuckCounter > 3; + }; + + const findSafestPath = (target) => { + const path = findPath(player, target); + if (path.length <= 1) { + // If you can't find a path, find the nearest enemy + const nearestEnemy = enemies.reduce((closest, enemy) => { + const distToCurrent = Math.abs(enemy.x - player.x) + Math.abs(enemy.y - player.y); + const distToClosest = closest ? Math.abs(closest.x - player.x) + Math.abs(closest.y - player.y) : Infinity; + return distToCurrent < distToClosest ? enemy : closest; + }, null); + + if (nearestEnemy) { + return [{x: player.x, y: player.y}, {x: nearestEnemy.x, y: nearestEnemy.y}]; + } + return null; + } + + const nextStep = path[1]; + const adjacentEnemies = enemies.filter(enemy => + Math.abs(enemy.x - nextStep.x) + Math.abs(enemy.y - nextStep.y) <= 1 + ); + + if (adjacentEnemies.length > 0 && player.health < 3) { + const alternativePaths = [ + {dx: 1, dy: 0}, {dx: -1, dy: 0}, + {dx: 0, dy: 1}, {dx: 0, dy: -1} + ].filter(({dx, dy}) => { + const newX = player.x + dx; + const newY = player.y + dy; + return isValidMove(newX, newY) && + !enemies.some(e => Math.abs(e.x - newX) + Math.abs(e.y - newY) <= 1); + }); + + if (alternativePaths.length > 0) { + const randomPath = alternativePaths[Math.floor(Math.random() * alternativePaths.length)]; + return [{x: player.x, y: player.y}, {x: player.x + randomPath.dx, y: player.y + randomPath.dy}]; + } + } + + return path; + }; + + const moveTowardsTarget = (target) => { + const path = findSafestPath(target); + if (path && path.length > 1) { + const nextStep = path[1]; + const dx = nextStep.x - player.x; + const dy = nextStep.y - player.y; + movePlayer(dx, dy); + return true; + } + return false; + }; + + const findBestTarget = () => { + // If health is low, prioritize healing items + if (player.health < 3) { + const healingItem = items.find(item => item.type === 'pentagon'); + if (healingItem && findPath(player, healingItem).length > 0) { + return healingItem; + } + } + + // If there's a nearby damage boost and we're healthy, grab it + const damageItem = items.find(item => + item.type === 'diamond' && + Math.abs(item.x - player.x) + Math.abs(item.y - player.y) < 5 + ); + if (damageItem && player.health > 2) { + return damageItem; + } + + // Default to exit + return exit; + }; + + const play = () => { + + if (!AUTO_PLAY) { + clearTimeout(autoPlayInterval); + autoPlayInterval = null; + return; + } + + if (playerAtExit()) return; + + if (checkIfStuck()) { + const directions = [{dx: 1, dy: 0}, {dx: -1, dy: 0}, {dx: 0, dy: 1}, {dx: 0, dy: -1}]; + const validDirections = directions.filter(({dx, dy}) => isValidMove(player.x + dx, player.y + dy)); + if (validDirections.length > 0) { + const {dx, dy} = validDirections[Math.floor(Math.random() * validDirections.length)]; + movePlayer(dx, dy); + } + } else { + const target = findBestTarget(); + moveTowardsTarget(target); + } + + autoPlayInterval = setTimeout(play, 400); + }; + + play(); +} + +document.addEventListener('keydown', (e) => { + if (e.key === 'v') { + AUTO_PLAY = !AUTO_PLAY; + if (AUTO_PLAY) { + console.log("Auto-play on"); + autoPlay(); + } else { + console.log("Auto-play off"); + } + } +}); \ No newline at end of file |