let num_cells = 25;

let cell_size;

let game_map;

let _noise;

​

const Cells = {

  FLOOR: 0,

  WALL: 1,

  GRASS: 2,

  SHORE: 3,

  WATER: 4,

  LAVA: 5,

  DIRT: 6,

};

​

// function rc_to_xy(r, c) {

​

// }

​

function keyPressed() {

  if (keyCode == UP_ARROW || key == "k") game_map.tryMove("Player", [0, -1]);

​

  if (keyCode == DOWN_ARROW || key == "j") game_map.tryMove("Player", [0, 1]);

​

  if (keyCode == LEFT_ARROW || key == "h") game_map.tryMove("Player", [-1, 0]);

​

  if (keyCode == RIGHT_ARROW || key == "l") game_map.tryMove("Player", [1, 0]);

​

  if (key == "y") game_map.tryMove("Player", [-1, -1]);

  if (key == "u") game_map.tryMove("Player", [1, -1]);

  if (key == "b") game_map.tryMove("Player", [-1, 1]);

  if (key == "n") game_map.tryMove("Player", [1, 1]);

​

  // num pad?

​

  game_map.updateDraw = true;

}

​

class Actor {

  constructor(who, r, c, char) {

    this.r = r;

    this.c = c;

    this.char = char;

​

    if (who == "Player") {

      this.isPlayer = true;

      this.color = color(255);

    } else {

      this.isPlayer = false;

      this.color = color(255, 0, 0);

    }

  }

​

  update() {}

​

  draw() {

    fill(this.color);

    stroke(this.color);

    text(

      this.char,

      this.c * cell_size + cell_size / 2,

      this.r * cell_size + cell_size / 2

    );

  }

}

​

class GameMap {

  constructor(num_cells) {

    this.map = new Array(num_cells);

    this.curr_img = null;

    this.entities = {};

    this.entities["Player"] = new Actor(

      "Player",

      int(num_cells / 2),

      int(num_cells / 2),

      "@"

    );

​

    for (let row = 0; row < this.map.length; row++) {

      this.map[row] = new Array(num_cells);

      for (let col = 0; col < this.map[row].length; col++) {

        if (

          row == 0 ||

          row == num_cells - 1 ||

          col == 0 ||

          col == num_cells - 1

        )

          this.map[row][col] = Cells.WALL;

        else {

          let _n = _noise.get2DNoise(col, row);

​

          if (_n < 0.0) this.map[row][col] = Cells.FLOOR;

          else if (_n < 0.1) this.map[row][col] = Cells.SHORE;

          else if (_n < 0.3) this.map[row][col] = Cells.WATER;

          else if (_n < 0.4) this.map[row][col] = Cells.GRASS;

          else if (_n < 0.7) this.map[row][col] = Cells.DIRT;

          else if (_n < 0.8) this.map[row][col] = Cells.LAVA;

          else this.map[row][col] = Cells.FLOOR;

        }

      }

    }

    this.updateDraw = true;

    // console.log(this.map)

  }

​

  validMove(r, c) {

    if (this.map[r][c] == Cells.WALL) return false;

    return true;

  }

​

  tryMove(who, dir) {

    let new_r = this.entities[who].r + dir[1];

    let new_c = this.entities[who].c + dir[0];

​

    if (this.validMove(new_r, new_c)) {

      this.entities[who].r = new_r;

      this.entities[who].c = new_c;

    }

  }

​

  draw() {

    if (this.updateDraw && this.curr_img == null) {

      gfx.clear();

      let x = 0;

      let y = 0;

​

      for (let r = 0; r < num_cells; r++) {

        x = 0;

        for (let c = 0; c < num_cells; c++) {

          gfx.noStroke();

          switch (this.map[r][c]) {

            case Cells.FLOOR:

              gfx.fill(color(20, 20, 20));

              break;

            case Cells.WALL:

              gfx.fill(color(0));

              break;

            case Cells.GRASS:

              gfx.fill(color(0, 255, 0));

              break;

            case Cells.SHORE:

              gfx.fill(color(120, 120, 0));

              break;

            case Cells.WATER:

              gfx.fill(color(0, 0, 255));

              break;

            case Cells.LAVA:

              gfx.fill(color(255, 0, 0));

              break;

            case Cells.DIRT:

              gfx.fill(color(120, 120, 0));

              break;

            default:

              console.log(r,c,this.map[r][c])

              gfx.fill(color(255, 0, 255));

              break;

          }

          gfx.rect(x, y, cell_size);

​

          // if (this.map[r][c] == Cells.FLOOR) {

          //   stroke(120);

          //   fill(120);

          //   text(".", x + cell_size / 2, y + cell_size / 2);

          // }

​

          x += cell_size;

        }

        y += cell_size;

      }

​

      dither(gfx);

      this.curr_img = gfx.get();

    }

    if (this.updateDraw) {

      drawShadow(4,null);

      image(this.curr_img,0,0);

      for (let e in this.entities) {

        this.entities[e].draw();

      }

      this.updateDraw = false;

    }

  }

​

  update() {}

}

​

let gfx;

function setup() {

  createCanvas(1000, 1000);

  gfx = createGraphics(width, height);

  cell_size = width / num_cells;

​

  _noise = new FastSimplexNoise({ frequency: 0.01, octaves: 4 });

​

  textFont("Courier New");

  textSize(cell_size);

  textAlign(CENTER, CENTER);

​

  game_map = new GameMap(num_cells);

}

​

function draw() {

  game_map.update();

  game_map.draw();

  push();

  textSize(32);

  stroke(255);

  fill(0);

  rect(0,0,40,40);

  fill(255);

  text(int(frameRate()), 20, 20);

  pop();

}

​

function drawShadow(b, g) {

  if (g == null) {

    drawingContext.shadowOffsetX = 3;

    drawingContext.shadowOffsetY = 3;

    drawingContext.shadowBlur = b;

    drawingContext.shadowColor = color(0); //"black";

  } else {

    if (b == 0) {

      g.drawingContext.shadowOffsetX = 0;

      g.drawingContext.shadowOffsetY = 0;

      g.drawingContext.shadowBlur = 0;

      g.drawingContext.shadowColor = color(0); //"black";

    } else {

      g.drawingContext.shadowOffsetX = 3;

      g.drawingContext.shadowOffsetY = 3;

      g.drawingContext.shadowBlur = b;

      g.drawingContext.shadowColor = color(0); //"black";

    }

  }

}

​

function index(x, y) {

  return (x + y * gfx.width) * 4;

}

​

function dither(g) {

  g.loadPixels();

  for (let y = 0; y < g.height - 1; y++) {

    for (let x = 1; x < g.width - 1; x++) {

      let oldr = g.pixels[index(x, y)];

      let oldg = g.pixels[index(x, y) + 1];

      let oldb = g.pixels[index(x, y) + 2];

​

      let factor = 1.0;

      let newr = round((factor * oldr) / 255) * (255 / factor);

      let newg = round((factor * oldg) / 255) * (255 / factor);

      let newb = round((factor * oldb) / 255) * (255 / factor);

​

      g.pixels[index(x, y)] = newr;

      g.pixels[index(x, y) + 1] = newg;

      g.pixels[index(x, y) + 2] = newb;

​

      g.pixels[index(x + 1, y)] += ((oldr - newr) * 7) / 16.0;

      g.pixels[index(x + 1, y) + 1] += ((oldr - newr) * 7) / 16.0;

      g.pixels[index(x + 1, y) + 2] += ((oldr - newr) * 7) / 16.0;

​

      g.pixels[index(x - 1, y + 1)] += ((oldr - newr) * 3) / 16.0;

      g.pixels[index(x - 1, y + 1) + 1] += ((oldr - newr) * 3) / 16.0;

      g.pixels[index(x - 1, y + 1) + 2] += ((oldr - newr) * 3) / 16.0;

​

      g.pixels[index(x, y + 1)] += ((oldr - newr) * 5) / 16.0;

      g.pixels[index(x, y + 1) + 1] += ((oldr - newr) * 5) / 16.0;

      g.pixels[index(x, y + 1) + 2] += ((oldr - newr) * 5) / 16.0;

​

      g.pixels[index(x + 1, y + 1)] += ((oldr - newr) * 1) / 16.0;

      g.pixels[index(x + 1, y + 1) + 1] += ((oldr - newr) * 1) / 16.0;

      g.pixels[index(x + 1, y + 1) + 2] += ((oldr - newr) * 1) / 16.0;

    }

  }

  g.updatePixels();

  // image(img, 600, 0);

}

​