void Scorpion::evSendReliable(od::StreamData& s)
{
    // 1-9 bytes message
    _prev_snap = _snap;

    const unsigned ChunkWid = 128*16;
    auto x = unsigned(std::max(0.f, std::roundf(pos.x)));
    auto y = unsigned(std::max(0.f, std::roundf(pos.y)));
    NetChunkCell chunk(ChunkCell(x/ChunkWid, y/ChunkWid));
    x %= ChunkWid;
    y %= ChunkWid;

    Assert(x < 0xFFFF && y < 0xFFFF);

    // Prepare new snapshot
    _snap.chunk  = chunk;
    _snap.fine_x = uint16_t(x);
    _snap.fine_y = uint16_t(y);
    _snap.state  = _state;
    _snap.frame = uint8_t(_frame);
    _snap.reversed  = _scalex < 0.f;
    _snap.berserk = (_fall_state.berserk_timer > 0.f);

    // Delta
    od::bitfield<8> flags;
    flags[0] = _snap.chunk.x != _prev_snap.chunk.x;
    flags[1] = _snap.chunk.y != _prev_snap.chunk.y;
    flags[2] = _snap.fine_x != _prev_snap.fine_x;
    flags[3] = _snap.fine_y != _prev_snap.fine_y;
    flags[4] = _snap.state != _prev_snap.state;
    flags[5] = _snap.frame != _prev_snap.frame;
    flags[6] = _snap.reversed;
    flags[7] = _snap.berserk;

    s << uint8_t(flags.to_ulong());
    if(flags[0]) { s << _snap.chunk.x; }
    if(flags[1]) { s << _snap.chunk.y; }
    if(flags[2]) { s << _prev_snap.fine_x; }
    if(flags[3]) { s << _prev_snap.fine_y; }
    if(flags[4]) { s << _snap.state; }
    if(flags[5]) { s << _snap.frame; }
}

/// @todo stream reader ...
void Scorpion::evReceiveReliable(od::StreamData& s)
{
    _prev_snap = _snap;

    uint8_t flags_bits;
    s >> flags_bits;
    od::bitfield<8> flags(flags_bits);

    if(flags[0]) { s >> _snap.chunk.x; }
    if(flags[1]) { s >> _snap.chunk.y; }
    if(flags[2]) { s >> _snap.fine_x; }
    if(flags[3]) { s >> _snap.fine_y; }
    if(flags[4]) { s >> _snap.state; }
    if(flags[5]) { s >> _snap.frame; }
    _snap.reversed = flags[6];
    if(flags[7]) {
        _fall_state.berserk_timer = 1.f;
    } else {
        _fall_state.berserk_timer = 0.f;
    }

    _snap_frame = 0;
}

void Scorpion::clientStep(float dt)
{
    // Compute the interpolation 't' value
    // 20Hz from 60Hz => 1 frame out of 3
    // _snap_frame: [0-3]
    const float t = std::min(1.f, _snap_frame / 4.f);

    const unsigned ChunkWid = 128*16;
    Vec2 prev_pos;
    prev_pos.x = _prev_snap.chunk.x*ChunkWid + _prev_snap.fine_x;
    prev_pos.y = _prev_snap.chunk.y*ChunkWid + _prev_snap.fine_y;

    Vec2 last_pos;
    last_pos.x = _snap.chunk.x*ChunkWid + _snap.fine_x;
    last_pos.y = _snap.chunk.y*ChunkWid + _snap.fine_y;

    pos = Vec2::lerp(prev_pos, last_pos, t);

    //pos = Vec2::lerp(_prev_snap.pos, _snap.pos, t);

    const Snapshot& snap = _snap;

    _state  = State(snap.state);
    _scalex = snap.reversed? -1.f: 1.f;
    _frame  = snap.frame;

    ++_snap_frame;
}