Arelin.fm

Arelin.Game.PlayerId : Type 
   F64

Arelin.Game.ModelId : Type 
  F64

Arelin.Game.ActionId : Type
  F64

Arelin.Game.SideId : Type
  F64

T Arelin.Game.Hitbox 
| nbox;
| cbox(rad: F64);
| pbox(pts: List(F64.V3));

T Arelin.Game.Effect 
| heal(lif: F64);
| damage(dmg: F64);
| repulse(mag: F64);
| impulse(mag: F64, dir: F64.V3);
| slow(dur: F64, val: F64);
| haste(dur: F64, val: F64);
| shield(dur: F64, val: F64);
| silence(dur: F64);
| root(dur: F64);
| stun(dur: F64);
| teleport_to(to_pos: F64.V3, all: F64); //1: everyone, 0: only team mates

T Arelin.Game.Buff 
| shielded(dur: F64, val: F64); // shields are hit before hp
| slowed(dur: F64, val: F64);
| hasted(dur: F64, val: F64);
| silenced(dur: F64);
| rooted(dur: F64);
| stunned(dur: F64);

T Arelin.Game.Hit 
| new(
  eff: List(Arelin.Game.Effect), 
  pos: F64.V3, 
  dir: F64.V3, 
  box: Arelin.Game.Hitbox);

T Arelin.Game.Light
| new(pos: F64.V3, rad: F64, rng: F64, sub: F64.V3, add: F64.V3);

T Arelin.Thing 
| new(
    fun : Arelin.Game.TxFunction,   // transaction function
    pid : Arelin.Game.PlayerId,     // number of playber controlling this
    mid : Arelin.Game.ModelId,      // id of model to be rendered
    act : Arelin.Game.ActionId,     // number of performing action
    sid : Arelin.Game.SideId,       // player side
    stt : Map(F64),                 // an arbitrary state
    nam : String,                   // name of thing
    lit : List(Arelin.Game.Light),  // list of lights to render
    tik : F64,                      // ticks passed since last act change
    pos : F64.V3,                   // in-game position
    mov : F64,                      // movement speed
    bst : F64,                      // movement speed multiplier 
    pad : F64.V3,                   // analog pad direction (len = 0 to 1)
    dir : F64.V3,                   // facing direction (len = 1)
    trg : F64.V3,                   // targeted position
    vel : F64.V3,                   // dash velocity vector
    box : Arelin.Game.Hitbox,       // hitbox (space occupied)
    wei : F64,                      // weight (affects friction)
    mhp : F64,                      // max health points
    dmg : F64,                      // damage taken
    knk : F64.V3,                   // launch direction and intensity
    buf : List(Arelin.Game.Buff),   // buffs and nerfs (status effects) applied
    chi : List(Arelin.Thing),       // children to be created on next tick
    hit : List(Arelin.Game.Hit),    // hits done by this 
    rst : Bool,                     // should this reset to idle?
    die : Bool                      // should this be removed? 
  );

Arelin.Game.TxFunction : Type
  Arelin.Thing -> Arelin.Thing 

T Arelin.Game 
| new(stage: List(Arelin.Thing));

T Arelin.Game.Input 
| sdir(dir: F64.V3); // stick direction
| key0(pos: F64.V3); // left down
| key1(pos: F64.V3); // middle down
| key2(pos: F64.V3); // right down
| key3(pos: F64.V3); // space down
| key4(pos: F64.V3); // extra down
| key5(pos: F64.V3); // shift down
| cmsg(txt: String); // chat message 

T Arelin.Game.Command
| new(pid: Arelin.Game.PlayerId, inp: Arelin.Game.Input);

Arelin.Thing.new_thing : Arelin.Thing
  Arelin.Thing.new(
    ((x) x) :: Arelin.Game.TxFunction, // fun
    F64.0,                             // pid
    F64.0,                             // mid 
    F64.0,                             // act
    F64.0,                             // sid 
    Map.new<>,                         // stt 
    List.nil<>,                        // nam
    List.nil<>,                        // lit
    F64.0,                             // tik
    F64.V3.new(F64.0,F64.0,F64.0),     // pos
    F64.parse("8"),                    // mov
    F64.1,                             // bst 
    F64.V3.new(F64.0,F64.0,F64.0),     // pad
    F64.V3.new(F64.0,F64._1,F64.0),    // dir
    F64.V3.new(F64.0,F64.0,F64.0),     // trg
    F64.V3.new(F64.0,F64.0,F64.0),     // vel
    Arelin.Game.Hitbox.nbox,           // box
    F64.1,                             // wei
    F64.parse("24"),                   // mhp
    F64.0,                             // dmg
    F64.V3.new(F64.0,F64.0,F64.0),     // knk
    List.nil<>,                        // buf
    List.nil<>,                        // chi
    List.nil<>,                        // hit
    Bool.false,                        // rst
    Bool.false)                        // die

// Getters and setters
Arelin.Thing.get_fun(thi: Arelin.Thing): Arelin.Game.TxFunction
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.fun;

Arelin.Thing.set_fun(
  thi: Arelin.Thing, 
  new_fun: Arelin.Game.TxFunction
) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | new_fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_pid(thi: Arelin.Thing): Arelin.Game.PlayerId
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.pid;

Arelin.Thing.set_pid(
  thi: Arelin.Thing, 
  new_pid: Arelin.Game.PlayerId
) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | new_pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_mid(thi: Arelin.Thing): Arelin.Game.ModelId
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.mid;

Arelin.Thing.set_mid(
  thi: Arelin.Thing, 
  new_mid: Arelin.Game.ModelId
) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | new_mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;  

Arelin.Thing.get_act(thi: Arelin.Thing): Arelin.Game.ActionId
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.act;

Arelin.Thing.set_act(
  thi: Arelin.Thing, 
  new_act: Arelin.Game.ActionId
) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | new_act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_sid(thi: Arelin.Thing): Arelin.Game.SideId
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.sid;

Arelin.Thing.set_sid(
  thi: Arelin.Thing, 
  new_sid: Arelin.Game.SideId
) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | new_sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_stt(thi: Arelin.Thing): Map(F64)
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.stt;

Arelin.Thing.set_stt(thi: Arelin.Thing, new_stt: Map(F64)) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | new_stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_nam(thi: Arelin.Thing): String
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.nam;

Arelin.Thing.set_nam(thi: Arelin.Thing, new_nam: String) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | new_nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_lit(thi: Arelin.Thing): List(Arelin.Game.Light)
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.lit;

Arelin.Thing.set_lit(
  thi: Arelin.Thing, 
  new_lit: List(Arelin.Game.Light)
  ) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | new_lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_tik(thi: Arelin.Thing): F64
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.tik;

Arelin.Thing.set_tik(thi: Arelin.Thing, new_tik: F64) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | new_tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_pos(thi: Arelin.Thing): F64.V3
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.pos;

Arelin.Thing.set_pos(thi: Arelin.Thing, new_pos: F64.V3) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | new_pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_mov(thi: Arelin.Thing): F64
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.mov;

Arelin.Thing.set_mov(thi: Arelin.Thing, new_mov: F64) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | new_mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_bst(thi: Arelin.Thing): F64
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.bst;

Arelin.Thing.set_bst(thi: Arelin.Thing, new_bst: F64) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | new_bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_pad(thi: Arelin.Thing): F64.V3
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.pad;

Arelin.Thing.set_pad(thi: Arelin.Thing, new_pad: F64.V3) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | new_pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_dir(thi: Arelin.Thing): F64.V3
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.dir;

Arelin.Thing.set_dir(thi: Arelin.Thing, new_dir: F64.V3) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | new_dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_trg(thi: Arelin.Thing): F64.V3
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.trg;

Arelin.Thing.set_trg(thi: Arelin.Thing, new_trg: F64.V3) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | new_trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_vel(thi: Arelin.Thing): F64.V3
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.vel;

Arelin.Thing.set_vel(thi: Arelin.Thing, new_vel: F64.V3) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | new_vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_box(thi: Arelin.Thing): Arelin.Game.Hitbox
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.box;

Arelin.Thing.set_box(
  thi: Arelin.Thing, 
  new_box: Arelin.Game.Hitbox
  ) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | new_box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_wei(thi: Arelin.Thing): F64
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.wei;

Arelin.Thing.set_wei(thi: Arelin.Thing, new_wei: F64): Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | new_wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_mhp(thi: Arelin.Thing): F64
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.mhp;

Arelin.Thing.set_mhp(thi: Arelin.Thing, new_mhp: F64): Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | new_mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_dmg(thi: Arelin.Thing): F64
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.dmg;

Arelin.Thing.set_dmg(thi: Arelin.Thing, new_dmg: F64): Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | new_dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_knk(thi: Arelin.Thing): F64.V3
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.knk;

Arelin.Thing.set_knk(thi: Arelin.Thing, new_knk: F64.V3): Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | new_knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_buf(thi: Arelin.Thing): List(Arelin.Game.Buff)
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.buf;

Arelin.Thing.set_buf(
  thi: Arelin.Thing, 
  new_buf: List(Arelin.Game.Buff)
  ): Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | new_buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ;

Arelin.Thing.get_chi(thi: Arelin.Thing): List(Arelin.Thing)
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.chi;

Arelin.Thing.set_chi(
  thi: Arelin.Thing, 
  new_chi: List(Arelin.Thing)
  ) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | new_chi;
    | thi.hit;
    | thi.rst;
    | thi.die;
  ; 

Arelin.Thing.get_hit(thi: Arelin.Thing): List(Arelin.Game.Hit)
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.hit; 

Arelin.Thing.set_hit(
  thi: Arelin.Thing, 
  new_hit: List(Arelin.Game.Hit)
  ) : Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | new_hit;
    | thi.rst;
    | thi.die;
  ; 

Arelin.Thing.get_rst(thi: Arelin.Thing): Bool
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.rst;

Arelin.Thing.set_rst(thi: Arelin.Thing, new_rst: Bool): Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | new_rst;
    | thi.die;
  ; 

Arelin.Thing.get_die(thi: Arelin.Thing): Bool
  case thi: 
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
  thi.die;

Arelin.Thing.set_die(thi: Arelin.Thing, new_die: Bool): Arelin.Thing
  case thi:
  | (thi.fun) (thi.pid) (thi.mid) (thi.act) (thi.sid) (thi.stt) (thi.nam) 
    (thi.lit) (thi.tik) (thi.pos) (thi.mov) (thi.bst) (thi.pad) (thi.dir) 
    (thi.trg) (thi.vel) (thi.box) (thi.wei) (thi.mhp) (thi.dmg) (thi.knk) 
    (thi.buf) (thi.chi) (thi.hit) (thi.rst) (thi.die)
    Arelin.Thing.new
    | thi.fun;
    | thi.pid;
    | thi.mid;
    | thi.act;
    | thi.sid;
    | thi.stt;
    | thi.nam;
    | thi.lit;
    | thi.tik;
    | thi.pos;
    | thi.mov;
    | thi.bst;
    | thi.pad;
    | thi.dir;
    | thi.trg;
    | thi.vel;
    | thi.box;
    | thi.wei;
    | thi.mhp;
    | thi.dmg;
    | thi.knk;
    | thi.buf;
    | thi.chi;
    | thi.hit;
    | thi.rst;
    | new_die;
  ;

Arelin.Thing.get_by_pid(
  pid: Arelin.Game.PlayerId, 
  gm: Arelin.Game
  ) : Maybe(Arelin.Thing)
  let cond = ((pid) (thi) 
    let thi.pid = Arelin.Thing.get_pid(thi)
    F64.eql(pid, thi.pid)) :: Arelin.Game.PlayerId -> Arelin.Thing -> Bool
  case gm: 
  | (stage) List.find<>(cond(pid), stage);

Arelin.Game.get_position_by_pid(
  pid : Arelin.Game.PlayerId,
  gm  : Arelin.Game
  ) : F64.V3
  case Arelin.Thing.get_by_pid(pid, gm):
  | #none# F64.V3.new(F64.0,F64.0,F64.0);
  | #some# (thi) Arelin.Thing.get_pos(thi);


Arelin.Game.map_stage(
  fn: Arelin.Game.TxFunction, 
  gm: Arelin.Game
  ) : Arelin.Game 
  get stage = gm 
  let new_stage = List.map<><>(fn)(stage)
  Arelin.Game.new(new_stage)
 
Arelin.Game.with_thing(
  pid : Arelin.Game.PlayerId,
  fn  : Arelin.Game.TxFunction,
  gm  : Arelin.Game
  ) : Arelin.Game
  let effect = ((thi)
    let thi.pid = Arelin.Thing.get_pid(thi)
    case F64.eql(thi.pid, pid):
    | #true#  fn(thi);
    | #false# thi;
  ) :: Arelin.Game.TxFunction 
  Arelin.Game.map_stage(effect, gm)

// Returns the direction the thing is looking to
Arelin.Thing.targ_dir(self: Arelin.Thing): F64.V3
  let pos = Arelin.Thing.get_pos(self)
  let trg = Arelin.Thing.get_trg(self)
  let dir = Arelin.Thing.get_dir(self)
  F64.V3.look_at(pos, trg, dir)

// Returns the position at a given distance towards targ_dir
Arelin.Thing.at_dist(self: Arelin.Thing, dist: F64): F64.V3
  let dir = Arelin.Thing.get_dir(self)
  let pos = Arelin.Thing.get_pos(self)
  F64.V3.add(pos, F64.V3.scale(dist, dir))

// Return the position within a maximum range towards targ_dir
Arelin.Thing.at_max_dist(self: Arelin.Thing, max_range: F64): F64.V3
  let pos = Arelin.Thing.get_pos(self)
  let trg = Arelin.Thing.get_trg(self)
  let dist_max = F64.V3.dist(pos, Arelin.Thing.at_dist(self, max_range))
  let dist_trg = F64.V3.dist(pos, trg)
  case F64.ltn(dist_trg, dist_max):
  | Arelin.Thing.at_dist(self, dist_trg);
  | Arelin.Thing.at_dist(self, max_range);

// Return the position within a mininum range towards targ_dir
Arelin.Thing.at_min_dist(self: Arelin.Thing, min_range: F64): F64.V3
  let pos = Arelin.Thing.get_pos(self)
  let trg = Arelin.Thing.get_trg(self)
  let dist_min = F64.V3.dist(pos, Arelin.Thing.at_dist(self, min_range))
  let dist_trg = F64.V3.dist(pos, trg)
  case F64.gtn(dist_trg, dist_min):
  | Arelin.Thing.at_dist(self, dist_trg);
  | Arelin.Thing.at_dist(self, min_range);

// Return the position within a mininum and maximun range towards look_dir
Arelin.Thing.between_dist(
  self: Arelin.Thing, 
  min_range: F64, 
  max_range: F64
  ) : F64.V3   
  let pos      = Arelin.Thing.get_pos(self)
  let trg      = Arelin.Thing.get_trg(self)
  let dist_trg = F64.V3.dist(pos, trg) 
  Arelin.Thing.at_dist(self, F64.max(min_range, F64.min(max_range, dist_trg)))

// Sets a thing's act
Arelin.Thing.init_act(
  self: Arelin.Thing, 
  new_act: F64, 
  new_trg: F64.V3
  ) : Arelin.Thing
  let act = Arelin.Thing.get_act(self)
  let trg = Arelin.Thing.get_trg(self)
  let tik = Arelin.Thing.get_tik(self) 
  let act = 
    case F64.eql(act, F64.0):
    | new_act;
    | act;

  let trg = 
    case F64.eql(act, F64.0):
    | new_trg;
    | trg;

  let tik = 
    case F64.eql(act, F64.0):
    | F64.0;
    | tik;

  let self = Arelin.Thing.set_act(self, act)
  let self = Arelin.Thing.set_trg(self, trg)
  let self = Arelin.Thing.set_tik(self, tik)
  self 

// Is this thing walking?
Arelin.Thing.is_walking(self: Arelin.Thing): Bool
  let this.pad = Arelin.Thing.get_pad(self)
  F64.gtn(F64.V3.len(this.pad), F64.0)

// Spawns another thing
// - self: thing that will create another thing
// - at_tik: number of the tik when thing will be created
// - at_pos: position on which thing will be created
// - thing: thing that will be created
Arelin.Thing.create_at(
  self      : Arelin.Thing,
  at_tik    : F64,
  new_thing : Arelin.Game.TxFunction 
  ) : Arelin.Thing
  let self.tik = Arelin.Thing.get_tik(self)
  case F64.eql(self.tik, at_tik):
  | let self.pid = Arelin.Thing.get_pid(self)
    let self.pos = Arelin.Thing.get_pos(self)
    let self = Arelin.Thing.set_fun(self, new_thing)
    let self = Arelin.Thing.set_pid(self, self.pid)
    let self = Arelin.Thing.set_pos(self, self.pos)
    self;
  | self;


// Resets to a given tick
Arelin.Thing.reset(self: Arelin.Thing, at_tik: F64): Arelin.Thing
  let curr_tik = Arelin.Thing.get_tik(self)
  case F64.gtn(curr_tik, F64.sub(at_tik, F64.1)):
  | #true#  Arelin.Thing.set_rst(self, Bool.true);
  | #false# self;

// Dies at a given tick
Arelin.Thing.die(self: Arelin.Thing, at_tik: F64): Arelin.Thing
  let curr_tik = Arelin.Thing.get_tik(self)
  case F64.gtn(curr_tik, F64.sub(at_tik, F64.1)):
  | #true#  Arelin.Thing.set_die(self, Bool.true);
  | #false# self;

// Performs an animation, reseting to idle when it ends
// - self: thing to be animated
// - boost: speed multiplier (0 = no move, 1 = normal spd)
// - model: id of the first model of the animation
// - count: total count of models on the animation
// - from: frame to start animating
// - til: last frame to animate
Arelin.Thing.animate_between(
  self  : Arelin.Thing,
  boost : F64,
  model : F64,
  count : F64,
  from  : F64,
  til   : F64
  ) : Arelin.Thing
  let self.tik = Arelin.Thing.get_tik(self)
  let self.pad = Arelin.Thing.get_pad(self)
  let self.act = Arelin.Thing.get_act(self)
  let self.dir = Arelin.Thing.get_dir(self)
  case F64.is_between(from,til, self.tik):
  | #true#   
    let pad_len = F64.V3.len(self.pad)
    let new_dir =  
      case Bool.and(F64.gtn(self.act, F64.0), F64.eql(pad_len, F64.0)):
      | Arelin.Thing.targ_dir(self); 
      | case F64.gtn(pad_len, F64.0):
        | F64.V3.norm(self.pad);
        | self.dir;;
    
    let new_mid = 
      let duration = F64.sub(til, from)
      let curr_tik = F64.sub(self.tik, from)
      let curr_tim = F64.div(curr_tik, duration)
      F64.add(model, F64.mod(F64.floor(F64.mul(curr_tim, count)), count))
    
    let self = Arelin.Thing.set_bst(self, boost)
    let self = Arelin.Thing.set_dir(self, new_dir)
    let self = Arelin.Thing.set_mid(self, new_mid)
    self;
  | #false#  self;

// Performs an animation, reseting to idle when it ends
// - self: thing to be animated
// - boost: speed multiplier (0 = no move, 1 = normal spd)
// - model: id of the first model of the animation
// - count: total count of models on the animation
// - durat: duration of the animation
Arelin.Thing.animate(
  self  : Arelin.Thing,
  boost : F64,
  model : F64,
  count : F64,
  durat : F64
  ) : Arelin.Thing
  let self = Arelin.Thing.animate_between(self,boost,model,count,F64.0,durat)
  let self = Arelin.Thing.reset(self, F64.sub(durat, F64.1))
  self 

// Performs an animation, dying when it ends
// - self: thing to be animated
// - boost: speed multiplier (0 = no move, 1 = normal spd)
// - model: id of the first model of the animation
// - count: total count of models on the animation
// - durat: duration of the animation
Arelin.Thing.animate_die(
  self : Arelin.Thing,
  boost : F64,
  model : F64,
  count : F64,
  durat : F64
  ) : Arelin.Thing
  let self = Arelin.Thing.animate_between(self,boost,model,count,F64.0,durat)
  let self = Arelin.Thing.die(self, F64.sub(durat, F64.1))
  self
  

// Avoid problems with "ghost frame after blink"
// - self: thing to be animated
// - boost: speed multiplier (0 = no move, 1 = normal spd)
// - model_atk: id of the main model of the animation
// - model_idle: idle000 of the character
// - count: total count of models on the animation
// - from: frame to start animating
// - til: last frame to animate
Arelin.Thing.animate_with_blink(
  self       : Arelin.Thing,
  boost      : F64,
  model_atk  : F64,
  model_idle : F64,
  count      : F64,
  from       : F64,
  til        : F64
  ) : Arelin.Thing
  let self = Arelin.Thing.animate_between(self,boost,model_atk,count,from,til)
  let self = 
    Arelin.Thing.animate_between(self,boost,model_idle)
    | F64.1;
    | til;
    | F64.add(til,F64.1);

  let self = Arelin.Thing.reset(self, til)
  self 

// Performs a dash between certain frames
// - self: thing that will dash
// - speed: dash speed in voxels/frame
// - from_tik: number of the tik it will start the dash
// - til_tik: number of the tik it will stop the dash
Arelin.Thing.dash(
  self     : Arelin.Thing,
  speed    : F64,
  from_tik : F64,
  til_tik  : F64
  ) : Arelin.Thing
  case Arelin.Thing.is_rooted(self):
  | self;
  | let self.tik = Arelin.Thing.get_tik(self) 
    let self.pos = Arelin.Thing.get_pos(self)
    let self.trg = Arelin.Thing.get_trg(self)
    let self.dir = Arelin.Thing.get_dir(self)
    let new_vel  = 
      case F64.is_between(from_tik, til_tik, self.tik):
      | F64.V3.scale(speed, F64.V3.look_at(self.pos, self.trg, self.dir));
      | F64.V3.new(F64.0, F64.0, F64.0);

    Arelin.Thing.set_vel(self, new_vel);
  
Arelin.Thing.move(self: Arelin.Thing, to_pos: F64.V3): Arelin.Thing
  Arelin.Thing.set_pos(self, to_pos)

// Blinks (teleports) to another position
// - self: thing that will blink
// - at_tik: number of the tik on which the blink happens
// - to_pos: position where the thing will blink to
Arelin.Thing.blink(
  self: Arelin.Thing, 
  at_tik: F64, 
  to_pos: F64.V3
  ) : Arelin.Thing
  case Arelin.Thing.is_rooted(self):
  | self;
  | case F64.eql(at_tik, Arelin.Thing.get_tik(self)):
    | Arelin.Thing.set_pos(self, to_pos);
    | self;;

Arelin.Thing.cast(
  self   : Arelin.Thing,
  at_tik : F64,
  do_hit : List(Arelin.Game.Hit)
  ) : Arelin.Thing
  let self.tik = Arelin.Thing.get_tik(self)
  case F64.eql(self.tik, at_tik):
  | Arelin.Thing.set_hit(self, do_hit); 
  | self;

// Spawns another thing
// - self: thing that will create another thing
// - at_tik: number of the tik when thing will be created
// - at_pos: position on which thing will be created
// - thing: thing that will be created
Arelin.Thing.spawn(
  self: Arelin.Thing, 
  at_tik: F64, 
  children: List(Arelin.Thing)
  ) : Arelin.Thing
  case F64.eql(Arelin.Thing.get_tik(self), at_tik):
  | Arelin.Thing.set_chi(self, children);
  | self;

// Creates lights at given tick
Arelin.Thing.illumine(
  self     : Arelin.Thing,
  from_tik : F64,
  to_tik   : F64,
  lights   : List(Arelin.Game.Light) 
) : Arelin.Thing
  case F64.is_between(from_tik, to_tik, Arelin.Thing.get_tik(self)):
  | Arelin.Thing.set_lit(self, lights);
  | Arelin.Thing.set_lit(self, List.nil<>); 


Arelin.Game.combine_mov_buffs(buff: Arelin.Game.Buff, i: F64): F64
  case buff:
  | #shielded# (buff.dur) (buff.val) i;
  | #slowed#   (buff.dur) (buff.val) F64.mul(i)(buff.val);
  | #hasted#   (buff.dur) (buff.val) F64.mul(i)(buff.val);
  | #silenced# (buff.dur)            i;
  | #rooted#   (buff.dur)            F64.0;
  | #stuned#   (buff.dur)            F64.0;

Arelin.Thing.speed_multiplier_of(self: Arelin.Thing): F64
  let self.bst = Arelin.Thing.get_bst(self)
  let self.buf = Arelin.Thing.get_buf(self) 
  List.fold<><>(self.bst, Arelin.Game.combine_mov_buffs, self.buf)

Arelin.Thing.is_silenced(self: Arelin.Thing): Bool
  let self.buf = Arelin.Thing.get_buf(self)
  let is_silence_buff = ((buff) 
    case buff:
    | #shielded# (buff.dur) (buff.val) Bool.false;
    | #slowed#   (buff.dur) (buff.val) Bool.false; 
    | #hasted#   (buff.dur) (buff.val) Bool.false;
    | #silenced# (buff.dur)            Bool.true;
    | #rooted#   (buff.dur)            Bool.false;
    | #stunned#  (buff.dur)            Bool.true;
  ) :: Arelin.Game.Buff -> Bool
  case List.find<>(is_silence_buff, self.buf):
  | #none# Bool.false;
  | (some) Bool.true;

Arelin.Thing.is_stunned(self: Arelin.Thing): Bool
  let self.buf = Arelin.Thing.get_buf(self)
  let is_stun_buff = ((buff) 
    case buff:
    | #shielded# (buff.dur) (buff.val) Bool.false;
    | #slowed#   (buff.dur) (buff.val) Bool.false; 
    | #hasted#   (buff.dur) (buff.val) Bool.false;
    | #silenced# (buff.dur)            Bool.false;
    | #rooted#   (buff.dur)            Bool.false;
    | #stunned#  (buff.dur)            Bool.true;
  ) :: Arelin.Game.Buff -> Bool
  case List.find<>(is_stun_buff, self.buf):
  | #none# Bool.false;
  | (some) Bool.true;

Arelin.Thing.is_rooted(self: Arelin.Thing): Bool
  let self.buf = Arelin.Thing.get_buf(self)
  let is_root_buff = ((buff) 
    case buff:
    | #shielded# (buff.dur) (buff.val) Bool.false;
    | #slowed#   (buff.dur) (buff.val) Bool.false; 
    | #hasted#   (buff.dur) (buff.val) Bool.false;
    | #silenced# (buff.dur)            Bool.false;
    | #rooted#   (buff.dur)            Bool.true;
    | #stunned#  (buff.dur)            Bool.true;
  ) :: Arelin.Game.Buff -> Bool
  case List.find<>(is_root_buff, self.buf):
  | #none# Bool.false;
  | (some) Bool.true;

Arelin.Thing.has_shield(self: Arelin.Thing): Bool
  let self.buf = Arelin.Thing.get_buf(self)
  let is_shield_buff = ((buff) 
    case buff:
    | #shielded# (buff.dur) (buff.val) Bool.true;
    | #slowed#   (buff.dur) (buff.val) Bool.false; 
    | #hasted#   (buff.dur) (buff.val) Bool.false;
    | #silenced# (buff.dur)            Bool.false;
    | #rooted#   (buff.dur)            Bool.false;
    | #stunned#  (buff.dur)            Bool.false;
  ) :: Arelin.Game.Buff -> Bool
  case List.find<>(is_shield_buff, self.buf):
  | #none# Bool.false;
  | (some) Bool.true;

Arelin.Game.use_shields(
  buff : Arelin.Game.Buff,
  acc  : Pair(F64, List(Arelin.Game.Buff))
  ) : Pair(F64, List(Arelin.Game.Buff))
  let curr_dmg = Pair.fst<><>(acc)
  let curr_buf = Pair.snd<><>(acc)
  case buff:
  | #shielded# (buff.dur) (buff.val) 
    case F64.eql(curr_dmg, F64.0):
    | acc;
    | case F64.compare_numbers(curr_dmg, buff.val):
      | #LT# 
        let remaining_shield = F64.sub(buff.val, curr_dmg)
        let remaining_buf    = 
          List.cons<>
          | Arelin.Game.Buff.shielded(buff.dur, remaining_shield);
          | curr_buf;
        
        Pair.new<><>(F64.0, remaining_buf);

      | #EQ# Pair.new<><>(F64.0, curr_buf);
      | #GT#
        let remaining_dmg = F64.sub(curr_dmg, buff.val)
        Pair.new<><>(remaining_dmg, curr_buf);
    ;
  ;
  | #slowed#   (buff.dur) (buff.val) 
    Pair.new<><>(curr_dmg, List.cons<>(buff, curr_buf))
  ; 
  | #hasted#   (buff.dur) (buff.val) 
    Pair.new<><>(curr_dmg, List.cons<>(buff, curr_buf))
  ;
  | #silenced# (buff.dur)   
    Pair.new<><>(curr_dmg, List.cons<>(buff, curr_buf))
  ;
  | #rooted#   (buff.dur)            
    Pair.new<><>(curr_dmg, List.cons<>(buff, curr_buf))
  ;
  | #stunned#  (buff.dur)            
    Pair.new<><>(curr_dmg, List.cons<>(buff, curr_buf))
  ;

Arelin.Thing.handle_shields(hit_dmg: F64, self: Arelin.Thing): Arelin.Thing
  let self.buf      = Arelin.Thing.get_buf(self)
  let self.dmg      = Arelin.Thing.get_dmg(self)
  let init_val      = Pair.new<><>(hit_dmg, List.nil<>)
  let res           = List.fold<><>(init_val, Arelin.Game.use_shields, self.buf)
  let remaining_dmg = F64.add(Pair.fst<><>(res), self.dmg)
  let remaining_buf = Pair.snd<><>(res)
  let self          = Arelin.Thing.set_dmg(self, remaining_dmg)
  let self          = Arelin.Thing.set_buf(self, remaining_buf)
  self 

Arelin.Thing.update_buff_dur(self: Arelin.Thing): Arelin.Thing
  let self.buf = Arelin.Thing.get_buf(self)
  let fn = ((buff) (acc) 
    case buff:
    | #shielded# (buff.dur) (buff.val) 
      case F64.eql(buff.dur, F64.0):
      | acc;
      | List.cons<>
        | Arelin.Game.Buff.shielded(F64.sub(buff.dur, F64.1), buff.val); 
        | acc;
      ;  
    ;
    | #slowed#   (buff.dur) (buff.val) 
      case F64.eql(buff.dur, F64.0):
      | acc;
      | List.cons<>
        | Arelin.Game.Buff.slowed(F64.sub(buff.dur, F64.1), buff.val);
        | acc;
      ;
    ; 
    | #hasted#   (buff.dur) (buff.val) 
      case F64.eql(buff.dur, F64.0):
      | acc;
      | List.cons<>
        | Arelin.Game.Buff.hasted(F64.sub(buff.dur, F64.1), buff.val);
        | acc;
      ;
    ;
    | #silenced# (buff.dur)            
      case F64.eql(buff.dur, F64.0):
      | acc;
      | List.cons<>
        | Arelin.Game.Buff.silenced(F64.sub(buff.dur, F64.1));
        | acc;
      ;
    ;
    | #rooted#   (buff.dur)            
      case F64.eql(buff.dur, F64.0):
      | acc;
      | List.cons<>
        | Arelin.Game.Buff.rooted(F64.sub(buff.dur, F64.1));
        | acc;
      ;
    ;
    | #stunned#  (buff.dur)           
      case F64.eql(buff.dur, F64.0):
      | acc;
      | List.cons<>
        | Arelin.Game.Buff.stunned(F64.sub(buff.dur, F64.1));
        | acc;
      ;
    ;
  ) :: Arelin.Game.Buff -> List(Arelin.Game.Buff) -> List(Arelin.Game.Buff)
  let new_buf = List.fold<><>(List.nil<>, fn, self.buf)
  Arelin.Thing.set_buf(self, new_buf)
  


// Ends an animation/transformation/thing after some ticks
// - self: thing that will end after a while
// - tx: the new animation to use when it ends
// - after_tiks: numbers of ticks passed until the end
// - stt_key: the key in the stt map
Arelin.Thing.end_thing(
  self       : Arelin.Thing,
  tx         : Arelin.Game.TxFunction,
  after_tiks : F64,
  stt_key    : Bits 
  ) : Arelin.Thing
  let self.stt    = Arelin.Thing.get_stt(self)
  let current_tik = Map.get<>(stt_key, self.stt)
  let empty_stt   = Map.set<>(stt_key, after_tiks, self.stt)
  case current_tik:
  | #none# Arelin.Thing.set_stt(self, empty_stt);
  | #some# (current_tik.value) 
    case F64.eql(current_tik.value, F64.0):
    | let self.pid = Arelin.Thing.get_pid(self)
      let self.pos = Arelin.Thing.get_pos(self)
      let self     = Arelin.Thing.set_fun(self, tx)
      let self     = Arelin.Thing.set_pid(self, self.pid)
      let self     = Arelin.Thing.set_pos(self, self.pos)
      let self     = Arelin.Thing.set_stt(self, empty_stt)
      self;  
    
    | let new_stt = 
        Map.set<>
        | stt_key;
        | case F64.gtn(current_tik.value, F64.0):
          | F64.sub(current_tik.value, F64.1);
          | F64.0;;
        | self.stt;
      Arelin.Thing.set_stt(self, new_stt);; 

Arelin.Thing.get_stt_value(self: Arelin.Thing, stt_key: Bits): F64
  let stt = Arelin.Thing.get_stt(self)
  case Map.get<>(stt_key, stt):
  | #none# F64.0;
  | #some# (value) value;

// this should be renamed
Arelin.POS_X_KEY : Bits
  // 01011101b
  (Bits.0(Bits.0(Bits.0(Bits.1(Bits.1(Bits.1(Bits.0(Bits.1(Bits.nil)))))))))
Arelin.POS_Y_KEY : Bits
  // 01110101b
  (Bits.0(Bits.1(Bits.1(Bits.1(Bits.0(Bits.1(Bits.0(Bits.1(Bits.nil)))))))))

Arelin.Thing.get_stt_value_v3(self: Arelin.Thing): F64.V3
  let x = Arelin.Thing.get_stt_value(self, Arelin.POS_X_KEY)
  let y = Arelin.Thing.get_stt_value(self, Arelin.POS_Y_KEY)
  // let z = Arelin.Thing.get_stt_value(self, Arelin.POS_Z_KEY)
  F64.V3.new(x,y,F64.0) 

Arelin.Thing.set_stt_value_v3(self: Arelin.Thing, v3: F64.V3): Arelin.Thing
  let self.stt = Arelin.Thing.get_stt(self)
  case v3:
  | (v3.x) (v3.y) (v3.z)
    let insert_x = Map.set<>(Arelin.POS_X_KEY, v3.x, self.stt)
    let insert_y = Map.set<>(Arelin.POS_Y_KEY, v3.x, self.stt)
    let self     = Arelin.Thing.set_stt(self, insert_x)
    let self     = Arelin.Thing.set_stt(self, insert_y)
    self 
  ;

Arelin.Thing.is_using_buff(self: Arelin.Thing, stt_key: Bits): Bool
  let stt = Arelin.Thing.get_stt(self)
  case Map.get<>(stt_key, stt):
  | #none# Bool.false;
  | #some# (current_tik)
    case F64.eql(current_tik, F64.0):
    | Bool.false;
    | Bool.true;;

Arelin.Thing.map_stt_key(
  self    : Arelin.Thing,
  stt_key : Bits,
  fn      : F64 -> F64
  ) : Arelin.Thing
  let stt = Arelin.Thing.get_stt(self)
  case Map.get<>(stt_key, stt):
  | #none# 
    Arelin.Thing.set_stt
    | self;
    | Map.set<>(stt_key, F64.0, stt);;
  | #some# (value)
    Arelin.Thing.set_stt 
    | self;
    | Map.set<>(stt_key, fn(value), stt);;

 

// Update a stt_key until the value associated to it ends. Used along with will_set_buff
// - self: thing with stt (usually character)
// - stt_key: the key in the stt map
Arelin.Thing.update_buff(self: Arelin.Thing, stt_key: Bits): Arelin.Thing
  let stt = Arelin.Thing.get_stt(self)
  case Map.get<>(stt_key, stt):
  | #none# self;
  | #some# (value)
    case F64.eql(value, F64.0):
    | let new_tik = F64.sub(value, F64.1)
      let new_stt = Map.set<>(stt_key, new_tik, stt)
      Arelin.Thing.set_stt(self, new_stt);
    | self;;



Arelin.exec_command(cmd: Arelin.Game.Command, gm: Arelin.Game): Arelin.Game
  case cmd:
  | (cmd.pid) (cmd.inp)
    let fn = ((this)
      let silenced = Arelin.Thing.is_silenced(this)
      let stunned  = Arelin.Thing.is_stunned(this)
      case stunned:
      | #true# 
        case cmd.inp:
        | #sdir# (dir) Arelin.Thing.init_act(this, F64.0, dir); 
        | #key0# (pos) this; 
        | #key1# (pos) this; 
        | #key2# (pos) this; 
        | #key3# (pos) this; 
        | #key4# (pos) this; 
        | #key5# (pos) this; 
        | #cmsg# (txt) this;
      ;
      | #false#
        case silenced:
        | #true#
          case cmd.inp:
          | #sdir# (dir) Arelin.Thing.set_pad(this, dir); 
          | #key0# (pos) this; 
          | #key1# (pos) this; 
          | #key2# (pos) this; 
          | #key3# (pos) this; 
          | #key4# (pos) this; 
          | #key5# (pos) this; 
          | #cmsg# (txt) this;
        ;          
        | #false#
          case cmd.inp:
          | #sdir# (dir) Arelin.Thing.set_pad(this, dir); 
          | #key0# (pos) Arelin.Thing.init_act(this,          F64.1, pos); 
          | #key1# (pos) Arelin.Thing.init_act(this, F64.parse("2"), pos); 
          | #key2# (pos) Arelin.Thing.init_act(this, F64.parse("3"), pos); 
          | #key3# (pos) Arelin.Thing.init_act(this, F64.parse("4"), pos); 
          | #key4# (pos) Arelin.Thing.init_act(this, F64.parse("5"), pos); 
          | #key5# (pos) Arelin.Thing.init_act(this, F64.parse("6"), pos); 
          | #cmsg# (txt) this;
        ;
      ;
    ) :: Arelin.Game.TxFunction 
    Arelin.Game.with_thing(cmd.pid, fn, gm);

// Checks if two boxes collide, returns outwards vector
Arelin.collide_with(
  a_pos : F64.V3,
  a_dir : F64.V3,
  a_box : Arelin.Game.Hitbox,
  b_pos : F64.V3,
  b_dir : F64.V3,
  b_box : Arelin.Game.Hitbox
) : Maybe(F64.V3)
  case a_box:
  | #nbox# Maybe.none<>;
  | #cbox# (a_box.rad)
    case b_box:
    | #nbox# Maybe.none<>;
    | #cbox# (b_box.rad)
      let dst = F64.V3.dist(a_pos, b_pos)
      let rad = F64.add(a_box.rad, b_box.rad)
      case Bool.and(F64.gtn(dst, F64.0), F64.ltn(dst, rad)):
      | let out_dir = F64.V3.norm(F64.V3.sub(a_pos, b_pos))
        let out_vec = F64.V3.scale(F64.sub(rad, dst), out_dir)
        Maybe.some<>(out_vec);
      | Maybe.none<>;;
    | #pbox# (b_box.pts)
      let nil = Maybe.none<>
      let cons = ((segment) (result)
        case result:
        | #none# 
          case segment:
          | (segment.a) (segment.b)
            let dst = F64.V3.point_segment_dist(a_pos, segment)
            let rad = a_box.rad 
            case F64.ltn(dst, rad):
            | #true#
              let out_dir = 
                F64.V3.rot_90(F64.V3.norm(F64.V3.sub(segment.a, segment.b)))
              let out_vec = F64.V3.scale(F64.sub(rad, dst), out_dir) 
              Maybe.some<>(out_vec);
            | #false# Maybe.none<>;;
          ;
        | #some# (value) Maybe.some<>(value); 
      ) :: F64.Segment -> Maybe(F64.V3) -> Maybe(F64.V3)
      let segs = F64.V3.polygon_to_segments(b_pos, b_dir, b_box.pts)
      List.fold<><>(nil,cons,segs);;
  | #pbox# (a_box.pts)
    //TODO
    Maybe.none<>
  ;

// Interaction function between two things
Arelin.interact_with(this: Arelin.Thing, that: Arelin.Thing): Arelin.Thing
  // Physical interactions
  let this.pos = Arelin.Thing.get_pos(this)
  let this.dir = Arelin.Thing.get_dir(this)
  let this.box = Arelin.Thing.get_box(this)
  let this.buf = Arelin.Thing.get_buf(this)
  let this.sid = Arelin.Thing.get_sid(this)
  let that.pos = Arelin.Thing.get_pos(that)
  let that.dir = Arelin.Thing.get_dir(that)
  let that.box = Arelin.Thing.get_box(that)
  let that.hit = Arelin.Thing.get_hit(that)
  let that.sid = Arelin.Thing.get_sid(this)
  let out_vec  = 
    Arelin.collide_with
    |this.pos;
    |this.dir;
    |this.box;
    |that.pos;
    |that.dir;
    |that.box;
  let this = 
    case out_vec:
    | #none# this;           
    | #some# (out_vec.value)  
      let new_pos = F64.V3.add(this.pos, out_vec.value)
      Arelin.Thing.set_pos(this, new_pos);
  let this = 
    // Hit by an effect
    let apply_hit = ((hit) (this)
      case hit:
      | (hit.eff) (hit.pos) (hit.dir) (hit.box)
        let out_vec = 
          Arelin.collide_with  
          |this.pos;
          |this.dir;
          |this.box;
          |hit.pos;
          |hit.dir;
          |hit.box;

        case out_vec:
        | #none# this;
        | #some# (value)
          let compare_sid = F64.eql(this.sid, that.sid) 
          let apply_eff   = ((eff) (this)
            case eff:
            | #heal# (eff.lif)
              let this.dmg = Arelin.Thing.get_dmg(this)
              // IMPORTANT: use commented code. 
              // The code is inverted so the puddle on debug mode could heal
              case compare_sid:
              | #true#   this;
              | #false#  Arelin.Thing.set_dmg(this, F64.sub(this.dmg, eff.lif));;
  
            | #damage# (eff.dmg)
              case compare_sid:
              | #true#   this;
              | #false#  Arelin.Thing.handle_shields(eff.dmg, this);;

            | #repulse# (eff.mag)
              case compare_sid:
              | #true#   this;
              | #false#  
                let v3  = F64.V3.new(F64.1, F64.0, F64.0)
                let dir = F64.V3.look_at(hit.pos, this.pos, v3)
                let vec = F64.V3.scale(eff.mag, dir)
                Arelin.Thing.set_knk(this, vec);;
 
          
            | #impulse# (eff.mag) (eff.dir)
              case compare_sid:
              | #true#   this;
              | #false#  
                let vec = F64.V3.scale(eff.mag, eff.dir)
                Arelin.Thing.set_knk(this, vec);;

            | #slow# (eff.dur) (eff.val)  
              case compare_sid:
              | #true#   this;
              | #false#  
                let updated_buffs = 
                  List.cons<>
                  | Arelin.Game.Buff.slowed(eff.dur, eff.val);
                  | this.buf;
                
                Arelin.Thing.set_buf(this, updated_buffs);;
            
            | #haste# (eff.dur) (eff.val)  
              case compare_sid:
              | #true#   this;
              | #false#  
                let updated_buffs = 
                  List.cons<>
                  | Arelin.Game.Buff.hasted(eff.dur, eff.val);
                  | this.buf;
                
                Arelin.Thing.set_buf(this, updated_buffs);;


            | #shield# (eff.dur) (eff.val)  
              case compare_sid:
              | #true#   this;
              | #false#  
                let updated_buffs = 
                  List.cons<>
                  | Arelin.Game.Buff.shielded(eff.dur, eff.val);
                  | this.buf;
                
                Arelin.Thing.set_buf(this, updated_buffs);;


            | #silence# (eff.dur)
              case compare_sid:
              | #true#   this;
              | #false#  
                let updated_buffs = 
                  List.cons<>
                  | Arelin.Game.Buff.silenced(eff.dur);
                  | this.buf;
                
                Arelin.Thing.set_buf(this, updated_buffs);;

            | #root# (eff.dur)
              case compare_sid:
              | #true#   this;
              | #false#  
                let updated_buffs = 
                  List.cons<>
                  | Arelin.Game.Buff.rooted(eff.dur);
                  | this.buf;
                
                Arelin.Thing.set_buf(this, updated_buffs);;

            | #stun# (eff.dur)
              case compare_sid:
              | #true#   this;
              | #false#  
                let updated_buffs = 
                  List.cons<>
                  | Arelin.Game.Buff.stunned(eff.dur);
                  | this.buf;
                
                Arelin.Thing.set_buf(this, updated_buffs);;

            | #teleport_to# (eff.to_pos) (eff.all)
              case F64.eql(eff.all, F64.1):
              | Arelin.Thing.move(this, eff.to_pos);
              | this;;
        ) :: Arelin.Game.Effect -> Arelin.Thing -> Arelin.Thing
       List.fold<><>(this, apply_eff, hit.eff);;
    ) :: Arelin.Game.Hit -> Arelin.Thing -> Arelin.Thing 
    List.fold<><>(this, apply_hit, that.hit)
  this  

    
// Like a fold, but with access to a list of other elements
Arelin.fold_with_context
  : <A : Type>                  -> 
    <B : Type>                  ->
    (i : B)                     ->
    (f: A -> List(A) -> B -> B) ->
    (xs : List(A))              -> 
    (ys : List(A) -> List(A))   ->
    B 
  <A> <B> (i) (f) (xs) (ys)
  xs<() B>
  | i;
  | (xs.head) (xs.tail)
    let ys2 = ((x) ys(List.cons<A>(xs.head)(xs))) :: List(A) -> List(A)
    let rest = Arelin.fold_with_context<A><B>(i)(f)(xs.tail)(ys2)
    f(xs.head)(ys(xs.tail))(rest);



Arelin.exec_turn(gm: Arelin.Game): Arelin.Game
  // Interaction function
  let intr = ((that) (this) Arelin.interact_with(this, that)) 
  :: Arelin.Thing -> Arelin.Thing -> Arelin.Thing 
  
  // For each thing in the game...
  let tick = ((this) (others) (res)
    
    // Removes past hits
    let this = Arelin.Thing.set_hit(this, List.nil<>)

    // Resets   
    let rst = Arelin.Thing.get_rst(this)
    let this = 
      case rst:
      | #true#
        let new_vel = F64.V3.new(F64.0,F64.0,F64.0)
        let new_bst = F64.1
        let new_box = Arelin.Game.Hitbox.cbox(F64.mul(F64.parse("3"), F64.parse("4")))
        let new_act = F64.0
        let new_tik = F64.0
        let new_lit = List.nil<Arelin.Game.Light>
        let new_rst = Bool.false 
        let this = Arelin.Thing.set_vel(this, new_vel)
        let this = Arelin.Thing.set_bst(this, new_bst)
        let this = Arelin.Thing.set_box(this, new_box)
        let this = Arelin.Thing.set_act(this, new_act)
        let this = Arelin.Thing.set_tik(this, new_tik)
        let this = Arelin.Thing.set_lit(this, new_lit)
        let this = Arelin.Thing.set_rst(this, new_rst)
        this;
      | #false# this;  

    // Integrates position with walk vector
    let boost = Arelin.Thing.speed_multiplier_of(this)
    let pos   = Arelin.Thing.get_pos(this)
    let mov   = Arelin.Thing.get_mov(this)
    let pad   = Arelin.Thing.get_pad(this)
    let this  = 
      Arelin.Thing.set_pos 
      |this;
      |F64.V3.add(pos, F64.V3.scale(F64.mul(mov, boost), pad));

    // Decreases duration of all buffs, removes from list if dur=0
    let this = Arelin.Thing.update_buff_dur(this)

    // Integrates position with knockback
    let pos = Arelin.Thing.get_pos(this)
    let knk = Arelin.Thing.get_knk(this)
    let wei = Arelin.Thing.get_wei(this)
    let new_pos = F64.V3.add(pos, knk)
    let knk_len = F64.V3.len(knk)
    let new_knk = 
      case F64.gtn(knk_len, F64.0):
      | #true#
        let force = F64.max(F64.sub(knk_len, wei), F64.0)
        F64.V3.scale(force, F64.V3.norm(knk));

      | #false# knk;
    let this = Arelin.Thing.set_pos(this)(new_pos)
    let this = Arelin.Thing.set_knk(this)(new_knk)

    // Calls the transaction function
    let fun = Arelin.Thing.get_fun(this)
    let this = fun(this)

    // Calls the interaction function with all other things
    let this = List.fold<><>(this, intr, others)

    // Increments tik counter
    let tik  = Arelin.Thing.get_tik(this)
    let this = Arelin.Thing.set_tik(this, F64.add(tik, F64.1))

    // Spawns children
    let this_chi = Arelin.Thing.get_chi(this)
    let chi_init = ((chi) 
      Arelin.Thing.get_fun(chi)(chi)
    ) :: Arelin.Thing -> Arelin.Thing
    let chi_list = List.map<><>(chi_init, this_chi)
    let this = Arelin.Thing.set_chi(this, List.nil<>)

    // Keeps inside map
    let this_pos = Arelin.Thing.get_pos(this)
    let pos_x = F64.V3.get_z(this_pos)
    let pos_y = F64.V3.get_y(this_pos)
    let pos_z = F64.V3.get_z(this_pos)
    let new_x = F64.min(F64.max(F64.parse("-256"))(pos_x))(F64.parse("256"))
    let new_y = F64.min(F64.max(F64.parse("-160"))(pos_y))(F64.parse("160"))
    let new_z = F64.min(F64.max(F64.0)(pos_z))(F64.parse("256"))
    let this  = Arelin.Thing.set_pos(this, F64.V3.new(new_x, new_y, new_z))

    // Bounds HP
    let dmg = Arelin.Thing.get_dmg(this)
    let mhp = Arelin.Thing.get_mhp(this)
    let new_dmg = F64.max(F64.0, F64.min(mhp, dmg))
    let this = Arelin.Thing.set_dmg(this)(new_dmg)

    // Dies when 0 is 0
    let sid = Arelin.Thing.get_sid(this)
    let dmg = Arelin.Thing.get_dmg(this)
    let mhp = Arelin.Thing.get_mhp(this)
    let no_hp = Bool.false
      // Bool.and(F64.gtn(sid)(F64.0))(F64.gte(dmg)(mhp))

    let die = Arelin.Thing.get_die(this)
    let xs = 
      case Bool.or(die, no_hp): 
      | #true#   res;
      | #false#  List.cons<>(this, res);

    List.concat<>(chi_list, xs)

  ) :: Arelin.Thing -> 
       List(Arelin.Thing) ->
       List(Arelin.Thing) ->
       List(Arelin.Thing)

  let things_id = ((x) x) :: List(Arelin.Thing) -> List(Arelin.Thing)
  get stage     = gm
  let stage_nil = List.nil<>
  let new_stage = Arelin.fold_with_context<><>(stage_nil, tick, stage, things_id)

  Arelin.Game.new(new_stage)