hyperrogue/rogueviz/platformer.cpp

#include "../rogueviz/rogueviz.h"

/** \brief Hyperbolic platformer.
The implementation of the platformer from https://twitter.com/ZenoRogue/status/1467233150380089345 
To play, load platformer.lev (e.g. `-load platformer.lev`)
Or create a new map by running with options:
 `-noscr -canvas B -geo dbin -platformer`
 
Keys:
up/left/right -- move the guy
c -- clear the current room (buggy, does not clear parts of the adjacent rooms)
g -- generate the current room (buggy)
m -- see the map (toggle)
p -- pause (toggle)
z -- screenshot menu
q -- quit
s -- save to platformer.lev
1 -- place a small block under the mouse
2 -- place a big block under the mouse
3 -- delete the block under the mouse

Have fun!
*/

namespace hr {

namespace platformer {

/* the size of a block, in pixels */
constexpr int block_x = 8;
constexpr int block_y = 8;

/* the size of a room (screen), in blocks */
constexpr int room_x = 32;
constexpr int room_y = 24;

/* the size of a room, in pixels */
constexpr int screen_x = block_x * room_x;
constexpr int screen_y = block_y * room_y;

/* the size of the area shared between right/left blocks */
constexpr int lr_margin = 4;

/* the size of the area shared with the block above */
constexpr int t_margin = 2;

/* the size of the area shared with the block below */
constexpr int b_margin = 2 * t_margin;

/* the position of margins in pixels */
constexpr int l_margin_at = lr_margin * block_x / 2;
constexpr int r_margin_at = screen_x - block_x * lr_margin / 2;
constexpr int t_margin_at = t_margin * block_y / 2;
constexpr int b_margin_at = screen_y - b_margin * block_y / 2;

/* between the margins */
constexpr int actual_screen_x = r_margin_at - l_margin_at;
constexpr int actual_screen_y = b_margin_at - t_margin_at;

int game_fps = 300;
bool bottom = 1;

basic_textureinfo roomtinf;

hpcshape roomshape;

constexpr auto yctr = (t_margin_at + b_margin_at) / 2.;  
constexpr auto xctr = (l_margin_at + r_margin_at) / 2.;  

double mscale = 100;

hyperpoint to_hyper(ld x, ld y) {
  y -= t_margin_at;
  y += actual_screen_y;
  x -= xctr;

  y /= mscale;
  x /= mscale;

  y += .5;
  ld d = x*x + y*y;
  x /= d;
  y /= d;
  y -= 1;
  hyperpoint h;
  h[0] = -x; h[1] = y; h[2] = 1;
  h = spin(-90*degree) * h;
  return perspective_to_space(h, 1, gcHyperbolic);
  }

pair<ld, ld> from_hyper(hyperpoint h) {
  h = spin(+90*degree) * h; h[0] = -h[0];
  h[2] += 1;
  h /= h[2];

  h[1] += 1;
  ld d = h[0]*h[0] + h[1]*h[1];
  h /= d;
  h[1] -= .5;
  
  double x = h[0], y = h[1];

  y *= mscale;
  x *= mscale;

  y -= actual_screen_y;
  y += t_margin_at;
  x += xctr;

  return {x, y};
  }

void prepare_tinf() {
  cgi.bshape(roomshape, PPR::WALL);
  
  auto add_vertex = [&] (double bx, double by) {
    roomtinf.tvertices.push_back(glhr::makevertex(bx / screen_x, (by + (screen_x-screen_y)/2.) / screen_x, 0));
    cgi.hpc.push_back(to_hyper(bx, by));
    };
  
  for(int by=t_margin_at; by<b_margin_at; by+=block_y)
  for(int bx=l_margin_at; bx<r_margin_at; bx+=block_x) {
    add_vertex(bx, by);
    add_vertex(bx+block_x, by);
    add_vertex(bx+block_x, by+block_y);
    add_vertex(bx, by);
    add_vertex(bx, by+block_y);
    add_vertex(bx+block_x, by+block_y);
    }
  cgi.last->flags |= POLY_TRIANGLES;
  cgi.last->tinf = &roomtinf;
  cgi.last->texture_offset = 0;
  cgi.finishshape();
  cgi.extra_vertices();
  println(hlog, "room generated at ", roomshape.s, " to ", roomshape.e, " tvertices = ", isize(roomtinf.tvertices));
  }

bool is_right(struct room *r);
struct room *get_adjacent(struct room *r, int i);

struct room {
  texture::texture_data *room_texture;
  cell *where;
  char block_at[room_y][room_x];
  
  void clear() {
    for(int y=0; y<room_y; y++)
    for(int x=0; x<room_x; x++)
      block_at[y][x] = 0;
    }
  
  void initial() {
    int ylev = where->master->distance;
    println(hlog, "ylev = ", ylev);
    if(ylev <= 0)
      for(int y=room_y-6; y<room_y; y++)
      for(int x=0; x<room_x; x++)
        block_at[y][x] = 8 + 4 + (x&1) + (y&1)*2;
    if(ylev < 0)
      for(int y=0; y<room_y-6; y++)
      for(int x=0; x<room_x; x++)
        block_at[y][x] = 8;
    }
  
  void place_small(int x, int y) {
    block_at[y][x] = 8;
    }

  void place_big(int x, int y) {
    block_at[y][x] = 8+4;
    block_at[y][x+1] = 8+5;
    block_at[y+1][x] = 8+6;
    block_at[y+1][x+1] = 8+7;
    }

  void place_block_full(int x, int y, int b) {
    indenter ind(2);
    println(hlog, "trying ", b, " at ", tie(x, y), " of ", where);
    

    if(x < 0 || y < 0 || x >= room_x || y >= room_y) return;
    if(b < 8) b = 0;
    if((b & 4) && (x&1) != (b&1)) return;
    if((b & 4) && (2*(y&1)) != (b&2)) return;
    if(y < t_margin && (b&4)) return;
    if(y > room_y - b_margin && !(b&4) && b) return;
    if(block_at[y][x] == b) return;
    
    block_at[y][x] = b;
    if(b & 4) {
      place_block_full(x^1, y, b^1);
      place_block_full(x, y^1, b^2);
      }
    else {
      if(block_at[y][x^1] & 4)
        place_block_full(x^1, y, 0);
      if(block_at[y^1][x] & 4)
        place_block_full(x, y^1, 0);
      }
    
    if(x < lr_margin)
      get_adjacent(this, 2)->place_block_full(x + room_x - lr_margin, y, b);
    if(x >= room_x - lr_margin)
      get_adjacent(this, 4)->place_block_full(x - room_x + lr_margin, y, b);
    if(y < t_margin) {
      if(x < room_x / 2) {
        get_adjacent(this, 1)->place_block_full((x - lr_margin/2) * 2 + lr_margin/2, room_y - b_margin + 2*y, b^4);
        }
      else {
        get_adjacent(this, 0)->place_block_full((x - room_x/2) * 2 + lr_margin/2, room_y - b_margin + 2*y, b^4);
        }
      }
    
    if(y >= room_y - b_margin) {
      bool r = is_right(this);
      x -= lr_margin/2;
      x /= 2;
      x += (r ? room_x/2 : lr_margin/2);
      y = y - room_y + b_margin;
      y /= 2;
      b &= ~3;
      get_adjacent(this, 3)->place_block_full(x, y, b ^ 4);
      }
    }
  
  void generate() {
    clear();
    place_small(0, 0);
    place_small(room_x/2-1, 0);
    place_small(room_x/2, 0);
    place_small(room_x-1, 0);
    place_big(0, room_y-2);
    place_big(room_x-2, room_y-2);
    
    /*
    for(int x=0; x<room_x; x+=2)
      if(hrand(100) < 10)
        place_big(x, room_y-2);

    for(int x=0; x<room_x; x++)
      if(hrand(100) < 10)
        place_small(x, 0); */

    for(int y=2; y<room_y-2; y+=2)
    for(int x=2; x<room_x-2; x+=2)
      if(hrand(room_y * 8) < y)
        place_big(x, y);

    for(int y=2; y<room_y-2; y++)
    for(int x=2; x<room_x-2; x++)
      if(block_at[y][x] == 0)
      if(hrand((room_y) * 8) < y)
        place_small(x, y);
      
    for(int y=room_y/2-2; y<room_y/2+2; y++)
    for(int x=room_x/2-2; x<room_x/2+2; x++)
      block_at[y][x] = 0;
    }
  
  void create_texture();
  };

map<cell*, room> rooms;

bool paused;

room *current_room;

void switch_to_room(room *r) {
  current_room = r;
  }

room *get_room_at(cell *c) {
  bool create = !rooms.count(c);
  auto& r = rooms[c];
  if(create) {
    r.where = c;
    r.clear();
    r.initial();
    c->wall = waNone;
    c->land = laCanvas;
    }
  return &r;
  }

bool is_right(room *r) {
  cell *c = r->where;
  c->cmove(3);
  return c->c.spin(3) == 0;
  }

room *get_adjacent(room *r, int i) {
  cell *c = r->where;
  c->cmove(i);
  c = c->cmove(i);
  return get_room_at(c);
  }

void switch_to_adjacent_room(int i) {
  switch_to_room(get_adjacent(current_room, i));
  }

string block[8] = {
  "11111111",
  "12444461",
  "13555571",
  "13555571",
  "13555571",
  "13555571",
  "14666671",
  "11111111"
  };

const int man_x = 8, man_y = 12;

string man[man_y] = {
  "..1111..",
  "..1111..",
  "..1111..",
  "11111111",
  "..1111..",
  "..1111..",
  "1..11..1",
  ".111111.",
  "...11...",
  "..1111..",
  ".11..11.",
  "11....11",
  };

double where_x = screen_x / 2.;
double where_y = screen_y / 2.;

double get_scale() {
  return (actual_screen_y + (where_y - t_margin_at)) / (actual_screen_y * 3/2.);
  }

struct bbox {
  int minx, miny, maxx, maxy;
  };

bbox get_pixel_bbox() {
  bbox b;
  double d = get_scale();
  b.minx = where_x - man_x * d / 2;
  b.maxx = where_x + man_x * d / 2 + 1;
  b.miny = where_y - man_y * d / 2;
  b.maxy = where_y + man_y * d / 2 + 1;
  return b;
  }

bbox pixel_to_block(bbox b) {
  b.minx /= block_x;
  b.miny /= block_y;
  b.maxx = (b.maxx + block_x-1) / block_x;
  b.maxy = (b.maxy + block_y-1) / block_y;
  if(b.minx < 0) b.minx = 0;
  if(b.miny < 0) b.miny = 0;
  if(b.maxx >= room_x) b.maxx = 0;
  if(b.maxy >= room_y) b.maxy = 0;
  return b;
  }

bool conflict_at(double x, double y) {
  dynamicval<double> fx(where_x, x);
  dynamicval<double> fy(where_y, y);
  bbox b = pixel_to_block(get_pixel_bbox());
  for(int xx=b.minx; xx<b.maxx; xx++)
  for(int yy=b.miny; yy<b.maxy; yy++)
    if(current_room->block_at[yy][xx]) return true;
  return false;
  }

static double gtime = 0;

double vel_x = 0, vel_y = 0;

static const double grav = 0.1;

bool map_on = false;

bool last_mkey = false;

extern int mousepx, mousepy;

void game_frame() {  
  const Uint8 *keystate = SDL12_GetKeyState(NULL);
  if(keystate['3'])
    current_room->place_block_full(mousepx / block_x, mousepy / block_y, 0);
  if(keystate['1'])
    current_room->place_block_full(mousepx / block_x, mousepy / block_y, 8);
  if(keystate['2'])
    current_room->place_block_full(mousepx / block_x, mousepy / block_y, 12);
  
  if(paused) return;

  double d = get_scale();
  
  bool on_floor = false;
  
  ld modv = 60. / game_fps;
  ld moda = modv * modv;
  
  vel_y += d * grav * moda;
  
  while(conflict_at(where_x, where_y + vel_y)) {
    if(vel_y > 0) on_floor = true;
    vel_y /= 2;
    if(vel_y < 1e-9) { vel_y = 0; break; }
    if(!conflict_at(where_x, where_y + vel_y)) where_y += vel_y;
    }
  where_y += vel_y;

  double avel_x = vel_x;
  while(conflict_at(where_x + vel_x, where_y)) {
    vel_x /= 2;
    if(vel_x < 1e-9) { vel_x = 0; break; }
    if(!conflict_at(where_x + vel_x, where_y)) where_x += vel_x;
    }
  where_x += vel_x;
  vel_x = avel_x;
  
  hyperpoint h_at = to_hyper(where_x, where_y);
  // ld test_x, test_y;
  // tie(test_x, test_y) = from_hyper(h_at);
  
  /*println(hlog, tie(where_x, where_y), " TO ", h_at, " TO ", tie(test_x, test_y));
  exit(1); */
  
  hyperpoint h_was = to_hyper(where_x - vel_x, where_y - vel_y);
  hyperpoint h_willbe = rgpushxto0(h_at) * MirrorX * MirrorY * gpushxto0(h_at) * h_was;
  ld next_x, next_y;
  tie(next_x, next_y) = from_hyper(h_willbe);
  vel_x = next_x - where_x;
  vel_y = next_y - where_y;
  
  if(on_floor) {
    if(keystate[SDLK_LEFT]) vel_x = -d * modv;
    else if(keystate[SDLK_RIGHT]) vel_x = d * modv;
    else vel_x = 0;
    if(keystate[SDLK_UP]) vel_y = -4 * d * modv;
    }
  else {
    if(keystate[SDLK_LEFT]) vel_x += -d * .01 * moda;
    else if(keystate[SDLK_RIGHT]) vel_x += d * .01 * moda;
    vel_y += d * grav * moda;
    }
  
  if(where_x < l_margin_at) {
    where_x += actual_screen_x;
    switch_to_adjacent_room(2);
    }
  if(where_x > r_margin_at) {
    where_x -= actual_screen_x;
    switch_to_adjacent_room(4);
    }
  
  if(where_y < t_margin_at) {
    where_y = (where_y - t_margin_at) * 2 + b_margin_at;
    where_x -= l_margin_at;
    where_x = 2 * where_x;
    if(where_x > actual_screen_x) {
      where_x -= actual_screen_x;
      switch_to_adjacent_room(0);
      }
    else
      switch_to_adjacent_room(1);
    where_x += l_margin_at;
    vel_x *= 2; vel_y *= 2;
    }
  if(where_y > b_margin_at) {
    where_x -= l_margin_at;
    where_y -= b_margin_at;
    where_y /= 2;
    where_y += t_margin_at;
    if(is_right(current_room))
      where_x += actual_screen_x;
    switch_to_adjacent_room(3);
    where_x /= 2;
    where_x += l_margin_at;
    vel_x /= 2; vel_y /= 2;
    }

  }

void room::create_texture() {
  if(room_texture) return;
  room_texture = new texture::texture_data;
  
  auto& tex = *room_texture;

  tex.twidth = tex.theight = 256;
  
  tex.tx = screen_x;
  tex.ty = screen_y;
  tex.stretched = false;
  tex.strx = tex.tx;
  tex.stry = tex.ty;
  tex.base_x = 0;
  tex.base_y = (tex.theight - tex.ty) / 2;
  }

texture::texture_data *sprite_texture;

void create_sprite_texture() {
  if(sprite_texture) return;
  sprite_texture = new texture::texture_data;
  auto& tex = *sprite_texture;
  tex.twidth = tex.theight = 256;
  tex.whitetexture();
  for(int y=0; y<256; y++)
  for(int x=0; x<256; x++)
    tex.get_texture_pixel(x, y) = 0;
  for(int y=0; y<man_y; y++)
  for(int x=0; x<man_x; x++)
    if(man[y][x] == '1')
      tex.get_texture_pixel(x, y) = 0xFFFFFFFF;
  tex.loadTextureGL();  
  }

struct dqi_poly_tex : dqi_poly {
  int texture_id;
  void draw() override { if(tinf) tinf->texture_id = texture_id; dqi_poly::draw(); }
  };  

basic_textureinfo sprite_vertices;

template<class R> void render_room_objects(room *r, R render_at);

void render_room(room *r);

bool draw_room_on_map(cell *c, const shiftmatrix& V) {
  hr::addaura(tC0(V), 0xFF00FF00, 0);
  if(!rooms.count(c)) {
    c->landparam = 0x101010;
    get_room_at(c);
    return false;
    }
  auto& r = rooms[c];
  if(!r.room_texture) render_room(&r);
  if(!r.room_texture) return false;

  auto& p = queuea<dqi_poly_tex> (PPR::WALL);
  p.V = V;
  p.offset = roomshape.s;
  p.cnt = roomshape.e - roomshape.s;
  p.color = 0xFFFFFFFF;
  p.tab = &cgi.ourshape;
  p.flags = roomshape.flags;
  p.tinf = &roomtinf;
  p.offset_texture = 0;
  p.texture_id = r.room_texture->textureid;
  println(hlog, "offset = ", p.offset, " texture_offset = ", p.offset_texture);
  
  auto render_at = [&] (GLuint texid, double px0, double py0, double px1, double py1,
    double tx0, double ty0, double tx1, double ty1) {

    auto addpoint = [&] (int x, int y) {
      curvepoint(to_hyper(x ? px1 : px0, y ? py1 : py0));
      sprite_vertices.tvertices.emplace_back(glhr::makevertex(x ? tx1 : tx0, y ? ty1 : ty0, 1));
      };
    
    int tcurvestart = isize(sprite_vertices.tvertices);
    
    addpoint(0, 0);
    addpoint(0, 1);
    addpoint(1, 1);
    addpoint(0, 0);
    addpoint(1, 0);
    addpoint(1, 1);
    
    auto& p = queuea<dqi_poly_tex> (PPR::MONSTER_BODY);
    p.V = V;
    p.offset = curvestart;
    p.cnt = isize(curvedata) - curvestart;
    curvestart = isize(curvedata);
    p.color = 0xFFFFFFFF;
    p.tab = &curvedata;
    p.flags = POLY_TRIANGLES;
    p.tinf = &sprite_vertices;
    p.offset_texture = tcurvestart;
    p.texture_id = texid;
    };
  
  render_room_objects(&r, render_at);
  return true;
  }

void render_room(room *r) {
  r->create_texture();
  auto& tex = *(r->room_texture);
  tex.whitetexture();
  
  auto pb = get_pixel_bbox();
  auto bb = pixel_to_block(pb);

  for(int y=0; y<screen_y; y++)
  for(int x=0; x<screen_x; x++)
    tex.get_texture_pixel(x, y) = 0;
  
  for(int y=0; y<screen_y; y++)
  for(int x=0; x<screen_x; x++) {
  
    int lx = x / block_x;
    int ly = y / block_y;
    char c = r->block_at[ly][lx];
    
    if(c == 0) {
      if(false && lx >= bb.minx && lx < bb.maxx && ly >= bb.miny && ly < bb.maxy)
        tex.get_texture_pixel(x, y + tex.base_y) = 0xFF008000;
      else
        tex.get_texture_pixel(x, y + tex.base_y) = 0xFF000000;
      }
    
    else {
      int ax = x % block_x;
      int ay = y % block_y;
      if(c & 4) {
        ax /= 2;
        ay /= 2;
        if(c & 1) ax += (block_x/2);
        if(c & 2) ay += (block_y/2);
        }
      char chr = block[ay][ax];
      tex.get_texture_pixel(x, y + tex.base_y) = 0xFFFFFFFF + 0x202020 * (chr - '7');
      }
    }
  
  tex.loadTextureGL();  
  }

template<class R> void render_room_objects(room *r, R render_at) {
  auto pb = get_pixel_bbox();  
  if(r != current_room) return;
  render_at(sprite_texture->textureid, pb.minx, pb.miny, pb.maxx, pb.maxy, 0, 0, man_x/256., man_y/256.);
  }

int mousepx, mousepy;

void draw_room() {
  render_room(current_room);
  create_sprite_texture();
  flat_model_enabler fme;
  auto& tex = *(current_room->room_texture);

  ld tx = tex.tx;
  ld ty = tex.ty;
  ld scalex = (vid.xres/2) / (current_display->radius * tx);
  ld scaley = (vid.yres/2) / (current_display->radius * ty);
  ld scale = min(scalex, scaley);
  scale *= 4;
  
  double low = tex.base_y * 1. / tex.theight;
  
  auto render_at = [&] (GLuint texid, double px0, double py0, double px1, double py1,
    double tx0, double ty0, double tx1, double ty1) {
    static vector<glhr::textured_vertex> rtver(4);  

    ld cx[4] = {1,0,0,1};
    ld cy[4] = {1,1,0,0};
  
    for(int i=0; i<4; i++) {
      rtver[i].texture[0] = cx[i] ? tx1 : tx0;
      rtver[i].texture[1] = cy[i] ? ty1 : ty0;
      rtver[i].coords[0] = ((cx[i] ? px1 : px0) - screen_x/2) * scale;
      rtver[i].coords[1] = ((cy[i] ? py1 : py0) - screen_y/2) * scale;
      rtver[i].coords[2] = 1;
      rtver[i].coords[3] = 1;
      }
    
    glhr::be_textured();
    current_display->set_projection(0, false);
    glBindTexture(GL_TEXTURE_2D, texid);
    glhr::color2(0xFFFFFFFF);
    glhr::id_modelview();
    current_display->set_mask(0);
    glhr::prepare(rtver);
    glhr::set_depthtest(false);
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
    };
  
  render_at(tex.textureid, 0, 0, screen_x, screen_y, 0, low, 1, 1-low);
  render_room_objects(current_room, render_at);
  
  mousepx = (mousex - current_display->xcenter) * 2 / scale / current_display->radius + screen_x/2;
  mousepy = (mousey - current_display->ycenter) * 2 / scale / current_display->radius + screen_y/2;
  }

void run() {
  clearMessages();
  dialog::init();

  sprite_vertices.tvertices.clear();
  if(map_on) {
    render_room(current_room);
    gamescreen(0);
    }
  else {
    draw_room();
    }
  
  dialog::add_key_action('c', [] { current_room->clear(); });
  dialog::add_key_action('g', [] { current_room->generate(); });
  dialog::add_key_action('m', [] { 
    map_on = !map_on;
    });
  dialog::add_key_action('p', [] { 
    paused = !paused;
    });
  dialog::add_key_action('z', [] { 
    pushScreen(shot::menu);
    });
  dialog::add_key_action('q', [] {  exit(0); });
  dialog::add_key_action('s', [] {  
    mapstream::saveMap("platformer.lev");
    });
  
  keyhandler = [] (int sym, int uni) {
    if(map_on && paused)
      handlePanning(sym, uni);
    dialog::handleNavigation(sym, uni);
    };
  }

void add_platf_hooks();

void set_sval() {
  
  ld s_min = 10, s_max = 1200;
  
  for(int it=0; it<100; it++) {
    mscale = sqrt(s_min * s_max);
    hyperpoint atop = deparabolic13(to_hyper(0, t_margin_at));
    if(atop[0] < -log(2)/2) s_max = mscale;
    else s_min = mscale;
    }
  }

void enable() {
  
  stop_game();
  
  set_sval();
  
  hyperpoint aleft = deparabolic13(to_hyper(l_margin_at, yctr));
  hyperpoint aright = deparabolic13(to_hyper(r_margin_at, yctr));
  
  vid.binary_width = abs(aright[1] - aleft[1]) / log(2);
  
  start_game();
  cgi.prepare_shapes();

  current_room = get_room_at(cwt.at);
  
  prepare_tinf();
  
  add_platf_hooks();
  }

void add_platf_hooks() {
 
  rogueviz::rv_hook(hooks_prestats, 90, [=] {
  
    if(nomap)
      draw_room();
    else
      render_room(current_room);
    
    return true;
    });

  rogueviz::rv_hook(shmup::hooks_turn, 90, [=] (int d) {
    gtime += d;
    while(gtime > 1000. / game_fps) {
      gtime -= 1000. / game_fps;
      game_frame();
      }
    return true;
    });

  rogueviz::rv_hook(hooks_drawcell, 90, draw_room_on_map);

  rogueviz::rv_hook(mapstream::hooks_savemap, 100, [] (fhstream& f) {
    f.write<int>(66);
    for(auto& p: rooms) {
      f.write(mapstream::cellids[p.first]);
      for(int y=0; y<room_y; y++)
      for(int x=0; x<room_x; x++)
        f.write(p.second.block_at[y][x]);
      f.write<int>(0);
      }
    f.write<int>(-1);
    f.write(mapstream::cellids[current_room->where]);
    f.write(where_x);
    f.write(where_y);
    f.write(vel_x);
    f.write(vel_y);
    });

  pushScreen(run);  
  }

auto chk = arg::add3("-platformer", enable)
+ addHook(mapstream::hooks_loadmap, 100, [] (fhstream& f, int id) {
    if(id == 66) {
      println(hlog, "loading platformer");
      while(true) {
        int i = f.get<int>();
        if(i == -1) break;
        auto r = get_room_at(mapstream::cellbyid[i]);
        for(int y=0; y<room_y; y++)
        for(int x=0; x<room_x; x++)
          f.read(r->block_at[y][x]);
        f.get<int>();
        }
      int id = f.get<int>();
      current_room = get_room_at(mapstream::cellbyid[id]);
      f.read(where_x);
      f.read(where_y);
      f.read(vel_x);
      f.read(vel_y);
      add_platf_hooks();
      println(hlog, "done");
      set_sval();

      cgi.prepare_shapes();
      prepare_tinf();
      }
    });

}
}