diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1695f91..28a62d5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,6 +4,8 @@ project(FPS-Game)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_VERBOSE_MAKEFILE ON)
 
+
+
 set(RAYLIB_VERSION 5.0)
 find_package(raylib ${RAYLIB_VERSION} QUIET) # QUIET or REQUIRED
 if (NOT raylib_FOUND) # If there's none, fetch and build raylib
@@ -21,23 +23,28 @@ if (NOT raylib_FOUND) # If there's none, fetch and build raylib
         add_subdirectory(${raylib_SOURCE_DIR} ${raylib_BINARY_DIR})
     endif()
 endif()
-include_directories("C:/Users/Joseph/Desktop/Intellectuals/FPS-Game/DevEnv/flatbuffers/include")
-include_directories("C:/Users/Joseph/Desktop/Intellectuals/FPS-Game/DevEnv/Enet Headers/include")
-link_directories(C:/Users/Joseph/Desktop/Intellectuals/FPS-Game/Dev Libs/"Dev_Libs")
-
-find_library(ENET_LIBRARY NAMES enet.a PATHS "Dev_Libs")
-if(NOT ENET_LIBRARY)
-    MESSAGE(FATAL_ERROR "ENet library not found")
-endif()
+#include_directories("C:/Users/Joseph/Desktop/Intellectuals/FPS-Game/DevEnv/flatbuffers/include")
+include_directories("/Users/anshulgowda/Documents/CODE/Odyssey/FPS-Game/DevEnv/flatbuffers/include")
+include_directories(/usr/local/include)
+#include_directories("C:/Users/Joseph/Desktop/Intellectuals/FPS-Game/DevEnv/Enet Headers/include")
+#link_directories(C:/Users/Joseph/Desktop/Intellectuals/FPS-Game/Dev Libs/"Dev_Libs") #contains enet.lib, I don't need that
+link_directories(/usr/local/lib)
+link_directories(/usr/local/bin)
 
-message(STATUS "ENet library found: ${ENET_LIBRARY}")
+#find_library(ENET_LIBRARY NAMES enet.a PATHS "Dev_Libs")
+#if(NOT ENET_LIBRARY)
+#    MESSAGE(FATAL_ERROR "ENet library not found")
+#endif()
+#
+#message(STATUS "ENet library found: ${ENET_LIBRARY}")
 
 
 
 add_executable(FPS-Game main.cpp Player.cpp Bullet.cpp game_state_generated.h game_state.fbs Transmitter.cpp Transmitter.h PacketBuffer.cpp PacketBuffer.h DummyClient.cpp DummyClient.h Gateway.cpp Gateway.h BufferHandler.h)
 
 target_link_libraries(${PROJECT_NAME} raylib)
-target_link_libraries(${PROJECT_NAME} ${ENET_LIBRARY} ws2_32 winmm)
+#target_link_libraries(${PROJECT_NAME} ${ENET_LIBRARY} ws2_32 winmm)
+target_link_libraries(${PROJECT_NAME} enet)
 
 # Web Configurations
 if (${PLATFORM} STREQUAL "Web")
diff --git a/Gateway.cpp b/Gateway.cpp
index e881394..b2a21cc 100644
--- a/Gateway.cpp
+++ b/Gateway.cpp
@@ -71,6 +71,7 @@ void Gateway::networkLoop() {
                     memcpy(bufferCopy.get(), event.packet->data, event.packet->dataLength);
                     unique_ptr<BufferHandler> packetBufferHandler = std::make_unique<BufferHandler>(std::move(bufferCopy), event.packet->dataLength);
                     receiveBuffer.addBufferHandler(std::move(packetBufferHandler));
+                    break;
                 }
                 case ENET_EVENT_TYPE_NONE:
                     cout << "nothing happened" << endl;
diff --git a/PacketBuffer.cpp b/PacketBuffer.cpp
index 650af5f..9f81a0a 100644
--- a/PacketBuffer.cpp
+++ b/PacketBuffer.cpp
@@ -21,11 +21,12 @@ void PacketBuffer::addPacket(unique_ptr<ENetPacket> packet) {
         }
         packetQueue.push(std::move(packet));
         numberOfPackets++;
-//        {
-//            std::lock_guard<std::mutex> guard(consoleMutex);
+        {
+            std::lock_guard<std::mutex> guard(consoleMutex);
 //            printf("Packet received in Output Buffer.\n\ttick = %zu\n", GetOD_Packet(packetQueue.back()->data)->tick()->tick_number());
-//
-//        }
+            printf("Packet received in Output Buffer.\n\ttick = %zu\n", GetOD_Packet(packetQueue.back()->data)->client_tick()->tick_number());
+
+        }
     }
 
     buffer_Condition.notify_all();
@@ -47,11 +48,11 @@ void PacketBuffer::addBufferHandler(unique_ptr<BufferHandler> packet) {
         }
         packetQueueIn.push(std::move(packet));
         numberOfPackets++;
-//        {
-//            std::lock_guard<std::mutex> guard(consoleMutex);
-//            printf("Packet received in Input Buffer.\n\ttick = %zu\n", packetQueueIn.back()->getPacketView()->tick()->tick_number());
-//
-//        }
+        {
+            std::lock_guard<std::mutex> guard(consoleMutex);
+            printf("Packet received in Input Buffer.\n\ttick = %zu\n", packetQueueIn.back()->getPacketView()->client_tick()->tick_number());
+
+        }
     }
 
     buffer_Condition.notify_all();
@@ -77,11 +78,11 @@ vector<unique_ptr<BufferHandler>> PacketBuffer::removePacketInstant() {
     packetList.reserve(packetQueueIn.size());
     while(!packetQueueIn.empty()){
         auto packet = std::move(packetQueueIn.front()); // pull out the packet
-//        {
-//            std::lock_guard<std::mutex> guard(consoleMutex);
-//            cout <<"Number of packets(pulling from buffer in transmitter): " <<numberOfPackets << endl;
-//            cout <<"Tick no. in transmitter: " <<packet->getPacketView()->tick()->tick_number() << endl;
-//        }
+        {
+            std::lock_guard<std::mutex> guard(consoleMutex);
+            cout <<"Number of packets(pulling from buffer in transmitter): " <<numberOfPackets << endl;
+            cout <<"Tick no. in transmitter: " <<packet->getPacketView()->client_tick()->tick_number() << endl;
+        }
         packetQueueIn.pop();
         packetList.push_back(std::move(packet));
         numberOfPackets--;
@@ -99,23 +100,23 @@ vector<unique_ptr<BufferHandler>> PacketBuffer::removePacketInstant() {
  */
 vector<unique_ptr<ENetPacket>> PacketBuffer::removePacketWait() {
     unique_lock<mutex> lock(bufferMutex); // lock the buffer
-//    {
-//        std::lock_guard<std::mutex> guard(consoleMutex);
-//        cout << "transmitter is attempting to pull from buffer" << endl;
-//
-//
-//    }
+    {
+        std::lock_guard<std::mutex> guard(consoleMutex);
+        cout << "transmitter is attempting to pull from buffer" << endl;
+
+
+    }
     // enter wait state and unlock lock until the packetQueue is notified, then check if it satisfies the lambda function if not
     // go back to waiting. This approach prevents random wakeups as even if it is woken up randomly it will not proceed unless it
     // can
     buffer_Condition.wait(lock, [this] {
         return (!packetQueue.empty() || shutdownFlag.load());
     });
-//    {
-//        std::lock_guard<std::mutex> guard(consoleMutex);
-//        cout << "transmitter got the green light" << endl;
-//
-//    }
+    {
+        std::lock_guard<std::mutex> guard(consoleMutex);
+        cout << "transmitter got the green light" << endl;
+
+    }
     if(packetQueue.empty() || shutdownFlag.load()){
         {
             std::lock_guard<std::mutex> guard(consoleMutex);
@@ -131,11 +132,11 @@ vector<unique_ptr<ENetPacket>> PacketBuffer::removePacketWait() {
 
     while(!packetQueue.empty()){
         auto packet = std::move(packetQueue.front()); // pull out the packet
-//        {
-//            std::lock_guard<std::mutex> guard(consoleMutex);
-//            cout <<"Number of packets(pulling from buffer in transmitter): " <<numberOfPackets << endl;
-//            cout <<"Tick no. in transmitter: " <<GetOD_Packet(packet->data)->tick()->tick_number() << endl;
-//        }
+        {
+            std::lock_guard<std::mutex> guard(consoleMutex);
+            cout <<"Number of packets(pulling from buffer in transmitter): " <<numberOfPackets << endl;
+            cout <<"Tick no. in transmitter: " <<GetOD_Packet(packet->data)->client_tick()->tick_number() << endl;
+        }
         packetQueue.pop();
         packetList.push_back(std::move(packet));
         numberOfPackets--;
@@ -153,4 +154,8 @@ void PacketBuffer::notifyAll() {
 void PacketBuffer::shutdown() {
     shutdownFlag.store(true);
     buffer_Condition.notify_all(); // wake all threads waiting of this shutdown command
-}
\ No newline at end of file
+}
+
+int PacketBuffer::getNumberOfPackets() const {
+    return numberOfPackets;
+}
diff --git a/PacketBuffer.h b/PacketBuffer.h
index 8d47252..4772004 100644
--- a/PacketBuffer.h
+++ b/PacketBuffer.h
@@ -63,6 +63,7 @@ class PacketBuffer {
     vector<unique_ptr<BufferHandler>> removePacketInstant();
     // wake all waiting threads
     void notifyAll();
+    int getNumberOfPackets() const;
 
     // TODO: get buffer stats, (% full, service rate, how often full, etc)
 
diff --git a/Transmitter.cpp b/Transmitter.cpp
index 70e1d43..7c0564f 100644
--- a/Transmitter.cpp
+++ b/Transmitter.cpp
@@ -36,19 +36,34 @@ void Transmitter::start(){
     transmitThread = thread(&Transmitter::transmitLoop,this);
 }
 void Transmitter::transmitLoop(){
+<<<<<<< HEAD
+    {
+        std::lock_guard<std::mutex> guard(consoleMutex);
+        cout << "in transmit loop" << endl;
+    }
+    connect("172.17.8.211",5450);
+=======
 //    {
 //        std::lock_guard<std::mutex> guard(consoleMutex);
 //        cout << "in transmit loop" << endl;
 //    }
     connect("192.168.56.1",5450);
+>>>>>>> 550e05ef4bdf2e0a8fb9d4f5a36438ce19f2141f
     while(!shutdownFlag.load()){
 
         auto packetList = transmitBuffer.removePacketWait();
         if(packetList.empty()) {
+<<<<<<< HEAD
+            {
+                std::lock_guard<std::mutex> guard(consoleMutex);
+                cout << "no packets to pull" << endl;
+            }
+=======
 //            {
 //                std::lock_guard<std::mutex> guard(consoleMutex);
 //                cout << "no packtes to pull" << endl;
 //            }
+>>>>>>> 550e05ef4bdf2e0a8fb9d4f5a36438ce19f2141f
             continue;
         }else{
             int packetListSize = packetList.size();
@@ -123,10 +138,6 @@ void Transmitter::transmitPacket(unique_ptr<ENetPacket> packet) {
 //
 //    }
     std::move(packet);
-
-
-
-
 }
 
 PacketBuffer &Transmitter::getPacketBuffer() {
diff --git a/game_state.fbs b/game_state.fbs
index 9d04db9..40cac35 100644
--- a/game_state.fbs
+++ b/game_state.fbs
@@ -1,17 +1,17 @@
 // defined to mirror RayLib's Vector3 def
-struct OD_Vector3 {
+table OD_Vector3 {
     x: float;
     y: float;
     z: float;
 }
 
-struct OD_Vector2 {
+table OD_Vector2 {
     x: float;
     y: float;
 }
 
 // defined to mirror RayLib's BoundingBox def
-struct OD_BoundingBox {
+table OD_BoundingBox {
     min: OD_Vector3;
     max: OD_Vector3;
 }
@@ -47,9 +47,10 @@ table DestPoint {
     port: uint;
 }
 // for both the client and server
-struct Tick{
+table Tick{
     tick_number: uint;
     dt: float;
+    wrap_around: int;
 }
 
 table OD_Camera3D {
@@ -60,20 +61,28 @@ table OD_Camera3D {
     projection: int;
 }
 
+table Buffer{
+    client_id: int;
+    buffered_client_tick: int;
+
+}
+
 // Define the contents of an Entity
 table Entity {
     entity_id: uint;
     entity_label: string;
     position: OD_Vector3;
-    facing: OD_Vector3;
+    // facing: OD_Vector3; // velocity already encodes this, not needed
     velocity: OD_Vector3;
     alive: bool;
+    claimed: bool;
 }
 
 // Define the state of a Client
 table Client {
     source_point: SourcePoint;
-    tick: Tick;
+    tick: Tick; // client never sends me their tick
+    rtt: float; // should be set only for the snapshot
     client_uid: uint;
     alive: bool;
     sprint: bool;
@@ -82,14 +91,182 @@ table Client {
     grounded: bool;
     cooldown: float;
     position: OD_Vector3;
-    facing: OD_Vector3;
+    // facing: OD_Vector3; // the facing is stored within the camera object's target ??
     velocity: OD_Vector3;
+    entities:[Entity];
+}
+
+table Input {
+    client_uid: uint;
+    tick: Tick;
+    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
+
+    // TODO: implement list[{client ID & buffered tick}]
+    // send changes to opponents buffer, NOT ALL!!!
+    // opponent_buffer_ticks:[Buffer];
+    // where the buffered tick is the player's client tick that the opponent is being rendered at
+    // (rendered tick is older than the current tick, creating buffering)
+}
+
+table ClientInputs {
+    client_inputs:[Input];
+}
+
+table ClientStates {
+    rtt: float; // should be set only for the deltas
+    client_states:[Client];
+}
 
+// These will generate a vector of states for a client, we need each client's vector
+union StatesOptions{
+    ClientInputs,
+    ClientStates,
+}
+
+table States {
+    state: StatesOptions;
+}
+
+table AllPlayerDeltas {
+    payload:[States];
+}
+
+table AllPlayerSnapshots {
+    payload:[States];
+}
+
+union PayloadTypes{
+    Input,
+    AllPlayerDeltas,
+    AllPlayerSnapshots,
+    ClientStates,
+    ClientInputs
+}
+
+table Payload{
+    payload: PayloadTypes;
+}
+
+table OD_Packet {
+    packet_type: PacketType;
+    client_id: int;
+    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)
+    server_tick: Tick;
+    client_tick: Tick;
+    payload: Payload;
+}
+
+root_type OD_Packet;
+
+/*
+// defined to mirror RayLib's Vector3 def
+table OD_Vector3 {
+    x: float;
+    y: float;
+    z: float;
+}
+
+table OD_Vector2 {
+    x: float;
+    y: float;
+}
+
+// defined to mirror RayLib's BoundingBox def
+table 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
+table Tick{
+    tick_number: uint;
+    dt: float;
+    wrap_around: int;
+}
+
+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 already encodes this, not needed
+    velocity: OD_Vector3;
+    alive: bool;
+    claimed: bool;
+}
+
+// Define the state of a Client
+table Client {
+    source_point: SourcePoint;
+    tick: Tick; // client never sends me their tick
+    rtt: float; // should be set only for the snapshot
+    client_uid: uint;
+    alive: bool;
+    sprint: bool;
+   // crouch: bool;
+    camera: OD_Camera3D;
+    grounded: bool;
+    cooldown: float;
+    position: OD_Vector3;
+    // facing: OD_Vector3; // the facing is stored within the camera object's target ??
+    velocity: OD_Vector3;
     entities:[Entity];
 }
 
 table Input {
-    client_uid:uint;
+    client_uid: uint;
     w: bool;
     a: bool;
     s: bool;
@@ -104,25 +281,49 @@ table Input {
     //implement future support for sliding
 }
 
-table GlobalState {
-    client_state:[Client];
+table ClientInputs {
+    client_inputs:[Input];
+}
+
+table ClientStates {
+    rtt: float; // should be set only for the deltas
+    client_states:[Client];
+}
+
+// These will generate a vector of states for a client, we need each client's vector
+union StatesOptions{
+    ClientInputs,
+    ClientStates,
 }
 
-union PacketPayload {
+table States {
+    state: StatesOptions;
+}
+
+table AllPlayerDeltas {
+    payload:[States];
+}
+
+union PayloadTypes{
     Input,
-    GlobalState,
+    AllPlayerDeltas,
+    ClientStates
 }
 
-table OD_Packet {
+table Payload{
+    payload: PayloadTypes;
+}
 
+table OD_Packet {
     packet_type: PacketType;
+    dest_client_id: int;
     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;
-
+    payload: Payload;
 }
 
-root_type OD_Packet;
\ No newline at end of file
+root_type OD_Packet;
+*/
diff --git a/game_state_generated.h b/game_state_generated.h
index 64a85d9..ad68371 100644
--- a/game_state_generated.h
+++ b/game_state_generated.h
@@ -14,10 +14,13 @@ static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
              "Non-compatible flatbuffers version included");
 
 struct OD_Vector3;
+struct OD_Vector3Builder;
 
 struct OD_Vector2;
+struct OD_Vector2Builder;
 
 struct OD_BoundingBox;
+struct OD_BoundingBoxBuilder;
 
 struct SourcePoint;
 struct SourcePointBuilder;
@@ -26,10 +29,14 @@ struct DestPoint;
 struct DestPointBuilder;
 
 struct Tick;
+struct TickBuilder;
 
 struct OD_Camera3D;
 struct OD_Camera3DBuilder;
 
+struct Buffer;
+struct BufferBuilder;
+
 struct Entity;
 struct EntityBuilder;
 
@@ -39,8 +46,23 @@ struct ClientBuilder;
 struct Input;
 struct InputBuilder;
 
-struct GlobalState;
-struct GlobalStateBuilder;
+struct ClientInputs;
+struct ClientInputsBuilder;
+
+struct ClientStates;
+struct ClientStatesBuilder;
+
+struct States;
+struct StatesBuilder;
+
+struct AllPlayerDeltas;
+struct AllPlayerDeltasBuilder;
+
+struct AllPlayerSnapshots;
+struct AllPlayerSnapshotsBuilder;
+
+struct Payload;
+struct PayloadBuilder;
 
 struct OD_Packet;
 struct OD_PacketBuilder;
@@ -108,151 +130,287 @@ inline const char *EnumNamePacketType(PacketType e) {
   return EnumNamesPacketType()[index];
 }
 
-enum PacketPayload : uint8_t {
-  PacketPayload_NONE = 0,
-  PacketPayload_Input = 1,
-  PacketPayload_GlobalState = 2,
-  PacketPayload_MIN = PacketPayload_NONE,
-  PacketPayload_MAX = PacketPayload_GlobalState
+enum StatesOptions : uint8_t {
+  StatesOptions_NONE = 0,
+  StatesOptions_ClientInputs = 1,
+  StatesOptions_ClientStates = 2,
+  StatesOptions_MIN = StatesOptions_NONE,
+  StatesOptions_MAX = StatesOptions_ClientStates
 };
 
-inline const PacketPayload (&EnumValuesPacketPayload())[3] {
-  static const PacketPayload values[] = {
-    PacketPayload_NONE,
-    PacketPayload_Input,
-    PacketPayload_GlobalState
+inline const StatesOptions (&EnumValuesStatesOptions())[3] {
+  static const StatesOptions values[] = {
+    StatesOptions_NONE,
+    StatesOptions_ClientInputs,
+    StatesOptions_ClientStates
   };
   return values;
 }
 
-inline const char * const *EnumNamesPacketPayload() {
+inline const char * const *EnumNamesStatesOptions() {
   static const char * const names[4] = {
+    "NONE",
+    "ClientInputs",
+    "ClientStates",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameStatesOptions(StatesOptions e) {
+  if (::flatbuffers::IsOutRange(e, StatesOptions_NONE, StatesOptions_ClientStates)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesStatesOptions()[index];
+}
+
+template<typename T> struct StatesOptionsTraits {
+  static const StatesOptions enum_value = StatesOptions_NONE;
+};
+
+template<> struct StatesOptionsTraits<ClientInputs> {
+  static const StatesOptions enum_value = StatesOptions_ClientInputs;
+};
+
+template<> struct StatesOptionsTraits<ClientStates> {
+  static const StatesOptions enum_value = StatesOptions_ClientStates;
+};
+
+bool VerifyStatesOptions(::flatbuffers::Verifier &verifier, const void *obj, StatesOptions type);
+bool VerifyStatesOptionsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+
+enum PayloadTypes : uint8_t {
+  PayloadTypes_NONE = 0,
+  PayloadTypes_Input = 1,
+  PayloadTypes_AllPlayerDeltas = 2,
+  PayloadTypes_AllPlayerSnapshots = 3,
+  PayloadTypes_ClientStates = 4,
+  PayloadTypes_ClientInputs = 5,
+  PayloadTypes_MIN = PayloadTypes_NONE,
+  PayloadTypes_MAX = PayloadTypes_ClientInputs
+};
+
+inline const PayloadTypes (&EnumValuesPayloadTypes())[6] {
+  static const PayloadTypes values[] = {
+    PayloadTypes_NONE,
+    PayloadTypes_Input,
+    PayloadTypes_AllPlayerDeltas,
+    PayloadTypes_AllPlayerSnapshots,
+    PayloadTypes_ClientStates,
+    PayloadTypes_ClientInputs
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesPayloadTypes() {
+  static const char * const names[7] = {
     "NONE",
     "Input",
-    "GlobalState",
+    "AllPlayerDeltas",
+    "AllPlayerSnapshots",
+    "ClientStates",
+    "ClientInputs",
     nullptr
   };
   return names;
 }
 
-inline const char *EnumNamePacketPayload(PacketPayload e) {
-  if (::flatbuffers::IsOutRange(e, PacketPayload_NONE, PacketPayload_GlobalState)) return "";
+inline const char *EnumNamePayloadTypes(PayloadTypes e) {
+  if (::flatbuffers::IsOutRange(e, PayloadTypes_NONE, PayloadTypes_ClientInputs)) return "";
   const size_t index = static_cast<size_t>(e);
-  return EnumNamesPacketPayload()[index];
+  return EnumNamesPayloadTypes()[index];
 }
 
-template<typename T> struct PacketPayloadTraits {
-  static const PacketPayload enum_value = PacketPayload_NONE;
+template<typename T> struct PayloadTypesTraits {
+  static const PayloadTypes enum_value = PayloadTypes_NONE;
 };
 
-template<> struct PacketPayloadTraits<Input> {
-  static const PacketPayload enum_value = PacketPayload_Input;
+template<> struct PayloadTypesTraits<Input> {
+  static const PayloadTypes enum_value = PayloadTypes_Input;
 };
 
-template<> struct PacketPayloadTraits<GlobalState> {
-  static const PacketPayload enum_value = PacketPayload_GlobalState;
+template<> struct PayloadTypesTraits<AllPlayerDeltas> {
+  static const PayloadTypes enum_value = PayloadTypes_AllPlayerDeltas;
 };
 
-bool VerifyPacketPayload(::flatbuffers::Verifier &verifier, const void *obj, PacketPayload type);
-bool VerifyPacketPayloadVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template<> struct PayloadTypesTraits<AllPlayerSnapshots> {
+  static const PayloadTypes enum_value = PayloadTypes_AllPlayerSnapshots;
+};
 
-FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) OD_Vector3 FLATBUFFERS_FINAL_CLASS {
- private:
-  float x_;
-  float y_;
-  float z_;
+template<> struct PayloadTypesTraits<ClientStates> {
+  static const PayloadTypes enum_value = PayloadTypes_ClientStates;
+};
 
- public:
-  OD_Vector3()
-      : x_(0),
-        y_(0),
-        z_(0) {
-  }
-  OD_Vector3(float _x, float _y, float _z)
-      : x_(::flatbuffers::EndianScalar(_x)),
-        y_(::flatbuffers::EndianScalar(_y)),
-        z_(::flatbuffers::EndianScalar(_z)) {
-  }
+template<> struct PayloadTypesTraits<ClientInputs> {
+  static const PayloadTypes enum_value = PayloadTypes_ClientInputs;
+};
+
+bool VerifyPayloadTypes(::flatbuffers::Verifier &verifier, const void *obj, PayloadTypes type);
+bool VerifyPayloadTypesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+
+struct OD_Vector3 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef OD_Vector3Builder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_X = 4,
+    VT_Y = 6,
+    VT_Z = 8
+  };
   float x() const {
-    return ::flatbuffers::EndianScalar(x_);
+    return GetField<float>(VT_X, 0.0f);
   }
   float y() const {
-    return ::flatbuffers::EndianScalar(y_);
+    return GetField<float>(VT_Y, 0.0f);
   }
   float z() const {
-    return ::flatbuffers::EndianScalar(z_);
+    return GetField<float>(VT_Z, 0.0f);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<float>(verifier, VT_X, 4) &&
+           VerifyField<float>(verifier, VT_Y, 4) &&
+           VerifyField<float>(verifier, VT_Z, 4) &&
+           verifier.EndTable();
   }
 };
-FLATBUFFERS_STRUCT_END(OD_Vector3, 12);
 
-FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) OD_Vector2 FLATBUFFERS_FINAL_CLASS {
- private:
-  float x_;
-  float y_;
-
- public:
-  OD_Vector2()
-      : x_(0),
-        y_(0) {
+struct OD_Vector3Builder {
+  typedef OD_Vector3 Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_x(float x) {
+    fbb_.AddElement<float>(OD_Vector3::VT_X, x, 0.0f);
+  }
+  void add_y(float y) {
+    fbb_.AddElement<float>(OD_Vector3::VT_Y, y, 0.0f);
   }
-  OD_Vector2(float _x, float _y)
-      : x_(::flatbuffers::EndianScalar(_x)),
-        y_(::flatbuffers::EndianScalar(_y)) {
+  void add_z(float z) {
+    fbb_.AddElement<float>(OD_Vector3::VT_Z, z, 0.0f);
   }
+  explicit OD_Vector3Builder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<OD_Vector3> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<OD_Vector3>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<OD_Vector3> CreateOD_Vector3(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    float x = 0.0f,
+    float y = 0.0f,
+    float z = 0.0f) {
+  OD_Vector3Builder builder_(_fbb);
+  builder_.add_z(z);
+  builder_.add_y(y);
+  builder_.add_x(x);
+  return builder_.Finish();
+}
+
+struct OD_Vector2 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef OD_Vector2Builder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_X = 4,
+    VT_Y = 6
+  };
   float x() const {
-    return ::flatbuffers::EndianScalar(x_);
+    return GetField<float>(VT_X, 0.0f);
   }
   float y() const {
-    return ::flatbuffers::EndianScalar(y_);
+    return GetField<float>(VT_Y, 0.0f);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<float>(verifier, VT_X, 4) &&
+           VerifyField<float>(verifier, VT_Y, 4) &&
+           verifier.EndTable();
   }
 };
-FLATBUFFERS_STRUCT_END(OD_Vector2, 8);
-
-FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) OD_BoundingBox FLATBUFFERS_FINAL_CLASS {
- private:
-  OD_Vector3 min_;
-  OD_Vector3 max_;
 
- public:
-  OD_BoundingBox()
-      : min_(),
-        max_() {
+struct OD_Vector2Builder {
+  typedef OD_Vector2 Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_x(float x) {
+    fbb_.AddElement<float>(OD_Vector2::VT_X, x, 0.0f);
   }
-  OD_BoundingBox(const OD_Vector3 &_min, const OD_Vector3 &_max)
-      : min_(_min),
-        max_(_max) {
+  void add_y(float y) {
+    fbb_.AddElement<float>(OD_Vector2::VT_Y, y, 0.0f);
   }
-  const OD_Vector3 &min() const {
-    return min_;
+  explicit OD_Vector2Builder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
   }
-  const OD_Vector3 &max() const {
-    return max_;
+  ::flatbuffers::Offset<OD_Vector2> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<OD_Vector2>(end);
+    return o;
   }
 };
-FLATBUFFERS_STRUCT_END(OD_BoundingBox, 24);
 
-FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Tick FLATBUFFERS_FINAL_CLASS {
- private:
-  uint32_t tick_number_;
-  float dt_;
+inline ::flatbuffers::Offset<OD_Vector2> CreateOD_Vector2(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    float x = 0.0f,
+    float y = 0.0f) {
+  OD_Vector2Builder builder_(_fbb);
+  builder_.add_y(y);
+  builder_.add_x(x);
+  return builder_.Finish();
+}
 
- public:
-  Tick()
-      : tick_number_(0),
-        dt_(0) {
+struct OD_BoundingBox FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef OD_BoundingBoxBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_MIN = 4,
+    VT_MAX = 6
+  };
+  const OD_Vector3 *min() const {
+    return GetPointer<const OD_Vector3 *>(VT_MIN);
   }
-  Tick(uint32_t _tick_number, float _dt)
-      : tick_number_(::flatbuffers::EndianScalar(_tick_number)),
-        dt_(::flatbuffers::EndianScalar(_dt)) {
+  const OD_Vector3 *max() const {
+    return GetPointer<const OD_Vector3 *>(VT_MAX);
   }
-  uint32_t tick_number() const {
-    return ::flatbuffers::EndianScalar(tick_number_);
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_MIN) &&
+           verifier.VerifyTable(min()) &&
+           VerifyOffset(verifier, VT_MAX) &&
+           verifier.VerifyTable(max()) &&
+           verifier.EndTable();
   }
-  float dt() const {
-    return ::flatbuffers::EndianScalar(dt_);
+};
+
+struct OD_BoundingBoxBuilder {
+  typedef OD_BoundingBox Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_min(::flatbuffers::Offset<OD_Vector3> min) {
+    fbb_.AddOffset(OD_BoundingBox::VT_MIN, min);
+  }
+  void add_max(::flatbuffers::Offset<OD_Vector3> max) {
+    fbb_.AddOffset(OD_BoundingBox::VT_MAX, max);
+  }
+  explicit OD_BoundingBoxBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<OD_BoundingBox> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<OD_BoundingBox>(end);
+    return o;
   }
 };
-FLATBUFFERS_STRUCT_END(Tick, 8);
+
+inline ::flatbuffers::Offset<OD_BoundingBox> CreateOD_BoundingBox(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<OD_Vector3> min = 0,
+    ::flatbuffers::Offset<OD_Vector3> max = 0) {
+  OD_BoundingBoxBuilder builder_(_fbb);
+  builder_.add_max(max);
+  builder_.add_min(min);
+  return builder_.Finish();
+}
 
 struct SourcePoint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef SourcePointBuilder Builder;
@@ -380,6 +538,67 @@ inline ::flatbuffers::Offset<DestPoint> CreateDestPointDirect(
       port);
 }
 
+struct Tick FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef TickBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_TICK_NUMBER = 4,
+    VT_DT = 6,
+    VT_WRAP_AROUND = 8
+  };
+  uint32_t tick_number() const {
+    return GetField<uint32_t>(VT_TICK_NUMBER, 0);
+  }
+  float dt() const {
+    return GetField<float>(VT_DT, 0.0f);
+  }
+  int32_t wrap_around() const {
+    return GetField<int32_t>(VT_WRAP_AROUND, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_TICK_NUMBER, 4) &&
+           VerifyField<float>(verifier, VT_DT, 4) &&
+           VerifyField<int32_t>(verifier, VT_WRAP_AROUND, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct TickBuilder {
+  typedef Tick Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_tick_number(uint32_t tick_number) {
+    fbb_.AddElement<uint32_t>(Tick::VT_TICK_NUMBER, tick_number, 0);
+  }
+  void add_dt(float dt) {
+    fbb_.AddElement<float>(Tick::VT_DT, dt, 0.0f);
+  }
+  void add_wrap_around(int32_t wrap_around) {
+    fbb_.AddElement<int32_t>(Tick::VT_WRAP_AROUND, wrap_around, 0);
+  }
+  explicit TickBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Tick> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Tick>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Tick> CreateTick(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t tick_number = 0,
+    float dt = 0.0f,
+    int32_t wrap_around = 0) {
+  TickBuilder builder_(_fbb);
+  builder_.add_wrap_around(wrap_around);
+  builder_.add_dt(dt);
+  builder_.add_tick_number(tick_number);
+  return builder_.Finish();
+}
+
 struct OD_Camera3D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef OD_Camera3DBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -390,13 +609,13 @@ struct OD_Camera3D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     VT_PROJECTION = 12
   };
   const OD_Vector3 *position() const {
-    return GetStruct<const OD_Vector3 *>(VT_POSITION);
+    return GetPointer<const OD_Vector3 *>(VT_POSITION);
   }
   const OD_Vector3 *target() const {
-    return GetStruct<const OD_Vector3 *>(VT_TARGET);
+    return GetPointer<const OD_Vector3 *>(VT_TARGET);
   }
   const OD_Vector3 *up() const {
-    return GetStruct<const OD_Vector3 *>(VT_UP);
+    return GetPointer<const OD_Vector3 *>(VT_UP);
   }
   float fovy() const {
     return GetField<float>(VT_FOVY, 0.0f);
@@ -406,9 +625,12 @@ struct OD_Camera3D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<OD_Vector3>(verifier, VT_POSITION, 4) &&
-           VerifyField<OD_Vector3>(verifier, VT_TARGET, 4) &&
-           VerifyField<OD_Vector3>(verifier, VT_UP, 4) &&
+           VerifyOffset(verifier, VT_POSITION) &&
+           verifier.VerifyTable(position()) &&
+           VerifyOffset(verifier, VT_TARGET) &&
+           verifier.VerifyTable(target()) &&
+           VerifyOffset(verifier, VT_UP) &&
+           verifier.VerifyTable(up()) &&
            VerifyField<float>(verifier, VT_FOVY, 4) &&
            VerifyField<int32_t>(verifier, VT_PROJECTION, 4) &&
            verifier.EndTable();
@@ -419,14 +641,14 @@ struct OD_Camera3DBuilder {
   typedef OD_Camera3D Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
   ::flatbuffers::uoffset_t start_;
-  void add_position(const OD_Vector3 *position) {
-    fbb_.AddStruct(OD_Camera3D::VT_POSITION, position);
+  void add_position(::flatbuffers::Offset<OD_Vector3> position) {
+    fbb_.AddOffset(OD_Camera3D::VT_POSITION, position);
   }
-  void add_target(const OD_Vector3 *target) {
-    fbb_.AddStruct(OD_Camera3D::VT_TARGET, target);
+  void add_target(::flatbuffers::Offset<OD_Vector3> target) {
+    fbb_.AddOffset(OD_Camera3D::VT_TARGET, target);
   }
-  void add_up(const OD_Vector3 *up) {
-    fbb_.AddStruct(OD_Camera3D::VT_UP, up);
+  void add_up(::flatbuffers::Offset<OD_Vector3> up) {
+    fbb_.AddOffset(OD_Camera3D::VT_UP, up);
   }
   void add_fovy(float fovy) {
     fbb_.AddElement<float>(OD_Camera3D::VT_FOVY, fovy, 0.0f);
@@ -447,9 +669,9 @@ struct OD_Camera3DBuilder {
 
 inline ::flatbuffers::Offset<OD_Camera3D> CreateOD_Camera3D(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    const OD_Vector3 *position = nullptr,
-    const OD_Vector3 *target = nullptr,
-    const OD_Vector3 *up = nullptr,
+    ::flatbuffers::Offset<OD_Vector3> position = 0,
+    ::flatbuffers::Offset<OD_Vector3> target = 0,
+    ::flatbuffers::Offset<OD_Vector3> up = 0,
     float fovy = 0.0f,
     int32_t projection = 0) {
   OD_Camera3DBuilder builder_(_fbb);
@@ -461,15 +683,66 @@ inline ::flatbuffers::Offset<OD_Camera3D> CreateOD_Camera3D(
   return builder_.Finish();
 }
 
+struct Buffer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef BufferBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_CLIENT_ID = 4,
+    VT_BUFFERED_CLIENT_TICK = 6
+  };
+  int32_t client_id() const {
+    return GetField<int32_t>(VT_CLIENT_ID, 0);
+  }
+  int32_t buffered_client_tick() const {
+    return GetField<int32_t>(VT_BUFFERED_CLIENT_TICK, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_CLIENT_ID, 4) &&
+           VerifyField<int32_t>(verifier, VT_BUFFERED_CLIENT_TICK, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct BufferBuilder {
+  typedef Buffer Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_client_id(int32_t client_id) {
+    fbb_.AddElement<int32_t>(Buffer::VT_CLIENT_ID, client_id, 0);
+  }
+  void add_buffered_client_tick(int32_t buffered_client_tick) {
+    fbb_.AddElement<int32_t>(Buffer::VT_BUFFERED_CLIENT_TICK, buffered_client_tick, 0);
+  }
+  explicit BufferBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Buffer> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Buffer>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Buffer> CreateBuffer(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t client_id = 0,
+    int32_t buffered_client_tick = 0) {
+  BufferBuilder builder_(_fbb);
+  builder_.add_buffered_client_tick(buffered_client_tick);
+  builder_.add_client_id(client_id);
+  return builder_.Finish();
+}
+
 struct Entity FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef EntityBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_ENTITY_ID = 4,
     VT_ENTITY_LABEL = 6,
     VT_POSITION = 8,
-    VT_FACING = 10,
-    VT_VELOCITY = 12,
-    VT_ALIVE = 14
+    VT_VELOCITY = 10,
+    VT_ALIVE = 12,
+    VT_CLAIMED = 14
   };
   uint32_t entity_id() const {
     return GetField<uint32_t>(VT_ENTITY_ID, 0);
@@ -478,26 +751,28 @@ struct Entity FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     return GetPointer<const ::flatbuffers::String *>(VT_ENTITY_LABEL);
   }
   const OD_Vector3 *position() const {
-    return GetStruct<const OD_Vector3 *>(VT_POSITION);
-  }
-  const OD_Vector3 *facing() const {
-    return GetStruct<const OD_Vector3 *>(VT_FACING);
+    return GetPointer<const OD_Vector3 *>(VT_POSITION);
   }
   const OD_Vector3 *velocity() const {
-    return GetStruct<const OD_Vector3 *>(VT_VELOCITY);
+    return GetPointer<const OD_Vector3 *>(VT_VELOCITY);
   }
   bool alive() const {
     return GetField<uint8_t>(VT_ALIVE, 0) != 0;
   }
+  bool claimed() const {
+    return GetField<uint8_t>(VT_CLAIMED, 0) != 0;
+  }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_ENTITY_ID, 4) &&
            VerifyOffset(verifier, VT_ENTITY_LABEL) &&
            verifier.VerifyString(entity_label()) &&
-           VerifyField<OD_Vector3>(verifier, VT_POSITION, 4) &&
-           VerifyField<OD_Vector3>(verifier, VT_FACING, 4) &&
-           VerifyField<OD_Vector3>(verifier, VT_VELOCITY, 4) &&
+           VerifyOffset(verifier, VT_POSITION) &&
+           verifier.VerifyTable(position()) &&
+           VerifyOffset(verifier, VT_VELOCITY) &&
+           verifier.VerifyTable(velocity()) &&
            VerifyField<uint8_t>(verifier, VT_ALIVE, 1) &&
+           VerifyField<uint8_t>(verifier, VT_CLAIMED, 1) &&
            verifier.EndTable();
   }
 };
@@ -512,18 +787,18 @@ struct EntityBuilder {
   void add_entity_label(::flatbuffers::Offset<::flatbuffers::String> entity_label) {
     fbb_.AddOffset(Entity::VT_ENTITY_LABEL, entity_label);
   }
-  void add_position(const OD_Vector3 *position) {
-    fbb_.AddStruct(Entity::VT_POSITION, position);
+  void add_position(::flatbuffers::Offset<OD_Vector3> position) {
+    fbb_.AddOffset(Entity::VT_POSITION, position);
   }
-  void add_facing(const OD_Vector3 *facing) {
-    fbb_.AddStruct(Entity::VT_FACING, facing);
-  }
-  void add_velocity(const OD_Vector3 *velocity) {
-    fbb_.AddStruct(Entity::VT_VELOCITY, velocity);
+  void add_velocity(::flatbuffers::Offset<OD_Vector3> velocity) {
+    fbb_.AddOffset(Entity::VT_VELOCITY, velocity);
   }
   void add_alive(bool alive) {
     fbb_.AddElement<uint8_t>(Entity::VT_ALIVE, static_cast<uint8_t>(alive), 0);
   }
+  void add_claimed(bool claimed) {
+    fbb_.AddElement<uint8_t>(Entity::VT_CLAIMED, static_cast<uint8_t>(claimed), 0);
+  }
   explicit EntityBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -539,16 +814,16 @@ inline ::flatbuffers::Offset<Entity> CreateEntity(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     uint32_t entity_id = 0,
     ::flatbuffers::Offset<::flatbuffers::String> entity_label = 0,
-    const OD_Vector3 *position = nullptr,
-    const OD_Vector3 *facing = nullptr,
-    const OD_Vector3 *velocity = nullptr,
-    bool alive = false) {
+    ::flatbuffers::Offset<OD_Vector3> position = 0,
+    ::flatbuffers::Offset<OD_Vector3> velocity = 0,
+    bool alive = false,
+    bool claimed = false) {
   EntityBuilder builder_(_fbb);
   builder_.add_velocity(velocity);
-  builder_.add_facing(facing);
   builder_.add_position(position);
   builder_.add_entity_label(entity_label);
   builder_.add_entity_id(entity_id);
+  builder_.add_claimed(claimed);
   builder_.add_alive(alive);
   return builder_.Finish();
 }
@@ -557,19 +832,19 @@ inline ::flatbuffers::Offset<Entity> CreateEntityDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     uint32_t entity_id = 0,
     const char *entity_label = nullptr,
-    const OD_Vector3 *position = nullptr,
-    const OD_Vector3 *facing = nullptr,
-    const OD_Vector3 *velocity = nullptr,
-    bool alive = false) {
+    ::flatbuffers::Offset<OD_Vector3> position = 0,
+    ::flatbuffers::Offset<OD_Vector3> velocity = 0,
+    bool alive = false,
+    bool claimed = false) {
   auto entity_label__ = entity_label ? _fbb.CreateString(entity_label) : 0;
   return CreateEntity(
       _fbb,
       entity_id,
       entity_label__,
       position,
-      facing,
       velocity,
-      alive);
+      alive,
+      claimed);
 }
 
 struct Client FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -577,14 +852,14 @@ struct Client FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_SOURCE_POINT = 4,
     VT_TICK = 6,
-    VT_CLIENT_UID = 8,
-    VT_ALIVE = 10,
-    VT_SPRINT = 12,
-    VT_CAMERA = 14,
-    VT_GROUNDED = 16,
-    VT_COOLDOWN = 18,
-    VT_POSITION = 20,
-    VT_FACING = 22,
+    VT_RTT = 8,
+    VT_CLIENT_UID = 10,
+    VT_ALIVE = 12,
+    VT_SPRINT = 14,
+    VT_CAMERA = 16,
+    VT_GROUNDED = 18,
+    VT_COOLDOWN = 20,
+    VT_POSITION = 22,
     VT_VELOCITY = 24,
     VT_ENTITIES = 26
   };
@@ -592,7 +867,10 @@ struct Client FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     return GetPointer<const SourcePoint *>(VT_SOURCE_POINT);
   }
   const Tick *tick() const {
-    return GetStruct<const Tick *>(VT_TICK);
+    return GetPointer<const Tick *>(VT_TICK);
+  }
+  float rtt() const {
+    return GetField<float>(VT_RTT, 0.0f);
   }
   uint32_t client_uid() const {
     return GetField<uint32_t>(VT_CLIENT_UID, 0);
@@ -613,13 +891,10 @@ struct Client FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     return GetField<float>(VT_COOLDOWN, 0.0f);
   }
   const OD_Vector3 *position() const {
-    return GetStruct<const OD_Vector3 *>(VT_POSITION);
-  }
-  const OD_Vector3 *facing() const {
-    return GetStruct<const OD_Vector3 *>(VT_FACING);
+    return GetPointer<const OD_Vector3 *>(VT_POSITION);
   }
   const OD_Vector3 *velocity() const {
-    return GetStruct<const OD_Vector3 *>(VT_VELOCITY);
+    return GetPointer<const OD_Vector3 *>(VT_VELOCITY);
   }
   const ::flatbuffers::Vector<::flatbuffers::Offset<Entity>> *entities() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Entity>> *>(VT_ENTITIES);
@@ -628,7 +903,9 @@ struct Client FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_SOURCE_POINT) &&
            verifier.VerifyTable(source_point()) &&
-           VerifyField<Tick>(verifier, VT_TICK, 4) &&
+           VerifyOffset(verifier, VT_TICK) &&
+           verifier.VerifyTable(tick()) &&
+           VerifyField<float>(verifier, VT_RTT, 4) &&
            VerifyField<uint32_t>(verifier, VT_CLIENT_UID, 4) &&
            VerifyField<uint8_t>(verifier, VT_ALIVE, 1) &&
            VerifyField<uint8_t>(verifier, VT_SPRINT, 1) &&
@@ -636,9 +913,10 @@ struct Client FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            verifier.VerifyTable(camera()) &&
            VerifyField<uint8_t>(verifier, VT_GROUNDED, 1) &&
            VerifyField<float>(verifier, VT_COOLDOWN, 4) &&
-           VerifyField<OD_Vector3>(verifier, VT_POSITION, 4) &&
-           VerifyField<OD_Vector3>(verifier, VT_FACING, 4) &&
-           VerifyField<OD_Vector3>(verifier, VT_VELOCITY, 4) &&
+           VerifyOffset(verifier, VT_POSITION) &&
+           verifier.VerifyTable(position()) &&
+           VerifyOffset(verifier, VT_VELOCITY) &&
+           verifier.VerifyTable(velocity()) &&
            VerifyOffset(verifier, VT_ENTITIES) &&
            verifier.VerifyVector(entities()) &&
            verifier.VerifyVectorOfTables(entities()) &&
@@ -653,8 +931,11 @@ struct ClientBuilder {
   void add_source_point(::flatbuffers::Offset<SourcePoint> source_point) {
     fbb_.AddOffset(Client::VT_SOURCE_POINT, source_point);
   }
-  void add_tick(const Tick *tick) {
-    fbb_.AddStruct(Client::VT_TICK, tick);
+  void add_tick(::flatbuffers::Offset<Tick> tick) {
+    fbb_.AddOffset(Client::VT_TICK, tick);
+  }
+  void add_rtt(float rtt) {
+    fbb_.AddElement<float>(Client::VT_RTT, rtt, 0.0f);
   }
   void add_client_uid(uint32_t client_uid) {
     fbb_.AddElement<uint32_t>(Client::VT_CLIENT_UID, client_uid, 0);
@@ -674,14 +955,11 @@ struct ClientBuilder {
   void add_cooldown(float cooldown) {
     fbb_.AddElement<float>(Client::VT_COOLDOWN, cooldown, 0.0f);
   }
-  void add_position(const OD_Vector3 *position) {
-    fbb_.AddStruct(Client::VT_POSITION, position);
+  void add_position(::flatbuffers::Offset<OD_Vector3> position) {
+    fbb_.AddOffset(Client::VT_POSITION, position);
   }
-  void add_facing(const OD_Vector3 *facing) {
-    fbb_.AddStruct(Client::VT_FACING, facing);
-  }
-  void add_velocity(const OD_Vector3 *velocity) {
-    fbb_.AddStruct(Client::VT_VELOCITY, velocity);
+  void add_velocity(::flatbuffers::Offset<OD_Vector3> velocity) {
+    fbb_.AddOffset(Client::VT_VELOCITY, velocity);
   }
   void add_entities(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Entity>>> entities) {
     fbb_.AddOffset(Client::VT_ENTITIES, entities);
@@ -700,25 +978,25 @@ struct ClientBuilder {
 inline ::flatbuffers::Offset<Client> CreateClient(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     ::flatbuffers::Offset<SourcePoint> source_point = 0,
-    const Tick *tick = nullptr,
+    ::flatbuffers::Offset<Tick> tick = 0,
+    float rtt = 0.0f,
     uint32_t client_uid = 0,
     bool alive = false,
     bool sprint = false,
     ::flatbuffers::Offset<OD_Camera3D> camera = 0,
     bool grounded = false,
     float cooldown = 0.0f,
-    const OD_Vector3 *position = nullptr,
-    const OD_Vector3 *facing = nullptr,
-    const OD_Vector3 *velocity = nullptr,
+    ::flatbuffers::Offset<OD_Vector3> position = 0,
+    ::flatbuffers::Offset<OD_Vector3> velocity = 0,
     ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Entity>>> entities = 0) {
   ClientBuilder builder_(_fbb);
   builder_.add_entities(entities);
   builder_.add_velocity(velocity);
-  builder_.add_facing(facing);
   builder_.add_position(position);
   builder_.add_cooldown(cooldown);
   builder_.add_camera(camera);
   builder_.add_client_uid(client_uid);
+  builder_.add_rtt(rtt);
   builder_.add_tick(tick);
   builder_.add_source_point(source_point);
   builder_.add_grounded(grounded);
@@ -730,22 +1008,23 @@ inline ::flatbuffers::Offset<Client> CreateClient(
 inline ::flatbuffers::Offset<Client> CreateClientDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     ::flatbuffers::Offset<SourcePoint> source_point = 0,
-    const Tick *tick = nullptr,
+    ::flatbuffers::Offset<Tick> tick = 0,
+    float rtt = 0.0f,
     uint32_t client_uid = 0,
     bool alive = false,
     bool sprint = false,
     ::flatbuffers::Offset<OD_Camera3D> camera = 0,
     bool grounded = false,
     float cooldown = 0.0f,
-    const OD_Vector3 *position = nullptr,
-    const OD_Vector3 *facing = nullptr,
-    const OD_Vector3 *velocity = nullptr,
+    ::flatbuffers::Offset<OD_Vector3> position = 0,
+    ::flatbuffers::Offset<OD_Vector3> velocity = 0,
     const std::vector<::flatbuffers::Offset<Entity>> *entities = nullptr) {
   auto entities__ = entities ? _fbb.CreateVector<::flatbuffers::Offset<Entity>>(*entities) : 0;
   return CreateClient(
       _fbb,
       source_point,
       tick,
+      rtt,
       client_uid,
       alive,
       sprint,
@@ -753,7 +1032,6 @@ inline ::flatbuffers::Offset<Client> CreateClientDirect(
       grounded,
       cooldown,
       position,
-      facing,
       velocity,
       entities__);
 }
@@ -762,21 +1040,25 @@ struct Input FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef InputBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_CLIENT_UID = 4,
-    VT_W = 6,
-    VT_A = 8,
-    VT_S = 10,
-    VT_D = 12,
-    VT_MOUSE_DELTA = 14,
-    VT_SHOOT = 16,
-    VT_SPACE = 18,
-    VT_DT = 20,
+    VT_TICK = 6,
+    VT_W = 8,
+    VT_A = 10,
+    VT_S = 12,
+    VT_D = 14,
+    VT_MOUSE_DELTA = 16,
+    VT_SHOOT = 18,
+    VT_SPACE = 20,
     VT_PREVIOUS_POSITION = 22,
     VT_SPRINT = 24,
-    VT_CROUCH = 26
+    VT_CROUCH = 26,
+    VT_OPPONENT_BUFFER_TICKS = 28
   };
   uint32_t client_uid() const {
     return GetField<uint32_t>(VT_CLIENT_UID, 0);
   }
+  const Tick *tick() const {
+    return GetPointer<const Tick *>(VT_TICK);
+  }
   bool w() const {
     return GetField<uint8_t>(VT_W, 0) != 0;
   }
@@ -790,7 +1072,7 @@ struct Input FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     return GetField<uint8_t>(VT_D, 0) != 0;
   }
   const OD_Vector2 *mouse_delta() const {
-    return GetStruct<const OD_Vector2 *>(VT_MOUSE_DELTA);
+    return GetPointer<const OD_Vector2 *>(VT_MOUSE_DELTA);
   }
   bool shoot() const {
     return GetField<uint8_t>(VT_SHOOT, 0) != 0;
@@ -798,11 +1080,8 @@ struct Input FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool space() const {
     return GetField<uint8_t>(VT_SPACE, 0) != 0;
   }
-  float dt() const {
-    return GetField<float>(VT_DT, 0.0f);
-  }
   const OD_Vector3 *previous_position() const {
-    return GetStruct<const OD_Vector3 *>(VT_PREVIOUS_POSITION);
+    return GetPointer<const OD_Vector3 *>(VT_PREVIOUS_POSITION);
   }
   bool sprint() const {
     return GetField<uint8_t>(VT_SPRINT, 0) != 0;
@@ -810,20 +1089,29 @@ struct Input FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool crouch() const {
     return GetField<uint8_t>(VT_CROUCH, 0) != 0;
   }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<Buffer>> *opponent_buffer_ticks() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Buffer>> *>(VT_OPPONENT_BUFFER_TICKS);
+  }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_CLIENT_UID, 4) &&
+           VerifyOffset(verifier, VT_TICK) &&
+           verifier.VerifyTable(tick()) &&
            VerifyField<uint8_t>(verifier, VT_W, 1) &&
            VerifyField<uint8_t>(verifier, VT_A, 1) &&
            VerifyField<uint8_t>(verifier, VT_S, 1) &&
            VerifyField<uint8_t>(verifier, VT_D, 1) &&
-           VerifyField<OD_Vector2>(verifier, VT_MOUSE_DELTA, 4) &&
+           VerifyOffset(verifier, VT_MOUSE_DELTA) &&
+           verifier.VerifyTable(mouse_delta()) &&
            VerifyField<uint8_t>(verifier, VT_SHOOT, 1) &&
            VerifyField<uint8_t>(verifier, VT_SPACE, 1) &&
-           VerifyField<float>(verifier, VT_DT, 4) &&
-           VerifyField<OD_Vector3>(verifier, VT_PREVIOUS_POSITION, 4) &&
+           VerifyOffset(verifier, VT_PREVIOUS_POSITION) &&
+           verifier.VerifyTable(previous_position()) &&
            VerifyField<uint8_t>(verifier, VT_SPRINT, 1) &&
            VerifyField<uint8_t>(verifier, VT_CROUCH, 1) &&
+           VerifyOffset(verifier, VT_OPPONENT_BUFFER_TICKS) &&
+           verifier.VerifyVector(opponent_buffer_ticks()) &&
+           verifier.VerifyVectorOfTables(opponent_buffer_ticks()) &&
            verifier.EndTable();
   }
 };
@@ -835,6 +1123,9 @@ struct InputBuilder {
   void add_client_uid(uint32_t client_uid) {
     fbb_.AddElement<uint32_t>(Input::VT_CLIENT_UID, client_uid, 0);
   }
+  void add_tick(::flatbuffers::Offset<Tick> tick) {
+    fbb_.AddOffset(Input::VT_TICK, tick);
+  }
   void add_w(bool w) {
     fbb_.AddElement<uint8_t>(Input::VT_W, static_cast<uint8_t>(w), 0);
   }
@@ -847,8 +1138,8 @@ struct InputBuilder {
   void add_d(bool d) {
     fbb_.AddElement<uint8_t>(Input::VT_D, static_cast<uint8_t>(d), 0);
   }
-  void add_mouse_delta(const OD_Vector2 *mouse_delta) {
-    fbb_.AddStruct(Input::VT_MOUSE_DELTA, mouse_delta);
+  void add_mouse_delta(::flatbuffers::Offset<OD_Vector2> mouse_delta) {
+    fbb_.AddOffset(Input::VT_MOUSE_DELTA, mouse_delta);
   }
   void add_shoot(bool shoot) {
     fbb_.AddElement<uint8_t>(Input::VT_SHOOT, static_cast<uint8_t>(shoot), 0);
@@ -856,11 +1147,8 @@ struct InputBuilder {
   void add_space(bool space) {
     fbb_.AddElement<uint8_t>(Input::VT_SPACE, static_cast<uint8_t>(space), 0);
   }
-  void add_dt(float dt) {
-    fbb_.AddElement<float>(Input::VT_DT, dt, 0.0f);
-  }
-  void add_previous_position(const OD_Vector3 *previous_position) {
-    fbb_.AddStruct(Input::VT_PREVIOUS_POSITION, previous_position);
+  void add_previous_position(::flatbuffers::Offset<OD_Vector3> previous_position) {
+    fbb_.AddOffset(Input::VT_PREVIOUS_POSITION, previous_position);
   }
   void add_sprint(bool sprint) {
     fbb_.AddElement<uint8_t>(Input::VT_SPRINT, static_cast<uint8_t>(sprint), 0);
@@ -868,6 +1156,9 @@ struct InputBuilder {
   void add_crouch(bool crouch) {
     fbb_.AddElement<uint8_t>(Input::VT_CROUCH, static_cast<uint8_t>(crouch), 0);
   }
+  void add_opponent_buffer_ticks(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Buffer>>> opponent_buffer_ticks) {
+    fbb_.AddOffset(Input::VT_OPPONENT_BUFFER_TICKS, opponent_buffer_ticks);
+  }
   explicit InputBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -882,21 +1173,23 @@ struct InputBuilder {
 inline ::flatbuffers::Offset<Input> CreateInput(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     uint32_t client_uid = 0,
+    ::flatbuffers::Offset<Tick> tick = 0,
     bool w = false,
     bool a = false,
     bool s = false,
     bool d = false,
-    const OD_Vector2 *mouse_delta = nullptr,
+    ::flatbuffers::Offset<OD_Vector2> mouse_delta = 0,
     bool shoot = false,
     bool space = false,
-    float dt = 0.0f,
-    const OD_Vector3 *previous_position = nullptr,
+    ::flatbuffers::Offset<OD_Vector3> previous_position = 0,
     bool sprint = false,
-    bool crouch = false) {
+    bool crouch = false,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Buffer>>> opponent_buffer_ticks = 0) {
   InputBuilder builder_(_fbb);
+  builder_.add_opponent_buffer_ticks(opponent_buffer_ticks);
   builder_.add_previous_position(previous_position);
-  builder_.add_dt(dt);
   builder_.add_mouse_delta(mouse_delta);
+  builder_.add_tick(tick);
   builder_.add_client_uid(client_uid);
   builder_.add_crouch(crouch);
   builder_.add_sprint(sprint);
@@ -909,73 +1202,433 @@ inline ::flatbuffers::Offset<Input> CreateInput(
   return builder_.Finish();
 }
 
-struct GlobalState FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef GlobalStateBuilder Builder;
+inline ::flatbuffers::Offset<Input> CreateInputDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t client_uid = 0,
+    ::flatbuffers::Offset<Tick> tick = 0,
+    bool w = false,
+    bool a = false,
+    bool s = false,
+    bool d = false,
+    ::flatbuffers::Offset<OD_Vector2> mouse_delta = 0,
+    bool shoot = false,
+    bool space = false,
+    ::flatbuffers::Offset<OD_Vector3> previous_position = 0,
+    bool sprint = false,
+    bool crouch = false,
+    const std::vector<::flatbuffers::Offset<Buffer>> *opponent_buffer_ticks = nullptr) {
+  auto opponent_buffer_ticks__ = opponent_buffer_ticks ? _fbb.CreateVector<::flatbuffers::Offset<Buffer>>(*opponent_buffer_ticks) : 0;
+  return CreateInput(
+      _fbb,
+      client_uid,
+      tick,
+      w,
+      a,
+      s,
+      d,
+      mouse_delta,
+      shoot,
+      space,
+      previous_position,
+      sprint,
+      crouch,
+      opponent_buffer_ticks__);
+}
+
+struct ClientInputs FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ClientInputsBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_CLIENT_INPUTS = 4
+  };
+  const ::flatbuffers::Vector<::flatbuffers::Offset<Input>> *client_inputs() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Input>> *>(VT_CLIENT_INPUTS);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_CLIENT_INPUTS) &&
+           verifier.VerifyVector(client_inputs()) &&
+           verifier.VerifyVectorOfTables(client_inputs()) &&
+           verifier.EndTable();
+  }
+};
+
+struct ClientInputsBuilder {
+  typedef ClientInputs Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_client_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Input>>> client_inputs) {
+    fbb_.AddOffset(ClientInputs::VT_CLIENT_INPUTS, client_inputs);
+  }
+  explicit ClientInputsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<ClientInputs> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<ClientInputs>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<ClientInputs> CreateClientInputs(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Input>>> client_inputs = 0) {
+  ClientInputsBuilder builder_(_fbb);
+  builder_.add_client_inputs(client_inputs);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<ClientInputs> CreateClientInputsDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<::flatbuffers::Offset<Input>> *client_inputs = nullptr) {
+  auto client_inputs__ = client_inputs ? _fbb.CreateVector<::flatbuffers::Offset<Input>>(*client_inputs) : 0;
+  return CreateClientInputs(
+      _fbb,
+      client_inputs__);
+}
+
+struct ClientStates FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ClientStatesBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_RTT = 4,
+    VT_CLIENT_STATES = 6
+  };
+  float rtt() const {
+    return GetField<float>(VT_RTT, 0.0f);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<Client>> *client_states() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Client>> *>(VT_CLIENT_STATES);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<float>(verifier, VT_RTT, 4) &&
+           VerifyOffset(verifier, VT_CLIENT_STATES) &&
+           verifier.VerifyVector(client_states()) &&
+           verifier.VerifyVectorOfTables(client_states()) &&
+           verifier.EndTable();
+  }
+};
+
+struct ClientStatesBuilder {
+  typedef ClientStates Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_rtt(float rtt) {
+    fbb_.AddElement<float>(ClientStates::VT_RTT, rtt, 0.0f);
+  }
+  void add_client_states(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Client>>> client_states) {
+    fbb_.AddOffset(ClientStates::VT_CLIENT_STATES, client_states);
+  }
+  explicit ClientStatesBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<ClientStates> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<ClientStates>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<ClientStates> CreateClientStates(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    float rtt = 0.0f,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Client>>> client_states = 0) {
+  ClientStatesBuilder builder_(_fbb);
+  builder_.add_client_states(client_states);
+  builder_.add_rtt(rtt);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<ClientStates> CreateClientStatesDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    float rtt = 0.0f,
+    const std::vector<::flatbuffers::Offset<Client>> *client_states = nullptr) {
+  auto client_states__ = client_states ? _fbb.CreateVector<::flatbuffers::Offset<Client>>(*client_states) : 0;
+  return CreateClientStates(
+      _fbb,
+      rtt,
+      client_states__);
+}
+
+struct States FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef StatesBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_STATE_TYPE = 4,
+    VT_STATE = 6
+  };
+  StatesOptions state_type() const {
+    return static_cast<StatesOptions>(GetField<uint8_t>(VT_STATE_TYPE, 0));
+  }
+  const void *state() const {
+    return GetPointer<const void *>(VT_STATE);
+  }
+  template<typename T> const T *state_as() const;
+  const ClientInputs *state_as_ClientInputs() const {
+    return state_type() == StatesOptions_ClientInputs ? static_cast<const ClientInputs *>(state()) : nullptr;
+  }
+  const ClientStates *state_as_ClientStates() const {
+    return state_type() == StatesOptions_ClientStates ? static_cast<const ClientStates *>(state()) : nullptr;
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint8_t>(verifier, VT_STATE_TYPE, 1) &&
+           VerifyOffset(verifier, VT_STATE) &&
+           VerifyStatesOptions(verifier, state(), state_type()) &&
+           verifier.EndTable();
+  }
+};
+
+template<> inline const ClientInputs *States::state_as<ClientInputs>() const {
+  return state_as_ClientInputs();
+}
+
+template<> inline const ClientStates *States::state_as<ClientStates>() const {
+  return state_as_ClientStates();
+}
+
+struct StatesBuilder {
+  typedef States Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_state_type(StatesOptions state_type) {
+    fbb_.AddElement<uint8_t>(States::VT_STATE_TYPE, static_cast<uint8_t>(state_type), 0);
+  }
+  void add_state(::flatbuffers::Offset<void> state) {
+    fbb_.AddOffset(States::VT_STATE, state);
+  }
+  explicit StatesBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<States> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<States>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<States> CreateStates(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    StatesOptions state_type = StatesOptions_NONE,
+    ::flatbuffers::Offset<void> state = 0) {
+  StatesBuilder builder_(_fbb);
+  builder_.add_state(state);
+  builder_.add_state_type(state_type);
+  return builder_.Finish();
+}
+
+struct AllPlayerDeltas FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef AllPlayerDeltasBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_PAYLOAD = 4
+  };
+  const ::flatbuffers::Vector<::flatbuffers::Offset<States>> *payload() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<States>> *>(VT_PAYLOAD);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_PAYLOAD) &&
+           verifier.VerifyVector(payload()) &&
+           verifier.VerifyVectorOfTables(payload()) &&
+           verifier.EndTable();
+  }
+};
+
+struct AllPlayerDeltasBuilder {
+  typedef AllPlayerDeltas Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_payload(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<States>>> payload) {
+    fbb_.AddOffset(AllPlayerDeltas::VT_PAYLOAD, payload);
+  }
+  explicit AllPlayerDeltasBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<AllPlayerDeltas> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<AllPlayerDeltas>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<AllPlayerDeltas> CreateAllPlayerDeltas(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<States>>> payload = 0) {
+  AllPlayerDeltasBuilder builder_(_fbb);
+  builder_.add_payload(payload);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<AllPlayerDeltas> CreateAllPlayerDeltasDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<::flatbuffers::Offset<States>> *payload = nullptr) {
+  auto payload__ = payload ? _fbb.CreateVector<::flatbuffers::Offset<States>>(*payload) : 0;
+  return CreateAllPlayerDeltas(
+      _fbb,
+      payload__);
+}
+
+struct AllPlayerSnapshots FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef AllPlayerSnapshotsBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_CLIENT_STATE = 4
+    VT_PAYLOAD = 4
   };
-  const ::flatbuffers::Vector<::flatbuffers::Offset<Client>> *client_state() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Client>> *>(VT_CLIENT_STATE);
+  const ::flatbuffers::Vector<::flatbuffers::Offset<States>> *payload() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<States>> *>(VT_PAYLOAD);
   }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_CLIENT_STATE) &&
-           verifier.VerifyVector(client_state()) &&
-           verifier.VerifyVectorOfTables(client_state()) &&
+           VerifyOffset(verifier, VT_PAYLOAD) &&
+           verifier.VerifyVector(payload()) &&
+           verifier.VerifyVectorOfTables(payload()) &&
            verifier.EndTable();
   }
 };
 
-struct GlobalStateBuilder {
-  typedef GlobalState Table;
+struct AllPlayerSnapshotsBuilder {
+  typedef AllPlayerSnapshots Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
   ::flatbuffers::uoffset_t start_;
-  void add_client_state(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Client>>> client_state) {
-    fbb_.AddOffset(GlobalState::VT_CLIENT_STATE, client_state);
+  void add_payload(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<States>>> payload) {
+    fbb_.AddOffset(AllPlayerSnapshots::VT_PAYLOAD, payload);
   }
-  explicit GlobalStateBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+  explicit AllPlayerSnapshotsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  ::flatbuffers::Offset<GlobalState> Finish() {
+  ::flatbuffers::Offset<AllPlayerSnapshots> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<GlobalState>(end);
+    auto o = ::flatbuffers::Offset<AllPlayerSnapshots>(end);
     return o;
   }
 };
 
-inline ::flatbuffers::Offset<GlobalState> CreateGlobalState(
+inline ::flatbuffers::Offset<AllPlayerSnapshots> CreateAllPlayerSnapshots(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Client>>> client_state = 0) {
-  GlobalStateBuilder builder_(_fbb);
-  builder_.add_client_state(client_state);
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<States>>> payload = 0) {
+  AllPlayerSnapshotsBuilder builder_(_fbb);
+  builder_.add_payload(payload);
   return builder_.Finish();
 }
 
-inline ::flatbuffers::Offset<GlobalState> CreateGlobalStateDirect(
+inline ::flatbuffers::Offset<AllPlayerSnapshots> CreateAllPlayerSnapshotsDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    const std::vector<::flatbuffers::Offset<Client>> *client_state = nullptr) {
-  auto client_state__ = client_state ? _fbb.CreateVector<::flatbuffers::Offset<Client>>(*client_state) : 0;
-  return CreateGlobalState(
+    const std::vector<::flatbuffers::Offset<States>> *payload = nullptr) {
+  auto payload__ = payload ? _fbb.CreateVector<::flatbuffers::Offset<States>>(*payload) : 0;
+  return CreateAllPlayerSnapshots(
       _fbb,
-      client_state__);
+      payload__);
+}
+
+struct Payload FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef PayloadBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_PAYLOAD_TYPE = 4,
+    VT_PAYLOAD = 6
+  };
+  PayloadTypes payload_type() const {
+    return static_cast<PayloadTypes>(GetField<uint8_t>(VT_PAYLOAD_TYPE, 0));
+  }
+  const void *payload() const {
+    return GetPointer<const void *>(VT_PAYLOAD);
+  }
+  template<typename T> const T *payload_as() const;
+  const Input *payload_as_Input() const {
+    return payload_type() == PayloadTypes_Input ? static_cast<const Input *>(payload()) : nullptr;
+  }
+  const AllPlayerDeltas *payload_as_AllPlayerDeltas() const {
+    return payload_type() == PayloadTypes_AllPlayerDeltas ? static_cast<const AllPlayerDeltas *>(payload()) : nullptr;
+  }
+  const AllPlayerSnapshots *payload_as_AllPlayerSnapshots() const {
+    return payload_type() == PayloadTypes_AllPlayerSnapshots ? static_cast<const AllPlayerSnapshots *>(payload()) : nullptr;
+  }
+  const ClientStates *payload_as_ClientStates() const {
+    return payload_type() == PayloadTypes_ClientStates ? static_cast<const ClientStates *>(payload()) : nullptr;
+  }
+  const ClientInputs *payload_as_ClientInputs() const {
+    return payload_type() == PayloadTypes_ClientInputs ? static_cast<const ClientInputs *>(payload()) : nullptr;
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint8_t>(verifier, VT_PAYLOAD_TYPE, 1) &&
+           VerifyOffset(verifier, VT_PAYLOAD) &&
+           VerifyPayloadTypes(verifier, payload(), payload_type()) &&
+           verifier.EndTable();
+  }
+};
+
+template<> inline const Input *Payload::payload_as<Input>() const {
+  return payload_as_Input();
+}
+
+template<> inline const AllPlayerDeltas *Payload::payload_as<AllPlayerDeltas>() const {
+  return payload_as_AllPlayerDeltas();
+}
+
+template<> inline const AllPlayerSnapshots *Payload::payload_as<AllPlayerSnapshots>() const {
+  return payload_as_AllPlayerSnapshots();
+}
+
+template<> inline const ClientStates *Payload::payload_as<ClientStates>() const {
+  return payload_as_ClientStates();
+}
+
+template<> inline const ClientInputs *Payload::payload_as<ClientInputs>() const {
+  return payload_as_ClientInputs();
+}
+
+struct PayloadBuilder {
+  typedef Payload Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_payload_type(PayloadTypes payload_type) {
+    fbb_.AddElement<uint8_t>(Payload::VT_PAYLOAD_TYPE, static_cast<uint8_t>(payload_type), 0);
+  }
+  void add_payload(::flatbuffers::Offset<void> payload) {
+    fbb_.AddOffset(Payload::VT_PAYLOAD, payload);
+  }
+  explicit PayloadBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Payload> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Payload>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Payload> CreatePayload(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    PayloadTypes payload_type = PayloadTypes_NONE,
+    ::flatbuffers::Offset<void> payload = 0) {
+  PayloadBuilder builder_(_fbb);
+  builder_.add_payload(payload);
+  builder_.add_payload_type(payload_type);
+  return builder_.Finish();
 }
 
 struct OD_Packet FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef OD_PacketBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_PACKET_TYPE = 4,
-    VT_DEST_POINT = 6,
-    VT_SOURCE_POINT = 8,
-    VT_LOBBY_NUMBER = 10,
-    VT_RELIABLE = 12,
-    VT_TICK = 14,
-    VT_PAYLOAD_TYPE = 16,
-    VT_PAYLOAD = 18
+    VT_CLIENT_ID = 6,
+    VT_DEST_POINT = 8,
+    VT_SOURCE_POINT = 10,
+    VT_LOBBY_NUMBER = 12,
+    VT_RELIABLE = 14,
+    VT_SERVER_TICK = 16,
+    VT_CLIENT_TICK = 18,
+    VT_PAYLOAD = 20
   };
   PacketType packet_type() const {
     return static_cast<PacketType>(GetField<int8_t>(VT_PACKET_TYPE, 0));
   }
+  int32_t client_id() const {
+    return GetField<int32_t>(VT_CLIENT_ID, 0);
+  }
   const DestPoint *dest_point() const {
     return GetPointer<const DestPoint *>(VT_DEST_POINT);
   }
@@ -988,47 +1641,35 @@ struct OD_Packet FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool reliable() const {
     return GetField<uint8_t>(VT_RELIABLE, 0) != 0;
   }
-  const Tick *tick() const {
-    return GetStruct<const Tick *>(VT_TICK);
-  }
-  PacketPayload payload_type() const {
-    return static_cast<PacketPayload>(GetField<uint8_t>(VT_PAYLOAD_TYPE, 0));
-  }
-  const void *payload() const {
-    return GetPointer<const void *>(VT_PAYLOAD);
+  const Tick *server_tick() const {
+    return GetPointer<const Tick *>(VT_SERVER_TICK);
   }
-  template<typename T> const T *payload_as() const;
-  const Input *payload_as_Input() const {
-    return payload_type() == PacketPayload_Input ? static_cast<const Input *>(payload()) : nullptr;
+  const Tick *client_tick() const {
+    return GetPointer<const Tick *>(VT_CLIENT_TICK);
   }
-  const GlobalState *payload_as_GlobalState() const {
-    return payload_type() == PacketPayload_GlobalState ? static_cast<const GlobalState *>(payload()) : nullptr;
+  const Payload *payload() const {
+    return GetPointer<const Payload *>(VT_PAYLOAD);
   }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_PACKET_TYPE, 1) &&
+           VerifyField<int32_t>(verifier, VT_CLIENT_ID, 4) &&
            VerifyOffset(verifier, VT_DEST_POINT) &&
            verifier.VerifyTable(dest_point()) &&
            VerifyOffset(verifier, VT_SOURCE_POINT) &&
            verifier.VerifyTable(source_point()) &&
            VerifyField<uint32_t>(verifier, VT_LOBBY_NUMBER, 4) &&
            VerifyField<uint8_t>(verifier, VT_RELIABLE, 1) &&
-           VerifyField<Tick>(verifier, VT_TICK, 4) &&
-           VerifyField<uint8_t>(verifier, VT_PAYLOAD_TYPE, 1) &&
+           VerifyOffset(verifier, VT_SERVER_TICK) &&
+           verifier.VerifyTable(server_tick()) &&
+           VerifyOffset(verifier, VT_CLIENT_TICK) &&
+           verifier.VerifyTable(client_tick()) &&
            VerifyOffset(verifier, VT_PAYLOAD) &&
-           VerifyPacketPayload(verifier, payload(), payload_type()) &&
+           verifier.VerifyTable(payload()) &&
            verifier.EndTable();
   }
 };
 
-template<> inline const Input *OD_Packet::payload_as<Input>() const {
-  return payload_as_Input();
-}
-
-template<> inline const GlobalState *OD_Packet::payload_as<GlobalState>() const {
-  return payload_as_GlobalState();
-}
-
 struct OD_PacketBuilder {
   typedef OD_Packet Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
@@ -1036,6 +1677,9 @@ struct OD_PacketBuilder {
   void add_packet_type(PacketType packet_type) {
     fbb_.AddElement<int8_t>(OD_Packet::VT_PACKET_TYPE, static_cast<int8_t>(packet_type), 0);
   }
+  void add_client_id(int32_t client_id) {
+    fbb_.AddElement<int32_t>(OD_Packet::VT_CLIENT_ID, client_id, 0);
+  }
   void add_dest_point(::flatbuffers::Offset<DestPoint> dest_point) {
     fbb_.AddOffset(OD_Packet::VT_DEST_POINT, dest_point);
   }
@@ -1048,13 +1692,13 @@ struct OD_PacketBuilder {
   void add_reliable(bool reliable) {
     fbb_.AddElement<uint8_t>(OD_Packet::VT_RELIABLE, static_cast<uint8_t>(reliable), 0);
   }
-  void add_tick(const Tick *tick) {
-    fbb_.AddStruct(OD_Packet::VT_TICK, tick);
+  void add_server_tick(::flatbuffers::Offset<Tick> server_tick) {
+    fbb_.AddOffset(OD_Packet::VT_SERVER_TICK, server_tick);
   }
-  void add_payload_type(PacketPayload payload_type) {
-    fbb_.AddElement<uint8_t>(OD_Packet::VT_PAYLOAD_TYPE, static_cast<uint8_t>(payload_type), 0);
+  void add_client_tick(::flatbuffers::Offset<Tick> client_tick) {
+    fbb_.AddOffset(OD_Packet::VT_CLIENT_TICK, client_tick);
   }
-  void add_payload(::flatbuffers::Offset<void> payload) {
+  void add_payload(::flatbuffers::Offset<Payload> payload) {
     fbb_.AddOffset(OD_Packet::VT_PAYLOAD, payload);
   }
   explicit OD_PacketBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
@@ -1071,48 +1715,91 @@ struct OD_PacketBuilder {
 inline ::flatbuffers::Offset<OD_Packet> CreateOD_Packet(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     PacketType packet_type = PacketType_CreateLobby,
+    int32_t client_id = 0,
     ::flatbuffers::Offset<DestPoint> dest_point = 0,
     ::flatbuffers::Offset<SourcePoint> source_point = 0,
     uint32_t lobby_number = 0,
     bool reliable = false,
-    const Tick *tick = nullptr,
-    PacketPayload payload_type = PacketPayload_NONE,
-    ::flatbuffers::Offset<void> payload = 0) {
+    ::flatbuffers::Offset<Tick> server_tick = 0,
+    ::flatbuffers::Offset<Tick> client_tick = 0,
+    ::flatbuffers::Offset<Payload> payload = 0) {
   OD_PacketBuilder builder_(_fbb);
   builder_.add_payload(payload);
-  builder_.add_tick(tick);
+  builder_.add_client_tick(client_tick);
+  builder_.add_server_tick(server_tick);
   builder_.add_lobby_number(lobby_number);
   builder_.add_source_point(source_point);
   builder_.add_dest_point(dest_point);
-  builder_.add_payload_type(payload_type);
+  builder_.add_client_id(client_id);
   builder_.add_reliable(reliable);
   builder_.add_packet_type(packet_type);
   return builder_.Finish();
 }
 
-inline bool VerifyPacketPayload(::flatbuffers::Verifier &verifier, const void *obj, PacketPayload type) {
+inline bool VerifyStatesOptions(::flatbuffers::Verifier &verifier, const void *obj, StatesOptions type) {
   switch (type) {
-    case PacketPayload_NONE: {
+    case StatesOptions_NONE: {
       return true;
     }
-    case PacketPayload_Input: {
+    case StatesOptions_ClientInputs: {
+      auto ptr = reinterpret_cast<const ClientInputs *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case StatesOptions_ClientStates: {
+      auto ptr = reinterpret_cast<const ClientStates *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    default: return true;
+  }
+}
+
+inline bool VerifyStatesOptionsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+  if (!values || !types) return !values && !types;
+  if (values->size() != types->size()) return false;
+  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+    if (!VerifyStatesOptions(
+        verifier,  values->Get(i), types->GetEnum<StatesOptions>(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline bool VerifyPayloadTypes(::flatbuffers::Verifier &verifier, const void *obj, PayloadTypes type) {
+  switch (type) {
+    case PayloadTypes_NONE: {
+      return true;
+    }
+    case PayloadTypes_Input: {
       auto ptr = reinterpret_cast<const Input *>(obj);
       return verifier.VerifyTable(ptr);
     }
-    case PacketPayload_GlobalState: {
-      auto ptr = reinterpret_cast<const GlobalState *>(obj);
+    case PayloadTypes_AllPlayerDeltas: {
+      auto ptr = reinterpret_cast<const AllPlayerDeltas *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case PayloadTypes_AllPlayerSnapshots: {
+      auto ptr = reinterpret_cast<const AllPlayerSnapshots *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case PayloadTypes_ClientStates: {
+      auto ptr = reinterpret_cast<const ClientStates *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case PayloadTypes_ClientInputs: {
+      auto ptr = reinterpret_cast<const ClientInputs *>(obj);
       return verifier.VerifyTable(ptr);
     }
     default: return true;
   }
 }
 
-inline bool VerifyPacketPayloadVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+inline bool VerifyPayloadTypesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
-    if (!VerifyPacketPayload(
-        verifier,  values->Get(i), types->GetEnum<PacketPayload>(i))) {
+    if (!VerifyPayloadTypes(
+        verifier,  values->Get(i), types->GetEnum<PayloadTypes>(i))) {
       return false;
     }
   }
diff --git a/main.cpp b/main.cpp
index c9803d3..a62fc99 100644
--- a/main.cpp
+++ b/main.cpp
@@ -51,9 +51,15 @@ int main(void)
 
 
     PacketBuffer outputBuffer(consoleMutex);
+<<<<<<< HEAD
+    Transmitter transmitter("172.17.8.211",6565,outputBuffer,consoleMutex);
+    PacketBuffer inputBuffer(consoleMutex);
+    Gateway gateway("172.17.8.211",5808,inputBuffer);
+=======
     Transmitter transmitter("192.168.56.1",5452,outputBuffer,consoleMutex);
     PacketBuffer inputBuffer(consoleMutex);
     Gateway gateway("192.168.56.1",5453,inputBuffer);
+>>>>>>> 550e05ef4bdf2e0a8fb9d4f5a36438ce19f2141f
     //TODO
     //implement join sequence
 
@@ -85,7 +91,12 @@ int main(void)
     const int screenWidth = GetMonitorWidth(0);
     const int screenHeight = GetMonitorHeight(0);
     Rl_CloseWindow();
+<<<<<<< HEAD
+
+    InitWindow(screenWidth-400, screenHeight-400, "Shooter Game");
+=======
     InitWindow(screenWidth, screenHeight, "Shooter Game");
+>>>>>>> 550e05ef4bdf2e0a8fb9d4f5a36438ce19f2141f
     //set fps
     SetTargetFPS(120);
     //disable cursor
@@ -108,20 +119,80 @@ int main(void)
         }
         //TODO
         //implement checking incoming packets against past packet buffer and update client position based off that
+        if(inputBuffer.getNumberOfPackets() > 0){
+            auto toProcess = inputBuffer.removePacketInstant();
+            {
+                {
+                    std::lock_guard<std::mutex> guard(consoleMutex);
+                    for(auto& packet : toProcess){
+
+                        cout << "Packet Label: " << EnumNamePacketType(packet->getPacketView()->packet_type()) << endl;
+                        cout << "Source Point: (IP: " << packet->getPacketView()->source_point()->address() << ", Port: " << packet->getPacketView()->source_point()->port() << ") " << endl;
+                        cout << "Destination Point: (IP: " << packet->getPacketView()->dest_point()->address() << ", Port: " << packet->getPacketView()->dest_point()->port() << ") " << endl;
+                        cout << "Lobby Number: " << packet->getPacketView()->lobby_number() << endl;
+                        cout << "Client Tick Number: " << packet->getPacketView()->client_tick()->tick_number() << endl;
+                        cout << "Payload: \n\t: ";
+                        cout << "Payload Type: " << EnumNamePayloadTypes(packet->getPacketView()->payload()->payload_type()) << endl;
+                        cout << "\tdt: " << packet->getPacketView()->client_tick()->dt() << endl;
+                        cout << "\tW: " << packet->getPacketView()->payload()->payload_as_Input()->w() << ", A: " << packet->getPacketView()->payload()->payload_as_Input()->a() << " S: " << packet->getPacketView()->payload()->payload_as_Input()->s() << " D: " << packet->getPacketView()->payload()->payload_as_Input()->d() << endl;
+                        cout << "\tMouseDelta: (" << packet->getPacketView()->payload()->payload_as_Input()->mouse_delta()->x() << ", " << packet->getPacketView()->payload()->payload_as_Input()->mouse_delta()->y() << ")" << endl;
+                        cout << "\tShoot: " << to_string(packet->getPacketView()->payload()->payload_as_Input()->shoot()) << ", Jump: " << to_string(packet->getPacketView()->payload()->payload_as_Input()->space()) << ", Sprint: " << to_string(packet->getPacketView()->payload()->payload_as_Input()->sprint()) << endl;
+                        cout << "\tPrevious State: (" << packet->getPacketView()->payload()->payload_as_Input()->previous_position()->x() << ", " << packet->getPacketView()->payload()->payload_as_Input()->previous_position()->y() << ", " << packet->getPacketView()->payload()->payload_as_Input()->previous_position()->z() << ")\n" << endl;
+                    }
+                    // TODO: Enter a decision tree determining what authoritative decision is required
+                }
+            }
+        }
+
+
         prevPosition = temp.getPosition();
 
         //read local inputs and update player positions/spawn bullet entities
         flatbuffers::FlatBufferBuilder builder(1024);
         auto destAddr = builder.CreateString("192.168.1.12");
         auto srcAddr = builder.CreateString("192.168.56.1");
-        const auto waste = OD_Vector2(GetMouseDelta().x,GetMouseDelta().y);
-        const auto waste2 = OD_Vector3(prevPosition.x,prevPosition.y,prevPosition.z);
-        auto dest = CreateDestPoint(builder,destAddr,5450);
+//        const auto waste = OD_Vector2(GetMouseDelta().x,GetMouseDelta().y);
+        const auto waste = CreateOD_Vector2(builder, GetMouseDelta().x, GetMouseDelta().y);
+//        const auto waste2 = OD_Vector3(prevPosition.x,prevPosition.y,prevPosition.z);
+        const auto waste2 = CreateOD_Vector3(builder, prevPosition.x, prevPosition.y, prevPosition.z);
+        auto dest = CreateDestPoint(builder,destAddr,5808);
         auto src = CreateSourcePoint(builder,srcAddr,6565);
-        auto input = CreateInput(builder,0,IsKeyDown(KEY_W),IsKeyDown(KEY_A),
-                                 IsKeyDown(KEY_S),IsKeyDown(KEY_D),&waste,IsMouseButtonDown(MOUSE_BUTTON_LEFT),IsKeyDown(KEY_SPACE)
-                ,GetFrameTime(),&waste2,IsKeyDown(KEY_LEFT_SHIFT)).Union();
-        const auto ticked = Tick(tick,GetFrameTime());
+        auto tickOffset = CreateTick(builder, tick, GetFrameTime());
+//        auto input = CreateInput(builder,0,IsKeyDown(KEY_W),IsKeyDown(KEY_A),
+//                                 IsKeyDown(KEY_S),IsKeyDown(KEY_D),&waste,IsMouseButtonDown(MOUSE_BUTTON_LEFT),IsKeyDown(KEY_SPACE)
+//                ,GetFrameTime(),&waste2,IsKeyDown(KEY_LEFT_SHIFT)).Union();
+//        auto input = CreateInput(builder
+//                ,0
+//                ,IsKeyDown(KEY_W)
+//                ,IsKeyDown(KEY_A),
+//                IsKeyDown(KEY_S),
+//                IsKeyDown(KEY_D),
+//                waste,IsMouseButtonDown(MOUSE_BUTTON_LEFT),
+//                IsKeyDown(KEY_SPACE),
+//                GetFrameTime(),
+//                waste2,IsKeyDown(KEY_LEFT_SHIFT)
+//                ).Union();
+        auto mouseDeltaOffset = CreateOD_Vector2(builder, GetMouseDelta().x, GetMouseDelta().y);
+        auto previousPositionOffset = CreateOD_Vector3(builder, prevPosition.x, prevPosition.y, prevPosition.z);
+
+        auto input = CreateInput(builder,
+                                 0,
+                                 tickOffset,
+                                 IsKeyDown(KEY_W),
+                                 IsKeyDown(KEY_A),
+                                 IsKeyDown(KEY_S),
+                                 IsKeyDown(KEY_D),
+                                 mouseDeltaOffset,
+                                 IsMouseButtonDown(MOUSE_BUTTON_LEFT),
+                                 IsKeyDown(KEY_SPACE),
+                                 previousPositionOffset,
+                                 IsKeyDown(KEY_LEFT_SHIFT),
+                                 IsKeyDown(KEY_LEFT_CONTROL)
+                );
+
+        auto payload = CreatePayload(builder, PayloadTypes_Input, input.Union());
+//        const auto ticked = Tick(tick,GetFrameTime());
+        const auto ticked = CreateTick(builder, tick, GetFrameTime(), 60);
         OD_PacketBuilder packetBuilder(builder);
 
         packetBuilder.add_reliable(false);
@@ -129,9 +200,11 @@ int main(void)
         packetBuilder.add_source_point(src);
         packetBuilder.add_packet_type(PacketType_Input);
         packetBuilder.add_lobby_number(0);
-        packetBuilder.add_payload_type(PacketPayload_Input);
-        packetBuilder.add_tick(&ticked);
-        packetBuilder.add_payload(input);
+        packetBuilder.add_payload(payload);
+//        packetBuilder.add_payload_type(PacketPayload_Input);
+//        packetBuilder.add_tick(&ticked);
+        packetBuilder.add_client_tick(ticked);
+//        packetBuilder.add_payload(input);
         auto packet = packetBuilder.Finish();
         builder.Finish(packet);
         uint8_t* buffer = builder.GetBufferPointer();