/**********************************************************************
 * 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
      // Lower water threshold to create more land areas
      if (value < -0.3) {  // Changed from 0.0 to -0.3 to reduce water
        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);
  const gridY = Math.floor((y + 2000) / 10);
  
  // 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 = 400;
const terrainHeight = 400;
const terrainScale = 50; // Smaller scale = more detailed terrain

// Initialize Perlin noise
const perlin = new Perlin();

// Generate the terrain map
let terrainMap = generateTerrain(terrainWidth, terrainHeight, terrainScale);