some of the changes i had

.gitignore

@@ -13,4 +13,5 @@ build
 Disassembly
 .vscode
 *.log
-Content/Roblox
+Content/Roblox
+build-release

Projects/Client/Studio/Source/MainWindow.cpp

@@ -202,15 +202,16 @@ void MainWindow::pause()
 
 void MainWindow::playSolo()
 {
-    this->ogreWidget->world->getRunService()->run();
 
     RNR::Players* players = (RNR::Players*)this->ogreWidget->world->getDatamodel()->getService("Players");
     RNR::Player* player = players->createLocalPlayer(0);
     if(!player) 
         return;
+    player->setParent(players);
     player->setName(QInputDialog::getText(this, "Player Name", "Enter your player name").toLocal8Bit().data());
     player->loadCharacter();
 
+    this->ogreWidget->world->getRunService()->run();
     updateTree(ogreWidget->world->getDatamodel());
 }
 

Projects/Engine/Header/App/GUI/TopMenuBar.hpp

@@ -15,7 +15,9 @@ namespace RNR
     {
         Ogre::TextAreaOverlayElement* m_debugText;
         Ogre::TextAreaOverlayElement* m_playerList;
+        Ogre::TextAreaOverlayElement* m_connectionText;
         Ogre::OverlayContainer* m_playerPanel;
+        Ogre::OverlayContainer* m_connectionPanel;
         Ogre::OverlayManager* m_overlayManager;
         World* m_world;
     public:

Projects/Engine/Header/App/Humanoid/Humanoid.hpp

@@ -38,6 +38,7 @@ namespace RNR
             float m_health;
             float m_maxHealth;
             float m_walkRotationalVelocity;
+            float m_walkSpeed;
             btKinematicCharacterController* m_characterController;
             btPairCachingGhostObject* m_playerGhostObject; 
     };

Projects/Engine/Header/App/V8/World/World.hpp

@@ -42,7 +42,7 @@ namespace RNR
         virtual void updateWorldLoad() = 0;
     };
 
-    class World
+    class World : Ogre::RenderSystem::Listener
     {
         private:
             static void globalInit();
@@ -108,7 +108,7 @@ namespace RNR
             void setMaxLoadProgress(int p) { m_maxLoadProgress = p; }
             int getLoadProgress() { return m_loadProgress; }
             void setLoadProgress(int p) { m_loadProgress = p; }
-
+            virtual void eventOccurred(const Ogre::String &eventName, const Ogre::NameValuePairList* parameters);
             Lock dynamicWorldLock;
     };
 }

Projects/Engine/Header/Network/ArkNet/ArkPacket.hpp

@@ -2,10 +2,32 @@
 
 namespace ArkNet
 {
+    class ArkStream;
+
+    const char PACKET_VERSION = 11;
+    const char OFFLINE_MAGIC[] = {
+        (char)0x00, 
+        (char)0xff, 
+        (char)0xff, 
+        (char)0x00, 
+        (char)0xfe, 
+        (char)0xfe, 
+        (char)0xfe, 
+        (char)0xfe, 
+        (char)0xfd, 
+        (char)0xfd, 
+        (char)0xfd, 
+        (char)0xfd, 
+        (char)0x12, 
+        (char)0x34, 
+        (char)0x56, 
+        (char)0x78
+    };
+
     struct ArkPacket
     {
         ArkPacket* owner;
-        char* data;
+        unsigned char* data;
         int dataSz;
 
         ArkPacket();
@@ -15,4 +37,38 @@ namespace ArkNet
         ArkPacket sub(int start, int sz);
     };
 
+    enum PacketReliablity
+    {
+        UNRELIABLE,
+        UNRELIABLE_SEQ,
+        RELIABLE,
+        RELIABLE_ORD,
+        RELIABLE_SEQ,
+        UNRELIABLE_ACK,
+        RELIABLE_ACK,
+        RELIABLE_ORD_ACK,
+    };
+
+    struct FrameSetPacket
+    {
+    public:
+        unsigned int frameSetIndex;
+        unsigned char flags;
+
+        unsigned short bitLength;
+        unsigned short byteLength;
+
+        unsigned int frameReliableIndex;
+        unsigned int frameSequenceIndex;
+
+        unsigned int orderedFrameIndex;
+        unsigned char orderedChannel;
+
+        unsigned int fragmentCompoundSize;
+        unsigned short fragmentCompoundID;
+        unsigned int fragmentIndex;
+
+        void writeToStream(ArkStream* stream);
+        void readFromStream(ArkStream* stream);
+    };
 }

Projects/Engine/Header/Network/ArkNet/ArkPeer.hpp

@@ -4,28 +4,61 @@
 #include <Network/ArkNet/ArkPacket.hpp>
 #include <Network/ArkNet/ArkUserData.hpp>
 #include <vector>
+#include <list>
+#include <map>
+#include <deque>
 
 namespace ArkNet
 {
     class ArkPeer;
     class IArkPeerListener
     {
     public:
-        virtual void onPacketReceiving(ArkPeer* peer, ArkPacket* packet) = 0;
+        // for raw packets, basically anything that isnt intercepted by ArkPeer
+        virtual void onPacketReceiving(ArkPeer* peer, ArkPacket* packet) {};
+        // for game packets sent via sendReliablePacket, this is probably the one you want to override
+        virtual void onGamePacketReceiving(ArkPeer* peer, ArkPacket* packet) {}; // packets with security
 
         virtual void onConnectionAccepted(ArkPeer* peer) {};
         virtual void onDisconnected(ArkPeer* peer) {};
     };
 
+    struct PendingPacket
+    {
+        unsigned char* data;
+        int dataSz;
+        int sendAtFrame;
+        int fspIndex;
+        int flags;
+    };
+
+    struct MegaPacket
+    {
+        ArkPacket* packet;
+        int size;
+        int packetsToBeReceived;
+        int packetsReceived;
+    };
+
     class ArkPeer
     {
     private:
         friend class ArkServer;
         ArkAddress m_remote;
         ArkSocket* m_socket;
         ArkUserData* m_userData;
+        std::deque<PendingPacket> m_pendingPackets;
         std::vector<IArkPeerListener*> m_listeners;
+        int m_lastSentFspIndex;
+        int m_lastRecvFspIndex;
+        int m_lastFragmentId;
+        std::map<int, MegaPacket> m_incomingMegaPackets;
         bool m_authorized;
+        int m_peerFrame;
+        int m_nextConnectionAttempt;
+        int m_connectionAttempts;
+        int m_connectionStage;
+        int m_peerMTU;
     public:
         ArkPeer(ArkSocket* socket);
         ArkPeer(ArkAddress remote, ArkSocket* socket);
@@ -36,17 +69,36 @@ namespace ArkNet
         void setRemote(ArkAddress remote) { m_remote = remote; };
         void addListener(IArkPeerListener* listener) { m_listeners.push_back(listener); }
 
-        int recvFrom(int bytes, char* data, ArkAddress* remote, int flags = 0);
-        int sendTo(int bytes, char* data, int flags = 0);
+        int recvFrom(int bytes, unsigned char* data, ArkAddress* remote, int flags = 0);
+        int sendTo(int bytes, unsigned char* data, int flags = 0);
         ArkPacket* recvPacket(ArkAddress* remote);
+        // most likely you want to be using sendReliablePacket, as this provides no reliability
+        // or fragmenting or ordering or sequencing or anything that you want
+        // the first byte of a packet sent using sendPacket is the ArkNet packet type
+        // and should be something that isnt already used (look at ArkPeer::pumpReadPacket)
         void sendPacket(ArkPacket* packet);
+        // sendReliablePacket requires ArkPeer::frame to be called continually,
+        // clientPump automatically handles calling it if you use it
+        // reliable packets will also not signal onPacketReceiving, and instead use onGamePacketReceiving
+        void sendReliablePacket(ArkPacket* packet, PacketReliablity reliablity);
 
         void authorize();
 
+        int newFspIndex() { return m_lastSentFspIndex++; }
+        int getConnectionAttempts() { return m_connectionAttempts; }
+        int getConnectionStage() { return m_connectionStage; }
+
+        void sendAcknowledge(int record);
+
+        bool pumpReadPacket(ArkPacket* in_packet);
         // read events, client-only, servers should use ArkServer::frame
         void clientPump(); 
+        void frame();
 
         ArkSocket* getSocket() { return m_socket; }
         ArkUserData* getUserData() { return m_userData; }
+        int getMTU() { return m_peerMTU; }
+        // this should be used for sendReliablePacket packets, as sending a reliable packet will add an extra overhead to it
+        int getGamePacketMTU() { return m_peerMTU - 64; } // TODO: make this better
     };
 }

Projects/Engine/Header/Network/ArkNet/ArkSocket.hpp

@@ -36,8 +36,8 @@ namespace ArkNet
         void markConnected() { m_socketStatus = ARKSOCKET_CONNECTED; }
         void markDisconnected() { m_socketStatus = ARKSOCKET_DISCONNECTED; }
 
-        int recvFrom(ArkAddress* remote, size_t bytes, char* output, int flags = 0);
-        int sendTo(ArkAddress* remote, size_t bytes, char* input, int flags = 0);
+        int recvFrom(ArkAddress* remote, size_t bytes, unsigned char* output, int flags = 0);
+        int sendTo(ArkAddress* remote, size_t bytes, unsigned char* input, int flags = 0);
 
         void closeSocket();
 

Projects/Engine/Header/Network/ArkNet/ArkStream.hpp

@@ -8,19 +8,19 @@ namespace ArkNet
 {
     class ArkStream
     {
-        char* m_data;
+        unsigned char* m_data;
         int m_dataOff;
         int m_dataSize;
     public:
-        ArkStream(char* data, int data_size);
+        ArkStream(unsigned char* data, int data_size);
         ArkStream(ArkPacket* packet);
 
         template<typename T>
         void write(T val)
         {
             size_t val_size = sizeof(val);
             if((m_dataOff + val_size) > m_dataSize)
-                throw std::runtime_error("Overflow");
+                throw std::runtime_error("write: Overflow");
             memcpy(m_data + m_dataOff, &val, val_size);
             m_dataOff += val_size;            
         }
@@ -29,18 +29,21 @@ namespace ArkNet
         T read()
         {
             size_t val_size = sizeof(T);
-            if((m_dataOff - val_size) < 0)
-                throw std::runtime_error("Underflow");
+            if((m_dataOff + val_size) > m_dataSize)
+                throw std::runtime_error("read: Overflow");
             T* ref = (T*)(m_data + m_dataOff);
             m_dataOff += val_size;
             return *ref;
         }
 
         ArkPacket readPacket(int sz);
 
-        // # of bytes that have been written to/read from the stream
+        // number of bytes that have been written to/read from the stream
         int size() { return m_dataOff; } 
+        // number of bytes that the stream can write to
+        int dataSize() { return m_dataSize; }
 
+        bool readMagic(); // true if valid magic
         void writeString(std::string val);
         std::string readString();
     };

Projects/Engine/Header/Network/NetworkPeer.hpp

@@ -20,6 +20,9 @@ namespace RNR
         void addNewInstance(Instance* instance);
         void addDelInstance(Instance* instance);
 
+        ArkNet::ArkPeer* getPeer() { return m_peer; }
+        ArkNet::ArkSocket* getSocket() { return m_socket; }
+
         void sendPendingReplicates();
 
         virtual std::string getClassName() { return "NetworkPeer"; }

Projects/Engine/Header/Network/Players.hpp

@@ -9,11 +9,15 @@ namespace RNR
     {
     private:
         Player* m_localPlayer;
+        int m_maxPlayers;
     public:
         Players();
 
         virtual std::string getClassName() { return "Players"; }
 
+        int getMaxPlayers() { return m_maxPlayers; }
+        void setMaxPlayers(int p) { m_maxPlayers = p; }
+
         Player* getLocalPlayer() { return m_localPlayer; };
         Player* createLocalPlayer(int userId);
         virtual void addProperties(std::vector<ReflectionProperty>& properties);