/// <summary>
/// Reads from a DarkRift reader and creates a new instance of the type written in the buffer (which has to implement ISync) and as tag it uses the parameter tag
/// </summary>
/// <param name="reader">The DarkRift reader to read from</param>
/// <param name="tag">The tag to use in DeserializeOptional</param>
/// <returns></returns>
public static ISync ReadSerializableSmart(this DarkRiftReader reader, int tag)
{
ExtraSyncData _extraSyncData = (ExtraSyncData)reader.ReadByte();
ISync _syncObject = default;
int _typeID;
int _tag;
switch (_extraSyncData)
{
case ExtraSyncData.Nothing:
Console.WriteLine("No TypeID provided!");
break;
case ExtraSyncData.TypeID:
_typeID = reader.ReadInt32();
_syncObject = (ISync)Activator.CreateInstance(MLAPI.SyncTypes[_typeID]);
_syncObject.DeserializeOptional(reader, tag);
break;
case ExtraSyncData.Tag:
Console.WriteLine("No TypeID provided!");
break;
case ExtraSyncData.TypeIDANDTag:
_typeID = reader.ReadInt32();
_tag = reader.ReadInt32();
_syncObject = (ISync)Activator.CreateInstance(MLAPI.SyncTypes[_typeID]);
_syncObject.DeserializeOptional(reader, tag);
break;
}
return(_syncObject);
}
void MessageReceived(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
using (DarkRiftReader reader = message.GetReader())
{
switch (message.Tag)
{
//////////////////////////////////////////////////////////////////////////////
//// LOGIC
case MessageTags.VIDEO_RESOLUTION:
{
uint checkflag = reader.ReadUInt32();
int width = reader.ReadInt32();
int height = reader.ReadInt32();
camera.targetTexture = new RenderTexture(width, height, 0);
Debug.Log($"W : {width}, H: {height}");
}
break;
}
}
}
}
/// <summary>
/// Reads from a DarkRift reader and updates the given instance (which has to implement ISync) and as tag it uses the parameter tag
/// </summary>
/// <param name="sync"></param>
/// <param name="reader"></param>
/// <param name="tag"></param>
public static void ReadSerializableSmart(this ISync sync, DarkRiftReader reader, int tag)
{
ExtraSyncData _extraSyncData = (ExtraSyncData)reader.ReadByte();
int _typeID;
int _tag;
switch (_extraSyncData)
{
case ExtraSyncData.Nothing:
sync.DeserializeOptional(reader, tag);
break;
case ExtraSyncData.TypeID:
_typeID = reader.ReadInt32();
sync.DeserializeOptional(reader, tag);
break;
case ExtraSyncData.Tag:
_tag = reader.ReadInt32();
sync.DeserializeOptional(reader, tag);
break;
case ExtraSyncData.TypeIDANDTag:
_typeID = reader.ReadInt32();
_tag = reader.ReadInt32();
sync.DeserializeOptional(reader, tag);
break;
}
}
private void RemovePiece(object sender, MessageReceivedEventArgs e)
{
if (e.Tag == NetworkTags.InGame.DEFEAT)
{
using (Message message = e.GetMessage() as Message)
{
using (DarkRiftReader reader = message.GetReader())
{
int tX = reader.ReadInt32();
int tY = reader.ReadInt32();
BoardGenerator.instance.RemovePiece(tX, tY);
}
}
}
}
void MessageReceived(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
// MOVE PLAYER
if (message.Tag == Tags.MovePlayerTag)
{
try
{
using (DarkRiftReader reader = message.GetReader())
{
// Wrap In While so we dont go outsite the bounts of the message
while (reader.Position < reader.Length)
{
//Read message
Vector3 newPosition = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
Vector3 newRotation = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
ushort id = reader.ReadUInt16();
//Update characters to move to new positions
networkPlayers[id].NewPosition = newPosition;
networkPlayers[id].NewRotation = newRotation;
}
}
}
catch (Exception ex)
{
Debug.LogError("Error: " + ex + "\r\n\r\n" + ex.StackTrace);
}
}
// PLAYER ANIMATION STATE
if (message.Tag == Tags.AnimationPlayerTag)
{
try
{
using (DarkRiftReader reader = message.GetReader())
{
// Wrap In While so we dont go outsite the bounts of the message
while (reader.Position < reader.Length)
{
//Read message
int speed = reader.ReadInt32();
byte jump = reader.ReadByte();
byte grounded = reader.ReadByte();
ushort id = reader.ReadUInt16();
//Update characters to move to new positions
networkPlayers[id].speed = speed;
networkPlayers[id].jump = jump;
networkPlayers[id].grounded = grounded;
}
}
}
catch (Exception ex)
{
Debug.LogError("Error: " + ex + "\r\n\r\n" + ex.StackTrace);
}
}
}
}
void UpdateServerMessageRecieved(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == NetworkTags.InGame.CALLBACK_PIECE)
{
using (DarkRiftReader reader = message.GetReader())
{
//BoardGenerator.instance.Set
var id = reader.ReadInt32();
int targetX = reader.ReadInt32();
int targetY = reader.ReadInt32();
testText.text = id.ToString();
NetworkObject obj = networkObjects.FirstOrDefault(x => x.id == id);
PlayerPiece targetPiece = obj.GetComponent <PlayerPiece>();
BoardGenerator.instance.SetPieceLocation(targetPiece, targetX, targetY);
SendObjectToSpawnTo(obj, e.Client);
}
}
}
}
public void ReadInt32Test()
{
// GIVEN a buffer of serialized data
mockMessageBuffer.Setup(m => m.Buffer).Returns(new byte[] { 0x23, 0x24, 0x30, 0x5C });
mockMessageBuffer.Setup(m => m.Offset).Returns(0);
mockMessageBuffer.Setup(m => m.Count).Returns(4);
// WHEN I read an int from the reader
int result = reader.ReadInt32();
// THEN the value is as expected
Assert.AreEqual(589574236, result);
}
/// <summary>
/// Reads from a DarkRift reader and creates a new instance of a given type T (which has to implement ISync) and as tag it uses the parameter tag
/// </summary>
/// <typeparam name="T">The I/O type</typeparam>
/// <param name="reader">The DarkRift reader to read from</param>
/// <param name="tag">The tag to use in DeserializeOptional</param>
/// <returns></returns>
public static T ReadSerializableSmart <T>(this DarkRiftReader reader, int tag) where T : ISync, new()
{
ExtraSyncData _extraSyncData = (ExtraSyncData)reader.ReadByte();
T _syncObject = default;
int _typeID;
int _tag;
switch (_extraSyncData)
{
case ExtraSyncData.Nothing:
_syncObject = (T)Activator.CreateInstance(typeof(T));
_syncObject.DeserializeOptional(reader, tag);
break;
case ExtraSyncData.TypeID:
_typeID = reader.ReadInt32();
_syncObject = (T)Activator.CreateInstance(typeof(T));
_syncObject.DeserializeOptional(reader, tag);
break;
case ExtraSyncData.Tag:
_tag = reader.ReadInt32();
_syncObject = (T)Activator.CreateInstance(typeof(T));
_syncObject.DeserializeOptional(reader, tag);
break;
case ExtraSyncData.TypeIDANDTag:
_typeID = reader.ReadInt32();
_tag = reader.ReadInt32();
_syncObject = (T)Activator.CreateInstance(typeof(T));
_syncObject.DeserializeOptional(reader, tag);
break;
}
return(_syncObject);
}
void RemovePiece(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == NetworkTags.InGame.DEFEAT)
{
using (DarkRiftReader reader = message.GetReader())
{
var id = reader.ReadInt32();
NetworkObject obj = networkObjects.FirstOrDefault(x => x.id == id);
BoardGenerator.instance.RemovePiece(obj.GetComponent <PlayerPiece>().x, obj.GetComponent <PlayerPiece>().y);
SendRemovePiece(obj.GetComponent <PlayerPiece>());
}
}
}
}
public void OnDataRecieved(byte tag, ushort subject, object data)
{
if (tag == (byte)TagsNSubjects.Tags.LOGINTAG)
{
if (subject == (ushort)TagsNSubjects.LoginSubjects.LOGINSUCCESS)
{
using (DarkRiftReader reader = data as DarkRiftReader) {
Globalmanager.id = reader.ReadInt32();
}
}
SceneManager.LoadScene("Lobby");
if (subject == (ushort)TagsNSubjects.LoginSubjects.LOGINFAILED)
{
Debug.Log("login failed");
}
}
}
void DeserialiseAnim(object data)
{
if (data is DarkRiftReader)
{
using (DarkRiftReader reader = (DarkRiftReader)data)
{
plValues.running = reader.ReadBoolean();
plValues.grounded = reader.ReadBoolean();
plValues.state = reader.ReadInt32();
plValues.speed = reader.ReadSingle();
plValues.hor = reader.ReadSingle();
plValues.ver = reader.ReadSingle();
}
}
else
{
Debug.LogError("Should have recieved a DarkRiftReciever but didn't! (Got: " + data.GetType() + ")");
transform.position = transform.position;
}
}
private void AnimationStateMessageReceived(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == Tags.AnimationPlayerTag)
{
// Read Player Coordinates From The Message
try
{
using (DarkRiftReader reader = message.GetReader())
{
// Get Player ID
PlayerAnimationState animstate = new PlayerAnimationState();
animstate.Speed = reader.ReadInt32();
animstate.Jump = reader.ReadByte();
animstate.Grounded = reader.ReadByte();
animstate.ID = e.Client.ID;
// Serialize Message
message.Serialize(animstate);
//Send to everyone else
foreach (IClient sendTo in ClientManager.GetAllClients().Except(new IClient[] { e.Client }))
{
sendTo.SendMessage(message, SendMode.Reliable);
}
}
}
catch (System.Exception ex)
{
Console.WriteLine("An error was logged when the animation state message was received: " + ex.Message);
Console.WriteLine(ex.InnerException);
Console.WriteLine(ex.Data);
Console.WriteLine(ex.StackTrace);
}
}
}
}
void MessageReceived(object sender, MessageReceivedEventArgs e)
{
Debug.Log("CreatePlayer entered");
using (Message message = e.GetMessage())
{
using (DarkRiftReader reader = message.GetReader())
{
if (message.Tag == Tags.CreatePlayerTag)
{
while (reader.Position < reader.Length)
{
ushort id = reader.ReadUInt16();
int index = reader.ReadInt32();
Debug.Log(id + " " + index);
if (id == client.ID)
{
if (index == 0)
{
redPlayerText.text += " Connected";
}
else if (index == 1)
{
bluePlayerText.text += " Connected";
}
connected = true;
}
else
{
players[index].SetPlayerController(networkPlayers[index]);
if (index == 0)
{
redPlayerText.text += " Connected";
}
else if (index == 1)
{
bluePlayerText.text += " Connected";
}
}
}
}
if (message.Tag == Tags.DespawnPlayerTag)
{
RemovePlayer(sender, e, reader);
}
else if (message.Tag == Tags.MovePieceTag)
{
while (reader.Position < reader.Length)
{
int pieceId = reader.ReadInt32();
float x = reader.ReadSingle();
float z = reader.ReadSingle();
float rotation = reader.ReadSingle();
Transform unitsParentTransform = GameObject.Find("Units").transform;
for (int i = 0; i < unitsParentTransform.childCount; i++)
{
if (pieceId == i)
{
Transform t = unitsParentTransform.GetChild(i);
MovePiece(t, x, z, rotation);
break;
}
}
while (reader.Position < reader.Length)
{
GameObject.Find("RedLaserGun").transform.rotation = new Quaternion(reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle());
GameObject.Find("BlueLaserGun").transform.rotation = new Quaternion(reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle());
}
StartCoroutine(TurnEnd());
}
}
else if (message.Tag == Tags.ChangeLaserDirectionTag)
{
while (reader.Position < reader.Length)
{
GameObject.Find("RedLaserGun").transform.rotation = new Quaternion(reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle());
GameObject.Find("BlueLaserGun").transform.rotation = new Quaternion(reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle(),
reader.ReadSingle());
}
}
}
}
}
void MessageReceived(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
using (DarkRiftReader reader = message.GetReader())
{
switch (message.Tag)
{
//// Byte[] 압축 수신일 경우
//case MessageTags.VIDEO_STREAMING:
// {
// uint checkflag = reader.ReadUInt32();
// short uid = reader.ReadInt16();
// MemoryStream input = new MemoryStream(reader.ReadBytes());
// MemoryStream output = new MemoryStream();
// using (DeflateStream dstream = new DeflateStream(input, CompressionMode.Decompress))
// {
// dstream.CopyTo(output);
// }
// SetCameraTexture(output.ToArray());
// }
// break;
//// LOGIC (DeflateStream Byte[]분할 수신일 경우)
case MessageTags.VIDEO_STREAMING:
{
uint checkflag = reader.ReadUInt32();
short uid = reader.ReadInt16();
int numOfDatas = reader.ReadInt32();
var idx = reader.ReadInt32();
if (idx == 0)
{
textureByteData.Clear();
}
textureByteData.AddRange(reader.ReadBytes());
if (idx == numOfDatas)
{
Debug.Log(textureByteData.Count);
MemoryStream input = new MemoryStream(textureByteData.ToArray());
MemoryStream output = new MemoryStream();
using (DeflateStream dstream = new DeflateStream(input, CompressionMode.Decompress))
{
dstream.CopyTo(output);
}
SetCameraTexture(output.ToArray());
}
}
break;
//// LOGIC (BitConverter Byte[]분할 수신일 경우)
//case MessageTags.VIDEO_STREAMING:
// {
// uint checkflag = reader.ReadUInt32();
// short uid = reader.ReadInt16();
// int numOfDatas = reader.ReadInt32();
// var idx = reader.ReadInt32();
// if (idx == 0)
// {
// textureByteData.Clear();
// }
// textureByteData.AddRange(reader.ReadBytes());
// if (idx == numOfDatas)
// {
// MemoryStream ms = new MemoryStream();
// var gzBuffer = textureByteData.ToArray();
// int msgLength = BitConverter.ToInt32(gzBuffer, 0);
// ms.Write(gzBuffer, 4, gzBuffer.Length - 4);
// byte[] buffer = new byte[msgLength];
// ms.Position = 0;
// GZipStream zip = new GZipStream(ms, CompressionMode.Decompress);
// zip.Read(buffer, 0, buffer.Length);
// SetCameraTexture(buffer);
// }
// }
// break;
}
}
}
}
void ClientMessageReceived(object sender, MessageReceivedEventArgs e)
{
//Messages with TRAIN_TAG are for spawning train cars
if (e.GetMessage().Tag == TRAIN_TAG)
{
using (Message message = e.GetMessage())
using (DarkRiftReader reader = message.GetReader())
{
int carCount = reader.ReadInt32();
for (int i = 0; i < carCount; i++)
{
ushort carID = reader.ReadUInt16();
ushort carType = reader.ReadUInt16();
GameObject newCar;
switch (carType)
{
case ENGINE:
newCar = Instantiate(enginePrefab);
break;
case DEFAULT_CAR:
newCar = Instantiate(carPrefab);
break;
case CABOOSE:
newCar = Instantiate(caboosePrefab);
break;
case KITCHEN_CAR:
newCar = Instantiate(kitchencarPrefab);
break;
default:
newCar = Instantiate(carPrefab);
break;
}
newCar.transform.parent = train.transform;
newCar.transform.rotation = Quaternion.identity;
newCar.transform.localPosition = new Vector3(0, 2.9f, -16.13f + 16.13f * i);
newCar.GetComponent <NetworkTrackable>().uniqueID = carID;
cars.Add(carID, newCar.transform);
}
}
SpawnedTrains = true;
}
//Message with OBJECT_TAG are for spawning Interactable Objects
else if (e.GetMessage().Tag == OBJECT_TAG)
{
using (Message message = e.GetMessage())
using (DarkRiftReader reader = message.GetReader())
{
int objectCount = reader.ReadInt32();
for (int i = 0; i < objectCount; i++)
{
ushort objID = reader.ReadUInt16();
ushort objType = reader.ReadUInt16();
Vector3 localPosition = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
Vector3 eulerRotation = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
NetworkObject netObj = new NetworkObject(objID, objType, localPosition, eulerRotation);
objects.Add(objID, netObj);
}
}
initializedObjects = true;
}
//Messages with PICKUP_TAG contain the new position and rotation of an object with "Pickup" attached
else if (e.GetMessage().Tag == PICKUP_TAG)
{
using (Message message = e.GetMessage())
using (DarkRiftReader reader = message.GetReader())
{
ushort objID = reader.ReadUInt16();
if (objects.ContainsKey(objID))
{
GameObject obj = objects[objID].gObj;
Vector3 newLocalPosition = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
float angleX = reader.ReadSingle();
float angleY = reader.ReadSingle();
float angleZ = reader.ReadSingle();
obj.transform.localPosition = newLocalPosition;
obj.GetComponent <Pickup>().lastPostion = newLocalPosition;
Vector3 newRotation = new Vector3(angleX, angleY, angleZ);
obj.transform.eulerAngles = newRotation;
objects[objID].localPosition = newLocalPosition;
objects[objID].rotation = newRotation;
}
}
}
//Messages with USE_TAG contain the new use state of an interactable object
else if (e.GetMessage().Tag == USE_TAG)
{
using (Message message = e.GetMessage())
using (DarkRiftReader reader = message.GetReader())
{
ushort objID = reader.ReadUInt16();
if (objects.ContainsKey(objID))
{
GameObject obj = objects[objID].gObj;
ushort useTag = reader.ReadUInt16();
switch (useTag)
{
case START_USE:
obj.GetComponent <Interactable>().StartUse();
break;
case DURING_USE:
obj.GetComponent <Interactable>().DuringUse();
break;
case AFTER_USE:
obj.GetComponent <Interactable>().AfterUse();
break;
case ABORT_USE:
obj.GetComponent <Interactable>().AbortUse();
break;
}
}
else
{
Debug.LogWarning("Warning, received ID does not match an object");
}
}
}
else if (e.GetMessage().Tag == NUM_PLAYERS_TAG)
{
using (Message message = e.GetMessage())
using (DarkRiftReader reader = message.GetReader())
{
int numPlayers = reader.ReadInt32();
numPlayerText.text = "Players: " + numPlayers.ToString();
}
}
else if (e.GetMessage().Tag == DESTROY_OBJ_TAG)
{
using (Message message = e.GetMessage())
using (DarkRiftReader reader = message.GetReader())
{
ushort objID = reader.ReadUInt16();
GameObject toDestroy = objects[objID].gObj;
Destroy(toDestroy);
objects.Remove(objID);
}
}
else if (e.GetMessage().Tag == SPAWN_OBJ_TAG)
{
using (Message message = e.GetMessage())
using (DarkRiftReader reader = message.GetReader())
{
ushort objID = reader.ReadUInt16();
ushort objType = reader.ReadUInt16();
Vector3 localPosition = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
Vector3 eulerRotation = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
NetworkObject netObj = new NetworkObject(objID, objType, localPosition, eulerRotation);
GameObject newObj;
switch (netObj.ObjType)
{
case 0:
newObj = Instantiate(testInteractablePrefab, train.transform.TransformPoint(netObj.localPosition), Quaternion.Euler(netObj.rotation.x, netObj.rotation.y, netObj.rotation.z), train.transform);
break;
case 1:
newObj = Instantiate(testPickupPrefab, train.transform.TransformPoint(netObj.localPosition), Quaternion.Euler(netObj.rotation.x, netObj.rotation.y, netObj.rotation.z), train.transform);
newObj.GetComponent <Pickup>().lastPostion = train.transform.InverseTransformPoint(netObj.localPosition);
newObj.GetComponent <Pickup>().ID = netObj.ID;
break;
default:
newObj = Instantiate(testInteractablePrefab, train.transform.TransformPoint(netObj.localPosition), Quaternion.Euler(netObj.rotation.x, netObj.rotation.y, netObj.rotation.z), train.transform);
break;
}
newObj.GetComponent <NetworkTrackable>().uniqueID = netObj.ID;
objects.Add(objID, netObj);
}
}
}
private void Client_MessageReceived(object sender, MessageReceivedEventArgs e)
{
try
{
using (Message message = e.GetMessage())
using (DarkRiftReader reader = message.GetReader())
{
OpCodes opCode = (OpCodes)message.Tag;
if (opCode != OpCodes.AuthenticationResponse && pendingConnections.Contains(e.Client.ID))
{
pendingConnections.Remove(e.Client.ID);
LeaveRoom(e.Client.ID);
e.Client.Disconnect();
return;
}
switch (opCode)
{
case OpCodes.UpdateRoomData:
string extraData = reader.ReadString();
int newMaxPlayers = reader.ReadInt32();
UpdateRoomData(e, extraData, newMaxPlayers);
break;
case OpCodes.AuthenticationResponse:
if (reader.ReadString() == authKey)
{
pendingConnections.Remove(e.Client.ID);
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
using (Message sendAuthed = Message.Create((ushort)OpCodes.Authenticated, writer))
e.Client.SendMessage(sendAuthed, SendMode.Reliable);
}
}
else
{
pendingConnections.Remove(e.Client.ID);
LeaveRoom(e.Client.ID);
e.Client.Disconnect();
}
break;
case OpCodes.RequestID:
SendClientID(e);
break;
case OpCodes.CreateRoom:
CreateRoom(e, reader.ReadInt32(), reader.ReadString(), reader.ReadBoolean(), reader.ReadString(), reader.ReadBoolean(), reader.ReadString());
break;
case OpCodes.JoinServer:
ushort hostID = reader.ReadUInt16();
bool useRelay = reader.ReadBoolean();
string clientLocalIP = reader.ReadString();
JoinRoom(e, hostID, useRelay, clientLocalIP);
break;
case OpCodes.SendData:
byte[] readBuffer = readBuffers.Rent(reader.ReadInt32());
reader.ReadBytesInto(readBuffer, 0);
ProcessData(e, reader, readBuffer, readBuffer.Length);
break;
case OpCodes.LeaveRoom:
LeaveRoom(e.Client);
break;
case OpCodes.KickPlayer:
ushort clientID = reader.ReadUInt16();
LeaveRoom(clientID, e.Client.ID);
break;
case OpCodes.RequestServers:
SendServerList(e);
break;
}
}
}
catch
{
// Do disconnect/kick maybe later if they do be acting up.
}
}
private void Client_MessageReceived(object sender, DarkRift.Client.MessageReceivedEventArgs e)
{
try
{
using (Message message = e.GetMessage())
using (DarkRiftReader reader = message.GetReader())
{
OpCodes opCode = (OpCodes)message.Tag;
switch (opCode)
{
case OpCodes.ServerConnectionData:
string serverIP = reader.ReadString();
if (directConnectModule == null)
{
directConnectAddress = "";
return;
}
directConnectAddress = serverIP;
if (showDebugLogs)
{
Debug.Log("Received direct connect info from server.");
}
break;
case OpCodes.Authenticated:
isAuthenticated = true;
if (showDebugLogs)
{
Debug.Log("Authenticated with server.");
}
break;
case OpCodes.AuthenticationRequest:
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(relayPassword);
using (Message sendAuthenticationResponse = Message.Create((ushort)OpCodes.AuthenticationResponse, writer))
drClient.Client.SendMessage(sendAuthenticationResponse, SendMode.Reliable);
}
if (showDebugLogs)
{
Debug.Log("Server requested authentication key.");
}
break;
case OpCodes.GetData:
int dataLength = reader.ReadInt32();
byte[] receivedData = new byte[dataLength];
System.Buffer.BlockCopy(reader.ReadBytes(), 0, receivedData, 0, dataLength);
if (isServer)
{
OnServerDataReceived?.Invoke(connectedRelayClients.GetByFirst(reader.ReadUInt16()), new ArraySegment <byte>(receivedData), e.SendMode == SendMode.Unreliable ? 1 : 0);
}
if (isClient)
{
OnClientDataReceived?.Invoke(new ArraySegment <byte>(receivedData), e.SendMode == SendMode.Unreliable ? 1 : 0);
}
break;
case OpCodes.ServerLeft:
if (isClient)
{
isClient = false;
OnClientDisconnected?.Invoke();
}
break;
case OpCodes.PlayerDisconnected:
if (isServer)
{
ushort user = reader.ReadUInt16();
OnServerDisconnected?.Invoke(connectedRelayClients.GetByFirst(user));
connectedRelayClients.Remove(user);
if (showDebugLogs)
{
Debug.Log($"Client {user} left room.");
}
}
break;
case OpCodes.RoomCreated:
serverID = reader.ReadUInt16();
isConnected = true;
if (showDebugLogs)
{
Debug.Log("Server Created on relay.");
}
break;
case OpCodes.ServerJoined:
ushort clientID = reader.ReadUInt16();
if (isClient)
{
isConnected = true;
OnClientConnected?.Invoke();
if (showDebugLogs)
{
Debug.Log("Successfully joined server.");
}
}
if (isServer)
{
connectedRelayClients.Add(clientID, currentMemberID);
OnServerConnected?.Invoke(currentMemberID);
currentMemberID++;
if (showDebugLogs)
{
Debug.Log($"Client {clientID} joined the server.");
}
}
break;
case OpCodes.ServerListResponse:
int serverListCount = reader.ReadInt32();
relayServerList.Clear();
for (int i = 0; i < serverListCount; i++)
{
relayServerList.Add(new RelayServerInfo()
{
serverName = reader.ReadString(),
currentPlayers = reader.ReadInt32(),
maxPlayers = reader.ReadInt32(),
serverID = reader.ReadUInt16(),
serverData = reader.ReadString()
});
}
serverListUpdated?.Invoke();
if (showDebugLogs)
{
Debug.Log("Received Server List.");
}
break;
}
}
}
catch
{
// Server shouldnt send messed up data but we do have an unreliable channel, so eh.
}
}
public void OnDataRecieved(byte tag, ushort subject, object data)
{
if (tag == (byte)TagsNSubjects.Tags.MATCHMAKING_TAG)
{
if (subject == (ushort)TagsNSubjects.MatchmakingSubjects.OPPONENTSLIST)
{
using (DarkRiftReader reader = data as DarkRiftReader) {
int n;
n = reader.ReadInt32();
string[] nn = new string[n];
nn = reader.ReadStrings();
Globalmanager.availablePlayers.Clear();
Globalmanager.availablePlayers.AddRange(nn);
Globalmanager.availablePlayersUpdated = true;
}
}
}
if (tag == (byte)TagsNSubjects.Tags.CARDTAG)
{
if (subject == (ushort)TagsNSubjects.CardSubjects.AVAILABLECARDS)
{
using (DarkRiftReader reader = data as DarkRiftReader) {
ushort n;
n = reader.ReadUInt16();
List <ushort> cardIds = new List <ushort> ();
for (int i = 0; i < n; i++)
{
cardIds.Add(reader.ReadUInt16());
}
Globalmanager.availableCards.Clear();
Globalmanager.availableCards.AddRange(cardIds);
Globalmanager.availableCardsUpdated = true;
}
}
}
if (tag == (byte)TagsNSubjects.Tags.MATCHMAKING_TAG)
{
if (subject == (ushort)TagsNSubjects.MatchmakingSubjects.CHALLENGE)
{
string challenger;
using (DarkRiftReader reader = data as DarkRiftReader) {
challenger = reader.ReadString();
}
StartCoroutine(Challenge(challenger));
}
if (subject == (ushort)TagsNSubjects.MatchmakingSubjects.GAMESTART)
{
SceneManager.LoadScene("Game");
using (DarkRiftReader reader = data as DarkRiftReader) {
List <ushort> deck1 = new List <ushort> ();
List <ushort> deck2 = new List <ushort> ();
for (int i = 0; i < Globalmanager.deckSize; i++)
{
deck1.Add(reader.ReadUInt16());
}
for (int i = 0; i < Globalmanager.deckSize; i++)
{
deck2.Add(reader.ReadUInt16());
}
Globalmanager.deckList1 = deck1;
Globalmanager.deckList2 = deck2;
Globalmanager.deckListsRecieved = true;
}
}
if (subject == (ushort)TagsNSubjects.MatchmakingSubjects.GAMESTARTFAILED)
{
Error.Instance.PopUp("Opponent Not Found");
}
}
}
void ItemMessageReceived(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
// Client wants to add item to container
if (message.Tag == Tags.AddItemToContainerTag)
{
using (DarkRiftReader reader = message.GetReader())
{
int networkID = reader.ReadInt32();
string itemName = reader.ReadString();
int amount = reader.ReadInt32();
NetworkItemContainer.itemContainerDictionary[networkID].AddItem(CreateItem(itemName, amount));
using (Message newMessage = Message.Create(Tags.AddItemToContainerTag, NetworkItemContainer.itemContainerDictionary[networkID]))
{
foreach (IClient c in ClientManager.GetAllClients())
{
c.SendMessage(newMessage, SendMode.Reliable);
}
}
}
}
// Client wants to delete item from container
if (message.Tag == Tags.DeleteItemFromContainerTag)
{
using (DarkRiftReader reader = message.GetReader())
{
int networkID = reader.ReadInt32();
string itemName = reader.ReadString();
int amount = reader.ReadInt32();
NetworkItemContainer.itemContainerDictionary[networkID].DeleteItem(CreateItem(itemName, amount));
using (Message newMessage = Message.Create(Tags.DeleteItemFromContainerTag, NetworkItemContainer.itemContainerDictionary[networkID]))
{
foreach (IClient c in ClientManager.GetAllClients())
{
c.SendMessage(newMessage, SendMode.Reliable);
}
}
}
}
// Client wants to transfer item from one container to another
if (message.Tag == Tags.TransferItemBetweenContainersTag)
{
using (DarkRiftReader reader = message.GetReader())
{
int fromContainerNetworkID = reader.ReadInt32();
int toContainerNetworkID = reader.ReadInt32();
string itemName = reader.ReadString();
int amount = reader.ReadInt32();
TransferItemBetweenContainers(CreateItem(itemName, amount), NetworkItemContainer.itemContainerDictionary[fromContainerNetworkID], NetworkItemContainer.itemContainerDictionary[toContainerNetworkID]);
// Update the donor container
using (Message newMessage = Message.Create(Tags.TransferItemBetweenContainersTag, NetworkItemContainer.itemContainerDictionary[fromContainerNetworkID]))
{
foreach (IClient c in ClientManager.GetAllClients())
{
c.SendMessage(newMessage, SendMode.Reliable);
}
}
// Update the receiver container
using (Message newMessage = Message.Create(Tags.TransferItemBetweenContainersTag, NetworkItemContainer.itemContainerDictionary[toContainerNetworkID]))
{
foreach (IClient c in ClientManager.GetAllClients())
{
c.SendMessage(newMessage, SendMode.Reliable);
}
}
}
}
}
}