My Networking System! Here for all of you to use!

UPDATE:

Due to the requests, I have created a DEMO project for you guys. Simply change the IP & Port in the server & client scripts and try it out. Build the server scene into an exe, and run it. Then run the client code in the editor and watch the console. ENSURE YOU SET THE PLAYER SETTINGS TO RUN IN BACKGROUND

Download: https://www.dropbox.com/s/di2m0mfv3jhcldy/NetworkDemo.zip?dl=0


So I noticed Unity's network system is a bit... useless in certain situations. It's great for a first person shooter type game, but from what I've seen most people use a 3rd party network server that is entirely outside of unity.

I needed a networking system for my game, so I created one for myself that actually uses only Unity. I used this for my mmorpg, and think others might find some use out of. I don't see why I shouldn't share and help out other people. Royalty free. Feel free to discuss this system with me too.

So here's how it works. I have a server and a client (in my case, an authoritative server) and they need to communicate back and forth, a large variety of things. I use a total of 2 RPC Functions, 1 on the server, 1 on the client, and they are both identical in ways they work. That's it! That's the only real Unity network functions that are used. All the data is sent through those RPC functions and understood by the receiver. Now this is a very efficient system, but due to the rpc function not being able to accept byte[] as a parameter, the data being sent back and forth is slightly larger than if it did accept byte[] parameters. Nonetheless... let's get to the actual code!

We've got two classes. The PacketWriter, and the PacketReader. Self explanatory, one class builds a packet and the other takes the received packet apart!

Here are the two classes: (MAKE SURE TO CHANGE YOUR_NETWORK_VIEW TO A REFERENCE TO YOUR NETWORK VIEW COMPONENT IN PACKETWRITER.CS)

Spoiler: PacketWriter.cs

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3. using System.Collections.Generic;
4. using System;
5.  
6. public class PacketWriter {
7.  
8.     private static int packetId;
9.     private static byte[] packetBytes;
10.  
11.     public static void BuildPacket(int i) {
12.         packetId = i;
13.         packetBytes = null;
14.     }
15.  
16.     public static void AddInt(int i) {
17.  
18.         byte[] newBytes = ByteConverter.getBytes(i);
19.         if(packetBytes != null) {
20.         List<byte> list1 = new List<byte>(packetBytes);
21.         List<byte> list2 = new List<byte>(newBytes);
22.         list1.AddRange(list2);
23.         packetBytes = list1.ToArray();
24.         } else
25.             packetBytes = newBytes;
26.  
27.     }
28.  
29.     public static void AddFloat(float f) {
30.  
31.         byte[] newBytes = ByteConverter.getBytes(f);
32.         if(packetBytes != null) {
33.         List<byte> list1 = new List<byte>(packetBytes);
34.         List<byte> list2 = new List<byte>(newBytes);
35.         list1.AddRange(list2);
36.         packetBytes = list1.ToArray();
37.         } else
38.             packetBytes = newBytes;
39.  
40.     }
41.  
42.     public static void AddString(string s) {
43.  
44.         byte[] newBytes = ByteConverter.getBytes(s);
45.         AddInt(s.Length);
46.         if(packetBytes != null) {
47.         List<byte> list1 = new List<byte>(packetBytes);
48.         List<byte> list2 = new List<byte>(newBytes);
49.         list1.AddRange(list2);
50.         packetBytes = list1.ToArray();
51.         } else
52.             packetBytes = newBytes;
53.  
54.     }
55.  
56.     public static void SendPacketToClient(NetworkPlayer c) {
57.        YOUR_NETWORK_VIEW.RPC("TransferData", c, packetId, packetBytes);
58.     }
59.  
60.     public static void SendPacketToServer() {
61.         YOUR_NETWORK_VIEW.RPC("TransferData", RPCMode.Server, packetId, packetBytes);
62.     }
63.  
64. }
65.  

Spoiler: PacketReader.cs

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3. using System.Collections.Generic;
4. using System;
5.  
6. public class PacketReader {
7.  
8.     private static byte[] packetBytes;
9.  
10.     public static void ReadPacket(byte[] packet) {
11.         packetBytes = packet;
12.     }
13.  
14.     public static int ReadInt() {
15.  
16.         byte[] intBytes = packetBytes;
17.         Array.Copy(packetBytes, 0, intBytes, 0, 4);
18.  
19.         int intFromBytes = ByteConverter.getInt(intBytes);
20.         int bytesToEliminate = 4;
21.         int newLength = packetBytes.Length - bytesToEliminate; //you may need to check if this positive
22.         byte[] newArray = new byte[newLength];
23.         Array.Copy(packetBytes, bytesToEliminate, newArray, 0, newLength);
24.         packetBytes = newArray;
25.  
26.         return intFromBytes;
27.  
28.     }
29.  
30.     public static float ReadFloat() {
31.  
32.         byte[] intBytes = packetBytes;
33.         Array.Copy(packetBytes, 0, intBytes, 0, 4);
34.  
35.         float floatFromBytes = ByteConverter.getFloat(intBytes);
36.         int bytesToEliminate = 4;
37.         int newLength = packetBytes.Length - bytesToEliminate; //you may need to check if this positive
38.         byte[] newArray = new byte[newLength];
39.         Array.Copy(packetBytes, bytesToEliminate, newArray, 0, newLength);
40.         packetBytes = newArray;
41.  
42.         return floatFromBytes;
43.  
44.     }
45.  
46.     public static string ReadString() {
47.  
48.         int stringLength = ReadInt();
49.  
50.         List<byte> list1 = new List<byte>(packetBytes);
51.         byte[] stringBytes = list1.GetRange(0, stringLength).ToArray();
52.  
53.         string stringFromBytes = ByteConverter.getString(stringBytes);
54.  
55.         int bytesToEliminate = stringLength;
56.         int newLength = packetBytes.Length - bytesToEliminate; //you may need to check if this positive
57.         byte[] newArray = new byte[newLength];
58.         Array.Copy(packetBytes, bytesToEliminate, newArray, 0, newLength);
59.         packetBytes = newArray;
60.  
61.         return stringFromBytes;
62.  
63.     }
64.  
65.  
66. }
67.  

There's another class you'll need.... this converts variables to byte arrays (byte[]) and back. More on this in a minute, here's the class:

Spoiler: ByteConverter.cs

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3. using System;
4.  
5. public class ByteConverter {
6.  
7.  
8.     public static byte[] getBytes(string s) {
9.         return System.Text.Encoding.UTF8.GetBytes(s);
10.     }
11.  
12.     public static string getString(byte[] bytes) {
13.         return new string(System.Text.Encoding.UTF8.GetChars(bytes));
14.     }
15.  
16.     public static byte[] getBytes(int I32) {
17.         return BitConverter.GetBytes(I32);
18.     }
19.  
20.     public static int getInt(byte[] b) {
21.         return BitConverter.ToInt32(b, 0);
22.     }
23.  
24.     public static float getFloat(byte[] b) {
25.         return BitConverter.ToSingle(b, 0);
26.     }
27.  
28.     public static byte[] getBytes(float f) {
29.         return BitConverter.GetBytes(f);
30.     }
31.  
32. }
33.  

Ok. So we got all of our static classes down. So let's get the set up going, and the rpc functions.
We will use the same RPC function in both the client and the server. The only thing different is deciding what to do with the data. This would be up to the developer using the system.

So firstly, you'll need a network view of course... So you add that to an object. Make sure to reference the networkview somehow through the script containing the RPC function. This applies to both the server and the client.

In your server script attached to the object with a network view, you can use this as an example:

Code (CSharp):

1.         [RPC]
2.         private void TransferData(int packetType, byte[] bytesInString) {
3.             if(packetType == 1) {
4.             PacketReader.ReadPacket(bytesInString);
5.             string chatbox_Input = PacketReader.ReadString();
6.             string receivedString = PacketReader.ReadString();
7.             int receivedInt = PacketReader.ReadInt();
8.             float receivedFloat = PacketReader.ReadFloat();
9.             Debug.Log("received string:"+receivedString+" received int:"+receivedInt+" received float:"+receivedFloat);
10.             }
11. }

You would use the same exact rpc function on the server as well. I just assume you'll do different things with the received data. Packet #s don't have to match up server to client. You could use packet 1 to send a single string to the client, and use packet #1 to send 2 integers to the server. Simply the rpc function on the receiving end has to know what it's expecting. If you wanted to receive two integers for packet #2, you'd use this code (within the rpc)

Code (CSharp):

1.  
2.             if(packetType == 2) {
3.             PacketReader.ReadPacket(bytesInString);
4.             float receivedint1 = PacketReader.ReadInt();
5.             float receivedint2 = PacketReader.ReadInt();
6.             Debug.Log("Received int1:"+receivedint1+" Received int2:"+receivedint2);
7.             }

Ok. So now we got to get into SENDING a packet. This can go in any class!
Here's an example on how to send the packet #2, two integer, packet mentioned just above. This is going to be from the CLIENT, and the code above receiving the packet will be in the SERVER. To reverse it, simply change PacketWriter.SendPacketToClient() to PacketWriter.SendPacketToServer(YOUR NETWORK PLAYER).

Code (CSharp):

1.         PacketWriter.BuildPacket(2);
2.         PacketWriter.AddInt(1337);
3.         PacketWriter.AddInt(2015);
4.         PacketWriter.SendPacketToClient();

So we know how to send packets back and forth now. To send floats/strings/etc, just look at the PacketWriter class for the functions. If you want to send other types of variables that aren't already in the code, feel free to add some more. It's not too complicated... just PM me/post a reply quoting me and I'll tell you how to.

So how does this all work? Let me explain.
The packetwriter will convert your variables into byte[] arrays and combine them all into one byte array. The byte array is sent over the RPC function, and the packet reader interprets the byte array and gives you the variables. Only one RPC function, it's easy stuff.

So that's everything you need! Of course make sure you connect to the server using the network class before sending any packets. If you have any questions/suggestions please let me know. Put a lot of work into making this thread. Hope you guys use this system!

I use this system in my MMORPG, and it can be used for really any type of data transferring. An MMORPG requires a LOT of data sending back and forth, to tons of players, and this system can handle it, despite how basic it really is. It's also so easy to just say, buildpacket,addstring,sendpacket. It's that simple.

This also works perfectly in Unity Free. It is just as fast as unity's rpc calls, but there's NO HASSLE! It's so easy to send data back and forth, and you don't have to create constant RPC methods in the server and client. This is ideal for any project, and almost necessary if you have advanced networking needs as in an mmorpg.

 

Bump

 

thank you for your contribution,

i do have a question tho:
you mention that your code is to expand unity stock networking engine right?
so, what exactly benefits will your code help me with?

i mean mmo feature wise?

would appreciate if you can elaborate more indepth on how to use and what benefits over the stock unity networking.

thanks again.

 

I think basically the data is lighter. Lighter data = swifter communications.

I do think that the code of him is very useful.

Thanks.

 

My recommendation to contribute to this is to collect new added objects in a temporary buffer of byte[] to only be concatenated together before sending the message to reduce array allocations. That way you only need at minimum n+1 many allocations instead of currently 3n or in the case of string 6n.

 

That may be a good idea. The processing time is already incredibly fast though. I'll work on adding that in the near future to speed it up a little bit.

 

Hi, Gambinold, that's a nice concept you got there! I'd like to try it out when I have the time. One thing came to my attention: You said that the RPCs do not accept byte arrays and so you have to convert byte arrays to ...I guess you're converting to strings ?
I am working on a file sharing system which sends bytes over the network using RPCs. It's not documented but RPCs support byte[].

 

Sounds ambitious! Any chance you have any speed comparisons vrs other networking solutions? What about in comparison to just rpc'ing all kinds of methods? And I'm assuming this works fine in unity free?

I'm curious of the advantages over photon, unity built in networking (mass rpc calls) and other popular unity free plugins.

 

It works in untiy free. It's not faster than unity's built in RPCs, since it USES unity's RPC system. It's the same speed, except it's wayyyyy nicer to use. To send something, you don't have to make a special RPC in the server and an RPC in the client to call. All you do is say...

PacketWriter.BuildPacket(1);
PacketWriter.AddString("String to send over to network.");
PacketWriter.SendPacketToServer();

Then the server receives the string. It's just much easier, and really gets rid of the annoying workflow of using a ton of RPC calls. It simply makes life a lot easier.

I am converting to strings. Well.... I will look into that right now! That would make this system even better!

Edit: Well.... you're right! It now just sends bytes back and forth. That really unclogs the network. When you send a string, you're sending around 3/4x the bytes. Now it's sending the raw bytes!! You sir helped me a lot haha.

I updated the code in the 1st post to reflect this change! Now we can all enjoy raw bytes being sent back and forth!

 

Glad I helped ! I remember struggling with the same issue before randomly finding out that byte arrays work. They really should have documented this feature.

 

I agree. I hope others find this networking system useful. Unity's regular networking on its own is not something I'd like to use for big projects.

 

There's a documentation section now, maybe somebody should post a thread about that in there.

 

wow, this looks totally usable and the code is really easy to grasp and to read. plus, at first glance, one who uses this doesn't need to setup the connection type (UDP or TCP) am i right?

will give a go with this in order to make my pong clone "networkable"

 

So I am still unsure of the exact usage method one should...use, lol - So am I right that you do something like prepare a packet with several variables to be sent over the network, and then call SendPacketToServer() when you have piled up some variables for a single frame or something?

I guess what I am asking is - if I wanted to use an RPC to send several things (like maybe a position of something, and a few random bools or perhaps some floats...) I would send some parameters through a RPC method to the clients, and instead with this I would just leave that all up to packetwriter? Like you just do maybe AddInt(ImportantInteger); then AddFloat(UpdatedFloat); and finally SendPacketToServer(); to have the actual RPC take place - which I guess is handing byte arrays as parameters between the RPC's?

I hope that all makes sense and is logical haha.

I think the project could benefit from maybe a github so others can contribute changes, and an example scene showcasing a few things going on (maybe just two cubes with synced movement [two clients or server and client] while sending a few random variables [int, string, bool, float...] every few seconds, and displaying them on a gui so you can visually see they are matching up across all clients/server).

This would help me understand tremendously, haha.

 

Well it uses Unity's RPC calls, which are UDP.

So in this system, a "packet" is a collection of data, with a number attached to it (a packet number).
The packet and packet number are sent to the receiving end, and the receiving end uses the packet number to know how to interpret the data.

So if I created a packet... lets say packet 1 to the server.

PacketWriter.BuildPacket(1);
PacketWriter.AddInt(50);
PacketWriter.AddInt(75);
PacketWriter.AddInt(20);
PacketWriter.SendPacketToServer();

The packet is a byte array (byte[]) holding the 3 integers added in the code above. The server would then have to read it, in the same order it was written.

So the server, in the receiving RPC,

if(packetType == 1) {
PacketReader.ReadPacket(bytesInString);
int x = PacketReader.ReadInt();
int y = PacketReader.ReadInt();
int z = PacketReader.ReadInt();
Vector3 receivedPosition = new Vector3(x,y,z);
}

As you can see, the receiving end has a set method of how to interpret the data based on the packet number (packetType variable). If the client sends 1 integer, then a string, the server must read 1 integer, and 1 string in the same order.

This system allows you to send a collection of data, such as a few strings, an integer, and the other send will receive those variables, for you to do what you want with them. You can have 100% of your networking go through this system. There is no need to set up additional RPCs, or even state synchronization. This allows you to choose exactly what you want to send back and forth. Imagine having 500 or so RPCs on both your client and server. This system gets rid of that.

If you have additional questions, just comment again. Tried my best to explain it!

 

I appreciate this explanation. I may actually gut my currently RPC solution I've written for this.

Let me make sure I understand this 100%. So, essentially what you've done here is designed a way to use these packetTypes however we wish in a custom format?

ie: My packetTypes of "56" are for transitioning a character's state across a zone-line into an adjacent zone (moving across zone borders in an open world).

So, just as an example, I'd pass:

PacketWriter.BuildPacket(56);
PacketWriter.AddString(curZone);
PacketWriter.AddString(curState);
PacketWriter.AddFloat(x);
PacketWriter.AddFloat(y);
PacketWriter.AddFloat(z);
PacketWriter.SendPacketToServer();

I'd have a custom method on the server that specifies what to do with a packetType of "56" like so: (example only!)

if(packetType == 56)
{
PacketReader.ReadPacket(bytesInString);
string cur_Zone = PacketReader.ReadString();
string cur_State = PacketReader.ReadString();
float cur_x = PacketReader.ReadFloat();
float cur_y = PacketReader.ReadFloat();
float cur_z = PacketReader.ReadFloat();
Vector3 receivedPosition = new Vector3(x,y,z);
}

That I could then use to see if that character is, or is not, in combat (state). As well as track what zone they're coming from so I can interpolate their x,y,z relative to that zone so I know exactly where they "should" end up on the new zone transition. Obviously this is an example, but I wanted to insure I understand your example that you've laid out for us !

So in essence the packetType's meaning is purely up to you and is an arbitrary way of telling the server how to handle information it receives?

 

Exactly, you understand it perfectly and your code is perfect.

 

As a suggestion you could use a BinaryReader and BinaryWriter to format the data, you'll have a lot of types already convertable for you. They require a stream and thus need to be disposed of properly but that's not hard

Nice idea and implementation though

 

Good idea. I've had some really weird issues with binary reader and writer though... I don't really trust it haha!

 

Hello Gambinolnd,

How usualy you reference your networkview in the PACKETWRITER class?

Regards,
Carlos

 

You need to reference the networkview somehow. The network view has to be attached to a gameobject in the scene. You can do the old... GameObject.Find("NetworkObject").GetComponent<NetworkView>()
Remember this is a slightly expensive function. You can always create one through code and attach it to an object. It's up to you.

 

Hi Gambinolnd,

This looks like a great addition to the Unity networking functionality, and one I am likely wanting to get familiar with when I come to make my MMO (all in baby steps, start SMO first).

A couple of questions t help towards implementation though: 1) How does this fit with the new UNET functionality in Unity? I see references to RPC and NetworkView which are considered "Legacy" - is there a risk these will become redundant/depreciated in future updates? 2) Are there any sample scenes available as requested above for a nooblet like myself to use as a guide into implementation?

Cheers

 

1) How does this fit with the new UNET functionality in Unity? I see references to RPC and NetworkView which are considered "Legacy" - is there a risk these will become redundant/depreciated in future updates?

This was made right before UNET was released. I believe these legacy methods will still be supported for a good amount of time, perhaps till Unity 6. If you notice, even the old legacy animation system from Unity 3 is still available in Unity 5. There is no guarantee how long it will be available though. If at any point they are completely removed/develop bugs that won't be fixed, it should be extremely easy to switch to UNET without changing much.

If you look at the code it uses exactly 1 single RPC function (well 1 on the client side and 1 to the server side). All this RPC does is send an integer (The packet ID) and a byte array (byte[]). If you developed an entire game using this system, and needed to change to UNET, all you would have to change is just the RPC function and nothing else. It would be extremely easy to move over without any change to your network. I'm sure I'll move it over before long because I use this system as well, but I currently am not familiar with the UNET networking system at the moment. Once I move it over I'll post it here.

2) Are there any sample scenes available as requested above for a nooblet like myself to use as a guide into implementation?

There are currently no sample scenes available. To use this system well you have to have a decent understanding of coding and some basic networking knowledge. The code is actually rather simple and I gave some examples of how to use it in the original post. The tricky part is how to use it correctly. Deciding which players to send packets to, and the structure of your server is the challenge. This must be learned. Because of this, I assume one who can use the system can understand how to implement it. Just give it a shot! You just have to copy the files over, and then make 2 scripts (1 for the server, and 1 for the client), attach them to objects with a networkview and place your transferdata rpcs into them as explained in the 1st post.

If you have any trouble though I am always happy to help other developers. Good luck!

 

Code (CSharp):

1. PacketWriter.SendPacketToClient();

How do I use that? also I get this error for it:
Assets/_Scripts/log.cs(89,38): error CS1501: No overload for method `SendPacketToClient' takes `0' arguments

 

Does anyone know how to use:

Code (CSharp):

1. PacketWriter.SendPacketToServer();
2. PacketWriter.SendPacketToClient();

for SendPacketToServer(Network.isServer);
and for SendPacketToClient(Network.isClient);
Is this the correct way? Also is there a way to yield return for a packet or something to have it wait for the server to say something back?

this
WWW loginReader = new WWW(login_URL);
yield return loginReader;
the WWW loginReader = WWW(login_URL); is what sends the information to a webpage and waits for the return
but I want to have it wait for a rpc or something

 

Due to the requests, I have created a DEMO project for you guys. Simply change the IP & Port in the server & client scripts and try it out. Build the server scene into an exe, and run it. Then run the client code in the editor and watch the console.

Download: https://dl.dropboxusercontent.com/u/113459534/NetworkDemo.zip

 

Does anyone here know if there is a way of saving and loading information from a WWW without the yield return part? Is this locked in?

 

Works, pretty neat

 

Awesome

 

Anyone got this?

 

Please explain this from the point of view of someone who has already created a complete networked game using U-Net.

 

Hello!

404 on Dropbox link.
What is the status of the project, can be downloaded from somewhere?

Thanks!

 

Hey GambinoInd...also interested in your project, but the file isn't showing up on Dropbox. Do you have an updated version? Thanks!

 

Can this networking system be used with realistic fps prefab .