Update index.html

index.html

@@ -53,6 +53,7 @@
         };
         let resources = {};
         let counts = {};
+        let animalPairs = new Map(); // Tracks paired animals
 
         function initializeEntities() {
             Object.keys(entities).forEach(category => {
@@ -68,9 +69,9 @@
                 for (let col = 0; col < cols; col++) {
                     let x = col * offsetX + 150;
                     let y = row * hexHeight + (col % 2 ? offsetY : 0) + 50;
-                    hexGrid.push({ x, y, type: "empty", entities: [], pollinated: false });
+                    hexGrid.push({ x, y, type: "empty", entities: [], nourishment: 0 });
                 }
-            }
+            });
         }
 
         function selectEntity(entity) {
@@ -118,24 +119,6 @@
             return neighbors;
         }
 
-        function pollinate() {
-            hexGrid.forEach((hex, index) => {
-                if (hex.entities.some(e => entities.insects.includes(e))) {
-                    hex.entities.forEach(entity => {
-                        if (entities.plants.includes(entity)) {
-                            getNeighbors(index).forEach(n => {
-                                if (hexGrid[n].type === "empty" && Math.random() < 0.1) {
-                                    hexGrid[n].entities.push(entity);
-                                    hexGrid[n].type = "occupied";
-                                    counts[entity]++;
-                                }
-                            });
-                        }
-                    });
-                }
-            });
-        }
-
         function aStar(startIdx, goalIdx) {
             const openSet = new Set([startIdx]);
             const cameFrom = {};
@@ -175,30 +158,89 @@
             return path;
         }
 
+        function pollinate() {
+            hexGrid.forEach((hex, index) => {
+                if (hex.entities.some(e => entities.insects.includes(e))) {
+                    hex.entities.forEach(entity => {
+                        if (entities.plants.includes(entity) && Math.random() < 0.2) {
+                            hex.entities.push(entity); // Spawn plant baby in same hex
+                            counts[entity]++;
+                        }
+                    });
+                }
+            });
+        }
+
         function moveAnimals() {
             hexGrid.forEach((hex, index) => {
+                let animalsToMove = [];
                 hex.entities.forEach((entity, i) => {
                     if (entities.animals.includes(entity)) {
-                        const neighbors = getNeighbors(index);
-                        const mateIdx = neighbors.find(n => hexGrid[n].entities.includes(entity));
-                        if (mateIdx && Math.random() < 0.05) {
-                            const emptyNeighbor = neighbors.find(n => hexGrid[n].type === "empty");
-                            if (emptyNeighbor) {
-                                hexGrid[emptyNeighbor].entities.push(entity);
-                                hexGrid[emptyNeighbor].type = "occupied";
-                                counts[entity]++;
+                        let nourishment = hex.nourishment;
+                        const hasPlants = hex.entities.some(e => entities.plants.includes(e));
+                        const hasInsects = hex.entities.some(e => entities.insects.includes(e));
+
+                        // Eat plants or insects for nourishment
+                        if (hasPlants && Math.random() < 0.3) {
+                            const plantIdx = hex.entities.findIndex(e => entities.plants.includes(e));
+                            hex.entities.splice(plantIdx, 1);
+                            nourishment += 2;
+                            counts[hex.entities[plantIdx]]--;
+                        } else if (hasInsects && Math.random() < 0.5) {
+                            const insectIdx = hex.entities.findIndex(e => entities.insects.includes(e));
+                            hex.entities.splice(insectIdx, 1);
+                            nourishment += 1;
+                            counts[hex.entities[insectIdx]]--;
+                        }
+
+                        // Pair bonding and reproduction
+                        const mateCount = hex.entities.filter(e => e === entity).length;
+                        if (mateCount >= 2 && nourishment >= 2 && Math.random() < 0.1) {
+                            hex.entities.push(entity); // Spawn baby in same hex
+                            counts[entity]++;
+                            nourishment -= 2; // Cost of reproduction
+                            if (!animalPairs.has(entity + index)) {
+                                animalPairs.set(entity + index, true); // Mark as paired
                             }
-                        } else if (Math.random() < 0.2) {
-                            const path = aStar(index, mateIdx || neighbors[Math.floor(Math.random() * neighbors.length)]);
-                            if (path.length > 1) {
-                                hexGrid[path[1]].entities.push(entity);
-                                hex.entities.splice(i, 1);
-                                if (hex.entities.length === 0) hex.type = "empty";
-                                hexGrid[path[1]].type = "occupied";
+                        }
+
+                        // Movement logic
+                        const neighbors = getNeighbors(index);
+                        let goalIdx = neighbors.find(n => hexGrid[n].entities.some(e => entities.plants.includes(e)));
+                        if (!goalIdx) goalIdx = neighbors.find(n => hexGrid[n].entities.some(e => entities.insects.includes(e)));
+                        if (!goalIdx) goalIdx = neighbors[Math.floor(Math.random() * neighbors.length)];
+
+                        const path = aStar(index, goalIdx);
+                        if (path.length > 1) {
+                            animalsToMove.push({ entity, fromIdx: index, toIdx: path[1], nourishment });
+                            if (animalPairs.has(entity + index)) {
+                                // Move pair together
+                                const pairIdx = hex.entities.indexOf(entity, i + 1);
+                                if (pairIdx !== -1) {
+                                    animalsToMove.push({ entity, fromIdx: index, toIdx: path[1], nourishment });
+                                }
                             }
                         }
                     }
                 });
+
+                // Process animal movement
+                animalsToMove.forEach(move => {
+                    const fromHex = hexGrid[move.fromIdx];
+                    const toHex = hexGrid[move.toIdx];
+                    const entityIdx = fromHex.entities.indexOf(move.entity);
+                    if (entityIdx !== -1) {
+                        fromHex.entities.splice(entityIdx, 1);
+                        toHex.entities.push(move.entity);
+                        toHex.nourishment += move.nourishment;
+                        if (fromHex.entities.length === 0) fromHex.type = "empty";
+                        toHex.type = "occupied";
+                        if (animalPairs.has(move.entity + move.fromIdx)) {
+                            animalPairs.delete(move.entity + move.fromIdx);
+                            animalPairs.set(move.entity + move.toIdx, true);
+                        }
+                    }
+                });
             });
         }