// non-Euclidean falling block game, implemented using the HyperRogue engine
// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details

#ifdef BRINGRIS

#define CUSTOM_CAPTION "Bringris 1.3"

#define MAXMDIM 4

#define CAP_INV 0
#define CAP_COMPLEX2 0
#define CAP_EDIT 0

#ifdef BWEB
#define CAP_BT 0
#define CAP_SOLV 0
#endif

#define CAP_THREAD 0
// #define CAP_ZLIB 0
#define CAP_FILES 1
#define CAP_CONFIG 1
// #define CAP_ANIMATIONS 0

#define CAP_RUG 0
#define CAP_SHOT 0
#define CAP_SVG 0
#define CAP_PNG 0
#define CAP_WRL 0
#define CAP_TOUR 0
#define CAP_IRR 0
#define CAP_CRYSTAL 0
#define CAP_ARCM 0
#define CAP_HISTORY 0
#define CAP_STARTANIM 0
#define CAP_SAVE 0
#define CAP_TRANS 0

#ifdef BWEB
#include "../hyperweb.cpp"
#else
#include "../hyper.cpp"
#endif

#include "subquotient.cpp"
#define SUBQ
#endif

#include "../hyper.h"

#define solnil (nil || sol)

namespace hr {

namespace subquotient {
  #ifndef SUBQ
  void create_subquotient(int qty = -1, int id = 0);
  #endif
  extern eGeometry gSubquotient;
  }

namespace bringris {

struct bgeometry {
  string name;
  string cap;
  flagtype flags;
  reaction_t create;
  };

enum eBringrisMove { bmDown, bmLeft, bmUp, bmRight, bmTurnLeft, bmTurnRight, bmDrop, bmFullDrop, bmPause, bmNothing, bmLast };

vector<string> move_names = { "move down", "move left", "move up", "move right", "turn left", "turn right", "drop by one", "full drop", "pause", "do nothing" };

int camera_level;

ld ang = 0, cur_ang = 0;

int lti;

int bgeom = 0;

int max_piece;
bool rotate_allowed = false;

bool in_bringris;

bool use_raycaster = true;

bool flashes = true;

int last_adjust, when_t;
transmatrix tView, pView;
cell* ncenter;

cell *well_center;

vector<cell*> level;

vector<cell*> out_level;

map<cell*, int> center_distance;

bool pro_game;

int well_size = 10;
int camera = 3;

int facing_mod = 0;

int draw_per_level = 2000;

int shape_id, next_shape_id;

cellwalker at;

int move_started;
int move_at;

int completed;
int bricks, cubes;

ld score;

bool paused;
bool explore;

enum eState {
  tsPreGame, tsFalling, tsBetween, tsCollect, tsGameover
  };

eState state = tsPreGame;

constexpr flagtype HYPERBOLIC = 1;
constexpr flagtype ORBIFOLD = 2;
constexpr flagtype SECRET = 4;
constexpr flagtype NONORIENTABLE = 8;
constexpr flagtype SPHERICAL = 16;
constexpr flagtype EUCLIDEAN = 32;
constexpr flagtype SUBQUOTIENT = 64;
constexpr flagtype HDUAL = 128;
constexpr flagtype BOUNDED_WELL = 256;
constexpr flagtype ASYMMETRIC_ONLY = 512;
constexpr flagtype FLAT_ONLY = 1024;

cell *get_center();
cell *shift_block_target(int dir);
void shift_block(int dir, bool camera_only = false);
void rotate_block(int dir, bool camera_only = false);

vector<bgeometry> bgeoms = {
  {"Bring surface", "the original Bringris geometry", HYPERBOLIC, [] {
    using namespace fieldpattern;
    current_extra = 2;
    auto& gxcur = fgeomextras[current_extra];
    while(isize(gxcur.primes) < 1) nextPrime(gxcur);
    fgeomextras[current_extra].current_prime_id = 0;
    enableFieldChange();
    set_geometry(gFieldQuotient);
    
    gp::param = gp::loc(1, 1);
    set_variation(eVariation::unrectified);

    set_geometry(gProduct);
    max_piece = 4;
    rotate_allowed = false;
    }},

  {"torus", "Euclidean level geometry", EUCLIDEAN, [] {
    auto& T0 = euc::eu_input.user_axes;
    T0[0][0] = 5;
    T0[0][1] = 0;
    T0[1][0] = 0;
    T0[1][1] = 5;
    euc::eu_input.twisted = 0;
    set_geometry(gEuclidSquare);
    set_variation(eVariation::pure);
    set_geometry(gProduct);
    max_piece = 4;
    rotate_allowed = true;
    }},

  {"Cube", "spherical level geometry", SPHERICAL, [] {
    set_geometry(gSmallSphere);
    set_variation(eVariation::pure);
    set_geometry(gProduct);
    max_piece = 3;
    rotate_allowed = false;
    }},

  {"Klein bottle", "non-orientable manifold", EUCLIDEAN | NONORIENTABLE, [] {
    auto& T0 = euc::eu_input.user_axes;
    T0[0][0] = 5;
    T0[0][1] = 0;
    T0[1][0] = 0;
    T0[1][1] = 5;
    euc::eu_input.twisted = 8;
    set_geometry(gEuclidSquare);
    set_variation(eVariation::pure);
    set_geometry(gProduct);
    max_piece = 4;
    rotate_allowed = true;
    }},

  {"pentagons", "different tiles on the Bring surface", HYPERBOLIC | HDUAL, [] {
    using namespace fieldpattern;
    current_extra = 2;
    auto& gxcur = fgeomextras[current_extra];
    while(isize(gxcur.primes) < 1) nextPrime(gxcur);
    fgeomextras[current_extra].current_prime_id = 0;
    enableFieldChange();
    set_geometry(gFieldQuotient);
    set_variation(eVariation::pure);
    set_geometry(gProduct);
    max_piece = 4;
    rotate_allowed = false;
    }},

  {"double cube", "six squares around a vertex", HYPERBOLIC, [] {
    using namespace fieldpattern;
    current_extra = 3;
    auto& gxcur = fgeomextras[current_extra];
    while(isize(gxcur.primes) < 1) nextPrime(gxcur);
    fgeomextras[current_extra].current_prime_id = 0;
    enableFieldChange();
    set_geometry(gFieldQuotient);
    
    gp::param = gp::loc(1, 1);
    set_variation(eVariation::unrectified);

    set_geometry(gProduct);
    max_piece = 3;
    rotate_allowed = true;
    }},

  {"30/6", "six squares around a vertex", HYPERBOLIC, [] {
    using namespace fieldpattern;
    current_extra = 3;
    auto& gxcur = fgeomextras[current_extra];
    while(isize(gxcur.primes) < 1) nextPrime(gxcur);
    fgeomextras[current_extra].current_prime_id = 2;
    enableFieldChange();
    set_geometry(gFieldQuotient);
    
    gp::param = gp::loc(1, 1);
    set_variation(eVariation::unrectified);

    set_geometry(gProduct);
    max_piece = 4;
    rotate_allowed = true;
    }},

  {"42", "seven squares around a vertex", HYPERBOLIC, [] {
    using namespace fieldpattern;
    current_extra = 4;
    auto& gxcur = fgeomextras[current_extra];
    while(isize(gxcur.primes) < 1) nextPrime(gxcur);
    fgeomextras[current_extra].current_prime_id = 0;
    enableFieldChange();
    set_geometry(gFieldQuotient);
    
    gp::param = gp::loc(1, 1);
    set_variation(eVariation::unrectified);

    set_geometry(gProduct);
    max_piece = 4;
    rotate_allowed = false;
    }},

  {"bounded well", "five squares around a vertex", BOUNDED_WELL, [] {
    set_geometry(g45);
    gp::param = gp::loc(1, 1);
    set_variation(eVariation::unrectified);
    set_geometry(gProduct);

    max_piece = 4;
    rotate_allowed = false;
    }},

  {"mirrored Bring", "hyperbolic and non-orientable", HYPERBOLIC | NONORIENTABLE | ASYMMETRIC_ONLY, [] {
    set_geometry(gBring);
    gp::param = gp::loc(1, 1);
    set_variation(eVariation::unrectified);
    start_game();
    subquotient::create_subquotient(2);
    set_geometry(gProduct);
    max_piece = 4;
    rotate_allowed = false;
    }},

  {"giant", "like mirrored Bring but much larger", HYPERBOLIC | NONORIENTABLE, [] {
    using namespace fieldpattern;
    current_extra = 2;
    auto& gxcur = fgeomextras[current_extra];
    while(isize(gxcur.primes) < 1) nextPrime(gxcur);
    fgeomextras[current_extra].current_prime_id = 1;
    enableFieldChange();
    set_geometry(gFieldQuotient);
    
    gp::param = gp::loc(1, 1);
    set_variation(eVariation::unrectified);
    subquotient::create_subquotient(2);

    set_geometry(gProduct);
    max_piece = 5;
    rotate_allowed = false;
    well_size = 6;
    }},

  {"orbifold", "one fifth of the giant", HYPERBOLIC | NONORIENTABLE | ORBIFOLD, [] {
    using namespace fieldpattern;
    current_extra = 2;
    auto& gxcur = fgeomextras[current_extra];
    while(isize(gxcur.primes) < 1) nextPrime(gxcur);
    fgeomextras[current_extra].current_prime_id = 1;
    enableFieldChange();
    set_geometry(gFieldQuotient);
    
    gp::param = gp::loc(1, 1);
    set_variation(eVariation::unrectified);
    subquotient::create_subquotient(10);

    set_geometry(gProduct);
    max_piece = 4;
    rotate_allowed = false;
    }},

  {"torus: shear", "Nil geometry: are you sure you want this?", SECRET, [] {
    nilv::nilperiod = make_array(5, 0, 5);
    // nilv::set_flags();
    set_geometry(gNil);
    max_piece = 4;
    rotate_allowed = false;
    }},

#if CAP_SOLV
  {"torus: Arnold's Cat", "Solv geometry: flat shapes are crazy enough", SECRET | FLAT_ONLY, [] {
    asonov::period_xy = 5;
    asonov::period_z = 0;
    asonov::set_flags();
    set_geometry(gArnoldCat);
    max_piece = 2;
    rotate_allowed = false;
    }},
#endif
  };

void create_game();

void enable_bgeom() {
  stop_game_and_switch_mode(rg::nothing);
  well_size = 10;
  bgeoms[bgeom].create();
  start_game();
  create_game();
  state = tsPreGame;
  }

void enable_bgeom(int b) {
  bgeom = b;
  enable_bgeom();
  }

flagtype bflags() { return bgeoms[bgeom].flags; }
  
using code_t = vector<pair<int, int>>;

struct piecedata {
  code_t code;
  int multi;
  int penalty;
  int symmetries;
  int count;
  };

vector<piecedata> piecelist;

map<set<cell*>, int> seen_blocks;

bool listed(const vector<cellwalker>& v, cell* c) {
  for(auto cw: v) if(cw.at == c) return true;
  return false;
  }

int down_dir() { return nil ? 4 : sol ? 0 : cwt.at->type-1; }
int up_dir() { return nil ? 1 : sol ? 6 : cwt.at->type-2; }

cell *get_at(cell *lev, int z) {
  if(prod)
    return hybrid::get_at(lev, z);
  else {
    // auto co = nilv::get_coord(lev->master);
    // co[2] += z * co[0];
    // co[1] = z;
    // return nilv::get_heptagon_at(co)->c7;
    while(z<0) z++, lev=lev->cmove(up_dir());
    while(z>0) z--, lev=lev->cmove(down_dir());
    return lev;
    }
  }

int get_z(cell* c) {
  if(prod) 
    return hybrid::get_where(c).second;
  else if(nil)
    return nilv::get_coord(c->master)[1];
  else if(sol)
    return asonov::get_coord(c->master)[2];
  else
    exit(1);
  }

pair<cell*, int> get_where(cell *what) {
  if(prod)
    return hybrid::get_where(what);
  else {
    int z = get_z(what);
    int zm = z;
    while(zm>0) what = what->cmove(up_dir()), zm--;
    while(zm<0) what = what->cmove(down_dir()), zm++;
    return {what, z};
    // co[2] -= co[1] * co[0];
    // co[1] = 0;
    // cell *c = nilv::get_heptagon_at(co)->c7;
    // return {c, z};
    }
  }

set<cell*> as_set(const vector<cellwalker>& shape) {
  set<cell*> res;
  for(auto sh: shape) res.insert(sh.at);
  return res;
  }

bool same(const vector<cellwalker>& shape, const vector<cellwalker>& shape2) {
  set<cell*> allcells;
  if(isize(shape) != isize(shape2)) return false;
  for(auto sh: shape) allcells.insert(sh.at);
  for(auto sh: shape2) allcells.erase(sh.at);
  return allcells.empty();
  }

cellwalker flatspin(cellwalker cw, int i) {
  if(solnil)
    cw.spin = i;
  else
    cw.spin = gmod(cw.spin + (cw.mirrored ? -i : i), cw.at->type - (hybri ? 2 : 0));
  return cw;
  }

int add_dir(cellwalker orig, int i, int sym = 0) {
  if(prod) {
    if(i >= orig.at->type-2) {
      if(sym&2) i ^= (orig.at->type-1) ^ (orig.at->type-2);
      return i;
      }
    else {
      if(sym&1) i = -i;
      return flatspin(orig, i).spin;
      }
    }
  return i;
  }

cellwalker add(cellwalker orig, int i, int sym = 0) {
  if(prod) {
    if(i >= orig.at->type-2) {
      if(sym&2) i ^= (orig.at->type-1) ^ (orig.at->type-2);
      orig.at = orig.at->cmove(i);
      return orig;
      }
    else {
      if(sym&1) i = -i;
      return flatspin(orig, i) + wstep;
      }
    }
  return orig + i + wstep;
  }

vector<cellwalker> build_from(const code_t& code, cellwalker start, int sym = 0) {
  vector<cellwalker> all = {start};
  for(auto c: code)
    all.push_back(add(all[c.first], c.second, sym));
  return all;
  }

vector<transmatrix> build_shape_matrices(const code_t& code, cellwalker start, int sym = 0) {
  vector<cellwalker> all = {start};
  vector<transmatrix> allm = {Id};
  for(auto c: code) {
    all.push_back(add(all[c.first], c.second, sym));
    allm.push_back(allm[c.first] * currentmap->adj(all[c.first].at, add_dir(all[c.first], c.second, sym)));
    }
  return allm;
  }

int penalty(const vector<cellwalker>& shape, const code_t& code) {
  int p = 0;
  if(prod) {
    int bad = shape[0].at->type-1;
    for(auto co: code) if(co.second == bad)
      p += 1000;
    }
  map<cell*, int> dists;
  for(auto cw: shape) dists[cw.at] = 99;
  dists[shape[0].at] = 0;
  for(int i=0; i<isize(shape); i++)
    for(auto c1: shape)
      for(auto c2: shape)
        if(neighborId(c1.at, c2.at) != -1)
          dists[c2.at] = min(dists[c2.at], dists[c1.at] + 1);
  for(auto d: dists) p += d.second * 10;
  for(auto c: code) if(c.second == 0 || c.second == 2) p++;
  if(solnil)
    for(auto s: shape) 
      if(get_z(s.at) > get_z(shape[0].at))
        p += 10000;
  if(bflags() & HDUAL) {
    if(!dists.count(shape[0].at->move(2)))
      p += 40000;
    if(!dists.count(shape[0].at->move(3)))
      p += 20000;
    }
  return p;
  }

bool builds(const vector<cellwalker>& shape, const code_t& code, int sym = 0, int eliminate = -1) {
  if(isize(shape) != isize(code)+1) return false;
  int ori = (solnil) ? 1 : prod ? shape[0].at->type-2 : shape[0].at->type;
  for(auto sh: shape) for(int i=0; i<ori; i++) {
    vector<cellwalker> shape2 = build_from(code, cellwalker(sh.at, i), sym);
    if(eliminate != -1) seen_blocks.emplace(as_set(shape2), eliminate);
    if(same(shape, shape2)) 
      return true;
    }
  return false;
  }

void generate_shapes_rec(vector<cellwalker>& sofar, code_t& code, int cnt) {
  if(isize(sofar) == cnt) {
    int p = penalty(sofar, code);
    auto ass = as_set(sofar);
    
    if(seen_blocks.count(ass)) {
      auto& pc = piecelist[seen_blocks[ass]];
      if(p < pc.penalty) pc.penalty = p, pc.code = code;
      pc.multi++;
      return;
      }

    int id = 0;
    for(auto& pc: piecelist) {
      if(builds(sofar, pc.code, 0, id)) {
        if(p < pc.penalty) pc.penalty = p, pc.code = code;
        pc.multi++;
        return;
        }
      id++;
      }
    int syms = 0;
    bool invalid = false;
    for(int i: {0,1,2,3}) if(builds(sofar, code, i)) { 
      syms++; 
      if((bflags() & ASYMMETRIC_ONLY) && i == 1 && cnt >= 4)
        invalid = true;
      }
    if(invalid) return;
    bool vertical = true;
    for(auto c: code) if(c.second < 4) vertical = false;
    if(vertical) syms *= 2;
    if(isize(code) == 0) syms = 1;
    piecelist.push_back(piecedata{code, 1, p, syms, 0});
    return;
    }
  for(int i=0; i<isize(sofar); i++)
  for(int t=0; t<sofar[i].at->type; t++) {
    if(sol && !among(t, 4, 5, 10, 11)) continue; 
    cellwalker ncw = add(sofar[i], t);
    if(listed(sofar, ncw.at)) continue;
    code.emplace_back(i, t);
    sofar.push_back(ncw);
    generate_shapes_rec(sofar, code, cnt);
    sofar.pop_back();
    code.pop_back();
    }
  }

void generate_shapes(int cnt) {
  vector<cellwalker> cws = { get_at(get_center(), -well_size - 1) };
  code_t co = {};
  generate_shapes_rec(cws, co, cnt);
  }

void list_all() {
  println(hlog, "number of shapes = ", isize(piecelist));
  // for(auto sh: piecelist) println(hlog, "multi=", sh.multi, " penalty=", sh.penalty, " syms=", sh.symmetries, " => ", sh.code);
  }

void water_shape() {
  auto shape = build_from(piecelist[shape_id].code, at);
  for(auto c: shape)
    c.at->wall = waSea; 
  }

set<cell*> to_disappear;

color_t hipso[] = {
  0x3030C0, 
  0x6060FF,
  0x9090FF,
  0xFFFFFF,
  0x008000,
  0x40FF00,
  0xFFFF00,
  0xFF8000,
  0xFF0000,
  0x800000,
  0x400040,
  0x500050,
  0x600060
  };

color_t get_hipso(ld y) {
  y += 12;
  if(well_size <= 5) y *= 2;
  return hipso[gmod(y, 13)];
  }

void draw_shape() {
  auto shape = build_from(piecelist[shape_id].code, at);
  for(auto c: shape) {
    int y = -get_z(c.at);
    c.at->wall = waWaxWall, c.at->landparam = get_hipso(y);
    }
  }

bool shape_drawn() {
  auto shape = build_from(piecelist[shape_id].code, at);
  for(auto c: shape)
    return c.at->wall == waWaxWall;
  return false;
  }
  
void remove_shape() {
  auto shape = build_from(piecelist[shape_id].code, at);
  for(auto c: shape)
    c.at->wall = waNone;
  }

bool shape_conflict(cellwalker cw) {  
  auto shape = build_from(piecelist[shape_id].code, cw);

  /* self-conflict possible in the orbifold */
  for(int i=0; i<isize(shape); i++) for(int j=0; j<i; j++)
    if(shape[i].at == shape[j].at)
      return true;

  for(auto c: shape)
    if(c.at->wall)
      return true;
  return false;
  }

ld current_move_time_limit() {
  return 50000 * pow(.9, completed) + 10000. / (1 + completed);
  }

int turn_animation = 500;
int collect_animation = 300;

int choose_piece() {
  ld total = 0;
  int sel = 0;
  ld lowest = 100000;
  for(auto &p: piecelist) 
    lowest = min(lowest, p.count * 1. / p.symmetries);
    
  vector<tuple<int,int,ld>> probs;
    
  for(int i=0; i<isize(piecelist); i++) {
    auto& p = piecelist[i];
    double cnt = p.symmetries * exp(log(.5) * (p.count * 1. / p.symmetries - lowest));
    probs.emplace_back(p.symmetries, p.count, cnt);
    total += cnt;
    if(randd() < cnt / total) 
      sel = i;
    }
  
  // println(hlog, "probs = ", probs);
  piecelist[sel].count++;
  return sel;
  }

void reset_view();
void set_tview(transmatrix T);

void new_piece() {
  if(well_center && true) {
    again:
    if(get_where(at.at).first != well_center) {
      at.at = get_at(get_where(at.at).first, -well_size - 1);  
      int d = center_distance[get_where(at.at).first];
      for(int i=0; i<4; i++) {
        auto mov = get_where(shift_block_target(i)).first;
        if(center_distance.count(mov) && center_distance[mov] < d) {
          shift_block(i, true);
          goto again;
          }
        }
      println(hlog, "failed to recenter");
      }
    while(at.spin) rotate_block(1, true);
    }  
  at.at = get_at(get_where(at.at).first, -well_size - 1);  
  shape_id = next_shape_id;
  next_shape_id = choose_piece();
  if(shape_conflict(at)) {
    playSound(cwt.at, "die-bomberbird");
    state = tsGameover;
    }
  else {
    draw_shape();
    state = tsFalling;
    move_started = ticks;
    move_at = ticks + current_move_time_limit();
    }    
  }

vector<int> by_level;

bool expert = true;

void find_lines() {
  by_level.clear();
  // println(hlog, "Removing levels");
  
  for(int z=1; z<=well_size; z++) {
    int ct = 0;
    for(auto lev: level) {
      cell *c = get_at(lev, -z);
      ct += (c->wall ? 1 : 0);
      }
    by_level.push_back(ct);
    }
  // println(hlog, by_level, " / ", isize(level));
  
  int points = 0;
  
  if(expert) {
    for(int z=1; z<=well_size; z++) if(by_level[z-1] >= isize(level)) {
      points++;
      for(auto lev: level) {
        cell *c = get_at(lev, -z);
        to_disappear.insert(c);
        }
      }
    }
  else {
    // int lines_found = 0;
    for(int z=1; z<=well_size; z++) {
      for(auto lev: level) for(int d=0; d<lev->type; d++) {
        cellwalker cw(get_at(lev, -z), d);
        cellwalker cw0 = cw;
        bool filled = true;
        do {
          if(!cw.at->wall) filled = false;
          cw += wstep;
          cw = flatspin(cw, lev->type/2);
          }
        while(cw != cw0);
        if(filled) {
          // lines_found = true;
          do {
            to_disappear.insert(cw.at);
            cw += wstep;
            cw = flatspin(cw, lev->type/2);
            }
          while(cw != cw0);
          }
        }
      }
    // println(hlog, "lines found = ", lines_found);
    }
  if(!to_disappear.empty()) {
    move_at = ticks + collect_animation;
    state = tsCollect;
    score += 10000000. * points * (points+1.) / current_move_time_limit();
    completed += points;
    playSound(cwt.at, points == 1 ? "pickup-gold" : "orb-mind");
    }
  }

void disappear_lines() {
  for(auto lev: level) {
    int nz = 1;
    for(int z=1; z<=well_size; z++) {
      cell *c1 = get_at(lev, -z);
      if(!to_disappear.count(c1)) {
        cell *c0 = get_at(lev, -nz);
        c0->wall = c1->wall;
        c0->landparam = get_hipso(nz);
        nz++;
        }
      }
    while(nz <= camera_level) {
      cell *c0 = get_at(lev, -nz);
      c0->wall = waNone;
      nz++;
      }
    }
  to_disappear.clear();
  state = tsBetween;
  }

void state_loop() {
  find_lines();
  if(to_disappear.empty()) new_piece();
  }
    
void fallen() {
  draw_shape();
  bricks++;
  cubes += isize(piecelist[shape_id].code)+1;
  state = tsBetween;
  playSound(cwt.at, "closegate");
  score += 20000000. / (current_move_time_limit() * 3 + ticks - move_started);
  }

void drop() {
  remove_shape();
  cellwalker fall = at;
  fall.at = fall.at->cmove(down_dir());
  if(shape_conflict(fall))
    fallen();
  else {
    at = fall;
    draw_shape();
    }
  move_at = ticks + current_move_time_limit();
  if(solnil) {
    pView = pView * currentmap->adj(cwt.at, down_dir());
    when_t = ticks + turn_animation;
    }
  }

void fulldrop() {
  remove_shape();
  cellwalker fall = at;
  int no = 0;
  auto last = fall;
  while(true) {
    last = fall;
    fall.at = fall.at->cmove(down_dir());
    if(shape_conflict(fall)) break;
    no++;
    }
  playSound(cwt.at, "hit-crush2");
  // println(hlog, "dropped by ", no);
  fall = last;
  at = fall;
  draw_shape();
  if(!no) fallen();
  }

void verify_matrix(transmatrix T) {
  vector<ld> ver;
  for(int i=0; i<3; i++)
  for(int j=0; j<3; j++) {
    ld a = T[0][i] * T[0][j] + T[1][i]*T[1][j] - T[2][i] * T[2][j];
    ver.push_back(kz(a));
    }
  println(hlog, ver);
  }

ld move_dist;

void set_view() {
  move_dist = hdist0(currentmap->adj(cwt.at, 0) * C0);
  
  if(in_h2xe() && PURE && S3 == 4) {
    ld dist = PIU(hdist0(get_corner_position(currentmap->gamestart(), 0)));
    dist -= 1e-4;
    move_dist = PIU(hdist(get_corner_position(currentmap->gamestart(), 0), get_corner_position(currentmap->gamestart(), 1)));
    tView = xpush(-dist) * tView;
    tView = spin(135*degree) * tView;
    }  
  if(in_h2xe() && UNRECTIFIED)
    tView = spin(135*degree) * tView;
  if(in_h2xe() && S7 == 4)
    tView = spin(90*degree) * tView;
  if(in_s2xe())
    tView = spin(90*degree) * tView;
  if(in_e2xe())
    tView = spin(90*degree) * tView;
  }

void set_tview(transmatrix T) {

  View = T * tView;

  transmatrix rel = pView * inverse(View);
  fixmatrix(rel);

  centerover = ncenter;
  optimizeview();
  ncenter = centerover;
  // tView = View;
  if(bgeom == 4)
    tView = spin(72*degree*at.spin);
  else
    tView = spin(90*degree*at.spin);
  if(at.mirrored)
    tView = MirrorY * tView;
  // tView = spin(90*degree*at.spin);
  set_view();  

  pView = rel * tView;
  when_t = ticks + turn_animation;
  }

void rotate_block(int d, bool camera_only) {
  if(!rotate_allowed && !camera_only) {
    playSound(cwt.at, "hit-crush3");
    return;
    }
  if(!camera_only) remove_shape();
  cellwalker at1 = flatspin(at, d);
  if(camera_only || !shape_conflict(at1)) {
    at = at1;
    set_tview(spin(d*90*degree));
    }
  else playSound(cwt.at, "hit-crush3");
  if(!camera_only) draw_shape();
  }    

int nilmap(int dir) {
  if(nil) {
    int nm[4] = {3, 2, 0, 5};
    return nm[dir];
    }
  if(sol) {
    int nm[4] = {11, 10, 5, 4};
    return nm[dir];
    }
  exit(1);
  }

cell *shift_block_target(int dir) {
  return flatspin(at, dir).cpeek();
  }

void shift_block(int dir, bool camera_only) {
  int t = currentmap->gamestart()->type;
  if(prod) t -= 2;

  if(!camera_only) remove_shape();
  
  cellwalker at1;
  
  if(solnil) {
    at1.at = at.at->cmove(nilmap(dir));
    }
  else if(t&1) {
    if(dir == 3)
      at1 = flatspin(flatspin(at, 4) + wstep, 3);
    if(dir == 1)
      at1 = flatspin(flatspin(at, 2) + wstep, 1);
    if(dir == 2)
      at1 = flatspin(flatspin(at, 3) + wstep, 4);
    if(dir == 0)
      at1 = flatspin(flatspin(at, 1) + wstep, 2);
    }
  else {
    int kspin = (t/2) - dir;     
    at1 = flatspin(at, dir);  
    at1 = flatspin(at1 + wstep, kspin);
    }

  ld angle = dir * 90 * degree;
  
  if(camera_only || !shape_conflict(at1)) {
    // playSound(cwt.at, "hit-crush1");
    at = at1;
    if(solnil) {
      pView = pView * currentmap->adj(cwt.at, nilmap(dir));
      when_t = ticks + turn_animation;
      }
    else
      set_tview(spin(-angle) * ypush(-move_dist) * spin(angle));
    if(!camera_only) draw_shape();
    }
  else playSound(cwt.at, "hit-crush3");
  }

void bringris_action(int k) {
  if(k < 4) shift_block(k);
  if(k == 4) rotate_block(1);
  if(k == 5) rotate_block(-1);
  if(k == 6) drop();
  if(k == 7) fulldrop();
  if(k == 8) paused = true;
  }

void create_matrices() {
  dq::clear_all();
  make_actual_view();
  dq::enqueue_by_matrix_c(centerover, cview());
  current_display->all_drawn_copies.clear();
  int id = 0;
  while(!dq::drawqueue_c.empty()) {
    auto& p = dq::drawqueue_c.front();
    cell*& c = p.first;
    shiftmatrix& V = p.second;
    current_display->all_drawn_copies[c].push_back(V);
    gmatrix[p.first] = p.second;
    if(id < draw_per_level) {
      auto go = [&] (int i) {
        cell *c1 = c->cmove(i);
        dq::enqueue_by_matrix_c(c1, optimized_shift(V * currentmap->adj(c, i)));       
        };
      if(prod) {
        for(int i=0; i<c->type-2; i++) go(i);
        }
      else if(sol) {
        go(4); go(5); go(10); go(11);
        }
      else if(nil) {
        go(0); go(2); go(3); go(5);
        }
      }      
    dq::drawqueue_c.pop();
    id++;
    }  
  }

transmatrix smooth;

void change_depth(shiftmatrix& V, int newlevel, int zlev) {
  if(solnil) {
    while(newlevel > zlev) zlev++, V = V * currentmap->adj(cwt.at, down_dir());
    while(newlevel < zlev) zlev--, V = V * currentmap->adj(cwt.at, up_dir());
    }
  else if(in_h2xe())
    V = shiftless(V.T, cgi.plevel * (newlevel - zlev));
  else
    V = shiftless(V.T * zpush(cgi.plevel * (newlevel - zlev)));
  }

void draw_wirecube_at(cell *c, const transmatrix& rel, int zlev, color_t col) {

  auto where_c = get_where(c);
  auto c_camera = get_at(where_c.first, zlev);
  
  for(shiftmatrix V: current_display->all_drawn_copies[c_camera]) {
    change_depth(V, where_c.second, zlev);
    for(int i=0; i<c->type; i++)
      queuepolyat(V * rel, cgi.shWireframe3D[i], 0, PPR::SUPERLINE).outline = col;
    }
  }

void draw_piece(int zlev, int id) {
  auto shape = build_from(piecelist[id].code, at);
  auto matrices = build_shape_matrices(piecelist[id].code, at);

  auto where_at = get_where(at.at);
  
  vid.linewidth *= 3;

  int mid = 0;

  for(auto c: shape) {    
    auto where_c = get_where(c.at);
    color_t levels[5] = {color_t(0xFFFFFFFFF), color_t(0xFFFF00FF), color_t(0xFF8000FF), color_t(0xFF0000FF), color_t(0xC000C0FF) };
    draw_wirecube_at(at.at, smooth * matrices[mid++], zlev, levels[where_at.second-where_c.second]);
    }  
  
  vid.linewidth /= 3;
  }

void draw_holes(int zlev) {
  bool d = state == tsFalling && shape_drawn();
  if(d) remove_shape();
  for(auto lev: level) {
    bool covered = false;
    for(int z=well_size; z>=1; z--) {
      cell *c1 = get_at(lev, -z);
      if(c1->wall) covered = true;
      else if(covered) {
        vid.linewidth *= 4;
        draw_wirecube_at(c1, Id, zlev, (get_hipso(z) << 8) | 0xFF);
        vid.linewidth /= 4;
        }
      }
    }
  if(d) draw_shape();
  }

void draw_all_noray(int zlev) {
  for(auto lev: level) {
    for(int z=0; z<=camera_level+1; z++) {
      cell *c1 = get_at(lev, -z);
      
      if(c1->wall) {
      
        auto c_camera = get_at(lev, zlev);
        
        for(shiftmatrix V: current_display->all_drawn_copies[c_camera]) {
          change_depth(V, -z, zlev);
          
          color_t wcol = c1->landparam;
          if(c1->wall == waBarrier) wcol = winf[waBarrier].color;

          int d = (wcol & 0xF0F0F0) >> 4;

          forCellIdCM(c2, i, c1)
            if(!c2->wall) {
              color_t col = darkena(wcol - d * get_darkval(c1, i), 0, 0xFF);
              auto &q = queuepolyat(V, cgi.shWall3D[i], col, PPR::WALL);
              q.tinf = &floor_texture_vertices[cgi.shFloor.id];
              ensure_vertex_number(*q.tinf, q.cnt);
              }
          }
        }
      }
    }
  }

void start_new_game();

bool use_equidistant;

void bringris_frame() {
  if(!in_bringris) return;
  ray::want_use = use_raycaster ? 2 : 0;
  #if CAP_VR
  vrhr::hsm = explore ? vrhr::eHeadset::holonomy : vrhr::eHeadset::reference;
  vrhr::eyes = use_equidistant ? vrhr::eEyes::equidistant : vrhr::eEyes::truesim;
  #endif
  
  int zlev = get_z(centerover);

  if(state == tsCollect) for(cell *c: to_disappear) c->landparam = flashes ? rand() & 0xFFFFFF : 0x101010;
  
  // just_gmatrix = true;

  create_matrices();

  if(!use_raycaster) 
    draw_all_noray(zlev);

  if(anyshiftclick) draw_holes(zlev);
  
  if(state == tsFalling && !explore && !cur_ang) draw_piece(zlev, shape_id);
  }

renderbuffer *next_buffer;

void draw_screen(int xstart, bool show_next) {
  int steps = camera_level - (-get_z(at.at));
  if(state != tsFalling) steps = camera_level - (well_size + 1);

  #if CAP_VR
  if(!explore) {
    E4;
    vrhr::hmd_at_ui = vrhr::hmd_ref_at * cspin(0, 2, 30*degree);
    }
  #endif
    
  
  dynamicval<display_data> ccd(*current_display);
  current_display->xmax = xstart * 1. / vid.xres;
  ray::max_cells = (isize(level) + isize(out_level)) * (camera_level+2);
  
  if(explore) {
    gamescreen(0);
    mouseaim_sensitivity = 0.01;
    camera_speed = 2;
    smooth_scrolling = true;
    }
  else {  
    mouseaim_sensitivity = 0;
    NLP = Id;
    View = pView;
    if(nil) {
      centerover = at.at;
      rotate_view(cspin(1, 2, -90*degree));
      shift_view(ztangent(3 * nilv::nilwidth));
      rotate_view(cspin(0, 1, -90*degree));
      anims::moved();
      }
    else if(sol) {
      centerover = at.at;
      rotate_view(cspin(1, 2, 180*degree));
      shift_view(ztangent(1));
      rotate_view(cspin(0, 1, -90*degree));
      anims::moved();
      }
    else {
      ld lv = -cgi.plevel * steps;
      shift_view(ztangent(lv));
      rotate_view(cspin(1, 2, cur_ang));
      shift_view(ztangent(cgi.plevel * (2 + max_piece)));
      centerover = ncenter;
      anims::moved();
      }

    // make_actual_view();
    // anims::moved();
    
    sightranges[geometry] *= 100;
    if(state == tsFalling && !explore && !cur_ang && !lctrlclick) remove_shape();    
    gamescreen(0);
    if(state == tsFalling && !explore && !cur_ang) draw_shape();

    extern void render_next(int xstart);
    render_next(xstart);

    sightranges[geometry] /= 100;

    if(state == tsBetween) state_loop();
    
    if(state == tsCollect && ticks >= move_at) 
      disappear_lines();
    
    if(ticks >= move_at && state == tsFalling && pro_game) {
      drop();
      }

    View = pView;
    centerover = ncenter;      
    NLP = Id;
    }
  }

void create_game();

void geometry_menu() {
  clearMessages();
  dialog::init("Bringris geometries");
  dialog::addBreak(100);
  for(int i=0; i<isize(bgeoms); i++) {
    dialog::addTitle(bgeoms[i].name, i == bgeom ? 0xFF00 : 0xFF0000, 150);
    dialog::items.back().key = 'a' + i;
    dialog::add_action([i] {      
      enable_bgeom(i);
      });
    dialog::addInfo(bgeoms[i].cap);
    dialog::items.back().key = 'a' + i;
    dialog::addBreak(50);
    if(i == bgeom) bgeoms[i].flags &= ~SECRET;
    if(bgeoms[i].flags & SECRET) {
      dialog::items.pop_back();
      dialog::items.pop_back();
      dialog::items.pop_back();
      }
    }
  dialog::addBreak(100);
  dialog::addSelItem("max piece", its(max_piece), 'M');
  dialog::add_action([] {
    max_piece++;
    if(max_piece == 6) max_piece = 2;
    create_game();
    state = tsPreGame;
    });
  if(bflags() & ASYMMETRIC_ONLY)
    dialog::addInfo("(only asymmetric large pieces)");
  else if(bflags() & FLAT_ONLY)
    dialog::addInfo("(only flat pieces)");
  else
    dialog::addBreak(100);

  dialog::addBreak(100);
  dialog::addBack();
  dialog::display();
  }

void visual_menu() {
  gamescreen(2);
  dialog::init("Bringris visuals");

  dialog::addBoolItem_action("flashes on level completed", flashes, 'f');

  dialog::addBoolItem_action("use raycasting", use_raycaster, 'r');

  dialog::addSelItem(XLAT("iterations in raycasting"), its(ray::max_iter_current()), 's');
  dialog::add_action([&] {
    dialog::numberdark = dialog::DONT_SHOW;
    dialog::editNumber(ray::max_iter_current(), 0, 600, 1, 60, XLAT("iterations in raycasting"), "");
    dialog::reaction = ray::reset_raycaster;
    });

  dialog::addSelItem(XLAT("reflective walls in raycasting"), fts(ray::reflect_val), 'R');
  dialog::add_action([&] {
    dialog::editNumber(ray::reflect_val, 0, 1, 0.1, 0, XLAT("reflective walls"), "");
    dialog::reaction = ray::reset_raycaster;
    });

  dialog::addSelItem(XLAT("cells to draw per level"), its(draw_per_level), 'R');
  dialog::add_action([&] {
    dialog::numberdark = dialog::DONT_SHOW;
    dialog::editNumber(draw_per_level, 0, 1000, 500, 50, XLAT("cells to draw"), 
      "If the level size is 30, 600 cells to draw means that every cell is drawn 20 times on average. "
      "Used when raycasting is off, and to draw the wireframes");
    });
  
  dialog::addBreak(200);
  
  #if CAP_VR  
  dialog::addBoolItem_action(XLAT("VR enabled"), vrhr::enabled, 'o');
  if(!vrhr::enabled)
    dialog::addBreak(100);
  else if(vrhr::failed)
    dialog::addInfo(XLAT("error: ") + vrhr::error_msg, 0xC00000);
  else
    dialog::addInfo(XLAT("VR initialized correctly"), 0x00C000);
  
  if(vrhr::active()) {
    dialog::addBoolItem_action(XLAT("equidistant VR"), use_equidistant, 'e');
    if(use_equidistant)
      dialog::addInfo("(distances are seen correctly)");
    else
      dialog::addInfo("(simulate non-Euclidean binocular vision)");
    add_edit(vrhr::cscr);
    }
  else
    dialog::addBreak(300);
  #endif
    
  dialog::addBreak(100);
  dialog::addBack();  

  dialog::display();
  }
  
void settings_menu() {
  emptyscreen();
  dialog::init("Bringris settings");
  dialog::addItem("alternative geometry", 'g');
  dialog::add_action_push(geometry_menu);
  dialog::addItem("visuals & Virtual Reality", 'v');
  dialog::add_action_push(visual_menu);
  dialog::addItem("configure keys", 'k');
  dialog::add_action_push(multi::get_key_configurer(1, move_names, "Bringris keys"));

  #if CAP_AUDIO
  add_edit(effvolume);
  add_edit(musicvolume);
  #endif

  dialog::addBreak(100);

  #if CAP_FILES && !ISWEB
  dialog::addItem("save the current config", 's');
  dialog::add_action([] {
    dynamicval<eGeometry> g(geometry, gNormal);
    saveConfig();
    });
  #endif
  
  dialog::addBack();
  dialog::display();
  }

void adjust_animation(ld part) {
  if(solnil) {
    hyperpoint sh = pView * C0;
    sh = lerp(C0, sh, 1-part);
    pView = eupush(sh);
    smooth = inverse(pView);
    }
  else {
    transmatrix T = pView * inverse(tView);
    hyperpoint vec = inverse_exp(shiftless(tC0(T)));
    transmatrix Tspin = gpushxto0(tC0(T)) * T;
    ld alpha = atan2(Tspin*xpush0(1));
    println(hlog, "vec=", vec, " part = ", part);
    pView = spin(alpha * part) * gpushxto0(direct_exp(vec*part)) * pView;
    fixmatrix(pView);
    View = tView;
    smooth = inverse(pView) * cview().T;
    }
  }

bool next_fail = false;

int TEXTURESIZE = 256;

int nxmin, nxmax, nymin, nymax;

void render_next(int xstart) {
  if(!next_buffer && !next_fail) {
    next_buffer = new renderbuffer(TEXTURESIZE, TEXTURESIZE, true);
    if(!next_buffer->valid) {
      next_fail = true;
      delete next_buffer;
      next_buffer = nullptr;
      println(hlog, "failed to create next_buffer");
      }
    else println(hlog, "valid next_buffer created");
    }
  
  nxmin = (xstart + vid.fsize);  
  nxmax = (vid.xres - vid.fsize);
  nymin = vid.yres - (vid.fsize * (18+8));  
  nymax = vid.yres - (vid.fsize * 18);

  int zlev = get_z(centerover);

  if(!next_buffer) {
    if(1) {
      dynamicval<display_data> ccd(*current_display);
      current_display->xmin = nxmin * 1. / vid.xres;
      current_display->xmax = nxmax * 1. / vid.xres;
      current_display->ymin = 1 - nymax * 1. / vid.yres;
      current_display->ymax = 1 - nymin * 1. / vid.yres;
      calcparam();
      initquickqueue();
      draw_piece(zlev, next_shape_id);
      quickqueue();
      }

    calcparam();
    return;
    }
  
  if(1) {
    resetbuffer rb;
    next_buffer->enable();
    dynamicval<int> dx(vid.xres, TEXTURESIZE);
    dynamicval<int> dy(vid.yres, TEXTURESIZE);
    dynamicval<ld> dxmi(current_display->xmin, 0);
    dynamicval<ld> dxma(current_display->xmax, 1);
    dynamicval<ld> dymi(current_display->ymin, 0);
    dynamicval<ld> dyma(current_display->ymax, 1);
    #if CAP_VR
    dynamicval<int> dvr(vrhr::state, 0);
    #endif
    calcparam();
    current_display->set_viewport(0);
    setGLProjection();
    
    // gamescreen(1);
    initquickqueue();
    draw_piece(zlev, next_shape_id);
    quickqueue();
    rb.reset();
    }
  }

EX void reset_vr_ref() {
  #if CAP_VR
  vrhr::hmd_ref_at = vrhr::hmd_at_ui = vrhr::hmd_at;
  #endif
  }

EX void display_next(int xstart) {

  if(next_buffer) {
    current_display->next_shader_flags = GF_TEXTURE;
    dynamicval<eModel> m(pmodel, mdPixel);
    current_display->set_all(0, 0);
    glBindTexture(GL_TEXTURE_2D, next_buffer->renderedTexture);
    glhr::id_modelview();
    glhr::set_depthtest(false);
    glhr::color2(0xFFFFFFFF);
    vector<glhr::textured_vertex> tvx;
    for(int a=0; a<6; a++) {
      int dx[6] = {0, 1, 1, 0, 0, 1};
      int dy[6] = {0, 0, 1, 0, 1, 1};
      glhr::textured_vertex tx;
      tx.coords[2] = 0;
      tx.coords[3] = 1;
      tx.coords[0] = (dx[a] ? nxmax : nxmin) - current_display->xcenter;
      tx.coords[1] = (dy[a] ? nymax : nymin) - current_display->ycenter;
      tx.texture[0] = dx[a];
      tx.texture[1] = dy[a];
      tvx.push_back(tx);
      }
    glhr::prepare(tvx);
    glDrawArrays(GL_TRIANGLES, 0, 6);    
    }
  }

void run() {

  clearMessages();
  dialog::init();

  if(ang < cur_ang) {
    cur_ang -= (ticks - lti) / 1000.;
    if(cur_ang < ang) cur_ang = ang;
    }
  
  if(ang > cur_ang) {
    cur_ang += (ticks - lti) / 1000.;
    if(cur_ang > ang) cur_ang = ang;
    }
  
  lti = ticks;
  
  if(explore) ;
  else if(ticks > when_t) {
    pView = tView; 
    View = pView;
    smooth = Id;
    }
  else adjust_animation((ticks - last_adjust) * 1. / (when_t - last_adjust));

  last_adjust = ticks;
  
  ray::want_use = use_raycaster ? 2 : 0;
  sightranges[geometry] = 50;
  if(!solnil) vid.cells_drawn_limit = 1;
  else vid.cells_drawn_limit = 2000;

  cmode = sm::NORMAL | sm::CENTER;
  if(!explore) cmode |= sm::VR_MENU;

  int xstart = vid.xres - vid.fsize * 10;
  
  getcstat = '-';
  
  bool show_next = state != tsGameover && state != tsPreGame && !paused;

  #if CAP_VR  
  dynamicval<reaction_t> d(vrhr::change_ui_bounds, [show_next, xstart] {
    vrhr::ui_xmin = xstart;
    vrhr::ui_xmax = vid.xres;
    if(show_next && !explore)
      vrhr::ui_ymin = vid.yres - vid.fsize * 28;
    });
  #endif

  draw_screen(xstart, show_next);
  
  calcparam();
  for(int i=0; i<isize(by_level); i++) {
    displaystr(xstart + vid.fsize, vid.yres - vid.fsize * (i+2), 0, vid.fsize, its(by_level[i]), get_hipso(i+1), 0);
    }
  displaystr(xstart + vid.fsize, vid.yres - vid.fsize * 1, 0, vid.fsize, its(isize(level)), winf[waBarrier].color, 0);

  if(state != tsPreGame) {
    displaystr(xstart + vid.fsize, vid.yres - vid.fsize * 16, 0, vid.fsize, "LEVELS " + its(completed), winf[waBarrier].color, 0);
    displaystr(xstart + vid.fsize, vid.yres - vid.fsize * 15, 0, vid.fsize, "BRICKS " + its(bricks), winf[waBarrier].color, 0);
    displaystr(xstart + vid.fsize, vid.yres - vid.fsize * 14, 0, vid.fsize, "CUBES " + its(cubes), winf[waBarrier].color, 0);
    if(pro_game)
      displaystr(xstart + vid.fsize, vid.yres - vid.fsize * 13, 0, vid.fsize, "SCORE " + fts(int(score)), winf[waBarrier].color, 0);
    }
  
  if(show_next) {
    displaystr(xstart + vid.fsize, vid.yres - vid.fsize * 27, 0, vid.fsize, "NEXT:", winf[waBarrier].color, 0);
    #if CAP_VR
    if(vrhr::active())
      vrhr::in_vr_ui([xstart] {
        display_next(xstart);
        });
    else
    #endif
      display_next(xstart);
    }
      
  bool in_menu = !show_next && !explore;
  
  if(explore) {
    int xx = (xstart + vid.xres) / 2;
    if(displayButtonS(xx, vid.fsize * 2, "backspace", 0xFFFFFFFF, 8, vid.fsize)) getcstat = SDLK_BACKSPACE;
    if(displayButtonS(xx, vid.fsize * 3, "to stop", 0xFFFFFFFF, 8, vid.fsize)) getcstat = SDLK_BACKSPACE;
    if(displayButtonS(xx, vid.fsize * 4, "exploring", 0xFFFFFFFF, 8, vid.fsize)) getcstat = SDLK_BACKSPACE;
    }
  
  if(in_menu) {
    int xx = (xstart + vid.xres) / 2;
    if(paused) {
      if(displayButtonS(xx, vid.fsize * 2, "CONTINUE", 0xFFFFFFFF, 8, vid.fsize)) getcstat = 'p';
      }
    else if(state == tsGameover) {
      displayButtonS(xx, vid.fsize * 2, "game over", 0xFFFFFFFF, 8, vid.fsize);
      }
    if(displayButtonS(xx, vid.fsize * 4, "NEW GAME", 0xFFFFFFFF, 8, vid.fsize)) getcstat = 'n';
    if(displayButtonS(xx, vid.fsize * 6, "EXPERT GAME", 0xFFFFFFFF, 8, vid.fsize)) getcstat = 'x';
    if(displayButtonS(xx, vid.fsize * 8, "SETTINGS", 0xFFFFFFFF, 8, vid.fsize)) getcstat = 's';
    if(state != tsPreGame)
      if(displayButtonS(xx, vid.fsize * 10, "EXPLORE", 0xFFFFFFFF, 8, vid.fsize)) getcstat = 'e';
    if(!ISWEB) {
      if(displayButtonS(xx, vid.fsize * 12, "QUIT", 0xFFFFFFFF, 8, vid.fsize)) getcstat = 'q';
      }
    else if(state == tsGameover)
      if(displayButtonS(xx, vid.fsize * 12, "TWEET", 0xFFFFFFFF, 8, vid.fsize)) getcstat = 't';
    
    if(vrhr::active())
      if(displayButtonS(xx, vid.fsize * 14, "RESET VR", 0xFFFFFFFF, 8, vid.fsize)) getcstat = 'V';
    }
  
  keyhandler = [xstart, in_menu] (int sym, int uni) {
    if(explore) handlePanning(sym, uni);
    if(explore && sym == SDLK_BACKSPACE) 
      explore = false;

    if(state == tsFalling && !paused) {
      multi::handleInput(0);
      bool consumed = false;
      for(int i=0; i<bmLast; i++)
        if(multi::actionspressed[16+i] && !multi::lactionpressed[16+i]) {
          bringris_action(i);
          consumed = true;
          }
      if(consumed) return;
      }

    dialog::handleNavigation(sym, uni);
    if(in_menu && sym == 'q' && !ISWEB) exit(0);
    if(sym == '-') {
      if(!which_pointer) {
        int ax = mousex * 3 / xstart;
        if(ax > 3) ax = 3;
        int ay = mousey * 3 / vid.yres;
        if(ay > 2) ay = 2;
        int id = ay * 4 + ax;
        eBringrisMove moves[12] = {
          bmTurnLeft, bmUp, bmTurnRight, bmPause,
          bmLeft, bmDrop, bmRight, bmFullDrop,
          bmNothing, bmDown, bmNothing, bmFullDrop
          };
        eBringrisMove mov = moves[id];
        if((state == tsFalling && !paused) || mov == bmPause)  
          bringris_action(mov);
        }
#if CAP_VR
      else {
        if(explore)
          explore = !explore;
        else if(
          mousex >= vrhr::ui_xmin && mousex <= vrhr::ui_xmax && 
          mousey >= vrhr::ui_ymin && mousey <= vrhr::ui_ymax)
            paused = !paused;
        else {
          vrhr::compute_vr_direction(which_pointer);
          ld r = 1 / sqrt(2);        
          auto& dir = vrhr::vr_direction;
          vector<pair<eBringrisMove, hyperpoint> > choices = {
            {bmLeft, hyperpoint(-1, 0, 0, 0)},
            {bmRight, hyperpoint(1, 0, 0, 0)},
            {bmUp, hyperpoint(0, -1, 0, 0)},
            {bmDown, hyperpoint(0, 1, 0, 0)},
            {bmTurnLeft, hyperpoint(-r, -r, 0, 0)},
            {bmTurnRight, hyperpoint(r, -r, 0, 0)},
            {bmDrop, hyperpoint(-r, r, 0, 0)},
            {bmFullDrop, hyperpoint(r, r, 0, 0)}
            };
          
          eBringrisMove mov = bmNothing;
          ld best = 0;
                    
          for(auto& b: choices) {
            ld dot = (dir | b.second);
            if(dot > best) best = dot, mov = b.first;
            }

          bringris_action(mov);          
          }
        println(hlog, vrhr::vr_direction);
        }
#endif
      return;
      }
    
    // if(sym == 'k') ang = 0;
    // if(sym == 'l') ang = 45 * degree;    
    if(sym == 'p' || sym == 'c' || (sym == SDLK_ESCAPE && !ISWEB)) {
      if(!paused) move_at = move_at - ticks;
      paused = !paused;
      if(!paused) move_at = move_at - ticks;
      explore = false;
      }
    if(sym == 't' && state == tsGameover) {
      const vector<const char*> emoji =
        {"😀","😎","👽","🤖","😺","🎩","🎓","👑","💍","🐯","🦁","🐮","🐷","🐽","🐸","🐙","🐵","🐦","🐧","🐔","🐒","🙉","🙈","🐣","🐥","🐺","🐗","🐴","🦄","🐝","🐛","🐢","🦀","🦂","🕷","🐜","🐞","🐌","🐠","🐟","🐡","🐬","🐋","🐊","🐆","🐘","🐫","🐪","🐄","🐂","🐃","🐏","🐑","🐀","🐁","🐓","🦃","🐉","🐾","🐿","🐇","🐈","🐩","🐕","🐲","🌵","🍁","🌻","🌎","⭐️","⚡️","🔥","❄️","☔️","☂️","💧","🍏","🍎","🍐","🍋","🍌","🍉","🍇","🌶","🍅","🍍","🍑","🍈","🍓","🌽","🍠","🍯","🍞","🍗","🧀","🍖","🍤","🌯","🌮","🍝","🍕","🌭","🍟","🍔","⚽️","🎱","🏆","🎪","🎲","🎳","🚗","🚕","🚙","🏎","⛺️","⛩","🕹","💾","☎️","⏱","🔦","💡","💰","💎","🔨","💣","🔑","❤️","🔔"};

      string out;
      if(pro_game) {
        out = "Got " + its(score) + " points for completing " + its(completed) + " levels in #Bringris!";
        }
      else if(completed) {
        out = "Used " + its(bricks) + " blocks to complete " + its(completed) + " levels in #Bringris!";
        }
      else {
        out = "Dropped " + its(bricks) + " blocks in #Bringris!";
        }
      if(bgeom || max_piece != 4) out += " (" + bgeoms[bgeom].name + "/" + its(max_piece) + ")";
      unsigned hash = time(NULL) / 600;
      for(char c: out) hash = 171 * hash + c;
      std::mt19937 invr;
      invr.seed(hash);
      out += " ";
      for(int i=0; i<4; i++)
        out += emoji[invr() % isize(emoji)];            
      // println(hlog, out);
      #if ISWEB
      EM_ASM({
        var tweetbegin = 'https://twitter.com/intent/tweet?text=';
        var tweettxt = UTF8ToString($0, $1);
        var finaltweet = tweetbegin +encodeURIComponent(tweettxt) + "&url=https://zenorogue.itch.io/bringris";
        window.open(finaltweet,'_blank');
        }, out.c_str(), isize(out));
      #endif
      }
    if(in_menu && sym == 'e') {
      explore = !explore;
      }
    if(sym == 'V') {
      reset_vr_ref();
      }
    if(in_menu && sym == 'n') {
      start_new_game();
      paused = false;
      explore = false;
      pro_game = false;
      playSound(cwt.at, "elementalgem");
      }
    if(in_menu && sym == 's') {
      pushScreen(settings_menu);
      }
    if(in_menu && sym == 'x') {
      start_new_game();
      paused = false;
      explore = false;
      pro_game = true;
      playSound(cwt.at, "elementalgem");
      }
    #if CAP_SHOT
    if(sym == ']') {
      static int id = 0;
      perfect_linewidth = 0;
      shot::shot_aa = 2;
      vid.linewidth *= 2;
      shot::take(format("bringris-%04d.png", id++), [] { draw_screen(vid.xres, false); });
      vid.linewidth /= 2;
      }
    #endif
    #ifdef MAKE_VIDEO
    if(sym == '[') {
      perfect_linewidth = 0;
      shot::shot_aa = 4;
      vid.linewidth *= 5;
      int dir = 3;
      int fpm = in_s2xe() ? 60 : 30;
      int steps = 0;
      auto att = at;
      bool boundedw = bflags() & BOUNDED_WELL;
      if(boundedw) steps = 20;
      else do {
        steps++;
        shift_block(dir);
        }
      while(at != att);
      println(hlog, steps, " steps of ", fpm, " frames each");
      anims::noframes = steps * fpm;
      anims::period = steps * fpm;
      int lt = -1;
      int p = addHook(anims::hooks_anim, 200, [&] {
        int t = ticks;
        if(t == lt) {
          println(hlog, "ignore");
          return;
          }
        lt = t;
        println(hlog, "t = ", t);
        if(t % fpm == 0) {
          pView = tView; 
          View = pView;
          smooth = Id;
          shift_block(dir);
          if(boundedw) dir = (1+dir) % 4;
          }
        if(boundedw) {
          auto f = [fpm] (ld k) { k /= fpm; return k * k * (3 - 2 * k); };
          ld a = f(t % fpm);
          ld b = f(t % fpm + 1);
          adjust_animation((b-a) / (1-a));
          }
        else
          adjust_animation(1. / (fpm - t % fpm));
        });
      anims::record_video("bringris.mp4", [] { return anims::record_animation_of( [] { println(hlog, "called"); draw_screen(vid.xres, false); } ); });
      delHook(anims::hooks_anim, p); 
      vid.linewidth /= 5;
      }
    #endif
    };
  }

cell *get_center() {
  return well_center ? well_center : level[0];
  }

void reset_view() {
  centerover = get_at(get_center(), -camera_level);
  cwt.at = centerover;
  ncenter = get_at(get_center(), -camera_level);
  
  NLP = Id;
  tView = Id;
  
  set_view();
  pView = tView;
  }
  
void start_new_game() {
  
  for(auto& p: piecelist) p.count = 0;

  for(auto lev: level) for(int z=0; z<=camera_level+1; z++) {
    cell *c = get_at(lev, -z);
    setdist(c, 7, nullptr);
    c->item = itNone;
    c->land = laCanvas;
    if(z == 0)
      c->wall = waBarrier, c->land = laBarrier;
    else if(z <= camera_level)
      c->wall = waNone;
    else 
      c->wall = waWaxWall, c->land = laCanvas, c->landparam = 0xC000C0;
    }

  for(auto lev: out_level) for(int z=1; z<=camera_level; z++) {
    cell *c = get_at(lev, -z);
    c->item = itNone;
    c->land = laCanvas;
    c->wall = waWaxWall;
    c->landparam = (get_hipso(z) & 0xFCFCFC) >> 2;
    }
  
  at = get_at(get_center(), -well_size - 1);
  next_shape_id = choose_piece();
  
  state = tsBetween;
  
  reset_view();

  // reset_view();

  completed = 0;
  bricks = 0;
  cubes = 0;
  score = 0;
  }

void get_level() {
  if(bflags() & BOUNDED_WELL) {
    set<cell*> all;
    well_center = currentmap->gamestart();
    all.insert(well_center);
    for(int i=0; i<4; i++)
    for(int l: {-1, 0, 1})
    for(int j=0; j<4; j++)
    for(int k: {-1, 1}) {
      cellwalker cw(well_center, i);
      cw += wstep;
      all.insert(cw.at);
      if(l) {
        cw += l;
        cw += wstep;
        all.insert(cw.at);
        }
      cw += j;
      cw += wstep;
      all.insert(cw.at);
      cw += k;
      cw += wstep;
      all.insert(cw.at);
      }
    set<cell*> all_ext;
    for(cell *c: all)
      forCellCM(d, c)
        if(!all.count(d))
          all_ext.insert(d);
          
    level.clear();
    for(auto c: all) 
      level.push_back(c);
    for(auto c: all_ext) 
      out_level.push_back(c);
    }
  else {
    level = currentmap->allcells();
    if(bflags() & ORBIFOLD) {
      vector<cell*> clist;
      set<cell*> visited;
      auto visit = [&] (cell *c) { 
        if(!visited.count(c))
          visited.insert(c),
          clist.push_back(c);
        };
      for(auto c: level) if(isNeighbor(c, c)) visit(c);
      for(int i=0; i<isize(clist); i++)
        for(int j=0; j<clist[i]->type; j++)
          visit(clist[i]->cmove(j));
      well_center = clist.back();
      }
    }
  if(well_center) {
    vector<cell*> visited;
    set<cell*> all;
    for(auto l: level) all.insert(l);
    auto visit = [&] (cell *c, int d) { 
      if(all.count(c) && !center_distance.count(c))
        center_distance[c] = d,
        visited.push_back(c);
      };
    visit(well_center, 0);
    for(int i=0; i<isize(visited); i++)
      for(int j=0; j<visited[i]->type; j++)
        visit(visited[i]->move(j), center_distance[visited[i]] + 1);
    }
  }
  
void create_game() {
  level.clear();
  out_level.clear();
  well_center = nullptr;

  if(!prod && !solnil) {
    println(hlog, "need product or Solnil geometry");
    exit(1);
    }
  if(nil) {
    for(int x=0; x<5; x++)
    for(int y=0; y<5; y++)
     level.push_back(nilv::get_heptagon_at(nilv::mvec(x, 0, y))->c7);
    }
  else if(sol) {
    level.clear();
    for(int x=0; x<5; x++)
    for(int y=0; y<5; y++)
     level.push_back(asonov::get_at(asonov::coord(x, y, 0))->c7);
    }
  else 
    PIU(get_level());  
  piecelist.clear();
  piecelist.reserve(2000);
  seen_blocks.clear();
  for(int ps=1; ps<=max_piece; ps++)  
    generate_shapes(ps);
  list_all();
  // println(hlog, "level size = ", isize(level));
  
  camera_level = well_size + max_piece + camera;
  
  playermoved = false;
  ray::want_use = 2;
  ray::exp_decay_poly = 200;
  ray::max_iter_current() = solnil ? 600 : 200;
  mapeditor::drawplayer = false;
  // sightranges[geometry] = 1;
  
    
  vid.fov = 90;
  vid.plevel_factor = 0.5;
  // vid.grid = true;

  mouseaim_sensitivity = 0;  
  
  start_new_game();
  state = tsPreGame;

  vid.axes3 = false;
  }

void init_all() {
  enable_bgeom();
  vid.texture_step = 8;
  showstartmenu = false;
  pushScreen(run);  
  in_bringris = true;
  }

int args() {
  using namespace arg;
           
  if(0) ;

  else if(argis("-list")) {
    PHASEFROM(3);
    start_game();
    shift(); int i = argi();
    generate_shapes(i);
    list_all();
    }

  else if(argis("-bringris0")) {
    PHASEFROM(3);
    start_game();
    create_game();
    }

  else if(argis("-bgeo")) {
    PHASEFROM(2);
    shift();
    enable_bgeom(argi());
    }
    
  else if(argis("-bringris")) {
    PHASEFROM(2);
    init_all();
    }

  else if(argis("-ray-off"))
    use_raycaster = false;

  else if(argis("-ray-on"))
    use_raycaster = true;

  else if(argis("-dpl")) {
    shift(); draw_per_level = argi();
    }

  else return 1;
  return 0;
  }

void change_default_key(int key, int val) {
  char* t = multi::scfg.keyaction;
  t[key] = val;
  set_saver_default(t[key]);
  }

void default_config() {
  for(int i=0; i<512; i++)
    if(multi::scfg.keyaction[i] >= 16 && multi::scfg.keyaction[i] < 32)
      change_default_key(i, 0);
  
  change_default_key('s', 16 + 0);
  change_default_key('a', 16 + 1);
  change_default_key('w', 16 + 2);
  change_default_key('d', 16 + 3);
  change_default_key('q', 16 + 4);
  change_default_key('e', 16 + 5);
  change_default_key(' ', 16 + 6);
  change_default_key('\r',16 + 7);
  change_default_key('p', 16 + 8);

  addsaver(bgeom, "bringris-geometry");
  addsaver(use_raycaster, "bringris-ray");
  addsaver(draw_per_level, "draw-per-level");
  addsaver(use_equidistant, "bringris-equidistant");
  addsaver(flashes, "bringris-flashes");
  }

auto hooks = 
    addHook(hooks_args, 100, args)
  + addHook(hooks_frame, 100, bringris_frame)
  + addHook(hooks_configfile, 100, default_config)
  + addHook(dialog::hooks_display_dialog, 100, [] () {
      if(dialog::items[0].body == "Bringris keys") {
        dialog::addBreak(200);
        if(!rotate_allowed)
          dialog::addHelp("note: rotation keys only available when necessary");
        dialog::addHelp("press SHIFT to highlight the holes");
        dialog::addHelp("mouse control by pressing parts of the game screen");
        }
      }); 

#ifdef BRINGRIS
auto hook1=
    addHook(hooks_config, 100, [] {
      if(arg::curphase == 1) 
        conffile = "bringris.ini";
      if(arg::curphase == 2) init_all();      
      });
#endif

}
}