// head hit - hp--, body hit - split or hp--

// hp-- on wall hit

​

// shader c/o: https://github.com/wessles/GLSL-CRT/blob/master/shader.frag

​

let game;

const CELL_SIZE = 24;

let HALF_CELL_SIZE;

const NUM_ROWS = 50;

const NUM_COLS = 50;

const MAX_DEPTH = 10;

let WINDOW_SCALE = 1.0;

​

let crt_fs;

​

function setup() {

  createCanvas(windowWidth, windowHeight);

  noiseDetail(8, 0.25);

​

  windowResized();

​

  HALF_CELL_SIZE = CELL_SIZE / 2;

​

  game = new Game();

​

  frameRate(10);

  noStroke();

​

  textAlign(LEFT, CENTER);

  textFont("Consolas");

  textSize(CELL_SIZE);

​

  crt_fs = createFilterShader(crt_src);

}

​

function draw() {

  //filter(crt_fs);

​

  switch (game.state) {

    case STATES.INIT:

    case STATES.PLAY:

    default:

      game.update();

      game.draw();

​

      // user input

      if (keyIsPressed) {

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

        if (key == "ArrowDown") next_pos.r = 1;

        if (key == "ArrowUp") next_pos.r = -1;

        if (key == "ArrowLeft") next_pos.c = -1;

        if (key == "ArrowRight") next_pos.c = 1;

​

        // any other key stops movement at present

        game.player.move_dir = next_pos;

​

        if (key == "a") {

          if (game.moving_entities[game.player.z].length > 1) {

            let rid = int(

              random(1, game.moving_entities[game.player.z].length)

            );

            game.trackEntity(0, rid);

          }

        }

        if (key == "r") game.trackEntity(0, 0);

​

        // if (

        //   game.tryMove(

        //     game.player.c + next_pos.c,

        //     game.player.r + next_pos.r,

        //     game.player.z

        //   )

        // ) {

        //   game.player.c += next_pos.c;

        //   game.player.r += next_pos.r;

        // }

​

        // game.dirty = true;

​

        // console.log(game.player,game.tracking)

      }

      break;

    case STATES.GAMEOVER:

      textSize(CELL_SIZE);

      textAlign(LEFT, CENTER);

      game.draw();

​

      fill(color(220, 0, 0, 20));

      rect(0, 0, width, game.game_over_y);

      game.game_over_y += random(1, 25);

​

      textSize(48);

      textAlign(CENTER, CENTER);

      fill(0);

      noStroke();

      text("GAME OVER", width / 2, height / 2);

​

      if (game.game_over_y > height - 1 || keyIsPressed) {

        game = null;

        game = new Game();

      }

​

      break;

  }

}

​

// todo: figure out rescaling plan

function windowResized() {

  let w = 640; //windowWidth;

  let h = 480; //windowHeight;

​

  resizeCanvas(w, h);

}

​

class Game {

  constructor() {

    this.num_cols = NUM_COLS;

    this.num_rows = NUM_ROWS;

    this.max_depth = MAX_DEPTH;

​

    this.state = STATES.PLAY;

    this.game_over_y = 0;

​

    this.game_map = new GameMap(this.num_cols, this.num_rows, this.max_depth);

​

    this.moving_entities = [];

    this.static_entities = [];

​

    for (let z = 0; z < this.max_depth; z++) {

      this.moving_entities[z] = [];

      this.static_entities[z] = [];

    }

​

    let oc = random(this.game_map.open_cells[0]);

    this.player = new Player("@", oc.c, oc.r, 0, this, SPRITES["@"].hp);

    this.moving_entities[0].push(this.player);

​

    for (let z = 0; z < this.max_depth; z++) {

      // enemies

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

        this.spawnLevelEnemy(z);

      }

      // items

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

        let aoc = random(this.game_map.open_cells[z]);

        let a = new Apple("a", aoc.c, aoc.r, z, this, SPRITES["a"].hp);

        this.static_entities[z].push(a);

      }

    }

​

    // camera

    this.dirty = true;

    this.ui_offset = CELL_SIZE; // ui bar

    this.cam_rows = int((height - this.ui_offset) / CELL_SIZE);

    this.cam_cols = int(width / CELL_SIZE);

    this.half_cam_rows = int(this.cam_rows / 2);

    this.half_cam_cols = int(this.cam_cols / 2);

    this.trackEntity(0, 0); // follow player {z, idx}

​

    textAlign(LEFT, CENTER);

    textSize(CELL_SIZE);

  }

​

  spawnLevelEnemy(lvl) {

    let roc = random(this.game_map.open_cells[lvl]);

    // spawn level appropriate enemy

    let r = new Rat("r", roc.c, roc.r, lvl, this, SPRITES["r"].hp);

    this.moving_entities[lvl].push(r);

  }

​

  update() {

    // update entities on level

    for (let e of this.moving_entities[this.player.z]) e.update();

    // try to eat if an enemy moved into player's mouth

    this.player.eat();

​

    // under level cap

    if (this.moving_entities.length - 1 < this.player.z + 100) {

      if (random() > 0.89 && frameCount % 10 == 0) {

        this.spawnLevelEnemy(this.player.z);

      }

    }

  }

​

  //   reset() {

  //     textAlign(LEFT, CENTER);

  //     textSize(CELL_SIZE);

  //     this.game_over_y = 0;

  //     this.state = STATES.INIT;

​

  //     this.player = null;

  //     let oc = random(this.game_map.open_cells[0]);

  //     this.player = new Player("@", oc.c, oc.r, 0, this);

​

  //   }

​

  draw() {

    // if (this.dirty) {

    background(20);

​

    let _x = 0;

    let _y = this.ui_offset;

​

    // camera

    let start_col, start_row, end_col, end_row;

    let curr_z = this.tracking.z;

​

    // setup viewport

    if (this.tracking.c < this.half_cam_cols) start_col = 0;

    else if (this.tracking.c > this.num_cols - this.half_cam_cols)

      start_col = this.num_cols - this.cam_cols;

    else start_col = this.tracking.c - this.half_cam_cols;

​

    if (this.tracking.r < this.half_cam_rows) start_row = 0;

    else if (this.tracking.r >= this.num_rows - this.half_cam_rows)

      start_row = this.num_rows - this.cam_rows;

    else start_row = this.tracking.r - this.half_cam_rows;

​

    // draw map

    for (let r = start_row; r < start_row + this.cam_rows; r++) {

      for (let c = start_col; c < start_col + this.cam_cols; c++) {

        // map

        let map_ch = this.game_map.getTile(c, r, curr_z);

        this.drawTile(map_ch, _x, _y);

​

        _x += CELL_SIZE;

      }

      _y += CELL_SIZE;

      _x = 0;

    }

​

    // draw entities in view

    let m_entities = [];

    let s_entities = [];

​

    // static entities

    if (

      this.moving_entities[curr_z] != undefined &&

      this.moving_entities[curr_z].length > 0

    ) {

      s_entities = this.static_entities[curr_z].filter(

        (e) =>

          e.r >= start_row &&

          e.r < start_row + this.cam_rows &&

          e.c >= start_col &&

          e.c < start_col + this.cam_cols

      );

    }

    for (let e of s_entities) {

      let x_offset = (e.c - start_col) * CELL_SIZE;

      let y_offset = (e.r - start_row) * CELL_SIZE + this.ui_offset;

      this.drawTile(e.name, x_offset, y_offset);

    }

​

    // moving entities

    if (

      this.moving_entities[curr_z] != undefined &&

      this.moving_entities[curr_z].length > 0

    ) {

      m_entities = this.moving_entities[curr_z].filter(

        (e) =>

          e.r >= start_row &&

          e.r < start_row + this.cam_rows &&

          e.c >= start_col &&

          e.c < start_col + this.cam_cols

      );

    }

    for (let e of m_entities) {

      let x_offset = (e.c - start_col) * CELL_SIZE;

      let y_offset = (e.r - start_row) * CELL_SIZE + this.ui_offset;

      this.drawTile(e.name, x_offset, y_offset, e.hp);

​

      // draw body

      if (e == game.player) {

        for (let b of game.player.body) {

          let b_x_offset = (b.c - start_col) * CELL_SIZE;

          let b_y_offset = (b.r - start_row) * CELL_SIZE + this.ui_offset;

​

          let ch = "o";

          if (b == game.player.body[game.player.body.length - 1]) ch = "+";

          this.drawTile(ch, b_x_offset, b_y_offset);

        }

      }

    }

​

    // tracked

    // let x_offset = (this.tracking.c - start_col) * CELL_SIZE;

    // let y_offset = ((this.tracking.r - start_row) * CELL_SIZE) + this.ui_offset;

    // this.drawTile(this.tracking.name, x_offset, y_offset);

​

    // ui

    let remaining = game.moving_entities[game.player.z].length - 1;

    fill(color(20, 0, 20));

    rect(0, height - this.ui_offset, width, this.ui_offset);

    fill(color(SPRITES.ui.col));

    textSize(CELL_SIZE);

    text(

      `| HP: ${game.player.hp}/${game.player.maxHP} | Level: ${

        game.player.z + 1

      }/${MAX_DEPTH} | Z enemies: ${remaining} |`,

      0,

      height - this.ui_offset + HALF_CELL_SIZE

    );

​

    // filter entities in range

    // for (let e of this.moving_entities) {

    //   e.update();

    //   e.draw();

    // }

  }

  // this.dirty = false;

  // }

​

  // focus camera on entity

  trackEntity(z, idx) {

    let e = this.moving_entities[z][idx];

    this.tracking = e;

  }

​

  // draw generic tile

  drawTile(ch, x, y, hp = null, maxHP = null) {

    // fill(20);

    // rect(x-HALF_CELL_SIZE, y-HALF_CELL_SIZE, CELL_SIZE, CELL_SIZE);

    fill(color(SPRITES[ch].col));

    noStroke();

    textSize(CELL_SIZE);

    text(ch, x, y - HALF_CELL_SIZE);

​

    if (hp != null) {

      textSize(HALF_CELL_SIZE);

      text(hp, x + HALF_CELL_SIZE, y);

    }

  }

​

  tryMove(c, r, z) {

    // valid moves

    if (c > 0 && c < this.num_cols - 1 && r > 0 && r < this.num_rows - 1) {

      if (this.game_map.game_map[z][r][c].ch != "#") return true;

    }

    return false;

  }

}

​

// in charge of map and camera

class GameMap {

  constructor(numC, numR, numZ) {

    this.max_depth = numZ;

    this.num_rows = numR;

    this.num_cols = numC;

​

    let ret = this.createMap();

    this.game_map = ret.game_map;

    this.open_cells = ret.open_cells;

  }

​

  createMap() {

    let game_map = [];

    let open_cells = [];

    for (let z = 0; z < this.max_depth; z++) {

      game_map[z] = [];

      open_cells[z] = [];

​

      let map_gen = random(["noise", "open"]);

​

      for (let r = 0; r < this.num_rows; r++) {

        game_map[z][r] = [];

        for (let c = 0; c < this.num_cols; c++) {

          if (

            c == 0 ||

            c == this.num_cols - 1 ||

            r == 0 ||

            r == this.num_rows - 1

          )

            game_map[z][r][c] = { ch: "#" };

          else {

            let ch = " ";

            if (map_gen == "noise") {

              let n = noise(c * 0.01, r * 0.01, z * 0.01);

​

              if (n < 0.25) ch = "#";

              else if (n < 0.5) ch = ".";

              else ch = " ";

​

              game_map[z][r][c] = { ch: ch };

            } else {

              // open

              if (random() > 0.9) ch = ".";

              game_map[z][r][c] = { ch: ch };

            }

​

            if (ch != "#") open_cells[z].push({ c: c, r: r });

          }

        }

      }

​

      // place stairs

      if (z < MAX_DEPTH - 1) {

        let num_stairs = int(random(1, 4));

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

          let o = random(open_cells[z]);

          console.log(o, z, game_map);

          while (game_map[z][o.r][o.c] == "<" || game_map[z][o.r][o.c] == ">") {

            o = random(open_cells[z]);

          }

          game_map[z][o.r][o.c].ch = ">";

        }

      }

    }

​

    return { game_map: game_map, open_cells: open_cells };

  }

​

  getTile(c, r, z) {

    return this.game_map[z][r][c].ch;

  }

​

  getOpenCell(z) {

    return random(this.open_cells[z]);

  }

}

​

class Entity {

  constructor(name, c, r, z, hp) {

    this.name = name;

    this.c = c;

    this.r = r;

    this.z = z;

    this.hp = hp;

  }

​

  update() {}

​

  hurt(amt) {

    this.hp--;

    if (this.hp <= 0) this.hp = 0;

  }

}

​

class Apple extends Entity {

  constructor(name, c, r, z, game, hp) {

    super(name, c, r, z, hp);

    this.game = game;

  }

}

​

class Rat extends Entity {

  constructor(name, c, r, z, game) {

    super(name, c, r, z, int(random(1, SPRITES[name].hp + 1)));

    this.game = game;

  }

​

  update() {

    if (random() > 0.9) {

      let next_pos = {

        c: this.c + random([-1, 0, 1]),

        r: this.r + random([-1, 0, 1]),

      };

      if (this.game.tryMove(next_pos.c, next_pos.r, this.z)) {

        this.c = next_pos.c;

        this.r = next_pos.r;

      }

    }

  }

}

​

class Player extends Entity {

  constructor(name, c, r, z, game, hp = 10) {

    super(name, c, r, z);

​

    this.game = game;

    this.move_dir = { r: 0, c: 0 };

​

    this.body = [];

    this.last_r = this.r;

    this.last_c = this.c;

​

    this.maxHP = hp;

    this.hp = this.maxHP;

​

    this.dmg = 1;

  }

​

  hurt(amt) {

    this.hp -= amt;

    if (this.hp <= 0) {

      this.hp = 0;

      console.log("dead");

​

      game.state = STATES.GAMEOVER;

      // noLoop();

    }

  }

​

  heal(amt) {

    this.hp += amt;

    if (this.hp > this.maxHP) this.hp = this.maxHP;

  }

​

  update() {

    // if (this.move_dir.r != 0 || this.move_dir.c != 0) {

    let next_pos = {

      c: this.c + this.move_dir.c,

      r: this.r + this.move_dir.r,

    };

​

    if (this.game.tryMove(next_pos.c, next_pos.r, this.z)) {

      // check map interactions

      if (this.game.game_map.getTile(next_pos.c, next_pos.r, this.z) == ">") {

        this.game.moving_entities[this.z].splice(0, 1);

​

        this.z++;

​

        let np = this.game.game_map.getOpenCell(this.z);

        this.c = np.c;

        this.r = np.r;

​

        for (let b of this.body) {

          b.c = this.c;

          b.r = this.r;

        }

​

        this.move_dir = { r: 0, c: 0 };

​

        this.game.moving_entities[this.z].unshift(this);

        this.game.trackEntity(this.z, 0);

      } else {

        // enemies

        for (

          let i = this.game.moving_entities[this.z].length - 1;

          i >= 1;

          i--

        ) {

          let e = this.game.moving_entities[this.z][i];

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

            if (e.hp <= 1) {

              // if health at 1, eat

              this.body.push({ r: this.last_r, c: this.last_c });

              this.game.moving_entities[this.z].splice(i, 1);

            } else {

              // otherwise, hurt

              e.hurt(this.dmg);

              this.move_dir = { r: 0, c: 0 };

              next_pos = { r: this.r, c: this.c };

            }

          }

        }

​

        // update body

        if (this.body.length >= 1) {

          this.last_r = this.body[this.body.length - 1].r;

          this.last_c = this.body[this.body.length - 1].c;

​

          for (let i = this.body.length - 1; i >= 1; i--) {

            this.body[i].c = this.body[i - 1].c;

            this.body[i].r = this.body[i - 1].r;

          }

​

          this.body[0].r = this.r;

          this.body[0].c = this.c;

        } else {

          // no body

          this.last_r = this.r;

          this.last_c = this.c;

        }

​

        this.c = next_pos.c;

        this.r = next_pos.r;

​

        if (this.move_dir.r != 0 || this.move_dir.c != 0) {

          // only hurt self when actively moving

          // check self hit

          for (let i = 0; i < this.body.length; i++) {

            if (this.c == this.body[i].c && this.r == this.body[i].r) {

              this.move_dir = { r: 0, c: 0 };

              this.hurt(99999);

            }

          }

        }

      }

    } else {

      // hit a wall

      this.move_dir = { r: 0, c: 0 };

      this.hurt(1);

    }

    // }

  }

​

  // eat enemies and items

  eat() {

    // items

    for (let i = this.game.static_entities[this.z].length - 1; i >= 0; i--) {

      let e = this.game.static_entities[this.z][i];

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

        if (this.hp >= this.maxHP) {

          // grow if full health

          this.body.push({ r: this.last_r, c: this.last_c });

        } else {

          // heal if not

          this.heal(e.hp);

        }

        this.game.static_entities[this.z].splice(i, 1);

      }

    }

​

    // enemy hit moved to update to avoid 'stuck on enemy and biting'

  }

}

​

let crt_src = `precision mediump float;

varying vec2 vTexCoord;

uniform sampler2D tex0;

​

uniform float CRT_CURVE_AMNTx; // curve amount on x

uniform float CRT_CURVE_AMNTy; // curve amount on y

#define CRT_CASE_BORDR 0.0125

#define SCAN_LINE_MULT 1250.0

​

//varying vec4 v_color;

//varying vec2 v_texCoords;

//uniform sampler2D u_texture;

​

void main() {

    vec2 tc = vec2(vTexCoord.x, vTexCoord.y);    

    vec4 color = texture2D(tex0, vTexCoord);

​

    // Distance from the center

    float dx = abs(0.5-tc.x);

    float dy = abs(0.5-tc.y);

​

    // Square it to smooth the edges

    dx *= dx;

    dy *= dy;

​

    tc.x -= 0.5;

    tc.x *= 1.0 + (dy * CRT_CURVE_AMNTx);

    tc.x += 0.5;

​

    tc.y -= 0.5;

    tc.y *= 1.0 + (dx * CRT_CURVE_AMNTy);

    tc.y += 0.5;

​

    // Get texel, and add in scanline if need be

    vec4 cta = texture2D(tex0, vec2(tc.x, tc.y));

​

    cta.rgb += sin(tc.y * SCAN_LINE_MULT) * 0.02;

​

    // Cutoff

    if(tc.y > 1.0 || tc.x < 0.0 || tc.x > 1.0 || tc.y < 0.0)

        cta = vec4(0.0);

​

    // Apply

    gl_FragColor = cta * color;

}`;

​