let px = 5; // size of pixels (Must divide width and height evenly)

let cell = 80; // alternative to pixels, determines pixel size based off of dividing screen - Doesnt need to divide evenly. Use this if you are going to use screen width instead of predetermined width

let useCells = false;

let noiseScale = 0.0005; // number between 0.0005 and 0.002 recommended (patterns form)

const levels = 128; // color detail - number between 4 and 254, values outside this range are degenerative.

let debug;

let colorScale;

let res;

let Offsets;

let change;

let lastVals;

let z = 0;

let xOff = 100000;

let yOff = -100000;

let pxw, pxh;

let forceChange = true;

let zoom = 15;

let errorLogger;

let count;

​

function setup() {

  debug = false;

  createCanvas(1000, 700);

  generateDom();

  if (useCells) {

    res = createVector(cell, cell);

    pxw = width / cell;

    pxh = height / cell;

  } else {

    res = createVector(width / px, height / px);

    pxw = px;

    pxh = px;

  }

  ipxw = 1 / pxw;

  ipxh = 1 / pxh;

  assignPixels(mapGen);

  // noLoop();

  noStroke();

  noFill();

  colorScale = 255 / levels;

  change = true;

  waterLevel = 1.2;

  errorLogger = [];

  count = 0;

}

​

function draw() {

  let z = 0;

  change = lastVals.x !== cliffs.value() ||

    lastVals.y !== WaterLevel.value() ||

    lastVals.z !== heat.value() ||

    forceChange || frameCount < 10;

​

  if (change) {

    background(sin(count * 0.01) * 32 + 32)

    z = heat.value();

    lastVals.x = cliffs.value();

    lastVals.y = WaterLevel.value();

    lastVals.z = heat.value();

    forceChange = false;

    waterLevel = WaterLevel.value();

    assignPixels(mapGen);

    pngDraw();

    forceChange = false;

  }

  if (errorLogger[0]) {

    console.log(errorLogger)

    errorLogger = [];

  }

}

​

​

​

// helper functions

​

function neighborDraw() {

  let count = 0;

  for (let item in pixArray) {

    noFill();

    if (!pixArray[item].visited) {

      stroke(pixArray[item].value);

      let todo = pxComp(item);

      beginShape();

      Object.keys(todo).forEach(cel => {

        if (todo[cel] && !todo[cel].drawn) {

          let cur = todo[cel];

          fill(cur.value);

          // rect(cur.x * 15 + 50, cur.y * 15 + 50, 10, 10);

​

​

          Object.keys(todo).forEach(edge => {

            if (todo[edge] && !todo[edge].drawn) {

              let cur2 = todo[edge];

              rect(cur2.x * pxw + pxw * 0.5, cur2.y * pxh + pxh * 0.5, 3, 3);

            }

          });

        }

      });

      endShape(CLOSE);

    }

  }

  // console.log(pixArray);

}

​

function pxComp(i, p = 0) {

  if (pixArray[i] && !pixArray[i].visited) {

    pixArray[i].visited = true;

    let curX = pixArray[i].x;

    let curY = pixArray[i].y;

    let curVal = pixArray[i].value;

    let top = pixArray[Number(i) - res.x];

    let right = pixArray[Number(i) + 1];

    let bottom = pixArray[Number(i) + res.x];

    let left = pixArray[Number(i) - 1];

    let result = {

      [i]: pixArray[i].end ? pixArray[i] : null

    };

    if (top && top.value === curVal)

      result = {

        ...result,

        ...pxComp(top.index, true)

      };

    else {

      result[i] = pixArray[i];

    }

    if (right && right.value === curVal)

      result = {

        ...result,

        ...pxComp(right.index, true)

      };

    else {

      result[i] = pixArray[i];

    }

    if (bottom && bottom.value === curVal)

      result = {

        ...result,

        ...pxComp(bottom.index, true)

      };

    else {

      result[i] = pixArray[i];

    }

    if (left && left.value === curVal)

      result = {

        ...result,

        ...pxComp(left.index, true)

      };

    else {

      result[i] = pixArray[i];

    }

    // if(pixArray[i].x === 39)

    //   console.log(result);

    return result;

  }

}

​

function pngDraw() {

  let lastPix = pixArray[0];

  let counter = 1;

  for (let i of pixArray) {

    if (lastPix === null) {

      lastPix = i;

    }

    if (i.value !== lastPix.value || i.end) {

​

      fill(lastPix.value);

      beginShape();

      vertex(lastPix.x * pxw, lastPix.y * pxh + pxh);

      vertex(lastPix.x * pxw, lastPix.y * pxh);

      vertex(i.x * pxw, i.y * pxh);

      vertex(i.x * pxw, i.y * pxh + pxh);

      endShape();

​

      //       Debug with dots

      if (debug) {

        stroke(0);

        fill(lastPix.value * 1, 255, 255);

        rect(lastPix.x * pxw, lastPix.y * pxh, 5, 5);

        fill(lastPix.value * 1, 0, 255);

        rect(i.x * pxw, i.y * pxh, 5, 5);

        rect(floor(mouseX * ipxw) * pxw, floor(mouseY * ipxh) * pxh, pxw, pxh);

        line(0, height * 0.5, width, height * 0.5)

        line(width * 0.5, 0, width * 0.5, height)

        errorLogger.push('pngDraw::: current, last, counter: ' + i + ', ' + lastPix + ', ' + counter);

      }

      //       End debug

​

      lastPix = i.end ? null : i;

      counter = 1;

    } else {

      counter++;

    }

  }

}

​

function assignPixels(modifier, drawMethod) {

  pixArray = [];

  for (let cy = 0; cy < res.y; cy++) {

    for (let cx = 0; cx < res.x; cx++) {

      let temp = (modifier(cx, cy, 10));

      temp.index = cy * res.x + cx;

      if (cx === 0 || cy === 0 || cy === res.y - 1 || cx === res.x - 1) {

        temp.end = true;

        pixArray[temp.index] = (temp);

      } else {

        temp.end = false;

        pixArray[temp.index] = (modifier(cx, cy, 10));

      }

    }

  }

}

​

function noiseFill(x, y, z) {

  return {

    x: x,

    y: y,

    z: z,

    value: ceil(

      noise(x * noiseScale + xOff * noiseScale,

        y * noiseScale + yOff * noiseScale,

        z * noiseScale) * levels) * colorScale,

    visited: false

  };

}

​

function gradient(x, y) {

  return {

    x: x,

    y: y,

    value: color(150, y * 5, 50)

  };

}

​

function mapGen(x, y, z) {

  let nVal = ceil(noise(

    x * (noiseScale * zoom) + xOff * noiseScale,

    y * (noiseScale * zoom) + yOff * noiseScale,

    z * noiseScale) * levels) * colorScale;

  let nVal2 = ceil(noise(

    x * (noiseScale * zoom) + xOff * noiseScale,

    y * (noiseScale * zoom) + yOff * noiseScale,

    z + 0.05 * noiseScale) * levels) * colorScale;

  let e = nVal % 1; // elevation

  let m = nVal2 % 1; // moisture

  let h = abs(1 - nVal) % 1; // heat

  return {

    x: x,

    y: y,

    z: z,

    value: terrain(e, m, h)

  };

}

​

function generateDom() {

  lastVals = createVector(0, 0, 0);

  cliffs = createSlider(0, 1, 0.5, 0.01);

  heat = createSlider(0, 1, 0.5, 0.01);

  WaterLevel = createSlider(0, 1, 0.7, 0.01);

  cliffs.addClass('cliffSlider');

  heat.addClass('zSlider');

  WaterLevel.addClass('waterSlider');

}

​

function mouseWheel() {

  forceChange = true;

  if (event.deltaY > 0 && zoom < 64) {

    zoom++;

    xOff -= (mouseX * ipxw);

    yOff -= (mouseY * ipxh);

  } else if (zoom > 1) {

    zoom--;

    xOff += (mouseX * ipxw);

    yOff += (mouseY * ipxh);

  }

​

  // console.log(zoom, xOff, yOff, pxw, pxh);

  return false;

}

​

function mouseDragged() {

  forceChange = true;

  xOff += ((pmouseX - mouseX) * ipxw) * (zoom);

  yOff += ((pmouseY - mouseY) * ipxh) * (zoom);

  // console.log(xOff, yOff);

  return false;

}