game_state.fbs

// defined to mirror RayLib's Vector3 def
struct OD_Vector3 {
    x: float;
    y: float;
    z: float;
}

struct OD_Vector2 {
    x: float;
    y: float;
}

// defined to mirror RayLib's BoundingBox def
struct OD_BoundingBox {
    min: OD_Vector3;
    max: OD_Vector3;
}

//TODO: define a Raylib Model in the future (many dependencies need to be defined)

// Define the enums. ALL RELIABLE except for Input & DifferentialState, ad GlobalState
enum PacketType : byte {
    // Client --> Server
    CreateLobby,
    Join,
    Start,
    Input,
    Leave,
    CreateLobbyResult,

    //Server --> Client
    StartResult,
    JoinResult,
    LeaveResult,
    GlobalState, //TODO: send global snapshot every so often
    DifferentialState, // TODO: portions of this will be null (so not sent/encoded)
    Timeout,
    Revert, //TODO: If there is packet loss, send this packet with the last ack'ed (full state) so client can revert back to this state
}

table SourcePoint {
    address: string;
    port: uint;
}
table DestPoint {
    address: string;
    port: uint;
}
// for both the client and server
struct Tick{
    tick_number: uint;
    dt: float;
}

table OD_Camera3D {
    position: OD_Vector3;
    target: OD_Vector3;
    up: OD_Vector3;
    fovy: float;
    projection: int;
}

// Define the contents of an Entity
table Entity {
    entity_id: uint;
    entity_label: string;
    position: OD_Vector3;
    facing: OD_Vector3;
    velocity: OD_Vector3;
    alive: bool;
}

// Define the state of a Client
table Client {
    source_point: SourcePoint;
    tick: Tick;
    client_uid: uint;
    alive: bool;
    sprint: bool;
   // crouch: bool;
    camera: OD_Camera3D;
    grounded: bool;
    cooldown: float;
    position: OD_Vector3;
    facing: OD_Vector3;
    velocity: OD_Vector3;

    entities:[Entity];
}

table Input {
    w: bool;
    a: bool;
    s: bool;
    d: bool;
    mouse_delta: OD_Vector2;
    shoot: bool;
    space: bool;
    dt: float;
    previous_position: OD_Vector3;
    sprint: bool;
    crouch: bool;
    //implement future support for sliding
}

table GlobalState {
    client_state:[Client];
}

union PacketPayload {
    Input,
    GlobalState,
}

table OD_Packet {
    packet_type: PacketType;
    dest_point: DestPoint;
    source_point: SourcePoint;
    lobby_number :uint;
    reliable: bool; //TODO: find a way to keep this out of the buffer (but have a way for the transmitter to check if it is reliable)
    tick: Tick;
    payload: PacketPayload;

}

root_type OD_Packet;