Manual changes saved

index.html

@@ -332,8 +332,18 @@
     }
 
     // Populate world
+    // Updated: enemies spawn already equipped with a weapon in inventory slot 0 (equipped)
     function populateWorld(){
       chests.length = 0; objects.length = 0; enemies.length = 0; pickups.length = 0;
+
+      // helper weapon pool for enemy spawns
+      const enemyWeapons = [
+        { name:'Pistol', dmg:12, rate:320, color:'#ffd86b', magSize:12, startReserve:24 },
+        { name:'SMG', dmg:6, rate:120, color:'#8ef0ff', magSize:30, startReserve:90 },
+        { name:'Shotgun', dmg:22, rate:800, color:'#ff9fb8', magSize:6, startReserve:18 },
+        { name:'Rifle', dmg:18, rate:400, color:'#c7ff9a', magSize:20, startReserve:60 }
+      ];
+
       for (let i=0;i<260;i++){
         const x = rand(150, WORLD.width-150);
         const y = rand(150, WORLD.height-150);
@@ -354,7 +364,9 @@
       for (let i=0;i<49;i++){
         const ex = rand(300, WORLD.width-300);
         const ey = rand(300, WORLD.height-300);
-        enemies.push({
+
+        // create enemy base
+        const enemy = {
           id:'e'+i, x:ex, y:ey, radius:14, angle:rand(0,Math.PI*2), speed:110+rand(-20,20),
           health: 80 + randInt(0,40), lastMelee:0, meleeRate:800 + randInt(-200,200),
           roamTimer: rand(0,3),
@@ -374,7 +386,24 @@
           tempTarget: null,
           tempTargetExpiry: 0,
           prioritizeChestsUntil: 0
-        });
+        };
+
+        // Give the enemy a weapon on spawn (random pick)
+        const w = enemyWeapons[randInt(0, enemyWeapons.length)];
+        const proto = makeWeaponProto(w);
+        enemy.inventory[0] = {
+          type: 'weapon',
+          weapon: proto,
+          ammoInMag: proto.magSize,
+          ammoReserve: proto.startReserve
+        };
+        enemy.equippedIndex = 0; // equip the weapon immediately
+        // Slightly bias them to seek chests early so they can refill/reload if needed
+        enemy.prioritizeChestsUntil = now + 4000 + rand(0,2000);
+        // Reduce gather time so they don't idle unnecessarily
+        enemy.gatherTimeLeft = Math.min(enemy.gatherTimeLeft, 6);
+
+        enemies.push(enemy);
       }
       updatePlayerCount();
     }
@@ -559,67 +588,48 @@
 
     // Enemy helpers
     function enemyEquipBestWeapon(e){
-      // prefer weapons that have ammo loaded or reserve; compute score and prefer loaded ones
       let bestIdx = -1;
       let bestScore = -Infinity;
       for (let i=0;i<5;i++){
         const it = e.inventory[i];
         if (it && it.type === 'weapon'){
-          const dmg = (it.weapon && it.weapon.dmg) ? it.weapon.dmg : 1;
-          const rate = (it.weapon && it.weapon.rate) ? it.weapon.rate : 300;
-          let score = dmg / rate;
-          // bonus if currently has ammo in mag
-          if (typeof it.ammoInMag === 'number' && it.ammoInMag > 0) score += 0.5;
-          if (typeof it.ammoReserve === 'number' && it.ammoReserve > 0) score += 0.2;
+          const score = (it.weapon.dmg || 1) / (it.weapon.rate || 300) + (it.ammoInMag > 0 ? 0.5 : 0);
           if (score > bestScore){ bestScore = score; bestIdx = i; }
         }
       }
-      if (bestIdx !== -1) {
-        e.equippedIndex = bestIdx;
-      } else {
-        e.equippedIndex = -1;
-      }
-    }
-
-    function normalizeWeaponPickup(p){
-      // ensure fields exist and are numbers
-      const w = p.weapon ? p.weapon : makeWeaponProto(p);
-      const ammoInMag = (typeof p.ammoInMag === 'number') ? p.ammoInMag : (w.magSize || w.magSize || 12);
-      const ammoReserve = (typeof p.ammoReserve === 'number') ? p.ammoReserve : (w.startReserve || (w.magSize*2) || 24);
-      return { type:'weapon', weapon: w, ammoInMag: Math.max(0, Math.floor(ammoInMag)), ammoReserve: Math.max(0, Math.floor(ammoReserve)) };
+      if (bestIdx !== -1) e.equippedIndex = bestIdx;
+      else e.equippedIndex = -1;
     }
 
     function enemyPickupCollect(e, p){
       if (!e || !p) return;
       if (p.type === 'weapon'){
-        const normalized = normalizeWeaponPickup(p);
-        // merge into existing same weapon
+        const w = p.weapon ? p.weapon : makeWeaponProto(p);
+        const ammoInMag = (typeof p.ammoInMag === 'number') ? p.ammoInMag : (w.magSize || 12);
+        const ammoReserve = (typeof p.ammoReserve === 'number') ? p.ammoReserve : (w.startReserve || 24);
         for (let s=0;s<5;s++){
           const it = e.inventory[s];
-          if (it && it.type==='weapon' && it.weapon.name === normalized.weapon.name){
-            it.ammoReserve = (it.ammoReserve || 0) + (normalized.ammoReserve || 0);
-            it.ammoInMag = Math.min(it.weapon.magSize, (it.ammoInMag || 0) + (normalized.ammoInMag || 0));
+          if (it && it.type==='weapon' && it.weapon.name === w.name){
+            it.ammoReserve += ammoReserve;
+            it.ammoInMag = Math.min(it.weapon.magSize, (it.ammoInMag || 0) + ammoInMag);
             enemyEquipBestWeapon(e);
-            // ensure they equip a loaded weapon if present
             if (it.ammoInMag > 0) e.equippedIndex = s;
             e.state = 'combat';
             e.lastAttackedTime = performance.now();
             return;
           }
         }
-        // place into empty slot if available
         for (let s=0;s<5;s++){
-          if (!e.inventory[s]){
-            e.inventory[s] = { type:'weapon', weapon: normalized.weapon, ammoInMag: normalized.ammoInMag, ammoReserve: normalized.ammoReserve };
+          if (!e.inventory[s]) {
+            e.inventory[s] = { type:'weapon', weapon: w, ammoInMag: ammoInMag, ammoReserve: ammoReserve };
             enemyEquipBestWeapon(e);
-            // equip this weapon if it has ammo or if no other better weapon
             if (e.inventory[s].ammoInMag > 0) e.equippedIndex = s;
             e.state = 'combat';
             e.lastAttackedTime = performance.now();
             return;
           }
         }
-        // replace worst weapon if pickup is better
+        // replace worst if pickup is better
         let worstIdx = -1, worstScore = Infinity;
         for (let s=0;s<5;s++){
           const it = e.inventory[s];
@@ -628,14 +638,14 @@
             if (score < worstScore){ worstScore = score; worstIdx = s; }
           }
         }
-        const pickupScore = (normalized.weapon.dmg || 1) / (normalized.weapon.rate || 300);
+        const pickupScore = (w.dmg || 1) / (w.rate || 300);
         if (pickupScore > worstScore && worstIdx !== -1){
-          e.inventory[worstIdx] = { type:'weapon', weapon: normalized.weapon, ammoInMag: normalized.ammoInMag, ammoReserve: normalized.ammoReserve };
+          e.inventory[worstIdx] = { type:'weapon', weapon: w, ammoInMag: ammoInMag, ammoReserve: ammoReserve };
           enemyEquipBestWeapon(e);
           e.state = 'combat';
           e.lastAttackedTime = performance.now();
         } else {
-          e.materials += Math.floor((normalized.ammoReserve || 0) / 2);
+          e.materials += Math.floor((ammoReserve || 0) / 2);
         }
       } else if (p.type === 'medkit'){
         for (let s=0;s<5;s++){
@@ -714,21 +724,17 @@
       else if (blocker.type === 'stone') br = 22;
       else if (blocker.type === 'wood') br = 16;
       else br = 18;
-      // vector from blocker to from
       const vx = fromX - blocker.x;
       const vy = fromY - blocker.y;
       const len = Math.hypot(vx, vy) || 0.0001;
-      // perp directions
       const px = -vy / len;
       const py = vx / len;
       const radius = br + padding + 8;
       const cand1 = { x: blocker.x + px * radius, y: blocker.y + py * radius };
       const cand2 = { x: blocker.x - px * radius, y: blocker.y - py * radius };
-      // choose candidate that's closer to goal and not inside other solids (approx)
       const d1 = Math.hypot(cand1.x - goalX, cand1.y - goalY);
       const d2 = Math.hypot(cand2.x - goalX, cand2.y - goalY);
       const chosen = d1 < d2 ? cand1 : cand2;
-      // clamp to world
       chosen.x = Math.max(16, Math.min(WORLD.width-16, chosen.x));
       chosen.y = Math.max(16, Math.min(WORLD.height-16, chosen.y));
       return chosen;
@@ -805,42 +811,17 @@
       return best;
     }
 
-    // Enemy AI (improved: detour around obstacles and prioritize chest looting early, ensure equipping)
+    // Enemy AI (kept mostly same; enemies spawn equipped now)
     function updateEnemies(dt, now){
       const minSeparation = 20;
       for (const e of enemies){
         if (e.health <= 0) continue;
         if (!e.spawnSafeUntil) e.spawnSafeUntil = performance.now() + SPAWN_PROTECT_MS;
 
-        // clear expired tempTarget
-        if (e.tempTarget && now > (e.tempTargetExpiry || 0)) { e.tempTarget = null; e.tempTargetExpiry = 0; }
-
-        // If in storm move towards safe zone, using detours around blockers
         if (storm.active){
           const distToSafeCenter = Math.hypot(e.x - storm.centerX, e.y - storm.centerY);
           if (distToSafeCenter > storm.radius){
             e.state = 'toSafe';
-            if (e.tempTarget){
-              const td = Math.hypot(e.tempTarget.x - e.x, e.tempTarget.y - e.y);
-              if (td > 8){
-                e.angle = Math.atan2(e.tempTarget.y - e.y, e.tempTarget.x - e.x);
-                const dx = Math.cos(e.angle) * e.speed * dt * 0.9;
-                const dy = Math.sin(e.angle) * e.speed * dt * 0.9;
-                moveEntityWithCollision(e, dx, dy, e.radius);
-                continue;
-              } else {
-                e.tempTarget = null;
-                e.tempTargetExpiry = 0;
-              }
-            }
-            if (!hasLineOfSight(e.x, e.y, storm.centerX, storm.centerY)){
-              const blocker = findBlockingObject(e.x, e.y, storm.centerX, storm.centerY);
-              if (blocker){
-                e.tempTarget = computeDetourWaypoint(e.x, e.y, blocker, storm.centerX, storm.centerY);
-                e.tempTargetExpiry = now + 2500;
-                if (e.tempTarget) { e.angle = Math.atan2(e.tempTarget.y - e.y, e.tempTarget.x - e.x); const dx = Math.cos(e.angle) * e.speed * dt * 0.95; const dy = Math.sin(e.angle) * e.speed * dt * 0.95; moveEntityWithCollision(e, dx, dy, e.radius); continue; }
-              }
-            }
             e.angle = Math.atan2(storm.centerY - e.y, storm.centerX - e.x);
             const dx = Math.cos(e.angle) * e.speed * dt * 0.95;
             const dy = Math.sin(e.angle) * e.speed * dt * 0.95;
@@ -850,7 +831,9 @@
           }
         }
 
-        // Healing logic
+        if (now - e.lastAttackedTime < 4000) e.state = 'combat';
+        if (e.state === 'gather') e.gatherTimeLeft -= dt;
+
         if (e.health < 60 && now >= (e.nextHealTime || 0)){
           let medIdx = -1;
           for (let s=0;s<5;s++){
@@ -867,19 +850,13 @@
           }
         }
 
-        // State transitions
         const hasUsefulWeapon = e.inventory.some(it => it && it.type === 'weapon' && (it.ammoInMag > 0 || it.ammoReserve > 0));
         if ((e.gatherTimeLeft <= 0 || e.materials >= 20 || hasUsefulWeapon) && e.state === 'gather') e.state = 'combat';
 
-        if (e.state === 'gather') e.gatherTimeLeft -= dt;
-
-        // Early-game chest priority: force chest-seeking for first few seconds to equip weapons quickly
-        const prioritizeChests = (e.prioritizeChestsUntil && now < e.prioritizeChestsUntil);
         if (e.state === 'gather'){
           if (now >= (e.spawnSafeUntil || 0)){
-            // pickups nearby priority (quick ammo/weapon)
             let p = findNearestPickup(e, 240);
-            if (p && !prioritizeChests){
+            if (p){
               const angle = Math.atan2(p.y - e.y, p.x - e.x);
               e.angle = angle;
               const dx = Math.cos(e.angle) * e.speed * dt * 0.9;
@@ -889,78 +866,40 @@
                 enemyPickupCollect(e, p);
                 const idx = pickups.indexOf(p);
                 if (idx >= 0) pickups.splice(idx,1);
-                // equip best weapon immediately if any
-                enemyEquipBestWeapon(e);
               }
               continue;
             }
           }
 
-          // If we don't have a useful weapon yet, prioritize chests strongly (extended radius)
-          let chestSearchRadius = prioritizeChests || !hasUsefulWeapon ? 1400 : 900;
-          let chestTarget = findNearestChest(e, chestSearchRadius);
+          let chestTarget = findNearestChest(e, 900);
           if (chestTarget){
             const d = Math.hypot(chestTarget.x - e.x, chestTarget.y - e.y);
             if (d > 20){
               e.angle = Math.atan2(chestTarget.y - e.y, chestTarget.x - e.x);
-              // navigate with detour logic if blocked
-              if (!hasLineOfSight(e.x, e.y, chestTarget.x, chestTarget.y)){
-                const blocker = findBlockingObject(e.x, e.y, chestTarget.x, chestTarget.y);
-                if (blocker){
-                  if (!e.tempTarget){
-                    e.tempTarget = computeDetourWaypoint(e.x, e.y, blocker, chestTarget.x, chestTarget.y);
-                    e.tempTargetExpiry = now + 2500;
-                  }
-                  if (e.tempTarget){
-                    const td = Math.hypot(e.tempTarget.x - e.x, e.tempTarget.y - e.y);
-                    if (td > 8){
-                      e.angle = Math.atan2(e.tempTarget.y - e.y, e.tempTarget.x - e.x);
-                      const dx = Math.cos(e.angle) * e.speed * dt * 0.9;
-                      const dy = Math.sin(e.angle) * e.speed * dt * 0.9;
-                      moveEntityWithCollision(e, dx, dy, e.radius);
-                      continue;
-                    } else {
-                      e.tempTarget = null;
-                      e.tempTargetExpiry = 0;
-                    }
-                  }
-                }
-              }
-              // If unobstructed or detour not set/needed, move directly
-              const dx = Math.cos(e.angle) * e.speed * dt * 0.95;
-              const dy = Math.sin(e.angle) * e.speed * dt * 0.95;
+              const dx = Math.cos(e.angle) * e.speed * dt * 0.9;
+              const dy = Math.sin(e.angle) * e.speed * dt * 0.9;
               moveEntityWithCollision(e, dx, dy, e.radius);
             } else {
-              // open chest and collect
               if (!chestTarget.opened){
                 chestTarget.opened = true;
                 const loot = chestTarget.loot;
-                if (loot.type === 'weapon') {
-                  const wp = { type:'weapon', weapon: makeWeaponProto(loot.weapon), ammoInMag:loot.weapon.magSize||12, ammoReserve:loot.weapon.startReserve||24 };
-                  enemyPickupCollect(e, wp);
-                } else if (loot.type === 'medkit') enemyPickupCollect(e, { type:'medkit', amount: loot.amount || 1 });
+                if (loot.type === 'weapon') enemyPickupCollect(e, { type:'weapon', weapon: makeWeaponProto(loot.weapon), ammoInMag:loot.weapon.magSize||12, ammoReserve:loot.weapon.startReserve||24 });
+                else if (loot.type === 'medkit') enemyPickupCollect(e, { type:'medkit', amount: loot.amount || 1 });
                 else if (loot.type === 'materials') enemyPickupCollect(e, { type:'materials', amount: loot.amount || 10 });
-                // ensure equip
                 enemyEquipBestWeapon(e);
                 if (e.equippedIndex !== -1){
                   const eq = e.inventory[e.equippedIndex];
                   if (eq && eq.type==='weapon' && eq.ammoInMag <= 0 && eq.ammoReserve > 0){
-                    // immediate reload
                     reloadItem(eq);
                   }
                 }
-                // after opening chest, prioritize combat if weapon obtained
-                if (e.inventory.some(it => it && it.type==='weapon')) {
-                  e.state = 'combat';
-                  e.lastAttackedTime = now;
-                }
               }
             }
             continue;
           }
 
           let objTarget = findNearestHarvestable(e, 700);
-          if (objTarget && !prioritizeChests){
+          if (objTarget){
             const d = Math.hypot(objTarget.x - e.x, objTarget.y - e.y);
             if (d > 26){
               e.angle = Math.atan2(objTarget.y - e.y, objTarget.x - e.x);
@@ -990,7 +929,7 @@
           continue;
         }
 
-        // Combat state
+        // Combat
         if (e.equippedIndex === -1) enemyEquipBestWeapon(e);
         if (e.reloadPending){
           if (now >= e.reloadingUntil){
@@ -1008,34 +947,6 @@
           }
         }
 
-        // If equipped weapon is empty and no reserve, try to swap to another loaded weapon
-        if (e.equippedIndex >= 0){
-          const eq = e.inventory[e.equippedIndex];
-          if (eq && eq.type === 'weapon' && eq.ammoInMag <= 0 && eq.ammoReserve <= 0){
-            // try to find another weapon with ammo
-            for (let i=0;i<5;i++){
-              const it = e.inventory[i];
-              if (it && it.type === 'weapon' && it.ammoInMag > 0){
-                e.equippedIndex = i;
-                break;
-              }
-            }
-            // if still no mag ammo, pick weapon with reserve
-            if (e.equippedIndex === -1 || (e.inventory[e.equippedIndex] && e.inventory[e.equippedIndex].ammoInMag <= 0)){
-              for (let i=0;i<5;i++){
-                const it = e.inventory[i];
-                if (it && it.type === 'weapon' && it.ammoReserve > 0){
-                  e.equippedIndex = i;
-                  // schedule reload
-                  e.reloadPending = true;
-                  e.reloadingUntil = now + 500 + rand(-80,80);
-                  break;
-                }
-              }
-            }
-          }
-        }
-
         let target = player;
         let bestDist = Math.hypot(player.x - e.x, player.y - e.y);
         if (bestDist > VIEW_RANGE){
@@ -1078,7 +989,6 @@
           continue;
         }
 
-        // If a target exists but blocked, try detour waypoint instead of always breaking/shooting blocker
         const blocked = !hasLineOfSight(e.x, e.y, target.x, target.y);
         if (blocked){
           const blocker = findBlockingObject(e.x, e.y, target.x, target.y);
@@ -1096,27 +1006,10 @@
                   const angle = Math.atan2(blocker.y - e.y, blocker.x - e.x);
                   shootBullet(e.x + Math.cos(angle)*12, e.y + Math.sin(angle)*12, blocker.x + (Math.random()-0.5)*6, blocker.y + (Math.random()-0.5)*6, eq, e.id);
                 }
-              }
-              if (!e.tempTarget){
-                const waypoint = computeDetourWaypoint(e.x, e.y, blocker, target.x, target.y);
-                if (waypoint){
-                  e.tempTarget = waypoint;
-                  e.tempTargetExpiry = now + 3000;
-                }
-              }
-              if (e.tempTarget){
-                const td = Math.hypot(e.tempTarget.x - e.x, e.tempTarget.y - e.y);
-                if (td > 8){
-                  e.angle = Math.atan2(e.tempTarget.y - e.y, e.tempTarget.x - e.x);
-                  moveEntityWithCollision(e, Math.cos(e.angle) * e.speed * dt * 0.8, Math.sin(e.angle) * e.speed * dt * 0.8, e.radius);
-                } else {
-                  e.tempTarget = null;
-                  e.tempTargetExpiry = 0;
-                }
               } else {
                 e.angle = Math.atan2(blocker.y - e.y, blocker.x - e.x);
-                e.x += Math.cos(e.angle) * e.speed * dt * 0.6;
-                e.y += Math.sin(e.angle) * e.speed * dt * 0.6;
+                e.x += Math.cos(e.angle) * e.speed * dt * 0.8;
+                e.y += Math.sin(e.angle) * e.speed * dt * 0.8;
               }
             }
             continue;
@@ -1134,14 +1027,6 @@
             const eq = e.inventory[e.equippedIndex];
             if (eq && eq.type === 'weapon' && !e.reloadPending && now - (e.lastShot||0) > (eq.weapon.rate || 300)){
               if (eq.ammoInMag <= 0){
-                // try reload or swap
-                if (eq.ammoReserve > 0 && !e.reloadPending){
-                  e.reloadPending = true;
-                  e.reloadingUntil = now + 600 + rand(-100,100);
-                } else {
-                  // swap to other weapon
-                  enemyEquipBestWeapon(e);
-                }
               } else {
                 if (hasLineOfSight(e.x, e.y, target.x, target.y)){
                   e.lastShot = now;
@@ -1173,29 +1058,18 @@
               const idx = pickups.indexOf(target);
               if (idx >= 0) pickups.splice(idx,1);
               e.state = 'gather';
-              enemyEquipBestWeapon(e);
             }
           } else if (target.hasOwnProperty('loot')){
             if (td > 20){
               e.angle = Math.atan2(target.y - e.y, target.x - e.x);
               moveEntityWithCollision(e, Math.cos(e.angle) * e.speed * dt * 0.9, Math.sin(e.angle) * e.speed * dt * 0.9, e.radius);
             } else {
-              if (!target.opened){
-                target.opened = true;
-                const loot = target.loot;
-                if (loot.type === 'weapon') enemyPickupCollect(e, { type:'weapon', weapon: makeWeaponProto(loot.weapon), ammoInMag:loot.weapon.magSize||12, ammoReserve:loot.weapon.startReserve||24 });
-                else if (loot.type === 'medkit') enemyPickupCollect(e, { type:'medkit', amount: loot.amount || 1 });
-                else if (loot.type === 'materials') enemyPickupCollect(e, { type:'materials', amount: loot.amount || 10 });
-                e.state = 'gather';
-                enemyEquipBestWeapon(e);
-                if (e.equippedIndex !== -1){
-                  const eq = e.inventory[e.equippedIndex];
-                  if (eq && eq.type==='weapon' && eq.ammoInMag <= 0 && eq.ammoReserve > 0){
-                    reloadItem(eq);
-                  }
-                }
-                if (e.inventory.some(it => it && it.type === 'weapon')){ e.state = 'combat'; e.lastAttackedTime = now; }
-              }
+              target.opened = true;
+              const loot = target.loot;
+              if (loot.type === 'weapon') enemyPickupCollect(e, { type:'weapon', weapon: makeWeaponProto(loot.weapon), ammoInMag:loot.weapon.magSize||12, ammoReserve:loot.weapon.startReserve||24 });
+              else if (loot.type === 'medkit') enemyPickupCollect(e, { type:'medkit', amount: loot.amount || 1 });
+              else if (loot.type === 'materials') enemyPickupCollect(e, { type:'materials', amount: loot.amount || 10 });
+              e.state = 'gather';
             }
           } else if (target.hasOwnProperty('type') && (target.type === 'wood' || target.type === 'stone')){
             if (td > 26){
@@ -1300,7 +1174,7 @@
       }
     }
 
-    // Drawing world & entities
+    // Drawing world & entities (unchanged)
     function drawWorld(){
       const TILE = 600;
       const cols = Math.ceil(WORLD.width / TILE);
@@ -1721,23 +1595,19 @@
       initHUD();
       cameraUpdate();
 
-      // Set each enemy to prioritize chests for a short time so they grab weapons early, and reposition away from player spawn
       for (const e of enemies){
         if (Math.hypot(e.x - player.x, e.y - player.y) < 180){
           e.x += (Math.random()<0.5? -1:1) * rand(160,260);
           e.y += (Math.random()<0.5? -1:1) * rand(160,260);
         }
-        e.inventory = [null,null,null,null,null];
-        e.equippedIndex = -1;
+        e.inventory = e.inventory || [null,null,null,null,null];
+        e.equippedIndex = (e.inventory && e.inventory.findIndex(it => it && it.type === 'weapon') !== -1) ? e.inventory.findIndex(it => it && it.type === 'weapon') : -1;
         e.spawnSafeUntil = performance.now() + SPAWN_PROTECT_MS;
         e.state = 'gather';
         e.nextHealTime = 0;
         e.tempTarget = null;
         e.tempTargetExpiry = 0;
-        // this flag makes them aggressively seek chests in the first few seconds
-        e.prioritizeChestsUntil = performance.now() + 6000 + rand(0,3000);
-        // also slightly reduce gatherTimeLeft so they don't linger on harvesting
-        e.gatherTimeLeft = Math.min(e.gatherTimeLeft, 6);
+        e.prioritizeChestsUntil = e.prioritizeChestsUntil || (performance.now() + 6000 + rand(0,3000));
       }
 
       gameTime = 300; storm.active = false; storm.radius = storm.maxRadius;