test

not working

ProftaakRH/BLEHandler.cs

@@ -7,6 +7,9 @@ using System.Security.Cryptography;
 
 namespace Hardware
 {
+    /// <summary>
+    /// <c>BLEHandler</c> class that handles connection and traffic to and from the bike
+    /// </summary>
     class BLEHandler
     {
         IDataConverter dataConverter;
@@ -14,12 +17,19 @@ namespace Hardware
         private BLE bleHeart;
         public bool Running { get; set; }
 
+        /// <summary>
+        /// Makes a new BLEHandler object
+        /// </summary>
+        /// <param name="dataConverter">the dataconverter object</param>
         public BLEHandler(IDataConverter dataConverter)
         {
             this.dataConverter = dataConverter;
             bool running = false;
         }
 
+        /// <summary>
+        /// Checks for available devices to connect to, and if one is found, it connects to it
+        /// </summary>
         public void Connect()
         {
             BLE bleBike = new BLE();
@@ -40,6 +50,11 @@ namespace Hardware
                 }
             }
         }
+
+        /// <summary>
+        /// Connects to the device with the given name
+        /// </summary>
+        /// <param name="deviceName">The name of the device to connect to</param>
         public async void Connect(string deviceName)
         {
             int errorCode = 0;
@@ -95,14 +110,17 @@ namespace Hardware
 
             Console.WriteLine("connected to BLE");
             this.Running = true;
+
         }
 
+        /// <summary>
+        /// Callback for when the subscription value of the ble bike has changed
+        /// </summary>
+        /// <param name="sender"> the sender object</param>
+        /// <param name="e">the value changed event</param>
         private void BleBike_SubscriptionValueChanged(object sender, BLESubscriptionValueChangedEventArgs e)
         {
-            //Console.WriteLine("Received from {0}: {1}", e.ServiceName,
-            //    BitConverter.ToString(e.Data).Replace("-", " "));
-            //send to dataconverter
-
+            
             if (e.ServiceName == "6e40fec2-b5a3-f393-e0a9-e50e24dcca9e")
             {
                 byte[] payload = new byte[8];
@@ -120,6 +138,9 @@ namespace Hardware
 
         }
 
+        /// <summary>
+        /// Disposes of the current BLE object, if it exists.
+        /// </summary>
         private void disposeBLE()
         {
             this.bleBike?.Dispose();
@@ -127,6 +148,10 @@ namespace Hardware
             this.Running = false;
         }
 
+        /// <summary>
+        /// Method <c>setResistance</c> converts the input percentage to bytes and sends it to the bike.
+        /// </summary>
+        /// <param name="percentage">The precentage of resistance to set</param>
         public void setResistance(float percentage)
         {
             byte[] antMessage = new byte[13];
@@ -140,7 +165,7 @@ namespace Hardware
                 antMessage[i] = 0xFF;
             }
             antMessage[11] = (byte)Math.Max(Math.Min(Math.Round(percentage / 0.5), 255), 0);
-            //antMessage[11] = 50; //hardcoded for testing
+            
 
             byte checksum = 0;
             for (int i = 0; i < 12; i++)
@@ -151,7 +176,7 @@ namespace Hardware
             antMessage[12] = checksum;//reminder that i am dumb :P
 
 
-            bleBike.WriteCharacteristic("6E40FEC3-B5A3-F393-E0A9-E50E24DCCA9E", antMessage);
+            bleBike.WriteCharacteristic("6e40fec3-b5a3-f393-e0a9-e50e24dcca9e", antMessage);
         }
     }
 }

ProftaakRH/BikeSimulator.cs

@@ -20,9 +20,12 @@ namespace Hardware.Simulators
         private int BPM = 0;
         private int cadence = 0;
         private double resistance = 0;
+        private double power;
+        private double accPower;
 
-        //Array for the speed bytes
-        byte[] array;
+        byte[] speedArray;
+        byte[] powerArray;
+        byte[] accPowerArray;
 
 
 
@@ -43,16 +46,12 @@ namespace Hardware.Simulators
             while (true)
             {
                 CalculateVariables(improvedPerlin.GetValue(x)+1);
-                
-                Console.WriteLine("BikeSimulation:\nSpeed: " + this.speed / 100 + "m/s\t" + this.BPM + "BPM\n"+"Resis: "+ this.resistance+"%\n");
 
                 //Simulate sending data
                 dataConverter.Bike(GenerateBike0x19());
                 dataConverter.Bike(GenerateBike0x10());
                 dataConverter.BPM(GenerateHeart());
 
-                
-
                 Thread.Sleep(1000);
 
                 x += 0.1f;
@@ -65,14 +64,15 @@ namespace Hardware.Simulators
         //Generate an ANT message for page 0x19
         private byte[] GenerateBike0x19()
         {
-            byte[] bikeByte = { 0x19, Convert.ToByte(eventCounter%256), 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+            byte statByte = (byte)(powerArray[1] >> 4);
+            byte[] bikeByte = { 0x19, Convert.ToByte(eventCounter%256), Convert.ToByte(cadence%254), accPowerArray[0], accPowerArray[1], powerArray[0], statByte, 0x20 };
             return bikeByte;
         }
 
         //Generate an ANT message for page 0x10
         private byte[] GenerateBike0x10()
         {
-            byte[] bikeByte = { 0x10, Convert.ToByte(equipmentType), Convert.ToByte(elapsedTime*4%64), Convert.ToByte(distanceTraveled), array[0], array[1], Convert.ToByte(BPM), 0xFF };
+            byte[] bikeByte = { 0x10, Convert.ToByte(equipmentType), Convert.ToByte(elapsedTime*4%64), Convert.ToByte(distanceTraveled), speedArray[0], speedArray[1], Convert.ToByte(BPM), 0xFF };
             return bikeByte;
         }
 
@@ -116,11 +116,15 @@ namespace Hardware.Simulators
         {
             this.speed = perlin * 5 / 0.01 ;
             short sped = (short)speed;
-            array = BitConverter.GetBytes(sped);
+            speedArray = BitConverter.GetBytes(sped);
             this.distanceTraveled = (distanceTraveled+(speed*0.01)) % 256;
             this.BPM = (int) (perlin * 80);
-            this.cadence = (int)speed * 4;
-
+            this.cadence = (int)speed/6;
+            this.power = ((1 + resistance) * speed)/14 % 4094;
+            this.accPower = (this.accPower + this.power) % 65536;
+            // TO DO power to power LSB & MSN
+            powerArray = BitConverter.GetBytes((short)this.power);
+            accPowerArray = BitConverter.GetBytes((short)accPower);
         }
 
         //Set resistance in simulated bike

ProftaakRH/DataConverter.cs

@@ -4,8 +4,15 @@ using System.Text;
 
 namespace Hardware
 {
+    /// <summary>
+    /// DataConverter class that handles all conversion of received data from the BLE bike.
+    /// </summary>
     class DataConverter : IDataConverter
     {
+        /// <summary>
+        /// Receives, parses and displays any incoming data from the bike.
+        /// </summary>
+        /// <param name="bytes">the array of bytes that was received</param>
         public void Bike(byte[] bytes)
         {
             if (bytes == null)
@@ -44,16 +51,17 @@ namespace Hardware
                         
                         Console.WriteLine($"Accumulated power: {accumPower} watt (Rollover 65536)");
 
-                        int instantPower = (bytes[5]) | (bytes[6]>>4)<<8;
+                        int instantPower = (bytes[5]) | (bytes[6] & 0b00001111)<<8;
                         
 
                         if (instantPower != 0xFFF)
                         Console.WriteLine($"Instant power: {instantPower} watt (Range 0-4094)");
 
-                        int trainerStatus = bytes[6] & 0b00001111; // bit 4-7
+                        int trainerStatus = bytes[6] & 0b11110000; // bit 4-7
                         int flags = bytes[7] >> 4;
                         int FEState = bytes[7] & 0b00001111;
 
+
                         break;
 
                     default:
@@ -68,6 +76,10 @@ namespace Hardware
             Console.WriteLine();
         }
 
+        /// <summary>
+        /// Gets and prints the BPM from the message received from the bike.
+        /// </summary>
+        /// <param name="bytes">The array with bytes that was received</param>
         public void BPM(byte[] bytes)
         {
             if (bytes == null)
@@ -92,6 +104,9 @@ namespace Hardware
         }
     }
 
+    /// <summary>
+    /// Dataconverter interface for handling data received from the bike
+    /// </summary>
     interface IDataConverter
     {
         void BPM(byte[] bytes);

ProftaakRH/Main.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Text;
 using Hardware;
@@ -12,11 +12,34 @@ namespace ProftaakRH
         static void Main(string[] agrs)
         {
             IDataConverter dataConverter = new DataConverter();
-            BikeSimulator bikeSimulator = new BikeSimulator(dataConverter);
-            bikeSimulator.setResistance(bikeSimulator.GenerateResistance(1f));
-            bikeSimulator.StartSimulation();
+            BLEHandler bLEHandler = new BLEHandler(dataConverter);
+            bLEHandler.Connect();
+            //BikeSimulator bikeSimulator = new BikeSimulator(dataConverter);
+            //bikeSimulator.setResistance(bikeSimulator.GenerateResistance(1f));
+            //bikeSimulator.StartSimulation();
 
-            Console.ReadLine();
+
+            bool running = true;
+            while (running)
+            {
+                string input = Console.ReadLine();
+                input.ToLower();
+                input.Trim();
+                if(input == "quit")
+                {
+                    running = false;
+                    break;
+                }
+                try
+                {
+                    int resistance = Int32.Parse(input);
+                    bLEHandler.setResistance(resistance);
+                }
+                catch
+                {
+                    //do nothing
+                }
+            }
         }
     }
 }

ProftaakRH/ProftaakRH.sln

@@ -3,7 +3,9 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 16
 VisualStudioVersion = 16.0.30413.136
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProftaakRH", "ProftaakRH.csproj", "{0F053CC5-D969-4970-9501-B3428EA3D777}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ProftaakRH", "ProftaakRH.csproj", "{0F053CC5-D969-4970-9501-B3428EA3D777}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RH-Engine", "..\RH-Engine\RH-Engine.csproj", "{E7D960C3-0848-4C56-9779-DD3D5829D3D6}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -15,6 +17,10 @@ Global
 		{0F053CC5-D969-4970-9501-B3428EA3D777}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0F053CC5-D969-4970-9501-B3428EA3D777}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0F053CC5-D969-4970-9501-B3428EA3D777}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E7D960C3-0848-4C56-9779-DD3D5829D3D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E7D960C3-0848-4C56-9779-DD3D5829D3D6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E7D960C3-0848-4C56-9779-DD3D5829D3D6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E7D960C3-0848-4C56-9779-DD3D5829D3D6}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

RH-Engine/CreateGraphics.cs

@@ -0,0 +1,359 @@
+using LibNoise.Primitive;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading;
+
+namespace RH_Engine
+{
+    class CreateGraphics
+    {
+        public const string STANDARD_HEAD = "Head";
+        public const string STANDARD_GROUND = "GroundPlane";
+        public const string STANDARD_SUN = "SunLight";
+        public const string STANDARD_LEFTHAND = "LeftHand";
+        public const string STANDARD_RIGHTHAND = "RightHand";
+
+
+
+        string tunnelID;
+
+        public CreateGraphics(string tunnelID)
+        {
+            this.tunnelID = tunnelID;
+        }
+
+        public string TerrainCommand(int[] sizeArray, float[] heightsArray)
+        {
+            dynamic payload = new
+            {
+                id = "scene/terrain/add",
+                data = new
+                {
+                    size = sizeArray,
+                    heights = heightsArray
+                }
+
+            };
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+        public string AddLayer(string uid, string texture)
+        {
+            dynamic payload = new
+            {
+                id = "scene/node/addlayer",
+                data = new
+                {
+                    id = uid,
+                    diffuse = @"C:\Users\woute\Downloads\NetworkEngine.18.10.10.1\NetworkEngine\data\NetworkEngine\textures\terrain\adesert_cracks_d.jpg",
+                    normal = @"C:\Users\woute\Downloads\NetworkEngine.18.10.10.1\NetworkEngine\data\NetworkEngine\textures\terrain\adesert_mntn_d.jpg",
+                    minHeight = 0,
+                    maxHeight = 10,
+                    fadeDist = 1
+                }
+            };
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+        public string UpdateTerrain()
+        {
+            dynamic payload = new
+            {
+                id = "scene/terrain/update",
+                data = new
+                {
+
+                }
+            };
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+
+        public string AddNodeCommand()
+        {
+            dynamic payload = new
+            {
+                id = "scene/node/add",
+                data = new
+                {
+                    name = "newNode",
+                    components = new
+                    {
+                        terrain = new
+                        {
+                            smoothnormals = true
+                        }
+                    }
+                }
+            };
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+
+        public string DeleteNode(string uuid)
+        {
+
+            dynamic payload = new
+            {
+                id = "scene/node/delete",
+                data = new
+                {
+                    id = uuid,
+
+                }
+
+            };
+            return JsonConvert.SerializeObject(Payload(payload));
+
+        }
+
+        public string AddBikeModel()
+        {
+            return AddModel("bike", "data\\NetworkEngine\\models\\bike\\bike.fbx");
+        }
+
+        public string AddModel(string nodeName, string fileLocation)
+        {
+            return AddModel(nodeName, fileLocation, null, new float[] { 0, 0, 0 }, 1, new float[] { 0, 0, 0 });
+        }
+
+        public string AddModel(string nodeName, string fileLocation, float[] positionVector, float scalar, float[] rotationVector)
+        {
+            return AddModel(nodeName, fileLocation, null, positionVector, scalar, rotationVector);
+        }
+
+        public string AddModel(string nodeName, string fileLocation, string animationLocation, float[] positionVector, float scalar, float[] rotationVector)
+        {
+            string namename = nodeName;
+            bool animatedBool = false;
+            if (animationLocation != null)
+            {
+                animatedBool = true;
+            }
+
+            dynamic payload = new
+            {
+                id = "scene/node/add",
+                data = new
+                {
+                    name = namename,
+                    components = new
+                    {
+                        transform = new
+                        {
+                            position = positionVector,
+                            scale = scalar,
+                            rotation = rotationVector
+
+                        },
+                        model = new
+                        {
+                            file = fileLocation,
+                            cullbackfaces = true,
+                            animated = animatedBool,
+                            animation = animationLocation
+                        },
+                    }
+                }
+
+            };
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+
+        public string MoveTo(string uuid, float[] positionVector, string rotateValue, float speedValue, float timeValue)
+        {
+            return MoveTo(uuid, "idk", positionVector, rotateValue, "linear", false, speedValue, timeValue);
+        }
+
+        private string MoveTo(string uuid, string stopValue, float[] positionVector, string rotateValue, string interpolateValue, bool followHeightValue, float speedValue, float timeValue)
+        {
+            dynamic payload = new
+            {
+                id = "scene/node/moveto",
+                data = new
+                {
+                    id = uuid,
+                    stop = stopValue,
+                    position = positionVector,
+                    rotate = rotateValue,
+                    interpolate = interpolateValue,
+                    followheight = followHeightValue,
+                    speed = speedValue,
+                    time = timeValue
+                }
+            };
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+
+        public string RouteCommand()
+        {
+            ImprovedPerlin improvedPerlin = new ImprovedPerlin(4325, LibNoise.NoiseQuality.Best);
+            Random r = new Random();
+            dynamic payload = new
+            {
+                id = "route/add",
+                data = new
+                {
+                    nodes = new dynamic[]
+                    {
+                        new
+                        {
+                            /*pos = GetPos(0.6f, improvedPerlin)*/
+                            pos = new int[] {0,0,5 },
+                            dir = new int[] { r.Next(20,100),0,-r.Next(20, 100) }
+                        },
+                        new
+                        {
+                            //pos = GetPos(1.6f, improvedPerlin),
+                            pos = new int[] {50,0,0 },
+                             dir = new int[] { r.Next(20, 100),0,r.Next(20, 100) }
+                        },
+                        new
+                        {
+                            //pos = GetPos(2.654f, improvedPerlin),
+                             pos = new int[] {20,0,20 },
+                             dir = new int[] { r.Next(20, 100),0,r.Next(20, 100) }
+                        },
+                        new
+                        {
+                            //pos = GetPos(3.6543f, improvedPerlin),
+                             pos = new int[] {10,0,50 },
+                             dir = new int[] { -r.Next(3,7),0,r.Next(3,7) }
+                        },
+                        new
+                        {
+                            pos = new int[] {0,0,50 },
+                             dir = new int[] { -r.Next(20, 50),0,-r.Next(20, 50) }
+                        }
+                    }
+                }
+            };
+            Console.WriteLine("route command: " + JsonConvert.SerializeObject(Payload(payload)));
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+
+        public string RouteFollow(string routeID, string nodeID, float speedValue)
+        {
+            return RouteFollow(routeID, nodeID, speedValue, new float[] { 0, 0, 0 });
+        }
+
+        public string RouteFollow(string routeID, string nodeID, float speedValue, float[] positionOffsetVector)
+        {
+            return RouteFollow(routeID, nodeID, speedValue, 0, "XYZ", 1, true, new float[] { 0, 0, 0 }, positionOffsetVector);
+        }
+        private string RouteFollow(string routeID, string nodeID, float speedValue, float offsetValue, string rotateValue, float smoothingValue, bool followHeightValue, float[] rotateOffsetVector, float[] positionOffsetVector)
+        {
+            dynamic payload = new
+            {
+                id = "route/follow",
+                data = new
+                {
+                    route = routeID,
+                    node = nodeID,
+                    speed = speedValue,
+                    offset = offsetValue,
+                    rotate = rotateValue,
+                    smoothing = smoothingValue,
+                    followHeight = followHeightValue,
+                    rotateOffset = rotateOffsetVector,
+                    positionOffset = positionOffsetVector
+
+                }
+            };
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+
+        private float[] GetPos(float n, ImprovedPerlin improvedPerlin)
+        {
+            float[] res = new float[] { improvedPerlin.GetValue(n) * 50, 0, improvedPerlin.GetValue(n) * 50 };
+            return res;
+        }
+
+        private int[] GetDir()
+        {
+            Random rng = new Random();
+            int[] dir = { rng.Next(50), 0, rng.Next(50) };
+            return dir;
+        }
+
+        public string FollowRouteCommand()
+        {
+            return "";
+        }
+
+        public string RoadCommand(string uuid_route)
+        {
+            Console.WriteLine("road");
+            dynamic payload = new
+            {
+                id = "scene/road/add",
+                data = new
+                {
+                    route = uuid_route,
+                    diffuse = "data/NetworkEngine/textures/tarmac_diffuse.png",
+                    normal = "data/NetworkEngine/textures/tarmac_normale.png",
+                    specular = "data/NetworkEngine/textures/tarmac_specular.png",
+                    heightoffset = 1f
+                }
+            };
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+
+        public string GetSceneInfoCommand()
+        {
+            dynamic payload = new
+            {
+                id = "scene/get"
+            };
+
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+
+        public string ResetScene()
+        {
+            dynamic payload = new
+            {
+                id = "scene/reset"
+            };
+
+            return JsonConvert.SerializeObject(Payload(payload));
+        }
+
+        public string SkyboxCommand(double timeToSet)
+        {
+            if (timeToSet < 0 || timeToSet > 24)
+            {
+                throw new Exception("The time must be between 0 and 24!");
+            }
+
+
+            dynamic payload = new
+            {
+                id = "scene/skybox/settime",
+                data = new
+                {
+                    time = timeToSet
+                }
+
+            };
+            return JsonConvert.SerializeObject(Payload(payload));
+
+        }
+
+
+        private object Payload(dynamic message)
+        {
+            return new
+            {
+                id = "tunnel/send",
+                data = new
+                {
+                    dest = tunnelID,
+                    data = message,
+                }
+            };
+        }
+
+
+
+    }
+}

RH-Engine/JSONParser.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Sockets;
+using System.Text;
+using Newtonsoft.Json;
+
+namespace RH_Engine
+{
+    class JSONParser
+    {
+        /// <summary>
+        /// returns all the users from the given response
+        /// </summary>
+        /// <param name="msg">the message gotten from the server, without the length prefix</param>
+        /// <returns></returns>
+        public static PC[] GetUsers(string msg)
+        {
+            dynamic jsonData = JsonConvert.DeserializeObject(msg);
+            Newtonsoft.Json.Linq.JArray data = jsonData.data;
+            PC[] res = new PC[data.Count];
+            int counter = 0;
+            foreach (dynamic d in data)
+            {
+                res[counter] = new PC((string)d.clientinfo.host, (string)d.clientinfo.user);
+                counter++;
+            }
+
+            return res;
+
+        }
+
+        public static string GetSessionID(string msg, PC[] PCs)
+        {
+            dynamic jsonData = JsonConvert.DeserializeObject(msg);
+            Newtonsoft.Json.Linq.JArray data = jsonData.data;
+            for (int i = data.Count-1; i >= 0; i--)
+            {
+                dynamic d = data[i];
+                foreach (PC pc in PCs)
+                {
+                    if (d.clientinfo.host == pc.host && d.clientinfo.user == pc.user)
+                    {
+                        Console.WriteLine("connecting to {0}, on {1} with id {2}", pc.user, pc.host, d.id);
+                        return d.id;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        public static string GetTunnelID(string json)
+        {
+            dynamic jsonData = JsonConvert.DeserializeObject(json);
+            if (jsonData.data.status == "ok")
+            {
+                return jsonData.data.id;
+            }
+            return null;
+        }
+
+        public static string GetRouteID(string json)
+        {
+            dynamic jsonData = JsonConvert.DeserializeObject(json);
+            if (jsonData.data.status == "ok")
+            {
+                return jsonData.data.uuid;
+            }
+            return null;
+        }
+
+    }
+}

RH-Engine/Program.cs

@@ -0,0 +1,247 @@
+using LibNoise.Primitive;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Globalization;
+using System.IO;
+using System.Net.Sockets;
+using System.Runtime.Intrinsics.X86;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Threading;
+
+namespace RH_Engine
+{
+
+    internal class Program
+    {
+        private static PC[] PCs = {
+            //new PC("DESKTOP-M2CIH87", "Fabian"),
+            new PC("T470S", "Shinichi"),
+            //new PC("DESKTOP-DHS478C", "semme")
+            //new PC("DESKTOP-TV73FKO", "Wouter"),
+            //new PC("DESKTOP-SINMKT1", "Ralf"),
+            //new PC("NA", "Bart")
+        };
+        private static void Main(string[] args)
+        {
+            TcpClient client = new TcpClient("145.48.6.10", 6666);
+
+            CreateConnection(client.GetStream());
+
+
+        }
+
+        /// <summary>
+        /// writes a message to the server
+        /// </summary>
+        /// <param name="stream">the network stream to use</param>
+        /// <param name="message">the message to send</param>
+        public static void WriteTextMessage(NetworkStream stream, string message)
+        {
+            byte[] msg = Encoding.ASCII.GetBytes(message);
+            byte[] res = new byte[msg.Length + 4];
+
+            Array.Copy(BitConverter.GetBytes(msg.Length), 0, res, 0, 4);
+            Array.Copy(msg, 0, res, 4, msg.Length);
+
+            stream.Write(res);
+
+            //Console.WriteLine("sent message " + message);
+        }
+
+        /// <summary>
+        /// reads a response from the server
+        /// </summary>
+        /// <param name="stream">the network stream to use</param>
+        /// <returns>the returned message from the server</returns>
+        public static string ReadPrefMessage(NetworkStream stream)
+        {
+            byte[] lengthBytes = new byte[4];
+
+            stream.Read(lengthBytes, 0, 4);
+            Console.WriteLine("read message..");
+
+            int length = BitConverter.ToInt32(lengthBytes);
+
+            //Console.WriteLine("length is: " + length);
+
+            byte[] buffer = new byte[length];
+            int totalRead = 0;
+
+            //read bytes until stream indicates there are no more
+            do
+            {
+                int read = stream.Read(buffer, totalRead, buffer.Length - totalRead);
+                totalRead += read;
+                //Console.WriteLine("ReadMessage: " + read);
+            } while (totalRead < length);
+
+            return Encoding.UTF8.GetString(buffer, 0, totalRead);
+        }
+        /// <summary>
+        /// connects to the server and creates the tunnel
+        /// </summary>
+        /// <param name="stream">the network stream to use</param>
+        private static void CreateConnection(NetworkStream stream)
+        {
+            WriteTextMessage(stream, "{\r\n\"id\" : \"session/list\"\r\n}");
+            string id = JSONParser.GetSessionID(ReadPrefMessage(stream), PCs);
+
+            string tunnelCreate = "{\"id\" : \"tunnel/create\",	\"data\" :	{\"session\" : \"" + id + "\"}}";
+
+            WriteTextMessage(stream, tunnelCreate);
+
+            string tunnelResponse = ReadPrefMessage(stream);
+
+            Console.WriteLine(tunnelResponse);
+
+            string tunnelID = JSONParser.GetTunnelID(tunnelResponse);
+            if (tunnelID == null)
+            {
+                Console.WriteLine("could not find a valid tunnel id!");
+                return;
+            }
+
+            CreateGraphics createGraphics = new CreateGraphics(tunnelID);
+
+
+            WriteTextMessage(stream, createGraphics.ResetScene());
+            ReadPrefMessage(stream);
+            string routeid = CreateRoute(stream, createGraphics);
+
+            WriteTextMessage(stream, createGraphics.TerrainCommand(new int[] { 256, 256 }, null));
+            Console.WriteLine(ReadPrefMessage(stream));
+            string command;
+
+            command = createGraphics.AddBikeModel();
+
+            WriteTextMessage(stream, command);
+
+            Console.WriteLine(ReadPrefMessage(stream));
+
+            command = createGraphics.AddModel("car", "data\\customModels\\TeslaRoadster.fbx");
+
+            WriteTextMessage(stream, command);
+
+            Console.WriteLine(ReadPrefMessage(stream));
+
+
+
+        }
+
+        /// <summary>
+        /// gets the id of the object with the given name
+        /// </summary>
+        /// <param name="name">the name of the object</param>
+        /// <param name="stream">the network stream to send requests to</param>
+        /// <param name="createGraphics">the create graphics object to create all the commands</param>
+        /// <returns> the uuid of the object with the given name, <c>null</c> otherwise.</returns>
+        public static string GetId(string name, NetworkStream stream, CreateGraphics createGraphics)
+        {
+            JArray children = GetChildren(stream, createGraphics);
+
+            foreach (dynamic child in children)
+            {
+                if (child.name == name)
+                {
+                    return child.uuid;
+                }
+            }
+            Console.WriteLine("Could not find id of " + name);
+            return null;
+
+        }
+
+        public static string CreateRoute(NetworkStream stream, CreateGraphics createGraphics)
+        {
+            WriteTextMessage(stream, createGraphics.RouteCommand());
+            dynamic response = JsonConvert.DeserializeObject(ReadPrefMessage(stream));
+            if (response.data.data.id == "route/add")
+            {
+                return response.data.data.data.uuid;
+            }
+            return null;
+
+        }
+
+        public static void CreateTerrain(NetworkStream stream, CreateGraphics createGraphics)
+        {
+            float x = 0f;
+            float[] height = new float[256 * 256];
+            ImprovedPerlin improvedPerlin = new ImprovedPerlin(0, LibNoise.NoiseQuality.Best);
+            for (int i = 0; i < 256 * 256; i++)
+            {
+                height[i] = improvedPerlin.GetValue(x / 10, x / 10, x * 100) + 1;
+                x += 0.001f;
+            }
+
+            WriteTextMessage(stream, createGraphics.TerrainCommand(new int[] { 256, 256 }, height));
+            Console.WriteLine(ReadPrefMessage(stream));
+
+            WriteTextMessage(stream, createGraphics.AddNodeCommand());
+            Console.WriteLine(ReadPrefMessage(stream));
+        }
+
+        /// <summary>
+        /// gets all the children in the current scene
+        /// </summary>
+        /// <param name="stream">the network stream to send requests to</param>
+        /// <param name="createGraphics">the create graphics object to create all the commands</param>
+        /// <returns>all the children objects in the current scene</returns>
+        public static JArray GetChildren(NetworkStream stream, CreateGraphics createGraphics)
+        {
+            WriteTextMessage(stream, createGraphics.GetSceneInfoCommand());
+            dynamic response = JsonConvert.DeserializeObject(ReadPrefMessage(stream));
+            return response.data.data.data.children;
+        }
+
+        /// <summary>
+        /// returns all objects in the current scene, as name-uuid tuples.
+        /// </summary>
+        /// <param name="stream">the network stream to send requests to</param>
+        /// <param name="createGraphics">the create graphics object to create all the commands</param>
+        /// <returns>an array of name-uuid tuples for each object</returns>
+        public static (string, string)[] GetObjectsInScene(NetworkStream stream, CreateGraphics createGraphics)
+        {
+            JArray children = GetChildren(stream, createGraphics);
+            (string, string)[] res = new (string, string)[children.Count];
+
+            int i = 0;
+            foreach (dynamic child in children)
+            {
+                res[i] = (child.name, child.uuid);
+                i++;
+            }
+
+            return res;
+
+        }
+
+        public static string getUUIDFromResponse(string response)
+        {
+            dynamic JSON = JsonConvert.DeserializeObject(response);
+            return JSON.data.data.data.uuid;
+        }
+
+    }
+
+    /// <summary>
+    /// struct used to store the host pc name and user
+    /// </summary>
+    public readonly struct PC
+    {
+        public PC(string host, string user)
+        {
+            this.host = host;
+            this.user = user;
+        }
+        public string host { get; }
+        public string user { get; }
+
+        public override string ToString()
+        {
+            return "PC - host:" + host + " - user:" + user;
+        }
+    }
+}

RH-Engine/RH-Engine.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <RootNamespace>RH_Engine</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="LibNoise" Version="0.2.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+  </ItemGroup>
+
+</Project>

RH-Engine/RH-Engine.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30503.244
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RH-Engine", "RH-Engine.csproj", "{12E8F82B-C464-4152-B4FB-FCB5E1A9FCFA}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{12E8F82B-C464-4152-B4FB-FCB5E1A9FCFA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{12E8F82B-C464-4152-B4FB-FCB5E1A9FCFA}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{12E8F82B-C464-4152-B4FB-FCB5E1A9FCFA}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{12E8F82B-C464-4152-B4FB-FCB5E1A9FCFA}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {C75B8E99-BE3D-496F-B2F0-03C4069493B2}
+	EndGlobalSection
+EndGlobal

RH-Engine/VRMessage.cs

@@ -0,0 +1,52 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace RH_Engine
+{
+    class VRMessage
+    {
+        public VRMessage(string id, params JObject[] data)
+        {
+            this.Id = id;
+            this.Data = data;
+        }
+
+        public string Id 
+        {
+            get; set; 
+        }
+
+        public JObject[] Data
+        {
+            get;set;
+        }
+
+        public string GetCommand()
+        {
+            StringBuilder sb = new StringBuilder();
+            StringWriter sw = new StringWriter(sb);
+
+            using (JsonWriter writer = new JsonTextWriter(sw))
+            {
+                writer.WriteStartObject();
+                writer.WritePropertyName("id");
+                writer.WriteValue(this.Id);
+                writer.WritePropertyName("data");
+                writer.WriteStartArray();
+                foreach (JObject o in Data)
+                {
+                    writer.WriteValue(o);
+                }
+                writer.WriteEndArray();
+                writer.WriteEndObject();
+            }
+
+            return sb.ToString();
+
+        }
+    }
+}