diff --git a/index.html b/index.html
index 6bcd4d9..2f756db 100644
--- a/index.html
+++ b/index.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
   <meta charset="UTF-8" />
-  <title>Virtual World</title>
+  <title>Virtual World: More Rabbits, Separate Wolf Spawning</title>
   <style>
     body {
       margin: 0;
@@ -10,33 +10,27 @@
       background: #e0f7fa;
       font-family: sans-serif;
     }
-
     #app {
       display: flex;
       flex-direction: column;
       align-items: center;
       padding: 10px;
     }
-
     h1 {
       margin: 5px;
       color: #333;
     }
-
     #controls {
       margin-bottom: 5px;
     }
-
     canvas {
       background: #ffffff;
       border: 2px solid #444;
       cursor: grab;
     }
-
     canvas:active {
       cursor: grabbing;
     }
-
     #log {
       width: 800px;
       height: 120px;
@@ -47,7 +41,6 @@
       padding: 5px;
       font-size: 0.9rem;
     }
-    
     .log-entry {
       margin: 2px 0;
     }
@@ -56,23 +49,22 @@
 <body>
 
 <div id="app">
-  <h1>Virtual World</h1>
+  <h1>Virtual World: Rabbits & Wolves (Separated Spawn)</h1>
   <p id="controls">Drag to move the map, scroll to zoom in/out.</p>
   <canvas id="worldCanvas" width="800" height="600"></canvas>
   <div id="log"></div>
 </div>
 
 <script>
-/* 
+/*
   ---------------------------------------------------------------------------------
-  Virtual World Simulation with:
-    - Builder & Farmer Professions
-    - Hunger & Energy
-    - Fruit Trees (gather fruit, plant new trees)
-    - Houses (store fruit, citizens can eat & rest)
-    - Roads automatically built between houses once they finish construction!
-    - Logging & Pan/Zoom
-    - Child Birth Events
+  Key Differences:
+   - STARTING_RABBITS = 30 (spawned randomly across [-1000, 1000])
+   - STARTING_WOLVES = 5 (spawned in a separate area [500..1000])
+   - Rest of the simulation remains the same:
+       * Citizens with Professions, Houses, Roads, Fruit Trees
+       * Rabbits & Wolves Reproduction
+       * Basic Predator/Prey & Combat
   ---------------------------------------------------------------------------------
 */
 
@@ -94,24 +86,27 @@ let lastMouseY = 0;
 // Frame counter for timed events
 let frameCount = 0;
 
-// Shared city storage for wood
+// City storage for wood
 const cityStorage = {
   wood: 0
 };
 
-// Array of resource nodes (trees & fruit trees)
+// Resource nodes (trees & fruit trees)
 let resources = [];
 
-// Buildings array (includes both House sites and Road sites)
+// Buildings array (houses, roads)
 let buildings = [];
 
 // Citizens
 let citizens = [];
 
+// Animals (rabbits & wolves)
+let animals = [];
+
 /**********************************************************************
  * SIMULATION CONSTANTS
  **********************************************************************/
-// Hunger & Energy
+// Hunger & energy for citizens
 const HUNGER_INCREMENT = 0.005;   
 const ENERGY_DECREMENT_WORK = 0.02;
 const ENERGY_INCREMENT_REST = 0.05;
@@ -120,12 +115,16 @@ const ENERGY_THRESHOLD = 30;
 const HUNGER_MAX = 100;
 const ENERGY_MAX = 100;
 
-// House building requirements
+// House building
 const HOUSE_WOOD_REQUIRED = 50;
 const HOUSE_BUILD_RATE = 0.2;
 const HOUSE_MAX_FRUIT = 30;
 
-// Fruit tree resource
+// Road building
+const ROAD_WOOD_REQUIRED = 10;
+const ROAD_BUILD_RATE = 0.3;
+
+// Fruit trees
 const FRUIT_TREE_START_AMOUNT = 20;
 const FRUIT_GATHER_RATE = 1;
 const FRUIT_PLANT_COST = 1;
@@ -133,10 +132,26 @@ const FRUIT_PLANT_COST = 1;
 // Professions
 const PROFESSIONS = ["Farmer", "Builder"];
 
-// Road building requirements
-// We'll make roads also be "buildings" with buildingType = "Road"
-const ROAD_WOOD_REQUIRED = 10;
-const ROAD_BUILD_RATE = 0.3;
+// Weapons
+const WEAPON_WOOD_COST = 10; // cost for a citizen to craft a weapon
+
+// Animal logic
+const STARTING_RABBITS = 30;
+const STARTING_WOLVES = 5;
+
+// Rabbit hunger
+const RABBIT_HUNGER_INCREMENT = 0.003; 
+// Wolf hunger
+const WOLF_HUNGER_INCREMENT = 0.006;  
+
+const ANIMAL_HUNGER_MAX = 100;  
+const KNOCKBACK_DISTANCE = 20;  
+
+// Reproduction
+const RABBIT_REPRO_COOLDOWN = 3000; // frames (~50s if ~60fps)
+const WOLF_REPRO_COOLDOWN   = 5000; // ~80s
+const RABBIT_REPRO_CHANCE   = 0.0005;  
+const WOLF_REPRO_CHANCE     = 0.0003;  
 
 /**********************************************************************
  * LOGGING
@@ -184,7 +199,8 @@ function createCitizen(name, x, y) {
     carryingFruit: 0,
     carryingCapacity: 10,
     hunger: 0,
-    energy: ENERGY_MAX
+    energy: ENERGY_MAX,
+    hasWeapon: false
   };
 }
 
@@ -192,18 +208,6 @@ function createResource(type, x, y, amount) {
   return { type, x, y, amount };
 }
 
-/**
- * Buildings can be:
- *  - House:
- *      x, y, buildingType="House"
- *      requiredWood, deliveredWood, buildProgress, completed
- *      storedFruit, maxFruit
- *  - Road:
- *      buildingType="Road"
- *      (x, y) as midpoint for drawing info
- *      x1, y1, x2, y2 for endpoints
- *      requiredWood, deliveredWood, buildProgress, completed
- */
 function createHouseSite(x, y) {
   return {
     buildingType: "House",
@@ -219,15 +223,13 @@ function createHouseSite(x, y) {
 }
 
 function createRoadSite(x1, y1, x2, y2) {
-  // midpoint for label
   const mx = (x1 + x2) / 2;
   const my = (y1 + y2) / 2;
-
   return {
     buildingType: "Road",
-    x: mx, 
+    x: mx,
     y: my,
-    x1, y1, 
+    x1, y1,
     x2, y2,
     requiredWood: ROAD_WOOD_REQUIRED,
     deliveredWood: 0,
@@ -236,18 +238,35 @@ function createRoadSite(x1, y1, x2, y2) {
   };
 }
 
+/** Animals: Rabbit & Wolf */
+function createAnimal(type, x, y) {
+  const initialCooldown = (type === "Rabbit") 
+    ? randInt(0, RABBIT_REPRO_COOLDOWN) 
+    : randInt(0, WOLF_REPRO_COOLDOWN);
+  return {
+    type,          
+    x, 
+    y,
+    vx: (Math.random() - 0.5) * 0.4,
+    vy: (Math.random() - 0.5) * 0.4,
+    hunger: 0,     
+    dead: false,
+    reproductionCooldown: initialCooldown
+  };
+}
+
 /**********************************************************************
  * WORLD INITIALIZATION
  **********************************************************************/
 function initWorld() {
-  // Create some normal wood trees
+  // Create normal trees
   for (let i = 0; i < 15; i++) {
     const x = randInt(-1000, 1000);
     const y = randInt(-1000, 1000);
     resources.push(createResource("Tree", x, y, 100));
   }
 
-  // Create some fruit trees
+  // Create fruit trees
   for (let i = 0; i < 10; i++) {
     const x = randInt(-1000, 1000);
     const y = randInt(-1000, 1000);
@@ -261,22 +280,46 @@ function initWorld() {
     logAction(`Citizen joined: ${c.name} [${c.profession}]`);
   }
 
+  // Spawn more rabbits all across the map
+  for (let i = 0; i < STARTING_RABBITS; i++) {
+    const rx = randInt(-1000, 1000);
+    const ry = randInt(-1000, 1000);
+    animals.push(createAnimal("Rabbit", rx, ry));
+  }
+
+  // Spawn wolves in a distant region (e.g. x,y in [500..1000])
+  for (let i = 0; i < STARTING_WOLVES; i++) {
+    const wx = randInt(500, 1000);
+    const wy = randInt(500, 1000);
+    animals.push(createAnimal("Wolf", wx, wy));
+  }
+
   // Start simulation
   requestAnimationFrame(update);
 }
 
 /**********************************************************************
- * UPDATE LOOP
+ * MAIN UPDATE LOOP
  **********************************************************************/
 function update() {
   frameCount++;
 
-  // Update each citizen
+  // Update citizens
   citizens.forEach((cit) => {
     updateCitizen(cit);
   });
 
-  // Periodically add new citizens (child births)
+  // Update animals
+  animals.forEach((ani) => {
+    if (!ani.dead) {
+      updateAnimal(ani);
+    }
+  });
+
+  // Remove any dead animals
+  animals = animals.filter(a => !a.dead);
+
+  // Periodic child births for citizens
   if (frameCount % 600 === 0) {
     const baby = createCitizen(randomName(), randInt(-200, 200), randInt(-200, 200));
     citizens.push(baby);
@@ -286,17 +329,12 @@ function update() {
   // Update buildings
   buildings.forEach((b) => {
     if (!b.completed && b.deliveredWood >= b.requiredWood) {
-      // House or Road? Different build rates
-      let buildRate = HOUSE_BUILD_RATE;
-      if (b.buildingType === "Road") {
-        buildRate = ROAD_BUILD_RATE;
-      }
+      let buildRate = (b.buildingType === "Road") ? ROAD_BUILD_RATE : HOUSE_BUILD_RATE;
       b.buildProgress += buildRate;
       if (b.buildProgress >= 100) {
         b.completed = true;
         if (b.buildingType === "House") {
           logAction(`A new House is completed at (${b.x}, ${b.y})!`);
-          // Once the house is completed, build a road from it to the nearest house
           maybeBuildRoad(b);
         } else {
           logAction(`A Road has been completed!`);
@@ -310,30 +348,27 @@ function update() {
 }
 
 /**********************************************************************
- * CITIZEN UPDATE (AI + Movement)
+ * CITIZEN UPDATE
  **********************************************************************/
 function updateCitizen(cit) {
-  // Hunger & energy
+  // Basic hunger & energy
   cit.hunger += HUNGER_INCREMENT;
   if (cit.hunger > HUNGER_MAX) cit.hunger = HUNGER_MAX;
 
-  if (cit.task === 'chop' || cit.task === 'gatherFruit' || cit.task === 'build') {
+  if (["chop","gatherFruit","build"].includes(cit.task)) {
     cit.energy -= ENERGY_DECREMENT_WORK;
-  } else if (cit.task === 'restAtHouse') {
+  } else if (cit.task === "restAtHouse") {
     cit.energy += ENERGY_INCREMENT_REST;
   } else {
-    cit.energy -= 0.0005; // slight passive drain
+    cit.energy -= 0.0005; 
   }
-
   if (cit.energy < 0) cit.energy = 0;
   if (cit.energy > ENERGY_MAX) cit.energy = ENERGY_MAX;
 
-  // Assign a new task if none
   if (!cit.task) {
     assignNewTask(cit);
   }
 
-  // Execute current task logic
   switch (cit.task) {
     case 'chop': chopTask(cit); break;
     case 'deliverWood': deliverWoodTask(cit); break;
@@ -346,16 +381,200 @@ function updateCitizen(cit) {
     default: randomWander(cit); break;
   }
 
-  // Apply velocity
   cit.x += cit.vx;
   cit.y += cit.vy;
 }
 
 /**********************************************************************
- * TASK ASSIGNMENT
+ * ANIMAL UPDATE
+ **********************************************************************/
+function updateAnimal(ani) {
+  if (ani.type === "Rabbit") {
+    updateRabbit(ani);
+  } else if (ani.type === "Wolf") {
+    updateWolf(ani);
+  }
+
+  ani.x += ani.vx;
+  ani.y += ani.vy;
+
+  // Decrement reproduction cooldown
+  if (ani.reproductionCooldown > 0) {
+    ani.reproductionCooldown -= 1;
+  }
+}
+
+function updateRabbit(rabbit) {
+  rabbit.hunger += RABBIT_HUNGER_INCREMENT;
+  if (rabbit.hunger >= ANIMAL_HUNGER_MAX) {
+    rabbit.dead = true;
+    logAction("A rabbit starved to death.");
+    return;
+  }
+
+  // Reproduction
+  if (rabbit.hunger < 50 && rabbit.reproductionCooldown <= 0) {
+    if (Math.random() < RABBIT_REPRO_CHANCE) {
+      spawnBabyAnimal("Rabbit", rabbit.x, rabbit.y);
+      rabbit.reproductionCooldown = RABBIT_REPRO_COOLDOWN;
+    }
+  }
+
+  if (rabbit.hunger > 50) {
+    const tree = findNearestResourceOfType({x: rabbit.x, y: rabbit.y}, "FruitTree");
+    if (tree) {
+      moveToward(rabbit, tree.x, tree.y, 0.4);
+      if (distance(rabbit.x, rabbit.y, tree.x, tree.y) < 10) {
+        if (tree.amount > 0) {
+          const eatAmount = 1; 
+          tree.amount -= eatAmount;
+          rabbit.hunger -= eatAmount * 2; 
+          if (rabbit.hunger < 0) rabbit.hunger = 0;
+          if (Math.random() < 0.02) {
+            logAction("A rabbit is eating fruit...");
+          }
+        }
+      }
+    } else {
+      randomAnimalWander(rabbit);
+    }
+  } else {
+    randomAnimalWander(rabbit);
+  }
+}
+
+function updateWolf(wolf) {
+  wolf.hunger += WOLF_HUNGER_INCREMENT;
+  if (wolf.hunger >= ANIMAL_HUNGER_MAX) {
+    wolf.dead = true;
+    logAction("A wolf starved to death.");
+    return;
+  }
+
+  // Reproduction
+  if (wolf.hunger < 50 && wolf.reproductionCooldown <= 0) {
+    if (Math.random() < WOLF_REPRO_CHANCE) {
+      spawnBabyAnimal("Wolf", wolf.x, wolf.y);
+      wolf.reproductionCooldown = WOLF_REPRO_COOLDOWN;
+    }
+  }
+
+  // 1) hunt rabbits
+  let targetRabbit = findNearestAnimalOfType(wolf, "Rabbit");
+  if (targetRabbit) {
+    moveToward(wolf, targetRabbit.x, targetRabbit.y, 0.5);
+    if (distance(wolf.x, wolf.y, targetRabbit.x, targetRabbit.y) < 10) {
+      targetRabbit.dead = true;
+      wolf.hunger = Math.max(0, wolf.hunger - 30);
+      logAction("A wolf killed a rabbit!");
+      knockback(wolf, targetRabbit.x, targetRabbit.y, KNOCKBACK_DISTANCE);
+    }
+    return;
+  }
+
+  // 2) no rabbit => maybe attack a citizen if hunger > 60
+  if (wolf.hunger > 60) {
+    let targetHuman = findNearestCitizen(wolf);
+    if (targetHuman) {
+      moveToward(wolf, targetHuman.x, targetHuman.y, 0.5);
+      if (distance(wolf.x, wolf.y, targetHuman.x, targetHuman.y) < 10) {
+        if (targetHuman.hasWeapon) {
+          wolf.dead = true;
+          logAction(`${targetHuman.name} defended against a wolf with a weapon! Wolf died.`);
+        } else {
+          logAction(`A wolf killed ${targetHuman.name}!`);
+          citizens.splice(citizens.indexOf(targetHuman), 1);
+        }
+        knockback(wolf, targetHuman.x, targetHuman.y, KNOCKBACK_DISTANCE);
+      }
+    } else {
+      randomAnimalWander(wolf);
+    }
+  } else {
+    randomAnimalWander(wolf);
+  }
+}
+
+function spawnBabyAnimal(type, x, y) {
+  const nx = x + randInt(-20, 20);
+  const ny = y + randInt(-20, 20);
+  const baby = createAnimal(type, nx, ny);
+  animals.push(baby);
+  logAction(`A new baby ${type} is born!`);
+}
+
+function knockback(entity, tx, ty, dist) {
+  const dx = entity.x - tx;
+  const dy = entity.y - ty;
+  const length = Math.sqrt(dx*dx + dy*dy);
+  if (length > 0.1) {
+    entity.x += (dx / length) * dist;
+    entity.y += (dy / length) * dist;
+  }
+}
+
+/**********************************************************************
+ * FINDERS
+ **********************************************************************/
+function findNearestResourceOfType(ref, rtype) {
+  let nearest = null;
+  let minDist = Infinity;
+  for (const res of resources) {
+    if (res.type === rtype && res.amount > 0) {
+      const d = distance(ref.x, ref.y, res.x, res.y);
+      if (d < minDist) {
+        minDist = d;
+        nearest = res;
+      }
+    }
+  }
+  return nearest;
+}
+
+function findNearestAnimalOfType(wolf, targetType) {
+  let nearest = null;
+  let minDist = Infinity;
+  for (const a of animals) {
+    if (a !== wolf && !a.dead && a.type === targetType) {
+      const d = distance(wolf.x, wolf.y, a.x, a.y);
+      if (d < minDist) {
+        minDist = d;
+        nearest = a;
+      }
+    }
+  }
+  return nearest;
+}
+
+function findNearestCitizen(wolf) {
+  let nearest = null;
+  let minDist = Infinity;
+  for (const c of citizens) {
+    const d = distance(wolf.x, wolf.y, c.x, c.y);
+    if (d < minDist) {
+      minDist = d;
+      nearest = c;
+    }
+  }
+  return nearest;
+}
+
+function findHouseWithFruit() {
+  return buildings.find(b => b.buildingType === "House" && b.completed && b.storedFruit > 0);
+}
+
+function findAnyCompletedHouse() {
+  return buildings.find(b => b.buildingType === "House" && b.completed);
+}
+
+function findHouseNeedingFruit() {
+  return buildings.find(b => b.buildingType === "House" && b.completed && b.storedFruit < b.maxFruit);
+}
+
+/**********************************************************************
+ * CITIZEN TASKS
  **********************************************************************/
 function assignNewTask(cit) {
-  // If hunger too high, eat if possible
   if (cit.hunger >= HUNGER_THRESHOLD) {
     const houseWithFruit = findHouseWithFruit();
     if (houseWithFruit) {
@@ -364,8 +583,6 @@ function assignNewTask(cit) {
       return;
     }
   }
-
-  // If energy too low, rest at any completed house
   if (cit.energy <= ENERGY_THRESHOLD) {
     const completedHouse = findAnyCompletedHouse();
     if (completedHouse) {
@@ -374,8 +591,18 @@ function assignNewTask(cit) {
       return;
     }
   }
-
-  // Profession-based
+  // If builder & no weapon => craft if enough wood
+  if (cit.profession === "Builder" && !cit.hasWeapon) {
+    if (cityStorage.wood >= WEAPON_WOOD_COST) {
+      cityStorage.wood -= WEAPON_WOOD_COST;
+      cit.hasWeapon = true;
+      logAction(`${cit.name} crafted a wooden weapon for defense!`);
+      cit.task = null;
+      cit.target = null;
+      return;
+    }
+  }
+  // Profession tasks
   if (cit.profession === "Builder") {
     builderTasks(cit);
   } else {
@@ -384,16 +611,13 @@ function assignNewTask(cit) {
 }
 
 function builderTasks(cit) {
-  // Find building needing wood
   const buildingNeedingWood = buildings.find(b => !b.completed && b.deliveredWood < b.requiredWood);
   if (buildingNeedingWood) {
-    // If carrying wood, deliver
     if (cit.carryingWood > 0) {
       cit.task = 'deliverWood';
       cit.target = buildingNeedingWood;
       return;
     }
-    // Otherwise chop wood
     const tree = findNearestResourceOfType(cit, "Tree");
     if (tree) {
       cit.task = 'chop';
@@ -401,30 +625,23 @@ function builderTasks(cit) {
       return;
     }
   }
-
-  // If there's a building with enough wood but not finished, build
   const buildingToConstruct = buildings.find(b => !b.completed && b.deliveredWood >= b.requiredWood);
   if (buildingToConstruct) {
     cit.task = 'build';
     cit.target = buildingToConstruct;
     return;
   }
-
-  // Otherwise chop wood (to store)
   const anyTree = findNearestResourceOfType(cit, "Tree");
   if (anyTree) {
     cit.task = 'chop';
     cit.target = anyTree;
     return;
   }
-  
-  // Idle
   cit.task = null;
   cit.target = null;
 }
 
 function farmerTasks(cit) {
-  // If carrying fruit, try delivering to a house
   if (cit.carryingFruit > 0) {
     const houseNeedingFruit = findHouseNeedingFruit();
     if (houseNeedingFruit) {
@@ -433,30 +650,21 @@ function farmerTasks(cit) {
       return;
     }
   }
-
-  // If no fruit in hand, gather fruit
   const fruitTree = findNearestResourceOfType(cit, "FruitTree");
   if (fruitTree && fruitTree.amount > 0) {
     cit.task = 'gatherFruit';
     cit.target = fruitTree;
     return;
   }
-
-  // Occasionally plant a new fruit tree if carrying fruit
   if (cit.carryingFruit >= FRUIT_PLANT_COST && Math.random() < 0.1) {
     cit.task = 'plantFruitTree';
     cit.target = null;
     return;
   }
-
-  // Idle
   cit.task = null;
   cit.target = null;
 }
 
-/**********************************************************************
- * TASK HANDLERS
- **********************************************************************/
 function chopTask(cit) {
   const tree = cit.target;
   if (!tree || tree.amount <= 0) {
@@ -509,7 +717,6 @@ function buildTask(cit) {
     return;
   }
   moveToward(cit, b.x, b.y, 0.3);
-  // Building progress handled globally
 }
 
 function gatherFruitTask(cit) {
@@ -544,7 +751,6 @@ function deliverFruitTask(cit) {
   }
   moveToward(cit, house.x, house.y, 0.4);
   if (distance(cit.x, cit.y, house.x, house.y) < 20) {
-    // Deliver fruit
     const space = house.maxFruit - house.storedFruit;
     if (space > 0 && cit.carryingFruit > 0) {
       const toDeliver = Math.min(cit.carryingFruit, space);
@@ -558,10 +764,8 @@ function deliverFruitTask(cit) {
 }
 
 function plantFruitTreeTask(cit) {
-  // Plant near the citizen
   const px = cit.x + randInt(-50, 50);
   const py = cit.y + randInt(-50, 50);
-
   moveToward(cit, px, py, 0.4);
   if (distance(cit.x, cit.y, px, py) < 10) {
     if (cit.carryingFruit >= FRUIT_PLANT_COST) {
@@ -583,7 +787,6 @@ function eatAtHouseTask(cit) {
   }
   moveToward(cit, house.x, house.y, 0.4);
   if (distance(cit.x, cit.y, house.x, house.y) < 20) {
-    // Eat some fruit
     if (house.storedFruit > 0 && cit.hunger > 0) {
       const amountToEat = 10;
       const eaten = Math.min(amountToEat, house.storedFruit);
@@ -606,7 +809,6 @@ function restAtHouseTask(cit) {
   }
   moveToward(cit, house.x, house.y, 0.4);
   if (distance(cit.x, cit.y, house.x, house.y) < 20) {
-    // Gains energy passively
     if (cit.energy >= ENERGY_MAX - 1) {
       cit.energy = ENERGY_MAX;
       cit.task = null;
@@ -615,88 +817,36 @@ function restAtHouseTask(cit) {
   }
 }
 
-/**********************************************************************
- * ROAD-BUILDING LOGIC
- **********************************************************************/
-/**
- * When a new house is completed, we build a road from it
- * to the nearest existing house (if one exists).
- */
-function maybeBuildRoad(newHouse) {
-  // Find the nearest completed house (other than the new one)
-  const otherHouses = buildings.filter(b => b.buildingType === "House" && b.completed && b !== newHouse);
-  if (otherHouses.length === 0) return; // no other house to connect
-
-  let nearest = null;
-  let minDist = Infinity;
-  otherHouses.forEach((oh) => {
-    const d = distance(newHouse.x, newHouse.y, oh.x, oh.y);
-    if (d < minDist) {
-      minDist = d;
-      nearest = oh;
-    }
-  });
-
-  if (!nearest) return;
-  // Place a road site
-  const roadSite = createRoadSite(newHouse.x, newHouse.y, nearest.x, nearest.y);
-  buildings.push(roadSite);
-  logAction(`A Road site created between houses at (${newHouse.x}, ${newHouse.y}) and (${nearest.x}, ${nearest.y}).`);
-}
-
-/**********************************************************************
- * FIND BUILDINGS OR RESOURCES
- **********************************************************************/
-function findNearestResourceOfType(cit, rtype) {
-  let nearest = null;
-  let nearestDist = Infinity;
-  for (const res of resources) {
-    if (res.type === rtype && res.amount > 0) {
-      const d = distance(cit.x, cit.y, res.x, res.y);
-      if (d < nearestDist) {
-        nearestDist = d;
-        nearest = res;
-      }
-    }
-  }
-  return nearest;
-}
-
-function findHouseWithFruit() {
-  return buildings.find(b => b.buildingType === "House" && b.completed && b.storedFruit > 0);
-}
-
-function findAnyCompletedHouse() {
-  return buildings.find(b => b.buildingType === "House" && b.completed);
-}
-
-function findHouseNeedingFruit() {
-  return buildings.find(b => b.buildingType === "House" && b.completed && b.storedFruit < b.maxFruit);
-}
-
 /**********************************************************************
  * RANDOM WANDER
  **********************************************************************/
 function randomWander(cit) {
   if (Math.random() < 0.01) {
-    cit.vx = (Math.random() - 0.5) * 0.5;
-    cit.vy = (Math.random() - 0.5) * 0.5;
+    cit.vx = (Math.random() - 0.5) * 0.3;
+    cit.vy = (Math.random() - 0.5) * 0.3;
+  }
+}
+
+function randomAnimalWander(ani) {
+  if (Math.random() < 0.01) {
+    ani.vx = (Math.random() - 0.5) * 0.4;
+    ani.vy = (Math.random() - 0.5) * 0.4;
   }
 }
 
 /**********************************************************************
  * MOVEMENT UTILS
  **********************************************************************/
-function moveToward(cit, tx, ty, speed = 0.4) {
-  const dx = tx - cit.x;
-  const dy = ty - cit.y;
+function moveToward(obj, tx, ty, speed = 0.4) {
+  const dx = tx - obj.x;
+  const dy = ty - obj.y;
   const dist = Math.sqrt(dx*dx + dy*dy);
   if (dist > 1) {
-    cit.vx = (dx / dist) * speed;
-    cit.vy = (dy / dist) * speed;
+    obj.vx = (dx / dist) * speed;
+    obj.vy = (dy / dist) * speed;
   } else {
-    cit.vx = 0;
-    cit.vy = 0;
+    obj.vx = 0;
+    obj.vy = 0;
   }
 }
 
@@ -706,10 +856,29 @@ function distance(x1, y1, x2, y2) {
   return Math.sqrt(dx*dx + dy*dy);
 }
 
+/**********************************************************************
+ * ROAD-BUILDING WHEN HOUSE IS COMPLETED
+ **********************************************************************/
+function maybeBuildRoad(newHouse) {
+  const otherHouses = buildings.filter(b => b.buildingType === "House" && b.completed && b !== newHouse);
+  if (otherHouses.length === 0) return;
+  let nearest = null;
+  let minDist = Infinity;
+  for (const oh of otherHouses) {
+    const d = distance(newHouse.x, newHouse.y, oh.x, oh.y);
+    if (d < minDist) {
+      minDist = d;
+      nearest = oh;
+    }
+  }
+  if (!nearest) return;
+  const roadSite = createRoadSite(newHouse.x, newHouse.y, nearest.x, nearest.y);
+  buildings.push(roadSite);
+  logAction(`A Road site created between houses at (${newHouse.x}, ${newHouse.y}) and (${nearest.x}, ${nearest.y}).`);
+}
+
 /**********************************************************************
  * AUTO-CREATION OF NEW HOUSE SITES
- * Similar logic to previous examples: if cityStorage has enough wood,
- * we place a new House site occasionally.
  **********************************************************************/
 setInterval(() => {
   const underConstruction = buildings.find(b => b.buildingType === "House" && !b.completed);
@@ -724,11 +893,10 @@ setInterval(() => {
 }, 5000);
 
 /**********************************************************************
- * DEPOSIT WOOD IN CITY STORAGE IF IDLE BUILDER
+ * DEPOSIT WOOD LOGIC
  **********************************************************************/
 const originalAssignNewTask = assignNewTask;
 assignNewTask = function(cit) {
-  // If builder carrying wood, but no building needs it, deposit to city center
   if (cit.profession === "Builder") {
     const buildingNeedingWood = buildings.find(b => !b.completed && b.deliveredWood < b.requiredWood);
     if (cit.carryingWood > 0 && !buildingNeedingWood) {
@@ -738,7 +906,6 @@ assignNewTask = function(cit) {
         logAction(`${cit.name} deposited ${cit.carryingWood} wood into city storage.`);
         cit.carryingWood = 0;
       } else {
-        // Move to city center
         moveToward(cit, 0, 0, 0.4);
         cit.task = null;
         cit.target = null;
@@ -755,29 +922,30 @@ assignNewTask = function(cit) {
 function drawWorld() {
   ctx.clearRect(0, 0, canvas.width, canvas.height);
 
-  // Draw grid
+  // Grid
   drawGrid();
 
-  // Draw resources
+  // Resources
   resources.forEach((res) => drawResource(res));
 
-  // Draw roads first (both completed or under construction)
+  // Roads
   buildings
     .filter(b => b.buildingType === "Road")
     .forEach(b => drawRoad(b));
 
-  // Draw houses
+  // Houses
   buildings
     .filter(b => b.buildingType === "House")
     .forEach(b => drawHouse(b));
 
-  // Draw city storage info
+  // City storage
   drawCityStorage();
 
-  // Draw citizens
-  citizens.forEach((cit) => {
-    drawCitizen(cit);
-  });
+  // Citizens
+  citizens.forEach((cit) => drawCitizen(cit));
+
+  // Animals
+  animals.forEach((ani) => drawAnimal(ani));
 }
 
 function drawGrid() {
@@ -801,7 +969,6 @@ function drawGrid() {
     ctx.lineTo(range, y);
     ctx.stroke();
   }
-
   ctx.restore();
 }
 
@@ -828,20 +995,15 @@ function drawResource(res) {
     ctx.font = "12px sans-serif";
     ctx.fillText(`Fruit (${res.amount})`, res.x - 25, res.y - 12);
   }
-
   ctx.restore();
 }
 
-/**
- * Draw a House building site or a completed House
- */
 function drawHouse(b) {
   ctx.save();
   ctx.translate(canvas.width / 2 + offsetX, canvas.height / 2 + offsetY);
   ctx.scale(scale, scale);
 
   if (!b.completed) {
-    // Construction site
     ctx.strokeStyle = "#FF8C00";
     ctx.lineWidth = 2 / scale;
     ctx.strokeRect(b.x - 15, b.y - 15, 30, 30);
@@ -852,7 +1014,6 @@ function drawHouse(b) {
     ctx.fillText(`Wood: ${b.deliveredWood}/${b.requiredWood}`, b.x - 30, b.y + 30);
     ctx.fillText(`Progress: ${Math.floor(b.buildProgress)}%`, b.x - 30, b.y + 42);
   } else {
-    // Completed
     ctx.fillStyle = "#DAA520";
     ctx.fillRect(b.x - 15, b.y - 15, 30, 30);
 
@@ -865,17 +1026,13 @@ function drawHouse(b) {
   ctx.restore();
 }
 
-/**
- * Draw a Road building site or a completed Road
- */
 function drawRoad(b) {
   ctx.save();
   ctx.translate(canvas.width / 2 + offsetX, canvas.height / 2 + offsetY);
   ctx.scale(scale, scale);
 
-  // Draw line between (b.x1, b.y1) and (b.x2, b.y2)
   if (!b.completed) {
-    ctx.setLineDash([5, 5]); // dashed if under construction
+    ctx.setLineDash([5, 5]);
     ctx.strokeStyle = "#888";
   } else {
     ctx.setLineDash([]);
@@ -888,7 +1045,6 @@ function drawRoad(b) {
   ctx.lineTo(b.x2, b.y2);
   ctx.stroke();
 
-  // Draw small label near midpoint
   ctx.fillStyle = "#000";
   ctx.font = "12px sans-serif";
   if (!b.completed) {
@@ -897,13 +1053,9 @@ function drawRoad(b) {
   } else {
     ctx.fillText(`Road`, b.x - 10, b.y - 5);
   }
-
   ctx.restore();
 }
 
-/**
- * Show city storage
- */
 function drawCityStorage() {
   ctx.save();
   ctx.fillStyle = "#000";
@@ -917,17 +1069,39 @@ function drawCitizen(cit) {
   ctx.translate(canvas.width / 2 + offsetX, canvas.height / 2 + offsetY);
   ctx.scale(scale, scale);
 
-  // Citizen circle
   ctx.fillStyle = cit.color;
   ctx.beginPath();
   ctx.arc(cit.x, cit.y, 7, 0, Math.PI * 2);
   ctx.fill();
 
-  // Show name, profession, carrying, hunger, energy
   ctx.fillStyle = "#000";
   ctx.font = "10px sans-serif";
-  ctx.fillText(`${cit.name} [${cit.profession}]`, cit.x + 10, cit.y - 2);
-  ctx.fillText(`W:${cit.carryingWood} F:${cit.carryingFruit} H:${Math.floor(cit.hunger)} E:${Math.floor(cit.energy)}`, cit.x + 10, cit.y + 10);
+  const wpn = cit.hasWeapon ? "ARMED" : "";
+  ctx.fillText(`${cit.name} [${cit.profession}] ${wpn}`, cit.x + 10, cit.y - 2);
+  ctx.fillText(`W:${cit.carryingWood} F:${cit.carryingFruit} H:${Math.floor(cit.hunger)} E:${Math.floor(cit.energy)}`,
+               cit.x + 10, cit.y + 10);
+
+  ctx.restore();
+}
+
+function drawAnimal(ani) {
+  if (ani.dead) return;
+  ctx.save();
+  ctx.translate(canvas.width / 2 + offsetX, canvas.height / 2 + offsetY);
+  ctx.scale(scale, scale);
+
+  if (ani.type === "Rabbit") {
+    ctx.fillStyle = "#999";
+  } else {
+    ctx.fillStyle = "#555";
+  }
+  ctx.beginPath();
+  ctx.arc(ani.x, ani.y, 6, 0, Math.PI * 2);
+  ctx.fill();
+
+  ctx.fillStyle = "#000";
+  ctx.font = "10px sans-serif";
+  ctx.fillText(ani.type, ani.x + 8, ani.y + 3);
 
   ctx.restore();
 }
