const maxDistance = 10; const minSnakePoints = 4; const speed = 1.75; const turnSpeed = 0.035; const worldSize = 4000; // Size of the "active" world area const minCollectables = 600; const collectableSize = 10; const numAISnakes = 40; const minSizeAICanSpawnAs = 25; const maxSizeAICanSpawnAs = 200; const leaderboardSize = 10; // A Grid used for optomization const gridCellSize = 100; // Size of each grid cell const gridWidth = Math.ceil(worldSize / gridCellSize); const gridHeight = Math.ceil(worldSize / gridCellSize); // Create the grids let collectableGrid = new Array(gridWidth).fill(null).map(() => new Array(gridHeight).fill(0)); let leaderboard = []; let player = null; let aiSnakes = []; let collectables = []; let gameState = "START"; let playerName = ""; let inputField; let titleAngle = 0; let titleScale = 1; let rainbowHue = 0; let camera = { x: 0, y: 0 }; class Snake { constructor(x, y, isPlayer, initialSize = minSnakePoints) { this.points = []; this.headAngle = random(TWO_PI); this.isPlayer = isPlayer; this.color = color(random(50, 220), random(50, 220), random(50, 220)); this.score = initialSize * 3; this.tillGrow = 3; this.amountLostToBoost = 0; this.dead = false; this.cautionFactor = random(0.25, 1.5) + (initialSize / maxSizeAICanSpawnAs); // How cautious this snake is this.decisionNoise = random(0, 1.5); // How "indecisive" this snake is this.agressiveFactor = random(0.15, 1.0); // How agressive this snake is this.ai_isBoosting = false; this.ai_boostDuration = 0; this.ai_amountLostToBoost = 0; this.ai_targetSnake = null; this.ai_targetDuration = 0; this.ai_circlingDistance = 100; this.ai_circlingDirection = 1; function capFirst(string) { return string.charAt(0).toUpperCase() + string.slice(1); } function getRandomInt(min, max) { return Math.floor(Math.random() * (max - min)) + min; } var name1 = ["abandoned", "able", "absolute", "adorable", "adventurous", "academic", "acceptable", "acclaimed", "accomplished", "accurate", "aching", "acidic", "acrobatic", "active", "actual", "adept", "admirable", "admired", "adolescent", "adorable", "adored", "advanced", "afraid", "affectionate", "aged", "aggravating", "aggressive", "agile", "agitated", "agonizing", "agreeable", "ajar", "alarmed", "alarming", "alert", "alienated", "alive", "all", "altruistic", "amazing", "ambitious", "ample", "amused", "amusing", "anchored", "ancient", "angelic", "angry", "anguished", "animated", "annual", "another", "antique", "anxious", "any", "apprehensive", "appropriate", "apt", "arctic", "arid", "aromatic", "artistic", "ashamed", "assured", "astonishing", "athletic", "attached", "attentive", "attractive", "austere", "authentic", "authorized", "automatic", "avaricious", "average", "aware", "awesome", "awful", "awkward", "babyish", "bad", "back", "baggy", "bare", "barren", "basic", "beautiful", "belated", "beloved", "beneficial", "better", "best", "bewitched", "big", "big-hearted", "biodegradable", "bite-sized", "bitter", "black", "black-and-white", "bland", "blank", "blaring", "bleak", "blind", "blissful", "blond", "blue", "blushing", "bogus", "boiling", "bold", "bony", "boring", "bossy", "both", "bouncy", "bountiful", "bowed", "brave", "breakable", "brief", "bright", "brilliant", "brisk", "broken", "bronze", "brown", "bruised", "bubbly", "bulky", "bumpy", "buoyant", "burdensome", "burly", "bustling", "busy", "buttery", "buzzing", "calculating", "calm", "candid", "canine", "capital", "carefree", "careful", "careless", "caring", "cautious", "cavernous", "celebrated", "charming", "cheap", "cheerful", "cheery", "chief", "chilly", "chubby", "circular", "classic", "clean", "clear", "clear-cut", "clever", "close", "closed", "cloudy", "clueless", "clumsy", "cluttered", "coarse", "cold", "colorful", "colorless", "colossal", "comfortable", "common", "compassionate", "competent", "complete", "complex", "complicated", "composed", "concerned", "concrete", "confused", "conscious", "considerate", "constant", "content", "conventional", "cooked", "cool", "cooperative", "coordinated", "corny", "corrupt", "costly", "courageous", "courteous", "crafty", "crazy", "creamy", "creative", "creepy", "criminal", "crisp", "critical", "crooked", "crowded", "cruel", "crushing", "cuddly", "cultivated", "cultured", "cumbersome", "curly", "curvy", "cute", "cylindrical", "damaged", "damp", "dangerous", "dapper", "daring", "darling", "dark", "dazzling", "dead", "deadly", "deafening", "dear", "dearest", "decent", "decimal", "decisive", "deep", "defenseless", "defensive", "defiant", "deficient", "definite", "definitive", "delayed", "delectable"]; var name2 = ["people", "history", "way", "art", "world", "information", "map", "family", "government", "health", "system", "computer", "meat", "year", "thanks", "music", "person", "reading", "method", "data", "food", "understanding", "theory", "law", "bird", "literature", "problem", "software", "control", "knowledge", "power", "ability", "economics", "love", "internet", "television", "science", "library", "nature", "fact", "product", "idea", "temperature", "investment", "area", "society", "activity", "story", "industry", "media", "thing", "oven", "community", "definition", "safety", "quality", "development", "language", "management", "player", "variety", "video", "week", "security", "country", "exam", "movie", "organization", "equipment", "physics", "analysis", "policy", "series", "thought", "basis", "boyfriend", "direction", "strategy", "technology", "army", "camera", "freedom", "paper", "environment", "child", "instance", "month", "truth", "marketing", "university", "writing", "article", "department", "difference", "goal", "news", "audience", "fishing", "growth", "income", "marriage", "user", "combination", "failure", "meaning", "medicine", "philosophy", "teacher", "communication", "night", "chemistry", "disease", "disk", "energy", "nation", "road", "role", "soup", "advertising", "location", "success", "addition", "apartment", "education", "math", "moment", "painting", "politics", "attention", "decision", "event", "property", "shopping", "student", "wood", "competition", "distribution", "entertainment", "office", "population", "president", "unit", "category", "cigarette", "context", "introduction", "opportunity", "performance"]; this.name = capFirst(name1[getRandomInt(0, name1.length)]) + ' ' + capFirst(name2[getRandomInt(0, name2.length)]); let spreadDistance = 40; // Distance between points for (let i = 0; i < initialSize; i++) { let pointX = x - cos(this.headAngle) * spreadDistance * i; let pointY = y - sin(this.headAngle) * spreadDistance * i; // Ensure the point is within the world boundaries // By looping it it sorta creates a neat effect of then not being straight // makes it look more natural even though this is technically wrong pointX = (pointX + worldSize) % worldSize; pointY = (pointY + worldSize) % worldSize; this.points.push({ x: pointX, y: pointY }); } } update() { if (this.isPlayer) { function shortestAngleDifference(from, to) { let difference = to - from; while (difference < -PI) difference += TWO_PI; while (difference > PI) difference -= TWO_PI; return difference; } let targetAngle = atan2(mouseY - height / 2, mouseX - width / 2); let angleDiff = shortestAngleDifference(this.headAngle, targetAngle); this.headAngle += angleDiff * turnSpeed; } else { this.updateAI(); } let currentSpeed = speed; if ((this.isPlayer && mouseIsPressed && this.score > 0) || (this.isBoosting && this.score > 0)) { currentSpeed *= 2.15; this.score -= 3 * (deltaTime / 1000); this.score = max(0, this.score); this.amountLostToBoost += 3 * (deltaTime / 1000); if (this.amountLostToBoost >= 1) { this.dropCollectableAtTail(); this.amountLostToBoost = 0; } } this.points[0].x += cos(this.headAngle) * currentSpeed; this.points[0].y += sin(this.headAngle) * currentSpeed; for (let i = 1; i < this.points.length; i++) { let currentPoint = this.points[i - 1]; let nextPoint = this.points[i]; let dir = { x: currentPoint.x - nextPoint.x, y: currentPoint.y - nextPoint.y, }; let dist = distance(currentPoint, nextPoint); let nDir = { x: dir.x / dist, y: dir.y / dist }; if (dist > maxDistance) { nextPoint.x += nDir.x * (dist - maxDistance); nextPoint.y += nDir.y * (dist - maxDistance); } } if (this.isPlayer) { camera.x = this.points[0].x - width / 2; camera.y = this.points[0].y - height / 2; } this.checkCollectables(); } updateAI() { // Check if we should start or stop targeting this.updateTargeting(); let targetAngle = 0; if (this.ai_targetSnake) { targetAngle = this.getTargetingAngle(); } else { targetAngle = this.findCombinedTarget(); } // Avoidance behavior let avoidanceVector = this.calculateAvoidanceVector(); if (avoidanceVector.mag() > 0) { let avoidanceAngle = atan2(avoidanceVector.y, avoidanceVector.x); // Blend targeting/seeking with avoidance targetAngle = this.blendAngles(targetAngle, avoidanceAngle, this.ai_targetSnake ? (this.cautionFactor * 1.25) : 1.0); } // Update head angle let angleDiff = this.shortestAngleDifference(this.headAngle, targetAngle); this.headAngle += angleDiff * turnSpeed; // Boosting logic (unchanged) const boostChance = (this.ai_targetSnake ? 0.001 : 0.00025) * (1.0 / this.cautionFactor); if (!this.isBoosting && random() < boostChance && this.score > 10) { this.isBoosting = true; this.boostDuration = random(3, 10); } if (this.isBoosting) { this.boostDuration -= deltaTime / 1000; if (this.boostDuration <= 0 || this.score <= 0) { this.isBoosting = false; } } } calculateAvoidanceVector() { let avoidanceVector = createVector(0, 0); let closePoints = 0; const ourRadius = this.getRadius() let allSnakes = aiSnakes; if (player !== null) allSnakes = [player, ...aiSnakes]; for (let snake of allSnakes) { if (snake === this) continue; const theirRadius = snake.getRadius(); let headDistance = dist(this.points[0].x, this.points[0].y, snake.points[0].x, snake.points[0].y); if (headDistance < 1000) { for (let point of snake.points) { let d = dist(this.points[0].x, this.points[0].y, point.x, point.y); if (d < (50 * this.cautionFactor) + (ourRadius + theirRadius)) { let escapeVector = createVector(this.points[0].x - point.x, this.points[0].y - point.y); escapeVector.normalize(); avoidanceVector.add(escapeVector); closePoints++; } } } } // Avoid world borders let borderAvoidanceDistance = (100 + ourRadius); // Distance to start avoiding borders let borderForce = 2; // Strength of border avoidance // Avoid left border if (this.points[0].x < borderAvoidanceDistance) { avoidanceVector.add(createVector(borderForce, 0)); closePoints++; } // Avoid right border if (this.points[0].x > worldSize - borderAvoidanceDistance) { avoidanceVector.add(createVector(-borderForce, 0)); closePoints++; } // Avoid top border if (this.points[0].y < borderAvoidanceDistance) { avoidanceVector.add(createVector(0, borderForce)); closePoints++; } // Avoid bottom border if (this.points[0].y > worldSize - borderAvoidanceDistance) { avoidanceVector.add(createVector(0, -borderForce)); closePoints++; } if (closePoints > 0) { avoidanceVector.div(closePoints); // Average the escape vector avoidanceVector.normalize(); } return avoidanceVector; } updateTargeting() { // Chance to start targeting if (random() < 0.001 * this.agressiveFactor) { // Adjust this probability as needed let allSnakes = aiSnakes; if (player !== null) allSnakes = [player, ...aiSnakes]; let nearest = null; let bestScore = -Infinity; for (let snake of allSnakes) { if (this === snake) continue; let d = dist(this.points[0].x, this.points[0].y, snake.points[0].x, snake.points[0].y); if (d > 400) continue; let sizeDiff = this.score - snake.score; let score = sizeDiff / d; if (score > bestScore) { bestScore = score; nearest = snake; } } if (nearest !== null) { this.ai_targetSnake = nearest; this.ai_targetDuration = random(10, 60); // Target for 10-60 seconds this.ai_circlingDirection = random() < 0.5 ? 1 : -1; // Randomly choose direction } } if (this.ai_targetSnake) { // Update targeting duration this.ai_targetDuration -= deltaTime / 1000; let d = dist(this.points[0].x, this.points[0].y, this.ai_targetSnake.points[0].x, this.ai_targetSnake.points[0].y); if (this.ai_targetDuration <= 0 || this.ai_targetSnake.dead || d > 400) { this.ai_targetDuration = 0; this.ai_targetSnake = null; } } } getTargetingAngle() { let targetHead = this.ai_targetSnake.points[0]; let toTarget = createVector(targetHead.x - this.points[0].x, targetHead.y - this.points[0].y); let distanceToTarget = toTarget.mag(); if (distanceToTarget > this.ai_circlingDistance) { // If far away, move directly towards the target return toTarget.heading(); } else { // Close enough to start circling if (this.points.length > this.ai_targetSnake.points.length) { // If longer, try to encircle the entire snake return this.getEncirclingAngle(); } else { // If shorter, circle around the head return this.getHeadCirclingAngle(); } } } getEncirclingAngle() { let targetHead = this.ai_targetSnake.points[0]; let targetTail = this.ai_targetSnake.points[this.ai_targetSnake.points.length - 1]; let center = p5.Vector.add(createVector(targetHead.x, targetHead.y), createVector(targetTail.x, targetTail.y)).div(2); let toCenter = createVector(center.x - this.points[0].x, center.y - this.points[0].y); let perpendicular = createVector(-toCenter.y, toCenter.x).normalize(); return perpendicular.heading(); } getHeadCirclingAngle() { let targetHead = this.ai_targetSnake.points[0]; let toHead = createVector(targetHead.x - this.points[0].x, targetHead.y - this.points[0].y); let perpendicular = createVector(-toHead.y, toHead.x).normalize(); return perpendicular.heading(); } blendAngles(angle1, angle2, weight) { weight = min(1.0, max(0.0, weight)); let x = cos(angle1) * (1 - weight) + cos(angle2) * weight; let y = sin(angle1) * (1 - weight) + sin(angle2) * weight; return atan2(y, x); } shortestAngleDifference(from, to) { let difference = to - from; while (difference < -PI) difference += TWO_PI; while (difference > PI) difference -= TWO_PI; return difference; } draw() { let radius = this.getRadius(); for (let i = 0; i < this.points.length; i++) { let screenX = this.points[i].x - camera.x; let screenY = this.points[i].y - camera.y; let darkenFactor = i / this.points.length; let segmentColor = this.getDarkerColor(darkenFactor); fill(segmentColor); stroke(segmentColor); circle(screenX, screenY, radius); } // Draw eyes on the head this.drawEyes(this.points[0].x - camera.x, this.points[0].y - camera.y, radius); strokeWeight(1); // Reset stroke weight } drawEyes(x, y, radius) { let eyeSize = radius * 0.4; let eyeDistance = radius * 0.5; // Calculate eye positions based on head angle let leftEyeX = x + cos(this.headAngle - PI / 4) * eyeDistance; let leftEyeY = y + sin(this.headAngle - PI / 4) * eyeDistance; let rightEyeX = x + cos(this.headAngle + PI / 4) * eyeDistance; let rightEyeY = y + sin(this.headAngle + PI / 4) * eyeDistance; // Draw eye whites //if (this.ai_targetSnake) // fill(140, 15, 15); //else fill(255); noStroke(); circle(leftEyeX, leftEyeY, eyeSize); circle(rightEyeX, rightEyeY, eyeSize); // Draw pupils let pupilSize = eyeSize * 0.6; fill(0); circle(leftEyeX + cos(this.headAngle) * eyeSize * 0.2, leftEyeY + sin(this.headAngle) * eyeSize * 0.2, pupilSize); circle(rightEyeX + cos(this.headAngle) * eyeSize * 0.2, rightEyeY + sin(this.headAngle) * eyeSize * 0.2, pupilSize); } getRadius() { let radius = 20 + Math.sqrt(this.score); return radius; } getDarkerColor(factor) { let r = red(this.color); let g = green(this.color); let b = blue(this.color); return color( r * (1 - factor * 0.5), g * (1 - factor * 0.5), b * (1 - factor * 0.5) ); } grow() { let lastPoint = this.points[this.points.length - 1]; this.points.push({ x: lastPoint.x, y: lastPoint.y }); } dropCollectableAtTail() { let tail = this.points[this.points.length - 1]; let newCollectable = { x: tail.x + random(-10, 10), // Add some randomness to prevent stacking y: tail.y + random(-10, 10) }; collectables.push(newCollectable); } checkCollectables() { for (let i = collectables.length - 1; i >= 0; i--) { if (distance(this.points[0], collectables[i]) < (this.getRadius() / 2) + (collectableSize / 2)) { this.score += 1; this.tillGrow -= 1; // Only grow each 3 points if (this.tillGrow <= 0) { this.tillGrow = 3; this.grow(); } collectables.splice(i, 1); } } } findNearestCollectableInCell(cellX, cellY) { let nearestCollectable = null; let minDist = Infinity; for (let collectable of collectables) { let collectableCell = { x: Math.floor(collectable.x / gridCellSize), y: Math.floor(collectable.y / gridCellSize) }; if (collectableCell.x === cellX && collectableCell.y === cellY) { let d = distance(this.points[0], collectable); if (d < minDist) { minDist = d; nearestCollectable = collectable; } } } return nearestCollectable; } findCombinedTarget() { let highDensityArea = this.findNearestHighDensityArea(this); if (highDensityArea) { let snakeCell = { x: Math.floor(this.points[0].x / gridCellSize), y: Math.floor(this.points[0].y / gridCellSize) }; let targetCell = { x: Math.floor(highDensityArea.x / gridCellSize), y: Math.floor(highDensityArea.y / gridCellSize) }; // If the snake is already in the target cell, look for the nearest collectable if (snakeCell.x === targetCell.x && snakeCell.y === targetCell.y) { let nearestCollectable = this.findNearestCollectableInCell(targetCell.x, targetCell.y); if (nearestCollectable) { return atan2(nearestCollectable.y - this.points[0].y, nearestCollectable.x - this.points[0].x); } } // If not in the target cell or no collectable found, move towards the center of the high-density cell return atan2(highDensityArea.y - this.points[0].y, highDensityArea.x - this.points[0].x); } // If all else fails, return the current angle (continue in the same direction) return this.headAngle; } findNearestHighDensityArea() { let snakeGridX = Math.floor(this.points[0].x / gridCellSize); let snakeGridY = Math.floor(this.points[0].y / gridCellSize); let maxDensity = 0; let bestCell = null; let searchRadius = 5; for (let dx = -searchRadius; dx <= searchRadius; dx++) { for (let dy = -searchRadius; dy <= searchRadius; dy++) { let gridX = snakeGridX + dx; let gridY = snakeGridY + dy; if (gridX >= 0 && gridX < gridWidth && gridY >= 0 && gridY < gridHeight) { let cellDensity = collectableGrid[gridX][gridY]; if (cellDensity > maxDensity) { maxDensity = cellDensity; bestCell = { x: gridX, y: gridY }; } } } } return bestCell ? { x: (bestCell.x + 0.5) * gridCellSize, y: (bestCell.y + 0.5) * gridCellSize } : null; } dropCollectables() { let radius = this.getRadius(); for (let i = 0; i < this.points.length; i++) { collectables.push({ x: this.points[i].x + random(-radius, radius), y: this.points[i].y + random(-radius, radius) }); } this.dead = true; } } resizeCanvas(800, 800); createInputField(); createPlayButton(); player = null; aiSnakes = []; collectables = []; for (let i = 0; i < numAISnakes; i++) { let x = random(0, worldSize); let y = random(0, worldSize); let initialSize = floor(random(minSnakePoints, random() > 0.1 ? minSizeAICanSpawnAs : maxSizeAICanSpawnAs)); // Random sizes aiSnakes.push(new Snake(x, y, false, initialSize)); } function killPlayer() { player = null; } function createInputField() { inputField = createInput(""); inputField.attribute('placeholder', 'Enter your name'); } function createPlayButton() { playButton = createButton('Play'); playButton.size(100, 30); playButton.mousePressed(startPlayer); } function startPlayer() { if (inputField.value().length > 0) { let playerName = inputField.value(); player = new Snake(random(worldSize), random(worldSize), true, minSnakePoints); player.name = playerName; } } function drawAnimatedTitle() { push(); translate(width / 2, height / 3); rotate(sin(titleAngle) * 0.1); scale(titleScale); textAlign(CENTER, CENTER); textSize(60); // Rainbow effect colorMode(HSB, 360, 100, 100, 1); let rainbow = color((rainbowHue % 360), 100, 100); fill(rainbow); stroke(0); strokeWeight(8); text("Slither.gg", 0, 0); pop(); // Update animation variables titleAngle += 0.05; titleScale = 1.25 + sin(titleAngle * 2) * 0.1; rainbowHue += 1; } draw = function() { // Make sure we always have enough Collectables in the world spawnCollectable(); updateCollectableGrid(); // Dont allow collectables outside the world for (let i = collectables.length - 1; i >= 0; i--) { // If this collectable exists outside the world delete it if (collectables[i].x < 100 || collectables[i].x > worldSize - 100 || collectables[i].y < 100 || collectables[i].y > worldSize - 100) { collectables.splice(i, 1); return; } } // update player, this also updates the camera if (player !== null) { player.update(); // Kill player if they go out of bounds if (player.points[0].x < 0 || player.points[0].x > worldSize || player.points[0].y < 0 || player.points[0].y > worldSize) { killPlayer(); return; } } else { camera.x = aiSnakes[0].points[0].x - width / 2; camera.y = aiSnakes[0].points[0].y - height / 2; } for (let snake of aiSnakes) snake.update(); manageAISnakes(); updateLeaderboard(); drawBackground(); drawCollectables(); if (player !== null) player.draw(); for (let snake of aiSnakes) snake.draw(); drawMinimap(); drawLeaderboard(); // Draw player coordinates and size fill(225); if (player !== null) text(`(${Math.round(player.points[0].x)}, ${Math.round(player.points[0].y)}) Score: ${player.score|0}`, 10, height - 10); text(`Collectables: ${collectables.length}` + ` AI: ${aiSnakes.length}`, 10, height - 24); text(`FPS: ${frameRate()|0}`, 10, height - 38); if (player === null) { // Draw the menu drawAnimatedTitle(); inputField.position(innerWidth / 2 - (inputField.width / 2), innerWidth / 2); playButton.position(innerWidth / 2 - 50, innerWidth / 2 + 40); inputField.show(); playButton.show(); } else { // Game is active, hide menu elements inputField.hide(); playButton.hide(); } } function spawnNewAISnake() { if (player) { const safeDistance = 500; // Minimum safe distance from player const maxAttempts = 10; // Maximum number of spawn attempts for (let i = 0; i < maxAttempts; i++) { let x = random(0, worldSize); let y = random(0, worldSize); // Check distance from player let distanceToPlayer = dist(x, y, player.points[0].x, player.points[0].y); if (distanceToPlayer >= safeDistance) { // Spawn successful aiSnakes.push(new Snake(x, y, false, minSnakePoints)); return; // Exit the function after successful spawn } } } // If we get here, all attempts failed, so force spawn at a random location let x = random(0, worldSize); let y = random(0, worldSize); aiSnakes.push(new Snake(x, y, false, minSnakePoints)); } function spawnCollectable() { if (collectables.length < minCollectables) { let x = random(0, worldSize); let y = random(0, worldSize); collectables.push({ x: x, y: y }); } } function drawCollectables() { fill(0, 255, 0); noStroke(); for (let collectable of collectables) { let screenX = collectable.x - camera.x; let screenY = collectable.y - camera.y; if (screenX > -20 && screenX < width + 20 && screenY > -20 && screenY < height + 20) { circle(screenX, screenY, collectableSize); } } } // Function to update the grid function updateCollectableGrid() { // Reset the grid for (let x = 0; x < gridWidth; x++) { for (let y = 0; y < gridHeight; y++) { collectableGrid[x][y] = 0; } } // Update the grid based on collectable positions for (let collectable of collectables) { let gridX = Math.floor(collectable.x / gridCellSize); let gridY = Math.floor(collectable.y / gridCellSize); if (gridX >= 0 && gridX < gridWidth && gridY >= 0 && gridY < gridHeight) { collectableGrid[gridX][gridY]++; } } } function manageAISnakes() { for (let i = aiSnakes.length - 1; i >= 0; i--) { let snake = aiSnakes[i]; if (player !== null) { let d = distance(player.points[0], snake.points[0]); // Check if player's head collides with AI snake body if (checkPlayerCollisionWithSnake(snake)) { killPlayer(); return; } // Check if AI snake's head collides with player's body if (checkSnakeCollisionWithPlayer(snake)) { snake.dropCollectables(); aiSnakes.splice(i, 1); continue; } } // Check collision with other snakes for (let j = 0; j < aiSnakes.length; j++) { if (i !== j && checkSnakeCollision(snake, aiSnakes[j])) { snake.dropCollectables(); aiSnakes.splice(i, 1); break; } } if (snake.points[0].x < 0 || snake.points[0].x > worldSize || snake.points[0].y < 0 || snake.points[0].y > worldSize) { snake.dropCollectables(); aiSnakes.splice(i, 1); return; } } // Spawn new snakes if there aren't enough while (aiSnakes.length < numAISnakes) { spawnNewAISnake(); } } function checkPlayerCollisionWithSnake(snake) { let playerHead = player.points[0]; let playerRadius = player.getRadius() / 2; let snakeRadius = snake.getRadius() / 2; let collisionRadius = playerRadius + snakeRadius; for (let i = 1; i < snake.points.length; i++) { if (distance(playerHead, snake.points[i]) < collisionRadius) { return true; } } return false; } function checkSnakeCollisionWithPlayer(snake) { let snakeHead = snake.points[0]; let snakeRadius = snake.getRadius() / 2; let playerRadius = player.getRadius() / 2; let collisionRadius = playerRadius + snakeRadius; for (let i = 1; i < player.points.length; i++) { if (distance(snakeHead, player.points[i]) < collisionRadius) { return true; } } return false; } function checkSnakeCollision(snake1, snake2) { let head = snake1.points[0]; let snake1Radius = snake1.getRadius() / 2; let snake2Radius = snake2.getRadius() / 2; let collisionRadius = snake1Radius + snake2Radius; for (let i = 1; i < snake2.points.length; i++) { if (distance(head, snake2.points[i]) < collisionRadius) { return true; } } return false; } function distance(p1, p2) { let dx = p2.x - p1.x; let dy = p2.y - p1.y; return Math.sqrt(dx * dx + dy * dy); } function drawMinimap() { const minimapSize = 150; const minimapMargin = 10; const minimapScale = minimapSize / worldSize; // Draw Background fill(200, 200, 200, 50); stroke(0); rect(width - minimapSize - minimapMargin, height - minimapSize - minimapMargin, minimapSize, minimapSize); noStroke(); for (let x = 0; x < gridWidth; x++) { for (let y = 0; y < gridHeight; y++) { let density = collectableGrid[x][y]; if (density > 2) { fill(0, 255, 0, density * 4.0); rect(width - minimapSize - minimapMargin + x * gridCellSize * minimapScale, height - minimapSize - minimapMargin + y * gridCellSize * minimapScale, gridCellSize * minimapScale, gridCellSize * minimapScale); } } } // Draw Player noStroke(); if (player !== null) { fill(0, 200, 0); for (let i = 0; i < player.points.length; i += 5) { if (i >= player.points.length) break; circle(width - minimapSize - minimapMargin + player.points[i].x * minimapScale, height - minimapSize - minimapMargin + player.points[i].y * minimapScale, 3); } } // Draw NPC's noStroke(); for (let snake of aiSnakes) { fill(snake.color); for (let i = 0; i < snake.points.length; i += 5) { if (i >= snake.points.length) break; circle(width - minimapSize - minimapMargin + snake.points[i].x * minimapScale, height - minimapSize - minimapMargin + snake.points[i].y * minimapScale, 3); } } // Draw Viewport noFill(); stroke(255, 0, 0); rect(width - minimapSize - minimapMargin + camera.x * minimapScale, height - minimapSize - minimapMargin + camera.y * minimapScale, width * minimapScale, height * minimapScale); } function updateLeaderboard() { // Combine player and AI snakes into one array let allSnakes = aiSnakes; if (player !== null) allSnakes = [player, ...aiSnakes]; // Sort snakes by score in descending order allSnakes.sort((a, b) => b.score - a.score); // Take the top 5 (or leaderboardSize) snakes leaderboard = allSnakes.slice(0, leaderboardSize); } function drawLeaderboard() { const leaderboardWidth = 175; const leaderboardHeight = 175; const margin = 10; // Draw leaderboard background fill(200, 200, 200, 50); stroke(0); rect(margin, margin, leaderboardWidth, leaderboardHeight); // Draw leaderboard title fill(0); noStroke(); textAlign(CENTER); textSize(12); text("Leaderboard", margin + leaderboardWidth / 2, margin + 20); // Draw leaderboard entries textAlign(LEFT); textSize(12); for (let i = 0; i < leaderboard.length; i++) { let snake = leaderboard[i]; fill(snake.color); text(`${i + 1} : ${Math.floor(snake.score)} - ${snake.name}`, margin + 10, margin + 40 + i * 14); } } function drawBackground() { // Draw the outer red rectangle (outside world) fill(255, 0, 0); // Red color noStroke(); rect(-camera.x - worldSize, -camera.y - worldSize, worldSize * 4, worldSize * 4); stroke(240); // Light grey color let gridSpacing = 50; // Adjust this value to change grid density // Draw the inner white rectangle (game world) fill(25); rect(-camera.x, -camera.y, worldSize, worldSize); // Vertical lines for (let x = 0; x <= worldSize; x += gridSpacing) { line(x - camera.x, -camera.y, x - camera.x, worldSize - camera.y); } // Horizontal lines for (let y = 0; y <= worldSize; y += gridSpacing) { line(-camera.x, y - camera.y, worldSize - camera.x, y - camera.y); } }