Based on the diffs you've shared, I can see that we've already made some modifications to the terrain-related functionality. However, I still need to see the full contents of the other files you mentioned to provide a comprehensive implementation. Could you please share the full contents of:

1. index.html
2. game.js
3. render.js
4. ai.js
5. events.js

The diffs show that we've added:
- A new terrain.js file with Perlin noise implementation
- Updated utils.js to handle water movement penalties
- Updated ai.js to handle water movement

To complete the implementation, I'll need to see the other files to ensure we:
- Add terrain drawing in render.js
- Prevent building on water in events.js
- Add water movement constants in game.js
- Update AI behaviors to avoid water in ai.js

Could you please share those files so I can provide a complete implementation?

ai.js

@@ -722,11 +722,18 @@ function moveAway(obj, tx, ty, speed=0.4) {
   let dx = obj.x - tx;
   let dy = obj.y - ty;
   let dist = Math.sqrt(dx*dx + dy*dy);
+  
+  // Apply water movement penalty if in water
+  let actualSpeed = speed;
+  if (isWater(obj.x, obj.y)) {
+    actualSpeed *= WATER_MOVEMENT_PENALTY;
+  }
+  
   if(dist > 1) {
-    obj.vx = (dx/dist) * speed;
-    obj.vy = (dy/dist) * speed;
+    obj.vx = (dx/dist) * actualSpeed;
+    obj.vy = (dy/dist) * actualSpeed;
   } else {
-    obj.vx = (Math.random() - 0.5) * speed;
-    obj.vy = (Math.random() - 0.5) * speed;
+    obj.vx = (Math.random() - 0.5) * actualSpeed;
+    obj.vy = (Math.random() - 0.5) * actualSpeed;
   }
 }

terrain.js

@@ -0,0 +1,145 @@
+/**********************************************************************
+ * TERRAIN GENERATION
+ **********************************************************************/
+
+// Perlin noise implementation
+// Based on https://github.com/josephg/noisejs
+class Perlin {
+  constructor() {
+    this.grad3 = [[1,1,0],[-1,1,0],[1,-1,0],[-1,-1,0],
+                  [1,0,1],[-1,0,1],[1,0,-1],[-1,0,-1],
+                  [0,1,1],[0,-1,1],[0,1,-1],[0,-1,-1]];
+    this.p = [];
+    for (let i=0; i<256; i++) {
+      this.p[i] = Math.floor(Math.random()*256);
+    }
+    
+    // To remove the need for index wrapping, double the permutation table length
+    this.perm = new Array(512);
+    this.gradP = new Array(512);
+    
+    // Skipping the seed function for simplicity
+    this.seed(0);
+  }
+  
+  seed(seed) {
+    if(seed > 0 && seed < 1) {
+      // Scale the seed out
+      seed *= 65536;
+    }
+
+    seed = Math.floor(seed);
+    if(seed < 256) {
+      seed |= seed << 8;
+    }
+
+    for(let i = 0; i < 256; i++) {
+      let v;
+      if (i & 1) {
+        v = this.p[i] ^ (seed & 255);
+      } else {
+        v = this.p[i] ^ ((seed>>8) & 255);
+      }
+
+      this.perm[i] = this.perm[i + 256] = v;
+      this.gradP[i] = this.gradP[i + 256] = this.grad3[v % 12];
+    }
+  }
+  
+  // 2D Perlin Noise
+  noise(x, y) {
+    // Find unit grid cell containing point
+    let X = Math.floor(x), Y = Math.floor(y);
+    // Get relative xy coordinates of point within that cell
+    x = x - X; y = y - Y;
+    // Wrap the integer cells at 255 (smaller integer period can be introduced here)
+    X = X & 255; Y = Y & 255;
+
+    // Calculate noise contributions from each of the four corners
+    let n00 = this.dot2(this.gradP[X+this.perm[Y]], x, y);
+    let n01 = this.dot2(this.gradP[X+this.perm[Y+1]], x, y-1);
+    let n10 = this.dot2(this.gradP[X+1+this.perm[Y]], x-1, y);
+    let n11 = this.dot2(this.gradP[X+1+this.perm[Y+1]], x-1, y-1);
+
+    // Compute the fade curve value for x
+    let u = this.fade(x);
+
+    // Interpolate the four results
+    return this.lerp(
+      this.lerp(n00, n10, u),
+      this.lerp(n01, n11, u),
+      this.fade(y));
+  }
+  
+  // Fading function
+  fade(t) {
+    return t*t*t*(t*(t*6-15)+10);
+  }
+  
+  // Linear interpolation
+  lerp(a, b, t) {
+    return (1-t)*a + t*b;
+  }
+  
+  // Dot product
+  dot2(g, x, y) {
+    return g[0]*x + g[1]*y;
+  }
+}
+
+// Terrain types
+const TERRAIN_WATER = 0;
+const TERRAIN_GRASS = 1;
+
+// Generate terrain map
+function generateTerrain(width, height, scale) {
+  const terrain = new Array(width);
+  for (let x = 0; x < width; x++) {
+    terrain[x] = new Array(height);
+    for (let y = 0; y < height; y++) {
+      // Generate noise value
+      let nx = x / scale;
+      let ny = y / scale;
+      let value = perlin.noise(nx, ny);
+      
+      // Adjust the value to get more interesting terrain
+      // Add multiple octaves of noise for more natural look
+      value += 0.5 * perlin.noise(nx * 2, ny * 2);
+      value += 0.25 * perlin.noise(nx * 4, ny * 4);
+      value /= 1.75; // Normalize
+      
+      // Determine terrain type based on noise value
+      if (value < -0.2) {
+        terrain[x][y] = TERRAIN_WATER;
+      } else {
+        terrain[x][y] = TERRAIN_GRASS;
+      }
+    }
+  }
+  return terrain;
+}
+
+// Check if a position is in water
+function isWater(x, y) {
+  // Convert world coordinates to terrain grid coordinates
+  const gridX = Math.floor((x + 2000) / 10) + 100;
+  const gridY = Math.floor((y + 2000) / 10) + 100;
+  
+  // Check bounds
+  if (gridX < 0 || gridX >= terrainWidth || gridY < 0 || gridY >= terrainHeight) {
+    return false; // Default to land if out of bounds
+  }
+  
+  return terrainMap[gridX][gridY] === TERRAIN_WATER;
+}
+
+// Terrain dimensions
+const terrainWidth = 500;
+const terrainHeight = 500;
+const terrainScale = 100;
+
+// Initialize Perlin noise
+const perlin = new Perlin();
+
+// Generate the terrain map
+let terrainMap = generateTerrain(terrainWidth, terrainHeight, terrainScale);

utils.js

@@ -50,9 +50,16 @@ function moveToward(obj, tx, ty, speed=0.4) {
   let dx = tx - obj.x;
   let dy = ty - obj.y;
   let dist = Math.sqrt(dx*dx + dy*dy);
+  
+  // Apply water movement penalty if in water
+  let actualSpeed = speed;
+  if (isWater(obj.x, obj.y)) {
+    actualSpeed *= WATER_MOVEMENT_PENALTY;
+  }
+  
   if(dist > 1) {
-    obj.vx = (dx/dist) * speed;
-    obj.vy = (dy/dist) * speed;
+    obj.vx = (dx/dist) * actualSpeed;
+    obj.vy = (dy/dist) * actualSpeed;
   } else {
     obj.vx = 0; 
     obj.vy = 0;