Create Project Chimera MVP Web App Create a self-contained, single-file web…
- User
Prompt: Create Project Chimera MVP Web App
Create a self-contained, single-file web application that demonstrates the core gameplay of Project Chimera - a tactical roguelite deckbuilder. The MVP should run entirely in a web browser with no external dependencies.
Core Game Concept
Project Chimera combines:
- Grid-based tactical combat (like Into the Breach) where positioning matters
- Card-based actions (like Slay the Spire) where players use cards to perform actions
- Deterministic outcomes - no RNG in combat, players can see exactly what enemies will do
MVP Requirements
1. Grid System
- 6x6 grid battlefield
- Player character starts on the left side
- 2-3 enemies start on the right side
- Some grid cells should have "cover" (marked differently, blocks all damage)
- Visual indication of which cells units can move to
2. Card System
Create these basic cards:
- Strike (Cost: 1) - Deal 3 damage to an adjacent enemy
- Shoot (Cost: 2) - Deal 2 damage to any enemy in line of sight
- Move (Cost: 1) - Move up to 2 spaces
- Block (Cost: 1) - Gain 3 armor (reduces next damage taken)
- Push (Cost: 1) - Push an adjacent enemy 1 space away
Start the player with a hand of 5 random cards from a deck containing 3 Strikes, 2 Moves, 2 Shoots, 2 Blocks, 1 Push.
3. Combat Flow
- Player has 3 energy per turn
- Playing cards costs energy
- Cards are dragged from hand onto valid targets/positions
- After player ends turn, enemies execute their displayed intentions
- Draw 3 new cards at turn start (shuffle discard pile into deck if needed)
4. Enemy Behavior (Deterministic)
- Guard - Moves 1 space toward player, then attacks for 2 damage if adjacent
- Sniper - Stays in position, shoots for 3 damage if has line of sight
- Show enemy intentions above them (e.g., "Move → Attack 2")
5. Visual Design
- Clean, readable design that works on mobile browsers
- Grid cells: 50x50px minimum
- Cards: Show name, cost, and effect clearly
- Units: Simple shapes (circle for player, triangles for enemies)
- Cover: Marked with gray squares
- HP/Armor displayed on units
- Energy display
- Current turn indicator
6. Game States
- Setup: Place units on grid
- Player Turn: Can play cards and see enemy intentions
- Enemy Turn: Enemies execute their actions in sequence
- Victory: All enemies defeated
- Defeat: Player HP reaches 0
7. Mobile-Friendly UI
- Touch/click to select cards
- Drag to play cards or click card then click valid target
- Minimum touch target: 44x44px
- "End Turn" button
- Responsive layout that works on phones and desktop
8. Technical Requirements
- Single HTML file with embedded CSS and JavaScript
- No external libraries (vanilla JS only)
- Use CSS Grid or Canvas for the battlefield
- Smooth animations for moves and attacks
- Save/load state to localStorage for continuing games
Code Structure Outline
// Game state const gameState = { player: { x: 0, y: 2, hp: 10, armor: 0, energy: 3 }, enemies: [ { type: 'guard', x: 5, y: 2, hp: 5, intention: 'move-attack' }, { type: 'sniper', x: 4, y: 0, hp: 3, intention: 'shoot' } ], grid: Array(6).fill().map(() => Array(6).fill('empty')), deck: [], hand: [], discard: [], turn: 'player' }; // Core systems needed: // 1. Grid rendering and interaction // 2. Card rendering and drag/drop // 3. Turn management // 4. Combat resolution // 5. Line of sight calculation // 6. Win/lose conditionsSpecific Implementation Notes
- Line of Sight: A straight line between units with no cover cells blocking
- Energy System: Display remaining energy clearly, gray out unplayable cards
- Card Target Validation: Highlight valid targets when card is selected
- Animation: 300ms transitions for moves, 200ms for attacks
- Mobile Testing: Ensure it works on viewport width 375px (iPhone SE)
Victory Condition for MVP
Player wins if all enemies are defeated. Show a "Victory!" message with a button to restart.
Example Starting Position
Legend: P=Player, G=Guard, S=Sniper, #=Cover, .=Empty . . . # S . . . . . . . P . . . . G . . . . . . . # . . # . . . . . . .Create this as a single, self-contained HTML file that can be opened directly in a web browser. Focus on demonstrating the core tactical card-based gameplay loop with clean, functional code that could be extended into a full game.
Assistant
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Project Chimera MVP</title> <style> * { box-sizing: border-box; margin: 0; padding: 0; } body { font-family: Arial, sans-serif; line-height: 1.6; background-color: #f0f0f0; color: #333; touch-action: manipulation; -webkit-tap-highlight-color: transparent; } .game-container { max-width: 600px; margin: 0 auto; padding: 10px; display: flex; flex-direction: column; height: 100vh; } .header { display: flex; justify-content: space-between; align-items: center; padding: 10px 0; flex-wrap: wrap; } .header h1 { font-size: 1.5rem; } .player-stats { display: flex; gap: 10px; } .turn-indicator { font-weight: bold; color: #007bff; } .battlefield { display: grid; grid-template-columns: repeat(6, 1fr); grid-template-rows: repeat(6, 1fr); gap: 2px; margin: 10px 0; aspect-ratio: 1/1; max-height: 50vh; } .cell { background-color: #ddd; position: relative; min-width: 50px; min-height: 50px; display: flex; justify-content: center; align-items: center; cursor: pointer; transition: background-color 0.2s; } .cell.cover { background-color: #888; } .cell.valid-move { background-color: rgba(0, 255, 0, 0.3); } .cell.valid-target { background-color: rgba(255, 0, 0, 0.3); } .unit { position: absolute; width: 80%; height: 80%; display: flex; justify-content: center; align-items: center; transition: transform 0.3s, opacity 0.2s; z-index: 10; } .unit.player { background-color: #2196F3; border-radius: 50%; } .unit.guard { background-color: #f44336; clip-path: polygon(50% 0%, 0% 100%, 100% 100%); } .unit.sniper { background-color: #ff9800; clip-path: polygon(50% 0%, 0% 100%, 100% 100%); } .unit-stats { position: absolute; top: -20px; left: 0; right: 0; text-align: center; font-size: 0.7rem; } .intention { position: absolute; bottom: -20px; left: 0; right: 0; text-align: center; font-size: 0.7rem; color: #d32f2f; } .hand-container { margin-top: auto; padding: 10px 0; overflow-x: auto; } .cards-container { display: flex; gap: 10px; padding: 5px; min-height: 120px; } .card { background-color: white; border: 2px solid #333; border-radius: 8px; width: 80px; height: 120px; padding: 5px; display: flex; flex-direction: column; justify-content: space-between; cursor: grab; user-select: none; transition: transform 0.2s; position: relative; } .card:active { cursor: grabbing; } .card.selected { transform: translateY(-10px); box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2); } .card.unplayable { opacity: 0.6; cursor: not-allowed; } .card-cost { position: absolute; top: 5px; left: 5px; width: 20px; height: 20px; background-color: #3f51b5; color: white; border-radius: 50%; display: flex; justify-content: center; align-items: center; font-size: 0.8rem; } .card-name { text-align: center; font-weight: bold; margin-top: 15px; } .card-description { text-align: center; font-size: 0.7rem; } .controls { display: flex; justify-content: center; margin: 10px 0; } #end-turn { background-color: #4CAF50; color: white; border: none; padding: 10px 20px; border-radius: 4px; cursor: pointer; font-size: 1rem; min-width: 120px; min-height: 44px; } #end-turn:hover { background-color: #45a049; } .game-messages { text-align: center; min-height: 30px; margin: 10px 0; font-weight: bold; } .modal { display: none; position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: rgba(0, 0, 0, 0.7); z-index: 100; justify-content: center; align-items: center; } .modal-content { background-color: white; padding: 20px; border-radius: 8px; text-align: center; max-width: 80%; } .modal button { background-color: #007bff; color: white; border: none; padding: 10px 20px; border-radius: 4px; cursor: pointer; margin-top: 15px; min-height: 44px; } /* Animations */ @keyframes attack { 0% { transform: scale(1); } 50% { transform: scale(1.2); } 100% { transform: scale(1); } } .attack-animation { animation: attack 0.2s ease-in-out; } /* Responsive adjustments */ @media (max-width: 600px) { .header { flex-direction: column; align-items: flex-start; } .header h1 { margin-bottom: 10px; } .battlefield { max-height: 40vh; } .card { width: 70px; height: 100px; } .card-description { font-size: 0.6rem; } } </style> </head> <body> <div class="game-container"> <div class="header"> <h1>Project Chimera</h1> <div class="player-stats"> <div class="hp">HP: <span id="player-hp">10</span></div> <div class="armor">Armor: <span id="player-armor">0</span></div> <div class="energy">Energy: <span id="player-energy">3</span>/3</div> </div> <div class="turn-indicator">Player Turn</div> </div> <div class="battlefield"> <!-- 6x6 grid will be generated via JavaScript --> </div> <div class="hand-container"> <div class="cards-container" id="hand"> <!-- Cards will be generated via JavaScript --> </div> </div> <div class="controls"> <button id="end-turn">End Turn</button> </div> <div class="game-messages" id="game-messages"></div> </div> <div class="modal" id="victory-modal"> <div class="modal-content"> <h2>Victory!</h2> <p>You've defeated all enemies!</p> <button id="restart-game">Restart Game</button> </div> </div> <div class="modal" id="defeat-modal"> <div class="modal-content"> <h2>Defeat</h2> <p>Your character has been defeated.</p> <button id="restart-game-defeat">Restart Game</button> </div> </div> <script> // Game Constants const GRID_SIZE = 6; const PLAYER_START_HP = 10; const PLAYER_START_ENERGY = 3; const HAND_SIZE = 5; const CARDS_PER_TURN = 3; // Card definitions const CARDS = { STRIKE: { name: 'Strike', cost: 1, description: 'Deal 3 damage to an adjacent enemy', type: 'attack', damage: 3, range: 1 }, SHOOT: { name: 'Shoot', cost: 2, description: 'Deal 2 damage to any enemy in line of sight', type: 'attack', damage: 2, range: 'line' }, MOVE: { name: 'Move', cost: 1, description: 'Move up to 2 spaces', type: 'move', distance: 2 }, BLOCK: { name: 'Block', cost: 1, description: 'Gain 3 armor', type: 'skill', armor: 3 }, PUSH: { name: 'Push', cost: 1, description: 'Push an adjacent enemy 1 space away', type: 'skill', range: 1 } }; // Initial deck composition const INITIAL_DECK = [ 'STRIKE', 'STRIKE', 'STRIKE', 'MOVE', 'MOVE', 'SHOOT', 'SHOOT', 'BLOCK', 'BLOCK', 'PUSH' ]; // Game state let gameState = { player: { x: 0, y: 2, hp: PLAYER_START_HP, armor: 0 }, enemies: [ { type: 'guard', x: 5, y: 2, hp: 5, intention: 'move-attack' }, { type: 'sniper', x: 4, y: 0, hp: 3, intention: 'shoot' } ], grid: Array(GRID_SIZE).fill().map(() => Array(GRID_SIZE).fill('empty')), deck: [], hand: [], discard: [], energy: PLAYER_START_ENERGY, turn: 'player', selectedCard: null, gameOver: false }; // DOM elements const battlefieldEl = document.querySelector('.battlefield'); const handEl = document.getElementById('hand'); const playerHpEl = document.getElementById('player-hp'); const playerArmorEl = document.getElementById('player-armor'); const playerEnergyEl = document.getElementById('player-energy'); const turnIndicatorEl = document.querySelector('.turn-indicator'); const endTurnBtn = document.getElementById('end-turn'); const gameMessagesEl = document.getElementById('game-messages'); const victoryModalEl = document.getElementById('victory-modal'); const defeatModalEl = document.getElementById('defeat-modal'); const restartBtns = document.querySelectorAll('#restart-game, #restart-game-defeat'); // Initialize the game function initGame() { // Set up the grid setupGrid(); // Place cover on the grid according to the example gameState.grid[0][3] = 'cover'; // x=3, y=0 gameState.grid[4][1] = 'cover'; // x=1, y=4 gameState.grid[4][4] = 'cover'; // x=4, y=4 // Initialize deck and draw starting hand gameState.deck = [...INITIAL_DECK]; shuffleDeck(); drawCards(HAND_SIZE); // Save initial state saveGame(); // Render everything renderGame(); } // Set up the grid function setupGrid() { battlefieldEl.innerHTML = ''; for (let y = 0; y < GRID_SIZE; y++) { for (let x = 0; x < GRID_SIZE; x++) { const cell = document.createElement('div'); cell.className = 'cell'; cell.dataset.x = x; cell.dataset.y = y; cell.addEventListener('click', () => handleCellClick(x, y)); battlefieldEl.appendChild(cell); } } } // Shuffle the deck function shuffleDeck() { for (let i = gameState.deck.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [gameState.deck[i], gameState.deck[j]] = [gameState.deck[j], gameState.deck[i]]; } } // Draw cards from the deck function drawCards(count) { for (let i = 0; i < count; i++) { if (gameState.deck.length === 0 && gameState.discard.length > 0) { // Shuffle discard into deck gameState.deck = [...gameState.discard]; gameState.discard = []; shuffleDeck(); } if (gameState.deck.length > 0) { const card = gameState.deck.pop(); gameState.hand.push(card); } } } // Render the entire game state function renderGame() { renderGrid(); renderHand(); updateStats(); updateTurnIndicator(); } // Render the grid and units function renderGrid() { // Clear all units and cell states document.querySelectorAll('.unit').forEach(el => el.remove()); document.querySelectorAll('.cell').forEach(cell => { cell.className = 'cell'; if (gameState.grid[cell.dataset.y][cell.dataset.x] === 'cover') { cell.classList.add('cover'); } }); // Render player renderUnit('player', gameState.player); // Render enemies gameState.enemies.forEach(enemy => renderUnit(enemy.type, enemy)); // If a card is selected, show valid targets if (gameState.selectedCard !== null) { showValidTargets(gameState.selectedCard); } } // Render a unit on the grid function renderUnit(type, unit) { const cell = document.querySelector(`.cell[data-x="${unit.x}"][data-y="${unit.y}"]`); if (!cell) return; const unitEl = document.createElement('div'); unitEl.className = `unit ${type}`; // Add unit stats const statsEl = document.createElement('div'); statsEl.className = 'unit-stats'; statsEl.textContent = `HP: ${unit.hp}`; if (unit.armor > 0) { statsEl.textContent += ` | Armor: ${unit.armor}`; } unitEl.appendChild(statsEl); // Add enemy intention if (type !== 'player' && unit.intention) { const intentionEl = document.createElement('div'); intentionEl.className = 'intention'; let intentionText = ''; if (unit.intention === 'move-attack') { intentionText = 'Move → Attack 2'; } else if (unit.intention === 'shoot') { intentionText = 'Shoot 3'; } intentionEl.textContent = intentionText; unitEl.appendChild(intentionEl); } cell.appendChild(unitEl); } // Render the player's hand function renderHand() { handEl.innerHTML = ''; gameState.hand.forEach((cardType, index) => { const card = CARDS[cardType]; const cardEl = document.createElement('div'); cardEl.className = 'card'; cardEl.dataset.index = index; cardEl.dataset.type = cardType; // Check if card is playable if (card.cost > gameState.energy) { cardEl.classList.add('unplayable'); } // Add cost const costEl = document.createElement('div'); costEl.className = 'card-cost'; costEl.textContent = card.cost; cardEl.appendChild(costEl); // Add name const nameEl = document.createElement('div'); nameEl.className = 'card-name'; nameEl.textContent = card.name; cardEl.appendChild(nameEl); // Add description const descEl = document.createElement('div'); descEl.className = 'card-description'; descEl.textContent = card.description; cardEl.appendChild(descEl); // Add event listeners cardEl.addEventListener('click', () => handleCardClick(index)); // Add draggable functionality cardEl.draggable = card.cost <= gameState.energy; cardEl.addEventListener('dragstart', (e) => handleDragStart(e, index)); handEl.appendChild(cardEl); }); } // Update player stats function updateStats() { playerHpEl.textContent = gameState.player.hp; playerArmorEl.textContent = gameState.player.armor; playerEnergyEl.textContent = gameState.energy; } // Update turn indicator function updateTurnIndicator() { turnIndicatorEl.textContent = gameState.turn === 'player' ? 'Player Turn' : 'Enemy Turn'; } // Handle card click function handleCardClick(index) { const cardType = gameState.hand[index]; const card = CARDS[cardType]; // Check if the card is playable if (card.cost > gameState.energy) { return; } // Toggle selection if (gameState.selectedCard === index) { gameState.selectedCard = null; document.querySelectorAll('.card').forEach(el => el.classList.remove('selected')); document.querySelectorAll('.cell').forEach(cell => { cell.classList.remove('valid-move', 'valid-target'); }); } else { gameState.selectedCard = index; document.querySelectorAll('.card').forEach(el => el.classList.remove('selected')); document.querySelector(`.card[data-index="${index}"]`).classList.add('selected'); showValidTargets(index); } } // Handle drag start function handleDragStart(e, index) { const cardType = gameState.hand[index]; const card = CARDS[cardType]; // Check if the card is playable if (card.cost > gameState.energy) { e.preventDefault(); return; } e.dataTransfer.setData('text/plain', index); gameState.selectedCard = index; showValidTargets(index); } // Show valid targets for a selected card function showValidTargets(index) { document.querySelectorAll('.cell').forEach(cell => { cell.classList.remove('valid-move', 'valid-target'); }); const cardType = gameState.hand[index]; const card = CARDS[cardType]; const x = parseInt(gameState.player.x); const y = parseInt(gameState.player.y); switch (card.type) { case 'move': // Show cells where player can move const validMoves = getValidMoves(x, y, card.distance); validMoves.forEach(([tx, ty]) => { const cell = document.querySelector(`.cell[data-x="${tx}"][data-y="${ty}"]`); if (cell) cell.classList.add('valid-move'); }); break; case 'attack': // Show valid attack targets const validTargets = getValidAttackTargets(x, y, card); validTargets.forEach(([tx, ty]) => { const cell = document.querySelector(`.cell[data-x="${tx}"][data-y="${ty}"]`); if (cell) cell.classList.add('valid-target'); }); break; case 'skill': if (cardType === 'BLOCK') { // Block targets the player const cell = document.querySelector(`.cell[data-x="${x}"][data-y="${y}"]`); if (cell) cell.classList.add('valid-target'); } else if (cardType === 'PUSH') { // Push targets adjacent enemies const adjacentEnemies = getAdjacentEnemies(x, y); adjacentEnemies.forEach(([tx, ty]) => { const cell = document.querySelector(`.cell[data-x="${tx}"][data-y="${ty}"]`); if (cell) cell.classList.add('valid-target'); }); } break; } } // Get valid moves for a position function getValidMoves(x, y, distance) { const moves = []; const visited = new Set(); const queue = [[x, y, 0]]; // [x, y, distanceSoFar] while (queue.length > 0) { const [cx, cy, dist] = queue.shift(); const key = `${cx},${cy}`; if (visited.has(key)) continue; visited.add(key); if (dist > 0) { moves.push([cx, cy]); } if (dist < distance) { // Check adjacent cells const directions = [[-1, 0], [1, 0], [0, -1], [0, 1]]; for (const [dx, dy] of directions) { const nx = cx + dx; const ny = cy + dy; // Check if within grid bounds if (nx >= 0 && nx < GRID_SIZE && ny >= 0 && ny < GRID_SIZE) { // Check if cell is empty (not cover and no unit) if (gameState.grid[ny][nx] !== 'cover' && !isUnitAt(nx, ny)) { queue.push([nx, ny, dist + 1]); } } } } } return moves; } // Get valid attack targets function getValidAttackTargets(x, y, card) { const targets = []; if (card.range === 1) { // Adjacent targets const directions = [[-1, 0], [1, 0], [0, -1], [0, 1]]; for (const [dx, dy] of directions) { const tx = x + dx; const ty = y + dy; if (tx >= 0 && tx < GRID_SIZE && ty >= 0 && ty < GRID_SIZE) { const enemy = getEnemyAt(tx, ty); if (enemy) { targets.push([tx, ty]); } } } } else if (card.range === 'line') { // Line of sight targets gameState.enemies.forEach(enemy => { if (hasLineOfSight(x, y, enemy.x, enemy.y)) { targets.push([enemy.x, enemy.y]); } }); } return targets; } // Get adjacent enemies function getAdjacentEnemies(x, y) { const enemies = []; const directions = [[-1, 0], [1, 0], [0, -1], [0, 1]]; for (const [dx, dy] of directions) { const tx = x + dx; const ty = y + dy; if (tx >= 0 && tx < GRID_SIZE && ty >= 0 && ty < GRID_SIZE) { const enemy = getEnemyAt(tx, ty); if (enemy) { enemies.push([tx, ty]); } } } return enemies; } // Check if a unit is at a position function isUnitAt(x, y) { // Check player if (gameState.player.x === x && gameState.player.y === y) { return true; } // Check enemies return gameState.enemies.some(enemy => enemy.x === x && enemy.y === y); } // Get enemy at a position function getEnemyAt(x, y) { return gameState.enemies.find(enemy => enemy.x === x && enemy.y === y); } // Check if there's a line of sight between two points function hasLineOfSight(x1, y1, x2, y2) { // If points are the same, there's no line of sight if (x1 === x2 && y1 === y2) return false; // Get the line between the points using Bresenham's line algorithm const line = getLine(x1, y1, x2, y2); // Check if any point in the line (except start and end) is blocked for (let i = 1; i < line.length - 1; i++) { const [x, y] = line[i]; if (gameState.grid[y][x] === 'cover') { return false; } } return true; } // Bresenham's line algorithm function getLine(x1, y1, x2, y2) { const points = []; const dx = Math.abs(x2 - x1); const dy = Math.abs(y2 - y1); const sx = x1 < x2 ? 1 : -1; const sy = y1 < y2 ? 1 : -1; let err = dx - dy; while (true) { points.push([x1, y1]); if (x1 === x2 && y1 === y2) break; const e2 = 2 * err; if (e2 > -dy) { err -= dy; x1 += sx; } if (e2 < dx) { err += dx; y1 += sy; } } return points; } // Handle cell click function handleCellClick(x, y) { if (gameState.turn !== 'player' || gameState.gameOver) return; if (gameState.selectedCard !== null) { const cardType = gameState.hand[gameState.selectedCard]; const card = CARDS[cardType]; if (card.cost > gameState.energy) { return; } let validAction = false; switch (card.type) { case 'move': const validMoves = getValidMoves(gameState.player.x, gameState.player.y, card.distance); const isValidMove = validMoves.some(([tx, ty]) => tx === x && ty === y); if (isValidMove) { movePlayer(x, y); validAction = true; } break; case 'attack': const validTargets = getValidAttackTargets(gameState.player.x, gameState.player.y, card); const isValidTarget = validTargets.some(([tx, ty]) => tx === x && ty === y); if (isValidTarget) { attackEnemy(x, y, card.damage); validAction = true; } break; case 'skill': if (cardType === 'BLOCK' && x === gameState.player.x && y === gameState.player.y) { // Block skill gameState.player.armor += card.armor; validAction = true; } else if (cardType === 'PUSH') { // Push skill const adjacentEnemies = getAdjacentEnemies(gameState.player.x, gameState.player.y); const isValidPush = adjacentEnemies.some(([tx, ty]) => tx === x && ty === y); if (isValidPush) { pushEnemy(x, y); validAction = true; } } break; } if (validAction) { // Use the card gameState.energy -= card.cost; gameState.discard.push(gameState.hand[gameState.selectedCard]); gameState.hand.splice(gameState.selectedCard, 1); gameState.selectedCard = null; // Update the game renderGame(); saveGame(); } } } // Move the player function movePlayer(x, y) { gameState.player.x = x; gameState.player.y = y; } // Attack an enemy function attackEnemy(x, y, damage) { const enemy = getEnemyAt(x, y); if (!enemy) return; const unitEl = document.querySelector(`.cell[data-x="${x}"][data-y="${y}"] .unit`); if (unitEl) { unitEl.classList.add('attack-animation'); setTimeout(() => { unitEl.classList.remove('attack-animation'); }, 200); } // Apply damage, considering armor if (enemy.armor > 0) { if (enemy.armor >= damage) { enemy.armor -= damage; damage = 0; } else { damage -= enemy.armor; enemy.armor = 0; } } enemy.hp -= damage; // Check if enemy is defeated if (enemy.hp <= 0) { const index = gameState.enemies.findIndex(e => e.x === x && e.y === y); gameState.enemies.splice(index, 1); // Check for victory if (gameState.enemies.length === 0) { gameState.gameOver = true; setTimeout(() => { victoryModalEl.style.display = 'flex'; }, 500); } } } // Push an enemy function pushEnemy(x, y) { const enemy = getEnemyAt(x, y); if (!enemy) return; // Calculate push direction const dx = x - gameState.player.x; const dy = y - gameState.player.y; // Normalize direction (we only push in cardinal directions) let nx = 0, ny = 0; if (Math.abs(dx) > Math.abs(dy)) { nx = dx > 0 ? 1 : -1; } else { ny = dy > 0 ? 1 : -1; } const newX = x + nx; const newY = y + ny; // Check if push destination is valid if ( newX >= 0 && newX < GRID_SIZE && newY >= 0 && newY < GRID_SIZE && gameState.grid[newY][newX] !== 'cover' && !isUnitAt(newX, newY) ) { enemy.x = newX; enemy.y = newY; } } // End player turn and start enemy turn function endPlayerTurn() { if (gameState.turn !== 'player' || gameState.gameOver) return; gameState.turn = 'enemy'; renderGame(); // Add a small delay before enemy actions setTimeout(() => { processEnemyTurn(); }, 500); } // Process enemy turn function processEnemyTurn() { // Process each enemy action for (let i = 0; i < gameState.enemies.length; i++) { const enemy = gameState.enemies[i]; setTimeout(() => { if (enemy.intention === 'move-attack') { // Guard: Move towards player, then attack if adjacent moveEnemyTowardsPlayer(enemy); // After moving, check if adjacent to player if (isAdjacentToPlayer(enemy.x, enemy.y)) { attackPlayer(enemy, 2); // Guard attacks for 2 damage } } else if (enemy.intention === 'shoot') { // Sniper: Shoot if has line of sight if (hasLineOfSight(enemy.x, enemy.y, gameState.player.x, gameState.player.y)) { attackPlayer(enemy, 3); // Sniper attacks for 3 damage } } // If this was the last enemy, end the enemy turn if (i === gameState.enemies.length - 1) { setTimeout(() => { startPlayerTurn(); }, 500); } }, i * 800); // Stagger enemy actions } // If no enemies left, start player turn immediately if (gameState.enemies.length === 0) { startPlayerTurn(); } } // Move enemy towards player function moveEnemyTowardsPlayer(enemy) { const ex = enemy.x; const ey = enemy.y; const px = gameState.player.x; const py = gameState.player.y; // Calculate direction towards player const dx = px > ex ? 1 : (px < ex ? -1 : 0); const dy = py > ey ? 1 : (py < ey ? -1 : 0); // Try moving horizontally first if (dx !== 0) { const newX = ex + dx; const newY = ey; if ( newX >= 0 && newX < GRID_SIZE && gameState.grid[newY][newX] !== 'cover' && !isUnitAt(newX, newY) ) { enemy.x = newX; renderGame(); return; } } // If can't move horizontally, try vertically if (dy !== 0) { const newX = ex; const newY = ey + dy; if ( newY >= 0 && newY < GRID_SIZE && gameState.grid[newY][newX] !== 'cover' && !isUnitAt(newX, newY) ) { enemy.y = newY; renderGame(); return; } } // If can't move in primary directions, try diagonals if (dx !== 0 && dy !== 0) { // Try diagonal const newX = ex + dx; const newY = ey + dy; if ( newX >= 0 && newX < GRID_SIZE && newY >= 0 && newY < GRID_SIZE && gameState.grid[newY][newX] !== 'cover' && !isUnitAt(newX, newY) ) { enemy.x = newX; enemy.y = newY; renderGame(); } } } // Check if a position is adjacent to the player function isAdjacentToPlayer(x, y) { const directions = [[-1, 0], [1, 0], [0, -1], [0, 1]]; for (const [dx, dy] of directions) { const nx = x + dx; const ny = y + dy; if (nx === gameState.player.x && ny === gameState.player.y) { return true; } } return false; } // Attack the player function attackPlayer(enemy, damage) { const playerEl = document.querySelector(`.cell[data-x="${gameState.player.x}"][data-y="${gameState.player.y}"] .unit`); if (playerEl) { playerEl.classList.add('attack-animation'); setTimeout(() => { playerEl.classList.remove('attack-animation'); }, 200); } // Apply damage, considering armor if (gameState.player.armor > 0) { if (gameState.player.armor >= damage) { gameState.player.armor -= damage; damage = 0; } else { damage -= gameState.player.armor; gameState.player.armor = 0; } } gameState.player.hp -= damage; // Check for defeat if (gameState.player.hp <= 0) { gameState.gameOver = true; setTimeout(() => { defeatModalEl.style.display = 'flex'; }, 500); } renderGame(); } // Start a new player turn function startPlayerTurn() { gameState.turn = 'player'; gameState.energy = PLAYER_START_ENERGY; drawCards(CARDS_PER_TURN); renderGame(); saveGame(); } // Save game to localStorage function saveGame() { localStorage.setItem('projectChimeraSave', JSON.stringify(gameState)); } // Load game from localStorage function loadGame() { const savedGame = localStorage.getItem('projectChimeraSave'); if (savedGame) { gameState = JSON.parse(savedGame); renderGame(); } else { initGame(); } } // Restart the game function restartGame() { gameState = { player: { x: 0, y: 2, hp: PLAYER_START_HP, armor: 0 }, enemies: [ { type: 'guard', x: 5, y: 2, hp: 5, intention: 'move-attack' }, { type: 'sniper', x: 4, y: 0, hp: 3, intention: 'shoot' } ], grid: Array(GRID_SIZE).fill().map(() => Array(GRID_SIZE).fill('empty')), deck: [], hand: [], discard: [], energy: PLAYER_START_ENERGY, turn: 'player', selectedCard: null, gameOver: false }; victoryModalEl.style.display = 'none'; defeatModalEl.style.display = 'none'; initGame(); } // Event listeners endTurnBtn.addEventListener('click', endPlayerTurn); restartBtns.forEach(btn => btn.addEventListener('click', restartGame)); // Handle drop events for the grid battlefieldEl.addEventListener('dragover', (e) => { e.preventDefault(); }); battlefieldEl.addEventListener('drop', (e) => { e.preventDefault(); const cardIndex = e.dataTransfer.getData('text/plain'); if (cardIndex === '') return; const cell = e.target.closest('.cell'); if (!cell) return; const x = parseInt(cell.dataset.x); const y = parseInt(cell.dataset.y); handleCellClick(x, y); }); // Initialize the game on load window.addEventListener('load', loadGame); </script> </body> </html>Would you like me to explain or break down the code?
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.