INIT: 0,

  MENU: 1,

  GAME: 2,

  GAMEOVER: 3,

};

let gameState;

let startMessage;

let border, border_pts;

const borderSpeed = 5;

let player;

let mapObject;

let NUM_ROWS, NUM_COLS;

let dirty;

let CELL_SIZE, HALF_CELL;

const MOVE_KEY_TIMER_START = 18; //4;

let MOVE_KEY_TIMER = -1;

​

let entities;

​

const dirs = [

  [-1, -1], [0, -1], [1, -1],

  [-1, 0], [0, 0], [1, 0],

  [-1, 1], [0, 1], [1, 1]

]

​

function initGame(level = null) {

  gameState = STATES.INIT;

  startMessage = random(START_MESSAGES);

  textFont("Courier");

  textSize(36);

  CELL_SIZE = 24;

  HALF_CELL = CELL_SIZE / 2;

​

  border = width * 0.05;

  border_pts = [

    { x: border, y: border, vx: borderSpeed, vy: 0 },

    { x: width - border, y: height - border, vx: -borderSpeed, vy: 0 },

  ];

​

  NUM_ROWS = 24;

  NUM_COLS = 32;

  dirty = true;

​

  if (level == null)

    player = { r: -1, c: -1, level: 0, num_turns: 0, sanity: 100 };

  else {

    player.level = level;

    player.num_turns = 0;

    player.sanity = 100;

  }

​

  mapObject = generateMap();

  entities = generateEntities();

}

​

function setup() {

  createCanvas(800, 600);

  background(20);

​

  initGame();

}

​

function drawUI() {

  textAlign(LEFT, TOP);

  textSize(HALF_CELL);

  stroke(220);

  strokeWeight(1);

  noFill();

​

  rect(1, 1, width - 2, HALF_CELL);

​

  let w = map(player.sanity, 100, 0, width - 8, 0);

  noStroke();

  let col = lerpColor(color(0, 220, 0), color(220, 0, 0), map(player.sanity, 100, 0, 0.0, 1.0));

  fill(col);

  rect(4, 4, w, HALF_CELL - 6);

​

  // noStroke();

  // fill(220);

  // text(`level: ${player.level}`, 1, 1)

​

​

​

}

​

function drawMap() {

  textAlign(CENTER, CENTER);

  textSize(CELL_SIZE);

  // noStroke();

  strokeWeight(1);

  // fill(220);

​

  let light_focii = [];

  let chance = map(player.num_turns, 0, mapObject.max_turns, 0.999, 0.5);

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

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

      if (random() > chance) {//0.98) {

        fill(random(20, 180));

        stroke(random(20, 180));

        text(mapObject.mapOverlay[r][c], CELL_SIZE + c * CELL_SIZE, CELL_SIZE + r * CELL_SIZE);

      } else {

​

​

        if (mapObject.currentMap[r][c] != " ") {

          if (mapObject.currentMap[r][c] == ".") {

            fill(80);

            stroke(80);

          } else if (mapObject.currentMap[r][c] == "!") {

            light_focii.push({ r: r, c: c });

          } else {

            stroke(220);

            fill(220);

          }

          text(

            mapObject.currentMap[r][c],

            CELL_SIZE + c * CELL_SIZE,

            CELL_SIZE + r * CELL_SIZE

          );

          // } else {

          //   text("~", CELL_SIZE + c * CELL_SIZE, CELL_SIZE + r * CELL_SIZE);

        }

      }

    }

  }

​

  // lights

  for (let l of light_focii) {

    for (let d of dirs) {

      let next = {r: l.r + d[1], c: l.c + d[0]};

      if (moveValid(next, d)) {

        stroke(color(120, 0, 0));

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

        text(

          mapObject.currentMap[next.r][next.c],

          CELL_SIZE + next.c * CELL_SIZE,

          CELL_SIZE + next.r * CELL_SIZE

        );

      }

    }

  }

​

​

  stroke(color(255, 0, 255));

  fill(20);

  for (let e of entities) {

    text(e.char, CELL_SIZE + e.c * CELL_SIZE, CELL_SIZE + e.r * CELL_SIZE);

    e.update(e);

  }

​

  stroke(220);

  fill(220);

  text("@", CELL_SIZE + player.c * CELL_SIZE, CELL_SIZE + player.r * CELL_SIZE);

}

​

function dumb(e) {

  if (random() > 0.5) {

    tryMove(e, { r: random([-1, 0, 1]), c: random([-1, 0, 1]) });

  }

}

​

function follow(e) {

  return;

}

​

function generateEntities() {

  let _entities = [];

​

  for (let _ = 0; _ < player.level * 2; _++) {

    let cell = random(mapObject.open_cells);

    let e = {

      r: cell.r, c: cell.c,

      char: String.fromCharCode(0x0 + random() * (0x30FF - 0x0 + 1)),

      update: dumb//random([dumb, follow])

    };

​

    _entities.push(e);

  }

  console.log(_entities)

​

  return _entities;

}

function generateMap() {

  let _map = [];

  let _mapOverlay = [];

​

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

    _map[r] = [];

    _mapOverlay[r] = [];

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

      // if (c == 0 || c == NUM_COLS-1 || r == 0 || r == NUM_ROWS-1)

      //   _map[r][c] = "3";

      // else

      _map[r][c] = " ";

      _mapOverlay[r][c] = String.fromCharCode(0x0 + random() * (0x30FF - 0x0 + 1));

    }

  }

​

  // drunkards walk

  let max_turns = 10000;

  let startr = int(NUM_ROWS / 2);

  let startc = int(NUM_COLS / 2);

​

  let open_cells = []

  for (let _ = 0; _ < 10; _++) {

    let timeout = 50;//100;

    let _r = startr;

    let _c = startc;

    while (timeout > 0) {

      _map[_r][_c] = ".";

      open_cells.push({ r: _r, c: _c });

​

      _r += random([-1, 0, 1]);

      _c += random([-1, 0, 1]);

​

      if (_r == 0 || _r > NUM_ROWS - 1 || _c == 0 || _c > NUM_COLS - 1) timeout = 0;

    }

  }

  let oc = random(open_cells);

  _map[oc.r][oc.c] = ">";

​

  oc = random(open_cells);

  _map[oc.r][oc.c] = "!";

​

​

  // just a path

  /*

  let startr = int(random(0, NUM_ROWS - 1));

  let startc = int(random(0, NUM_COLS - 1));

  let endr, endc;

  do {

    endr = int(random(0, NUM_ROWS - 1));

    endc = int(random(0, NUM_COLS - 1));

  } while (startr == endr && startc == endc);

  _map[endr][endc] = ">";

  let currr = startr;

  let currc = startc;

  let max_turns = 0;

  for (let i = 0; i < player.level + 1; i++) {

    while (currc != endc || currr != endr) {

      _map[currr][currc] = ".";

      if (currc < endc) currc++;

      else if (currc > endc) currc--;

      else if (currr < endr) currr++;

      else if (currr > endr) currr--;

      max_turns++;

    }

    currr = int(random(0, NUM_ROWS - 1));

    currc = int(random(0, NUM_COLS - 1));

  }

  */

​

  /*

  while (!done) {

    _map[currr][currc] = ".";

    if (currc > endc) currc++;

    else if (currc < endc) currc--;

    else if (currr > endr) currr--;

    else if (currr < endr) currr++;

    if (currr == endr && currc == endc) done = true;

  }*/

​

  player.r = startr;

  player.c = startc;

​

  return { currentMap: _map, mapOverlay: _mapOverlay, max_turns: max_turns, open_cells: open_cells };

}

function keyPressed() {

  if (gameState == STATES.INIT) {

    gameState = STATES.GAME;

  }

}

​

function draw() {

  switch (gameState) {

    case STATES.INIT:

      background(color(20, 20, 20, 10));

      stroke(0, 128, 128);

      strokeWeight(2);

      for (let p of border_pts) {

        point(p.x, p.y);

        p.x += p.vx;

        p.y += p.vy;

​

        if (p.vx > 0 && p.x > width - border) {

          p.vx = 0;

          p.vy = borderSpeed;

        } else if (p.vx < 0 && p.x < border) {

          p.vx = 0;

          p.vy = -borderSpeed;

        } else if (p.vy > 0 && p.y > height - border) {

          p.vx = -borderSpeed;

          p.vy = 0;

        } else if (p.vy < 0 && p.y < border) {

          p.vx = borderSpeed;

          p.vy = 0;

        }

        p.x = constrain(p.x, border, width - border);

        p.y = constrain(p.y, border, height - border);

      }

      textAlign(CENTER);

      // translate(width / 2, height / 2);

      if (random() > 0.5) {

        fill(color(180, 0, 180));

        stroke(color(180, 0, 180));

        text(

          startMessage,

          width / 2 + random(-5, 5),

          height / 2 + random(-5, 5)

        );

      }

      // fill(20);

      noFill();

      stroke(20);

      text(startMessage, width / 2, height / 2);

      // translate(-width / 2, -height / 2);

      break;

​

    default:

      if (dirty) {

        background(20);

        // translate(width/2,height/2)

        drawMap();

        drawUI();

        dirty = false;

      }

​

      handleMove();

      break;

  }

}

​

function handleMove() {

  let dir = { r: 0, c: 0 };

  let isMoving = false;

​

  // if we're at "running" or "initialized", move

  // otherwise wait a tick or two before moving

  if (MOVE_KEY_TIMER <= 0) {

    if (keyIsDown(74) || keyIsDown(83) || keyIsDown(DOWN_ARROW) || keyIsDown(98)) {

      dir.r = 1;

      dirty = true;

      isMoving = true;

    }

    if (keyIsDown(75) || keyIsDown(87) || keyIsDown(UP_ARROW) || keyIsDown(104)) {

      dir.r = -1;

      dirty = true;

      isMoving = true;

    }

    if (keyIsDown(72) || keyIsDown(65) || keyIsDown(LEFT_ARROW) || (keyIsDown(100))) {

      dir.c = -1;

      dirty = true;

      isMoving = true;

    }

    if (keyIsDown(76) || keyIsDown(68) || keyIsDown(RIGHT_ARROW) || keyIsDown(102)) {

      dir.c = 1;

      dirty = true;

      isMoving = true;

    }

​

    // up left

    if (keyIsDown(89) || keyIsDown(103) || keyIsDown(81)) {

      dir.c = -1;

      dir.r = -1;

      dirty = true;

      isMoving = true;

    }

    // up right

    if (keyIsDown(85) || keyIsDown(105) || keyIsDown(69)) {

      dir.c = 1;

      dir.r = -1;

      dirty = true;

      isMoving = true;

    }

    // down left

    if (keyIsDown(66) || keyIsDown(97) || keyIsDown(90)) {

      dir.c = -1;

      dir.r = 1;

      dirty = true;

      isMoving = true;

    }

    // down right

    if (keyIsDown(78) || keyIsDown(99) || keyIsDown(67)) {

      dir.c = 1;

      dir.r = 1;

      dirty = true;

      isMoving = true;

    }

​

    if (MOVE_KEY_TIMER == -1) MOVE_KEY_TIMER = MOVE_KEY_TIMER_START;

  }

  if (isMoving) {

    let ret = tryMove(player, dir);

    if (ret == "valid") {

      player.num_turns++;

      player.sanity--;

    } else if (ret == "newlevel") {

      player.num_turns++;

      initGame(player.level + 1);

    } else if (ret == "refill") { // also could cast a circle of light that refills sanity while standing in it

      mapObject.currentMap[player.r][player.c] = ".";

      player.num_turns++;

      player.sanity = 100;

    }

​

    /*

    let pmoved = tryMove(player, dir);

    if (player.movingEntity != null && pmoved) {

      // handle double move

      if (

        !(player.d == 0 && entities[player.movingEntity].c == player.c + 1) &&

        !(player.d == 1 && entities[player.movingEntity].r == player.r + 1) &&

        !(player.d == 2 && entities[player.movingEntity].c == player.c - 1) &&

        !(player.d == 3 && entities[player.movingEntity.r] == player.r - 1)

      )

        tryMove(entities[player.movingEntity], dir);

    }

*/

    player.r = constrain(player.r, 0, NUM_ROWS - 1);

    player.c = constrain(player.c, 0, NUM_COLS - 1);

  }

  if (MOVE_KEY_TIMER > 0) MOVE_KEY_TIMER--;

​

  if (!keyIsPressed) MOVE_KEY_TIMER = -1;

​

  if (player.sanity <= 0) {

    player.sanity = 0;

    // gameState = STATES.INIT;

    initGame(0);

  }

}

​

// try moving something to a new location

function tryMove(e, dir) {

  let next = { r: e.r + dir.r, c: e.c + dir.c };

  if (moveValid(next, dir)) {

    e.r = next.r;

    e.c = next.c;

​

    if (mapObject.currentMap[e.r][e.c] == ">" && e == player) return "newlevel";//initGame(player.level + 1);

    if (mapObject.currentMap[e.r][e.c] == "!" && e == player) return "refill";

    return "valid";//true;

  }

  return "invalid";//false;

}

​

// check if move is valid and push entities if they're in the way

function moveValid(next, dir) {

  // out of bounds

  if (

    next.r < 0 ||

    next.r > NUM_ROWS - 1 ||

    next.c < 0 ||

    next.c > NUM_COLS - 1

  )

    return false;

  else {

    /*

    // entity in way?

    let entity_in_way = false;

    // for (let e of entities) {

    for (const [key, e] of Object.entries(entities)) {

      if (next.r == e.r && next.c == e.c) {

        // push entity?

        let ret = tryMove(e, dir);

        if (ret) continue; // move into entity's space

        entity_in_way = true;

        break;

      }

    }

    if (entity_in_way) return false;*/

​

    // wall in way?

    if (isWalkable(next)) return true;

    return false;

  }

  console.log("error - not handled movement");

  return false;

}

​

function isWalkable(next) {

  let entity_in_way = false;

  // // for (let e of entities) {

  // for (const [key, e] of Object.entries(entities)) {

  //   if (next.r == e.r && next.c == e.c) {

  //     entity_in_way = true;

  //     break;

  //   }

  // }

​

  if (mapObject.currentMap[next.r][next.c] != " " && !entity_in_way) return true;

  return false;

}