code guessing, round #9 (completed)

// a pac-man game in curses that tries to be somewhat faithful to the original
// starts at level 21 for no reason and also you can go inside the ghost house!
// please enjoy
// build with -lncurses -lm
// requires ncurses
// please enjoy
// you may want to decrease your initial key repeat delay using xkbset or control panel to make input work gooder

#include <ncurses.h>
#include <locale.h>
#include <stdbool.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#include <math.h>

typedef struct {
    int dx;
    int dy;
} Dir;

static const Dir LEFT = {.dx = -1, .dy = 0 };
static const Dir UP = { .dx = 0, .dy = -1 };
static const Dir RIGHT = { .dx = 1, .dy = 0 };
static const Dir DOWN = { .dx = 0, .dy = 1 };

#define board_width 28
#define board_height 31
static const char board_init[] =
"\
############################\
#............##............#\
#.####.#####.##.#####.####.#\
#O#  #.#   #.##.#   #.#  #O#\
#.####.#####.##.#####.####.#\
#..........................#\
#.####.##.########.##.####.#\
#.####.##.########.##.####.#\
#......##....##....##......#\
######.##### ## #####.######\
     #.##### ## #####.#     \
     #.##   '  '   ##.#     \
     #.## ###--### ##.#     \
######.## #      # ##.######\
TTTTTT.   #  B   #   .TTTTTT\
######.## #      # ##.######\
     #.## ######## ##.#     \
     #.##          ##.#     \
     #.## ######## ##.#     \
######.## ######## ##.######\
#............##............#\
#.####.#####.##.#####.####.#\
#.####.#####.##.#####.####.#\
#O..##......:> :......##..O#\
###.##.##.########.##.##.###\
###.##.##.########.##.##.###\
#......##....##....##......#\
#.##########.##.##########.#\
#.##########.##.##########.#\
#..........................#\
############################";

typedef struct {
    int x;
    int y;
    Dir dir;
    double subpoint;
} Entity;

typedef enum {
    Scatter,
    Chase,
    Frightened,
} AIState;

typedef struct {
    Entity e;
    AIState state;
} Ghost;

typedef struct {
    unsigned long score;
    unsigned short lvl, lives;
    unsigned short remaining;
    char board[board_height][board_width];
    bool xlife;
    Entity pacman;
    Ghost blinky, pinky, inky, clyde;
    AIState default_state;
    int fruit_x, fruit_y, ghost_x, ghost_y;
    unsigned long fruit_timer, scatter_timer, frightened_timer;
    int elroy;
    int inp_buffer, buffered_inp;
} Game;

void advance(Game *game, Entity *e, double speed) {
    int nx = e->x + e->dir.dx;
    if (nx == -1) nx = board_width-1;
    if (nx == board_width) nx = 0;
    int ny = e->y + e->dir.dy;
    e->subpoint += speed/6.0;
    if (game->board[ny][nx] == '#' && e->subpoint > 0.5) {
        e->subpoint = 0.5;
        return;
    }
    if (e->subpoint >= 1.0) {
        e->subpoint -= 1.0;
        e->x = nx;
        e->y = ny;
    }
}

bool turn(Game *game, Entity *e, Dir dir) {
    if (game->board[e->y+dir.dy][e->x+dir.dx] == '#') {
        // can't turn
        return false;
    } else if (dir.dx != e->dir.dx && dir.dy != e->dir.dy) {
        // turn
        e->subpoint = 0.5 - 0.414214*fabs(0.5-e->subpoint);
    } else if (dir.dx != e->dir.dx || dir.dy != e->dir.dy) {
        // reverse
        e->subpoint = 1-e->subpoint;
    }
    e->dir = dir;
    return true;
}

void change_state(Ghost *g, AIState state) {
    g->e.dir.dx *= -1;
    g->e.dir.dy *= -1;
    g->state = state;
}

void change_all_states(Game *game, AIState state) {
    change_state(&game->blinky, state);
    change_state(&game->pinky, state);
    change_state(&game->inky, state);
    change_state(&game->clyde, state);
}

int ghost_colour(Ghost *g, int pair) {
    if (g->state == Frightened) {
        return COLOR_PAIR(6);
    }
    return COLOR_PAIR(pair);
}

void spawn_ghosts(Game *game) {
    game->blinky.e.x = game->ghost_x;
    game->blinky.e.y = game->ghost_y;
    game->blinky.e.dir = LEFT;
    game->pinky.e.x = game->ghost_x;
    game->pinky.e.y = game->ghost_y;
    game->pinky.e.dir = LEFT;
    game->inky.e.x = game->ghost_x;
    game->inky.e.y = game->ghost_y;
    game->inky.e.dir = RIGHT;
    game->clyde.e.x = game->ghost_x;
    game->clyde.e.y = game->ghost_y-3;
    game->clyde.e.dir = RIGHT;
}

void init_game_board(Game *game) {
    for (int y = 0; y < board_height; y++) {
        for (int x = 0; x < board_width; x++) {
            char c = board_init[y*board_width+x];
            switch (c) {
                case '>':
                    game->pacman.x = x;
                    game->pacman.y = y;
                    game->pacman.dir = LEFT;
                    game->fruit_x = x;
                    game->fruit_y = y;
                    c = ' ';
                    break;
                case 'B':
                    game->ghost_x = x;
                    game->ghost_y = y;
                    spawn_ghosts(game);
                    c = ' ';
                    break;
                case '.': case 'O': case ':':
                    game->remaining++;
                    break;
            }
            game->board[y][x] = c;
        }
    }
}

Game init_game() {
    Game game = {0};
    game.lvl = 21;
    game.lives = 2;
    init_game_board(&game);
    return game;
}

void print_board(Game *game) {
    mvprintw(0, 0, "%lu\n", game->score);

    for (int y = 0; y < board_height; y++) {
        for (int x = 0; x < board_width; x++) {
            int c = game->board[y][x];
            if (c == ':') c = '.';
            if (game->pacman.x == x && game->pacman.y == y) {
                #define if_dir(d) (game->pacman.dir.dx == d.dx && game->pacman.dir.dy == d.dy) ?
                if (game->pacman.subpoint > 0.25 && game->pacman.subpoint < 0.75) {
                    c = (if_dir(LEFT) '>' : if_dir(UP) 'v' : if_dir(RIGHT) '<' : if_dir(DOWN) '^' : 0) | A_BOLD | COLOR_PAIR(1);
                } else {
                    c = (if_dir(LEFT) '-' : if_dir(UP) 'v' : if_dir(RIGHT) '-' : if_dir(DOWN) '^' : 0) | A_BOLD | COLOR_PAIR(1);
                }
            } else if (game->blinky.e.x == x && game->blinky.e.y == y) {
                c = 'B' | A_BOLD | ghost_colour(&game->blinky, 2);
            } else if (game->pinky.e.x == x && game->pinky.e.y == y) {
                c = 'P' | A_BOLD | ghost_colour(&game->pinky, 3);
            } else if (game->inky.e.x == x && game->inky.e.y == y) {
                c = 'I' | A_BOLD | ghost_colour(&game->inky, 4);
            } else if (game->clyde.e.x == x && game->clyde.e.y == y) {
                c = 'C' | A_BOLD | ghost_colour(&game->clyde, 5);
            } else if (c == '#') {
                c |= A_DIM | COLOR_PAIR(6);
            } else if (c == '.' || c == 'O') {
                c |= A_DIM | COLOR_PAIR(7);
            } else if (c == 'T' || c == '\'') {
                c = ' ';
            } else if (c == 'K') {
                c |= A_BOLD | COLOR_PAIR(8);
            }

            addch(c);
            addch(' ');
        }
        addch('\n');
    }

    printw("lvl: %hu, lives: %hu\n", game->lvl, game->lives);

    refresh();
}

void process_input(Game *game) {
    int inp = getch();

    bool manual = true;
    if (inp == ERR && game->inp_buffer) {
        game->inp_buffer--;
        inp = game->buffered_inp;
        manual = false;
    }

    bool satisfied = false;
    switch (inp) {
        case KEY_LEFT:
            satisfied = turn(game, &game->pacman, LEFT);
            break;
        case KEY_UP:
            satisfied = turn(game, &game->pacman, UP);
            break;
        case KEY_RIGHT:
            satisfied = turn(game, &game->pacman, RIGHT);
            break;
        case KEY_DOWN:
            satisfied = turn(game, &game->pacman, DOWN);
            break;
    }

    if (satisfied) {
        game->inp_buffer = 0;
    } else if (manual) {
        game->inp_buffer = 16;
        game->buffered_inp = inp;
    }
}

typedef enum {
    Oikake,
    Machibuse,
    Kimagure,
    Otoboke,
} AIType;

void do_ghost(Game *game, Ghost *g, AIType ai) {
    int tx, ty;

    if (g->state == Chase || (ai == Oikake && game->elroy)) {
        switch (ai) {
            case Oikake:
                tx = game->pacman.x;
                ty = game->pacman.y;
                break;
            case Machibuse:
                tx = game->pacman.x + game->pacman.dir.dx*4;
                ty = game->pacman.y + game->pacman.dir.dy*4;
                // uncomment for the overflow bug from the original game
                //short dirs = *(short*)&game->pacman.dir * 4;
                //Dir dir = *(Dir*)&dirs;
                //tx = game->pacman.x + dir.dx;
                //ty = game->pacman.y + dir.dy;
                break;
            case Kimagure:
                tx = game->blinky.e.x + (game->pacman.x + game->pacman.dir.dx*2 - game->blinky.e.x)*2;
                ty = game->blinky.e.y + (game->pacman.y + game->pacman.dir.dy*2 - game->blinky.e.y)*2;
                //short dirs = *(short*)&game->pacman.dir * 2;
                //Dir dir = *(Dir*)&dirs;
                //tx = game->blinky.e.x + (game->pacman.x + dir.dx - game->blinky.e.x)*2;
                //ty = game->blinky.e.y + (game->pacman.y + dir.dy - game->blinky.e.y)*2;
                break;
            case Otoboke:
                int dx = game->pacman.x-g->e.x;
                int dy = game->pacman.y-g->e.y;
                if (dx*dx+dy*dy <= 8*8) {
                    tx = 0;
                    ty = 31;
                } else {
                    tx = game->pacman.x;
                    ty = game->pacman.y;
                }
                break;
        }
    } else if (g->state == Scatter) {
        switch (ai) {
            case Oikake:
                tx = board_width-3;
                ty = -2;
                break;
            case Machibuse:
                tx = 2;
                ty = -2;
                break;
            case Kimagure:
                tx = board_width-1;
                ty = board_height;
                break;
            case Otoboke:
                tx = 0;
                ty = board_height;
                break;
        }
    }

    double last = g->e.subpoint;
    double elroy_bonus = ai == Oikake ? 0.05*game->elroy : 0;
    advance(game, &g->e, elroy_bonus + (game->frightened_timer ? 0.60 : game->board[g->e.y][g->e.x] == 'T' ? 0.50 : 0.95));

    if ((g->e.subpoint >= 0.5 && last < 0.5) || g->e.subpoint == last) {
        Dir dir;
        int d = -1;

        Dir dirs[4] = {UP, LEFT, DOWN, RIGHT};
        if (g->state == Frightened) {
            d = 0;
            int r = rand()%4, s = r;
            while (true) {
                if (--r == -1) r = 3;
                if (r == s) break;
                dir = dirs[r];
                if (dir.dx == -g->e.dir.dx && dir.dy == -g->e.dir.dy) continue;
                if (game->board[g->e.y+dir.dy][g->e.x+dir.dx] == '#') continue;
                break;
            }
        } else {
            for (int i = 0; i < 4; i++) {
                Dir ndir = dirs[i];
                int nx = g->e.x + ndir.dx;
                int ny = g->e.y + ndir.dy;

                if (ndir.dx == -g->e.dir.dx && ndir.dy == -g->e.dir.dy) continue;
                if (game->board[ny][nx] == '#' || (i == 2 && game->board[ny][nx] == '-')) continue;
                if (i == 0 && (game->board[g->e.y][g->e.x] == '\'' || game->board[g->e.y][g->e.x] == ':')) continue;

                int nd = (nx-tx)*(nx-tx)+(ny-ty)*(ny-ty);
                if (d == -1 || nd<d) {
                    dir = ndir;
                    d = nd;
                }
            }
        }

        if (d != -1) {
            g->e.dir = dir;
        }
    }

    if (g->e.x == game->pacman.x && g->e.y == game->pacman.y) {
        if (!game->lives) {
            endwin();
            printf("game over\n\n%lu points\n", game->score);
            exit(0);
        }
        game->lives--;
        game->pacman.x = game->fruit_x;
        game->pacman.y = game->fruit_y;
        change_all_states(game, Scatter);
        game->default_state = Scatter;
        game->scatter_timer = 0;
        spawn_ghosts(game);
    }
}

void do_tick(Game *game) {
    process_input(game);

    char *h = &game->board[game->pacman.y][game->pacman.x];
    if (*h == 'K') {
        *h = ' ';
        game->score += 5000;
    } else if (*h == '.' || *h == ':' || *h == 'O') {
        game->remaining--;
        if (game->remaining == 120 || game->remaining == 60) {
            game->elroy++;
        }
        if (game->remaining == 174 || game->remaining == 74) {
            game->board[game->fruit_y][game->fruit_x] = 'K';
            game->fruit_timer = 9*60 + rand()%60;
        }
        if (!game->remaining) {
            change_all_states(game, Scatter);
            game->default_state = Scatter;
            game->scatter_timer = 0;
            game->fruit_timer = 0;
            game->lvl++;
            init_game_board(game);
        }
    }
    if (*h == '.' || *h == ':') {
        game->score += 10;
    } else if (*h == 'O') {
        *h = ' ';
        game->score += 50;
        change_all_states(game, Frightened);
        game->frightened_timer = 1;
    } else {
        advance(game, &game->pacman, 0.9);
    }
    if (*h == '.') {
        *h = ' ';
    } else if (*h == ':') {
        *h = '\'';
    }

    if (!game->xlife && game->score >= 10000) {
        game->xlife = true;
        game->lives++;
    }

    if (game->fruit_timer) {
        game->fruit_timer--;
        if (!game->fruit_timer) {
            game->board[game->fruit_y][game->fruit_x] = ' ';
        }
    }

    if (game->frightened_timer) {
        game->frightened_timer--;
        if (!game->frightened_timer) {
            game->blinky.state = game->default_state;
            game->pinky.state = game->default_state;
            game->inky.state = game->default_state;
            game->clyde.state = game->default_state;
        }
    } else {
        game->scatter_timer++;
        if (game->scatter_timer == 5*60 || game->scatter_timer == 30*60 || game->scatter_timer == 55*60 || game->scatter_timer == 1092*60+1) {
            game->default_state = Chase;
            change_all_states(game, Chase);
        } else if (game->scatter_timer == 25*60 || game->scatter_timer == 50*60 || game->scatter_timer == 1092*60) {
            game->default_state = Scatter;
            change_all_states(game, Scatter);
        }
    }

    do_ghost(game, &game->blinky, Oikake);
    do_ghost(game, &game->pinky, Machibuse);
    do_ghost(game, &game->inky, Kimagure);
    do_ghost(game, &game->clyde, Otoboke);
}

int main() {
    setlocale(LC_ALL, "");
    initscr();
    start_color();
    cbreak();
    keypad(stdscr, TRUE);
    noecho();
    timeout(0);
    curs_set(0);

    init_pair(1, COLOR_YELLOW, COLOR_BLACK);
    init_pair(2, COLOR_RED, COLOR_BLACK);
    init_pair(3, COLOR_MAGENTA, COLOR_BLACK);
    init_pair(4, COLOR_BLUE, COLOR_BLACK);
    init_pair(5, 172, COLOR_BLACK);
    init_pair(6, 19, COLOR_BLACK);
    init_pair(7, 223, COLOR_BLACK);
    init_pair(8, COLOR_CYAN, COLOR_BLACK);

    Game game = init_game();

    clock_t last_frame = clock();
    double ft = CLOCKS_PER_SEC / 60;
    while (true) {
        do_tick(&game);
        print_board(&game);
        clock_t target = last_frame + ft;
        while (clock() < target);
        last_frame = target;
    }
}

// Minesweeper 2.0
var readline = require("readline")
var crypto = require("crypto")
var readline = require("readline")
readline.emitKeypressEvents(process.stdin);
var stdin = process.stdin
var stdout = process.stdout
stdin.setRawMode(true);
var width = 35
var height = 15
var minesCount = 75
var started = false
var lost = false
var won = false
var cheated = false
var zoom = false
var currentSpeed = 1
var zoomSpeed = 5
var normalSpeed = 1
var bonuses = 0
var pos = {x:0, y:0}
var mines = Array()
var flags = Array()
var unknowns = Array()
var revealed = Array()
var firstMove = false
var start = null
var moves = 0
var actions = 0
for (var i = 0; i < height; i++) {
  var line = Array()
  for (let j = 0; j < width; j++) {
    line.push(false)
  }
  flags.push(line)
}
for (var i = 0; i < height; i++) {
  var line = Array()
  for (let j = 0; j < width; j++) {
    line.push(false)
  }
  unknowns.push(line)
}
for (var i = 0; i < height; i++) {
  var line = Array()
  for (let j = 0; j < width; j++) {
    line.push(false)
  }
  revealed.push(line)
}
function totalCount() {
  return width * height
}
function mineCount() {
  var count = 0;
  for (var i = 0; i < height; i++) {
    for (let j = 0; j < width; j++) {
      if (mines[i][j]) {
        count += 1
      }
    }
  }
  return count
}
function flagCount() {
  var count = 0;
  for (var i = 0; i < height; i++) {
    for (let j = 0; j < width; j++) {
      if (flags[i][j]) {
        count += 1
      }
    }
  }
  return count
}
function revealedCount() {
  var count = 0;
  for (var i = 0; i < height; i++) {
    for (let j = 0; j < width; j++) {
      if (revealed[i][j]) {
        count += 1
      }
    }
  }
  return count
}
function blankCount() {
  return totalCount() - flagCount() - revealedCount()
}
function show() {
  var string = ""
  string += mineCount().toString() + " mines " + flagCount().toString() + " flags (" + (mineCount() - flagCount()).toString() + " unflagged) " + revealedCount().toString() + " revealed " + blankCount().toString() + " blank \n"
  string += moves + " moves " + time(Date.now() - start) + " " + stat().toString() + " m/s " + stat2().toString() + " a/s\n"
  for (var i = 0; i < height; i++) {
    for (let j = 0; j < width; j++) {
      var value = "."
      if (revealed[i][j]) {
        var nearby = minesNearby({x:j, y:i}).toString()
        if (nearby == "0") {
          value = " "
        } else {
          value = nearby
        }
      } else if (flags[i][j]) {
        value = "F"
      } else if (unknowns[i][j]) {
        value = "?"
      }
      string += color(value);
      if (pos.x == j && pos.y == i) {
        string += "[" + value + "]\x1b[0m"
      } else {
        string += " " + value + " \x1b[0m"
      }
    }
    string += "\n"
  }
  stdout.write(string)
}
function showEmpty() {
  var string = ""
  string += minesCount.toString() + " mines " + flagCount().toString() + " flags (" + minesCount.toString() + " unflagged) 0 revealed " + blankCount().toString() + " blank \n"
  if (firstMove) {
    string += moves + " moves " + time(Date.now() - start) + " " + stat().toString() + " m/s " + stat2().toString() + " a/s\n"
  }
  for (var i = 0; i < height; i++) {
    for (let j = 0; j < width; j++) {
      var value = "."
      if (flags[i][j]) {
        value = "F"
      } else if (unknowns[i][j]) {
        value = "?"
      }
      string += color(value);
      if (pos.x == j && pos.y == i) {
        string += "[" + value + "]\x1b[0m"
      } else {
        string += " " + value + " \x1b[0m"
      }
    }
    string += "\n"
  }
  stdout.write(string)
}
function showLose() {
  if (cheated) {
    stdout.write("You lost (and you cheated)\n")
  } else {
    stdout.write("You lost\n")
  }
  var string = ""
  string += moves + " moves " + time(Date.now() - start) + " " + stat().toString() + " m/s " + stat2().toString() + " a/s\n"
  for (var i = 0; i < height; i++) {
    for (let j = 0; j < width; j++) {
      var value = "."
      if (revealed[i][j]) {
        var nearby = minesNearby({x:j, y:i}).toString()
        if (nearby == "0") {
          value = " "
        } else {
          value = nearby
        }
      } else if (flags[i][j] && !mines[i][j]) {
        value = "X"
      } else if (flags[i][j]) {
        value = "F"
      } else if (mines[i][j]) {
        value = "*"
      }
      string += color(value);
      if (pos.x == j && pos.y == i) {
        string += "[" + value + "]\x1b[0m"
      } else {
        string += " " + value + " \x1b[0m"
      }
    }
    string += "\n"
  }
  stdout.write(string)
}
function showWin() {
  if (cheated) {
    stdout.write("You win (but you cheated)\n")
  } else if (bonuses > 0) {
    stdout.write("You win with " + bonuses.toString() + " extra challenges\n")
  } else {
    stdout.write("You win\n")
  }
  var string = ""
  string += moves + " moves " + time(Date.now() - start) + " " + stat().toString() + " m/s " + stat2().toString() + " a/s\n"
  for (var i = 0; i < height; i++) {
    for (let j = 0; j < width; j++) {
      var value = "."
      if (revealed[i][j]) {
        var nearby = minesNearby({x:j, y:i}).toString()
        if (nearby == "0") {
          value = " "
        } else {
          value = nearby
        }
      } else if (mines[i][j]) {
        value = "*"
      }
      string += color(value) + " " + value + " \x1b[0m"
    }
    string += "\n"
  }
  stdout.write(string)
}
function minesNearby(position) {
  var sum = 0
  if (position.x > 0) {
    if (mines[position.y][position.x - 1]) {
      sum += 1;
    }
    if (position.y > 0) {
      if (mines[position.y - 1][position.x - 1]) {
        sum += 1;
      }   
    }
    if (position.y < height - 1) {
      if (mines[position.y + 1][position.x - 1]) {
        sum += 1;
      }   
    }
  }
  if (position.x < width - 1) {
    if (mines[position.y][position.x + 1]) {
      sum += 1;
    }
    if (position.y > 0) {
      if (mines[position.y - 1][position.x + 1]) {
        sum += 1;
      }   
    }
    if (position.y < height - 1) {
      if (mines[position.y + 1][position.x + 1]) {
        sum += 1;
      }   
    }
  }
  if (position.y > 0) {
    if (mines[position.y - 1][position.x]) {
      sum += 1;
    }   
  }
  if (position.y < height - 1) {
    if (mines[position.y + 1][position.x]) {
      sum += 1;
    }   
  }
  return sum
}
function flagsNearby() {
  var sum = 0
  if (pos.x > 0) {
    if (flags[pos.y][pos.x - 1]) {
      sum += 1;
    }
    if (pos.y > 0) {
      if (flags[pos.y - 1][pos.x - 1]) {
        sum += 1;
      }   
    }
    if (pos.y < height - 1) {
      if (flags[pos.y + 1][pos.x - 1]) {
        sum += 1;
      }   
    }
  }
  if (pos.x < width - 1) {
    if (flags[pos.y][pos.x + 1]) {
      sum += 1;
    }
    if (pos.y > 0) {
      if (flags[pos.y - 1][pos.x + 1]) {
        sum += 1;
      }   
    }
    if (pos.y < height - 1) {
      if (flags[pos.y + 1][pos.x + 1]) {
        sum += 1;
      }   
    }
  }
  if (pos.y > 0) {
    if (flags[pos.y - 1][pos.x]) {
      sum += 1;
    }   
  }
  if (pos.y < height - 1) {
    if (flags[pos.y + 1][pos.x]) {
      sum += 1;
    }   
  }
  return sum
}
function blanksNearby() {
  var sum = 0
  if (pos.x > 0) {
    if (!flags[pos.y][pos.x - 1] && !revealed[pos.y][pos.x - 1]) {
      sum += 1;
    }
    if (pos.y > 0) {
      if (!flags[pos.y - 1][pos.x - 1] && !revealed[pos.y - 1][pos.x - 1]) {
        sum += 1;
      }   
    }
    if (pos.y < height - 1) {
      if (!flags[pos.y + 1][pos.x - 1] && !revealed[pos.y + 1][pos.x - 1]) {
        sum += 1;
      }   
    }
  }
  if (pos.x < width - 1) {
    if (!flags[pos.y][pos.x + 1] && !revealed[pos.y][pos.x + 1]) {
      sum += 1;
    }
    if (pos.y > 0) {
      if (!flags[pos.y - 1][pos.x + 1] && !revealed[pos.y - 1][pos.x + 1]) {
        sum += 1;
      }   
    }
    if (pos.y < height - 1) {
      if (!flags[pos.y + 1][pos.x + 1] && !revealed[pos.y + 1][pos.x + 1]) {
        sum += 1;
      }   
    }
  }
  if (pos.y > 0) {
    if (!flags[pos.y - 1][pos.x] && !revealed[pos.y - 1][pos.x]) {
      sum += 1;
    }   
  }
  if (pos.y < height - 1) {
    if (!flags[pos.y + 1][pos.x] && !revealed[pos.y + 1][pos.x]) {
      sum += 1;
    }   
  }
  return sum
}
function color(string) {
  switch (string) {
    case " ":
      return "\x1b[48;5;238m";
    case "1":
      return "\x1b[48;5;240;38;5;45m";
    case "2":
      return "\x1b[48;5;240;38;5;46m";
    case "3":
      return "\x1b[48;5;240;38;5;208m";
    case "4":
      return "\x1b[48;5;240;38;5;33m";
    case "5":
      return "\x1b[48;5;240;38;5;160m";
    case "6":
      return "\x1b[48;5;240;38;5;43m";
    case "7":
      return "\x1b[48;5;240;38;5;15m";
    case "8":
      return "\x1b[48;5;240;38;5;242m";
    case "F":
      return "\x1b[48;5;236;38;5;220m";
    case "?":
      return "\x1b[48;5;236;38;5;183m";
    case ".":
      return "\x1b[48;5;236m";
    case "X":
      return "\x1b[48;5;88m";
    case "*":
      if (lost) {
        return "\x1b[48;5;88m";
      } else {
        return "\x1b[48;5;236;38;5;196m";
      }
    default:
      break;
  }
}
function pass() {}
function makeGrid() {
  var notReady = true
  while (notReady) {
    for (var i = 0; i < height; i++) {
      var line = Array()
      var bytes = crypto.randomBytes(width)
      for (let j = 0; j < width; j++) {
        var byte = bytes[j];
        if (byte > 256 * minesCount / totalCount()) {
          line.push(false);
        } else {
          if (-1 <= (pos.x - j) && (pos.x - j) <= 1 && -1 <= (pos.y - i) && (pos.y - i) <= 1) {
            line.push(false);
          } else {
            line.push(true);
          }
        }
      }
      mines.push(line)
    }
    if (mineCount() == minesCount) {
      notReady = false;
    } else {
      mines = Array()
    }
  }
}
function reveal() {
  revealArg(pos);
}
function revealArg(position) {
  if (revealed[position.y][position.x]) {
    pass()
  } else if (flags[position.y][position.x]) {
    pass()
  } else {
    if (mines[position.y][position.x]) {
      lost = true
    } else {
      revealed[position.y][position.x] = true;
      if (revealedCount() + minesCount == totalCount()) {
        won = true;
        return;
      }
      if (minesNearby(position) == 0) {
        if (position.x > 0) {
          revealArg({x:position.x - 1, y:position.y})
          if (position.y > 0) {
            revealArg({x:position.x - 1, y:position.y - 1})
          }
          if (position.y < height - 1) {
            revealArg({x:position.x - 1, y:position.y + 1})
          }
        }
        if (position.x < width - 1) {
          revealArg({x:position.x + 1, y:position.y})
          if (position.y > 0) {
            revealArg({x:position.x + 1, y:position.y - 1})
          }
          if (position.y < height - 1) {
            revealArg({x:position.x + 1, y:position.y + 1})
          }
        }
        if (position.y > 0) {
          revealArg({x:position.x, y:position.y - 1})
        }
        if (position.y < height - 1) {
          revealArg({x:position.x, y:position.y + 1})
        }
      }
    }
  }
}
function flag() {
  if (!revealed[pos.y][pos.x]) {
    var currentFlag = flags[pos.y][pos.x]
    if (currentFlag) {
      flagUnset(pos)
    } else {
      flagSet(pos)
    }
  }
}
function flagSet(position) {
  if (!revealed[position.y][position.x]) {
    flags[position.y][position.x] = true
    unknowns[position.y][position.x] = false
  }
}
function flagUnset(position) {
  if (!revealed[position.y][position.x]) {
    flags[position.y][position.x] = false
  }
}
function cord() {
  if (revealed[pos.y][pos.x]) {
    if (minesNearby(pos) == flagsNearby()) {
      if (pos.x > 0) {
        revealArg({x:pos.x - 1, y:pos.y})
        if (pos.y > 0) {
          revealArg({x:pos.x - 1, y:pos.y - 1})
        }
        if (pos.y < height - 1) {
          revealArg({x:pos.x - 1, y:pos.y + 1})
        }
      }
      if (pos.x < width - 1) {
        revealArg({x:pos.x + 1, y:pos.y})
        if (pos.y > 0) {
          revealArg({x:pos.x + 1, y:pos.y - 1})
        }
        if (pos.y < height - 1) {
          revealArg({x:pos.x + 1, y:pos.y + 1})
        }
      }
      if (pos.y > 0) {
        revealArg({x:pos.x, y:pos.y - 1})
      }
      if (pos.y < height - 1) {
        revealArg({x:pos.x, y:pos.y + 1})
      }
    }
  } else {
    flag()
  }
}
function extra() {
  if (revealed[pos.y][pos.x]) {
    if (flagCount() != 0 && blanksNearby() == 0) {
      if (pos.x > 0) {
        flagUnset({x:pos.x - 1, y:pos.y})
        if (pos.y > 0) {
          flagUnset({x:pos.x - 1, y:pos.y - 1})
        }
        if (pos.y < height - 1) {
          flagUnset({x:pos.x - 1, y:pos.y + 1})
        }
      }
      if (pos.x < width - 1) {
        flagUnset({x:pos.x + 1, y:pos.y})
        if (pos.y > 0) {
          flagUnset({x:pos.x + 1, y:pos.y - 1})
        }
        if (pos.y < height - 1) {
          flagUnset({x:pos.x + 1, y:pos.y + 1})
        }
      }
      if (pos.y > 0) {
        flagUnset({x:pos.x, y:pos.y - 1})
      }
      if (pos.y < height - 1) {
        flagUnset({x:pos.x, y:pos.y + 1})
      }
    } else if (blanksNearby() + flagsNearby() == minesNearby(pos)) {
      if (pos.x > 0) {
        flagSet({x:pos.x - 1, y:pos.y})
        if (pos.y > 0) {
          flagSet({x:pos.x - 1, y:pos.y - 1})
        }
        if (pos.y < height - 1) {
          flagSet({x:pos.x - 1, y:pos.y + 1})
        }
      }
      if (pos.x < width - 1) {
        flagSet({x:pos.x + 1, y:pos.y})
        if (pos.y > 0) {
          flagSet({x:pos.x + 1, y:pos.y - 1})
        }
        if (pos.y < height - 1) {
          flagSet({x:pos.x + 1, y:pos.y + 1})
        }
      }
      if (pos.y > 0) {
        flagSet({x:pos.x, y:pos.y - 1})
      }
      if (pos.y < height - 1) {
        flagSet({x:pos.x, y:pos.y + 1})
      }
    }
  } else {
    flag()
  }
}
function unknown() {
  if (!revealed[pos.y][pos.x] && !flags[pos.y][pos.x]) {
    var currentUnknown = unknowns[pos.y][pos.x]
    if (currentUnknown) {
      unknowns[pos.y][pos.x] = false
    } else {
      unknowns[pos.y][pos.x] = true
    }
  }
}
function blank() {
  if (flags[pos.y][pos.x]) {
    flags[pos.y][pos.x] = false
  }
  if (unknowns[pos.y][pos.x]) {
    unknowns[pos.y][pos.x] = false
  }
}
function please() {
  if (!revealed[pos.y][pos.x] && !flags[pos.y][pos.x]) {
    if (unknowns[pos.y][pos.x]) {
      if (!started) {
        makeGrid()
        started = true
      }
      cheated = true
      if (mines[pos.y][pos.x]) {
        flag()
      } else {
        reveal()
      }
    } else {
      unknown()
    }
  }
}
function moreMines() {
  var mineRate = minesCount / totalCount()
  if (started) {
    for (var i = 0; i < height; i++) {
      for (let j = 0; j < width; j++) {
        if (!mines[i][j] & !flags[i][j] & !revealed[i][j]) {
          if (crypto.randomInt(100) < 33.333 * mineRate) {
            mines[i][j] = true;
          }
        }
      }
    }
    if (revealedCount() + mineCount() == totalCount()) {
      won = true;
      cheated = true;
    }
  } else {
    minesCount += crypto.randomInt(Math.floor(mineRate * (totalCount() - minesCount) / 3))
    if (revealedCount() + minesCount == totalCount()) {
      won = true;
      cheated = true;
    }
  }
}
function time(seconds) {
  var seconds = seconds / 1000
  var hours = Math.floor(seconds / 60 / 60)
  var minutes = Math.floor((seconds - hours * 60 * 60) / 60)
  var seconds = seconds - hours * 60 * 60 - minutes * 60
  var string = seconds.toString() + "s"
  if (minutes != 0 || hours != 0) {
    string = minutes.toString() + "m " + string
  }
  if (hours != 0) {
    hours.toString() + "h " + string
  }
  return string
}
function stat() {
  var now = Date.now()
  var seconds = (now - start) / 1000
  var rate = moves / seconds
  if (rate > 100 || isNaN(rate)) {
    return "X"
  } else {
    return Math.round(rate * 10) / 10
  }
}
function stat2() {
  var now = Date.now()
  var seconds = (now - start) / 1000
  var rate = actions / seconds
  if (rate > 100 || isNaN(rate)) {
    return "X"
  } else {
    return Math.round(rate * 10) / 10
  }
}
function quit() {
  process.exit()
}
function controls() {
  stdout.write("Minesweeper 2.0\n")
  stdout.write("Controls:\n")
  stdout.write("WASD: Move\n")
  stdout.write("R: Reveal\n")
  stdout.write("F: Flag\n")
  stdout.write("C: Cord\n")
  stdout.write("E: Extra\n")
  stdout.write("U: Unknown\n")
  stdout.write("B: Blank\n")
  stdout.write("P: Please (cheats)\n")
  stdout.write("IJKL: Move to blank\n")
  stdout.write("N: Move to nearest blank\n")
  stdout.write("N: Move to middle\n")
  stdout.write("Z: Zoom mode (toggle)\n")
  stdout.write("X: Xtra challenge\n")
  stdout.write("H: Help\n")
  stdout.write("Q: Quit\n")
  stdout.write("\n")
}
stdin.on("keypress", (data, key) => {
  input = key.name
  if (input.length == 1) {
    switch (input.toLowerCase()) {
      case "w":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        pos.y-=currentSpeed
        if (pos.y <= -1) {
          pos.y = pos.y + height
        }
        break;
      case "a":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        pos.x-=currentSpeed
        if (pos.x <= -1) {
          pos.x = pos.x + width
        }
        break;
      case "s":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        pos.y+=currentSpeed
        if (pos.y >= height) {
          pos.y = pos.y - height
        }
        break;
      case "d":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        pos.x+=currentSpeed
        if (pos.x >= width) {
          pos.x = pos.x - width
        }
        break;
      case "r":
        moves += 1
        actions += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        if (started) {
          reveal()
        } else {
          makeGrid()
          started = true
          reveal()
        }
        break;
      case "f":
        moves += 1
        actions += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        flag()
        break;
      case "c":
        moves += 1
        actions += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        cord()
        break;
      case "e":
        moves += 1
        actions += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        extra()
        break;
      case "u":
        moves += 1
        actions += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        unknown()
        break;
      case "b":
        moves += 1
        actions += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        blank()
        break;
      case "p":
        moves += 1
        actions += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        please()
        break;
      case "i":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        var y = pos.y - 1;
        if (y == -1) {
          pos.y = height - 1;
          break;
        }
        while (y != pos.y) {
          if (y == -1) {
            pos.y = 0;
            break;
          }
          if (!revealed[y][pos.x] && !flags[y][pos.x]) {
            pos.y = y;
            break;
          }
          y -= 1;
        }
        break;
      case "j":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        var x = pos.x - 1;
        if (x == -1) {
          pos.x = width - 1;
          break;
        }
        while (x != pos.x) {
          if (x == -1) {
            pos.x = 0;
            break;
          }
          if (!revealed[pos.y][x] && !flags[pos.y][x]) {
            pos.x = x;
            break;
          }
          x -= 1;
        }
        break;
      case "k":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        var y = pos.y + 1;
        if (y == height) {
          pos.y = 0;
          break;
        }
        while (y != pos.y) {
          if (y == height) {
            pos.y = height - 1;
            break;
          }
          if (!revealed[y][pos.x] && !flags[y][pos.x]) {
            pos.y = y;
            break;
          }
          y += 1;
        }
        break;
      case "l":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        var x = pos.x + 1;
        if (x == width) {
          pos.x = 0;
          break;
        }
        while (x != pos.x) {
          if (x == width) {
            pos.x = width - 1;
            break;
          }
          if (!revealed[pos.y][x] && !flags[pos.y][x]) {
            pos.x = x;
            break;
          }
          x += 1;
        }
        break;
      case "m":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        pos.x = Math.floor(width / 2)
        pos.y = Math.floor(height / 2)
        break;
      case "n":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        if (blankCount() == 1) {
          for (var i = 0; i < height; i++) {
            for (let j = 0; j < width; j++) {
              if (!revealed[j][i] && !flags[j][i]) {
                pos.x = j;
                pos.y = i;
              }
            }
          }
        } else {
          var distance = 1;
          var done = false
          while (!done) {
            for (var i = 0; i < height; i++) {
              if (!done) {
                for (let j = 0; j < width; j++) {
                  if (!revealed[i][j] && !flags[i][j]) {
                    if (1 <= Math.abs(i - pos.y) + Math.abs(j - pos.x) && Math.abs(i - pos.y) + Math.abs(j - pos.x) <= distance) {
                      pos.x = j;
                      pos.y = i;
                      done = true;
                      break;
                    }
                  }
                }
              }
            }
            distance += 1
          }
        }
        break;
      case "x":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        moreMines();
        bonuses += 1;
        break;
      case "z":
        moves += 1
        if (start == null) {
          start = Date.now()
          firstMove = true
        }
        if (zoom) {
          zoom = false
          currentSpeed = normalSpeed
        } else {
          zoom = true
          currentSpeed = zoomSpeed
        }
        break;
      case "h":
        controls()
        return;
      case "q":
        quit()
        return;
      default:
        break;
    }
    if (lost) {
      showLose();
      quit();
      return;
    } else if (won) {
      showWin();
      quit();
      return;
    }
    if (started) {
      show();
    } else {
      showEmpty();
    }
  }
})
controls();
showEmpty();