void SerialisePos(Vector3 pos)
{
//Here is where we actually serialise things manually. To do this we need to add
//any data we want to send to a DarkRiftWriter. and then send this as we would normally.
//The advantage of custom serialisation is that you have a much smaller overhead than when
//the default BinaryFormatter is used, typically about 50 bytes.
using(DarkRiftWriter writer = new DarkRiftWriter())
{
//Next we write any data to the writer, as we never change the z pos there's no need to
//send it.
writer.Write(pos.x);
writer.Write(pos.y);
DarkRiftAPI.SendMessageToOthers(0, (ushort)cubeID, writer);
}
}
/// <summary>
/// Sends the position and rotation of this character.
/// </summary>
void SendTransform()
{
//Serialize
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(transform.position.x);
writer.Write(transform.position.y);
writer.Write(transform.position.z);
writer.Write(transform.eulerAngles.x);
writer.Write(transform.eulerAngles.y);
writer.Write(transform.eulerAngles.z);
//Send
using (Message message = Message.Create(BlockTags.Movement, writer))
client.SendMessage(message, SendMode.Unreliable);
}
//Store last values sent
lastPosition = transform.position;
lastRotation = transform.eulerAngles;
}
void SendTransform()
{
//Serialize
DarkRiftWriter writer = new DarkRiftWriter();
writer.Write(transform.position.x);
writer.Write(transform.position.y);
writer.Write(transform.position.z);
writer.Write(transform.eulerAngles.x);
writer.Write(transform.eulerAngles.y);
writer.Write(transform.eulerAngles.z);
TagSubjectMessage message = new TagSubjectMessage(MOVEMENT_TAG, 0, writer);
//Send
client.SendMessage(message, SendMode.Unreliable);
//Store last values sent
lastPosition = transform.position;
lastRotation = transform.eulerAngles;
}
void SendMessage(int id)
{
if (id == 0)
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(House);
using (Message message = Message.Create(Tags.HouseNormal, writer))
{
foreach (IClient client in Clients.Values)
{
client.SendMessage(message, SendMode.Reliable);
}
}
}
}
else if (id == 1)
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.WriteSmart(House, ExtraSyncData.TypeIDANDTag, 1);
using (Message message = Message.Create(Tags.HouseNothing, writer))
{
foreach (IClient client in Clients.Values)
{
client.SendMessage(message, SendMode.Reliable);
}
}
}
}
else if (id == 2)
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.WriteSmart(House, 1, true);
using (Message message = Message.Create(Tags.HouseType, writer))
{
foreach (IClient client in Clients.Values)
{
client.SendMessage(message, SendMode.Reliable);
}
}
}
}
else if (id == 3)
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.WriteSmart(House, 1, false, true);
using (Message message = Message.Create(Tags.HouseTag, writer))
{
foreach (IClient client in Clients.Values)
{
client.SendMessage(message, SendMode.Reliable);
}
}
}
}
else if (id == 4)
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.WriteSmart(House, 1);
using (Message message = Message.Create(Tags.HouseTypeANDTag, writer))
{
foreach (IClient client in Clients.Values)
{
client.SendMessage(message, SendMode.Reliable);
}
}
}
}
else if (id == 5)
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.WriteSmart(House, ExtraSyncData.TypeIDANDTag, 1);
using (Message message = Message.Create(Tags.HouseUpdateNothing, writer))
{
foreach (IClient client in Clients.Values)
{
client.SendMessage(message, SendMode.Reliable);
}
}
}
}
else if (id == 6)
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.WriteSmart(House, ExtraSyncData.TypeID, 1);
using (Message message = Message.Create(Tags.HouseUpdateTag, writer))
{
foreach (IClient client in Clients.Values)
{
client.SendMessage(message, SendMode.Reliable);
}
}
}
}
Console.WriteLine("Insert a message number from 0 to 6 ");
SendMessage(int.Parse(Console.ReadLine()));
}
public void WhenIStressTestWithPerClient(string direction, int count)
{
List <Thread> threads = new List <Thread>();
// Send from clients
if (direction == "client to server" || direction == "both")
{
foreach (DarkRiftClient client in world.GetClients())
{
threads.Add(new Thread(() =>
{
Random random = new Random();
for (int i = 0; i < count; i++)
{
string value = random.NextDouble().ToString();
ushort tag = (ushort)random.Next(65536);
//SendMode sendMode = random.Next(2) == 0 ? SendMode.Reliable : SendMode.Unreliable;
SendMode sendMode = SendMode.Reliable; //TODO test unreliable but with less data
using DarkRiftWriter writer = DarkRiftWriter.Create();
writer.Write(value);
using Message message = Message.Create(tag, writer);
bool success = client.SendMessage(message, sendMode);
Assert.IsTrue(success);
messageAssertions.ExpectMessageOnServer(new ReceivedMessage(value, client.ID, 0, tag, sendMode));
}
}));
}
}
// Send from server
if (direction == "server to client" || direction == "both")
{
foreach (IClient client in world.GetServer(0).ClientManager.GetAllClients())
{
threads.Add(new Thread(() =>
{
Random random = new Random();
for (int i = 0; i < count; i++)
{
string value = random.NextDouble().ToString();
ushort tag = (ushort)random.Next(65536);
//SendMode sendMode = random.Next(2) == 0 ? SendMode.Reliable : SendMode.Unreliable;
SendMode sendMode = SendMode.Reliable; //TODO test unreliable but with less data
using DarkRiftWriter writer = DarkRiftWriter.Create();
writer.Write(value);
using Message message = Message.Create(tag, writer);
bool success = client.SendMessage(message, sendMode);
Assert.IsTrue(success);
messageAssertions.ExpectMessageOnClient(new ReceivedMessage(value, ushort.MaxValue, client.ID, tag, sendMode));
}
}));
}
}
// Start all the threads
foreach (Thread thread in threads)
{
thread.Start();
}
// Join all the threads
foreach (Thread thread in threads)
{
thread.Join();
}
}
private void CommandHandler(object sender, CommandEventArgs e)
{
if (e.Arguments.Length < 3)
{
throw new CommandSyntaxException($"Expected 3 arguments but found {e.Arguments.Length}.");
}
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
ushort clientID;
try
{
clientID = ushort.Parse(e.Arguments[0]);
}
catch (FormatException)
{
throw new CommandSyntaxException($"Unable to parse the client ID. Expected a number but got '{e.Arguments[0]}'.");
}
SendMode sendMode;
switch (e.Arguments[1].ToLower())
{
case "unreliable":
case "u":
sendMode = SendMode.Unreliable;
break;
case "reliable":
case "r":
sendMode = SendMode.Reliable;
break;
default:
throw new CommandSyntaxException($"Expected 'unreliable' or 'reliable' but got '{e.Arguments[1]}'.");
}
ushort tag;
try
{
tag = ushort.Parse(e.Arguments[2]);
}
catch (FormatException)
{
throw new CommandSyntaxException($"Unable to parse the tag. Expected a number but got '{e.Arguments[2]}'.");
}
try {
IEnumerable <byte> bytes =
e.Arguments
.Skip(3)
.Select((a) => byte.Parse(a));
foreach (byte b in bytes)
{
writer.Write(b);
}
}
catch (FormatException)
{
throw new CommandSyntaxException("An argument was unable to be parsed to a number.");
}
using (Message message = Message.Create(tag, writer))
{
try
{
ClientManager[clientID].SendMessage(message, sendMode);
}
catch (KeyNotFoundException)
{
Logger.Error("No client with id " + clientID);
}
}
}
}
private void PlayerUpdateMessageRecieved(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == Tags.PlayerUpdateTag)
{
using (DarkRiftReader reader = message.GetReader())
{
while (reader.Position < reader.Length)
{
WorldData World = WorldManager.clients[e.Client].World;
PlayerUpdateClientDTO playerUpdateData = reader.ReadSerializable <PlayerUpdateClientDTO>();
Player player;
if (playerUpdateData.PlayerID < 128)
{
player = World.players[e.Client];
}
else
{
player = World.AIPlayers[playerUpdateData.PlayerID];
}
player.X = playerUpdateData.x;
player.Y = playerUpdateData.y;
player.Z = playerUpdateData.z;
player.RX = playerUpdateData.rx;
player.RY = playerUpdateData.ry;
player.RZ = playerUpdateData.rz;
player.VX = playerUpdateData.vx;
player.VY = playerUpdateData.vy;
player.VZ = playerUpdateData.vz;
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
PlayerUpdateServerDTO playerUpdateOutData = new PlayerUpdateServerDTO();
playerUpdateOutData.ID = player.ID;
playerUpdateOutData.x = player.X;
playerUpdateOutData.y = player.Y;
playerUpdateOutData.z = player.Z;
playerUpdateOutData.rx = player.RX;
playerUpdateOutData.ry = player.RY;
playerUpdateOutData.rz = player.RZ;
playerUpdateOutData.vx = player.VX;
playerUpdateOutData.vy = player.VY;
playerUpdateOutData.vz = player.VZ;
playerUpdateOutData.triggerQueue = playerUpdateData.triggerQueue;
writer.Write(playerUpdateOutData);
using (Message playerUpdateMessage = Message.Create(Tags.PlayerUpdateTag, writer))
{
foreach (IClient c in World.GetClients().Where(x => x != e.Client))
{
c.SendMessage(playerUpdateMessage, e.SendMode);
}
}
}
}
}
}
}
}
/// <summary>
/// If Return false. the playing client is in the wrong match
/// </summary>
/// <param name="slateIndex"></param>
/// <param name="client"></param>
/// <returns></returns>
public bool PlayerTakesSlate(ushort slateIndex, IClient client)
{
if (currentPlayerClientID != client.ID)
{
Console.WriteLine("not you turn!");
return(false);
}
// invalid slate index
if (slateIndex >= slates.Length)
{
Console.WriteLine("slate invalid");
return(false);
}
// check if slate is available
if (slates[slateIndex] != SlateStatus.NONE)
{
Console.WriteLine("slate taken already");
return(false);
}
if (player1.Client == client)
{
Console.WriteLine($"player 1 (client-{player1.Client.ID}) took slate {slateIndex}");
}
else if (player2.Client == client)
{
Console.WriteLine($"player 2 (client-{player2.Client.ID}) took slate {slateIndex}");
}
else
{
Console.WriteLine("are you tring to **** me?");
return(false);
}
// assign slate to played player
slates[slateIndex] = player1.Client == client ? SlateStatus.PLAYER1 : SlateStatus.PLAYER2;
using (DarkRiftWriter writer = DarkRiftWriter.Create()) {
ushort winnerClientID = 0;
bool win = MatchHelper.GetWinner(slates, player1.Client.ID, player2.Client.ID, out winnerClientID);
bool draw = true;
if (win == false)
{
// check if board is full
for (int i = 0; i < slates.Length; i++)
{
if (slates[i] == SlateStatus.NONE)
{
draw = false;
break;
}
}
}
writer.Write(slateIndex);
writer.Write(client.ID);
Console.WriteLine($"move was made by client id: {client.ID}.");
if (win)
{
writer.Write((byte)1);
}
else if (draw)
{
writer.Write((byte)2);
}
else
{
writer.Write((byte)0);
}
if (win)
{
MatchOver = true;
writer.Write(winnerClientID);
Console.BackgroundColor = ConsoleColor.Yellow;
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.WriteLine("Uno se gano el Grammy");
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.White;
}
else if (draw)
{
MatchOver = true;
Console.BackgroundColor = ConsoleColor.Yellow;
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.WriteLine("Se empato esta vaina");
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.White;
}
using (Message msg = Message.Create((ushort)Tags.Tag.SERVER_CONFIRM_SLATE_TAKEN, writer)) {
player1.Client.SendMessage(msg, SendMode.Reliable);
player2.Client.SendMessage(msg, SendMode.Reliable);
}
currentPlayerClientID = currentPlayerClientID == player1.Client.ID ? player2.Client.ID : player1.Client.ID;
Console.WriteLine($"turn of client id: {currentPlayerClientID}");
}
return(true);
}
void AddPlayer(object sender, MessageReceivedEventArgs e)
{
//Message to tell all players about train
using (DarkRiftWriter trainWriter = DarkRiftWriter.Create())
{
trainWriter.Write(testTrain.Cars.Count);
for (int i = 0; i < testTrain.Cars.Count; i++)
{
trainWriter.Write(testTrain.Cars[i].ID);
trainWriter.Write(testTrain.Cars[i].CarType);
}
using (Message trainMessage = Message.Create(TRAIN_TAG, trainWriter))
{
e.Client.SendMessage(trainMessage, SendMode.Reliable);
}
}
//Message to tell new player about interactable objects
using (DarkRiftWriter objectWriter = DarkRiftWriter.Create())
{
objectWriter.Write(objects.Count);
foreach (InteractableObject obj in objects.Values)
{
objectWriter.Write(obj.ID);
objectWriter.Write(obj.objectType);
objectWriter.Write(obj.X);
objectWriter.Write(obj.Y);
objectWriter.Write(obj.Z);
objectWriter.Write(obj.angleX);
objectWriter.Write(obj.angleY);
objectWriter.Write(obj.angleZ);
}
using (Message objectMessage = Message.Create(OBJECT_TAG, objectWriter))
{
e.Client.SendMessage(objectMessage, SendMode.Reliable);
}
}
//Mesage to tell client that connected about all players
using (DarkRiftWriter playerWriter = DarkRiftWriter.Create())
{
foreach (Player player in players.Values)
{
playerWriter.Write(player.ID);
playerWriter.Write(player.parentCarID);
playerWriter.Write(player.X);
playerWriter.Write(player.Y);
playerWriter.Write(player.Z);
playerWriter.Write(player.angleX);
playerWriter.Write(player.angleY);
playerWriter.Write(player.angleZ);
}
using (Message playerMessage = Message.Create(0, playerWriter))
{
e.Client.SendMessage(playerMessage, SendMode.Reliable);
}
}
//Mesage to tell all other clients about new player
using (DarkRiftWriter newPlayerWriter = DarkRiftWriter.Create())
{
Player newPlayer = players[e.Client];
newPlayerWriter.Write(newPlayer.ID);
newPlayerWriter.Write(newPlayer.parentCarID);
newPlayerWriter.Write(newPlayer.X);
newPlayerWriter.Write(newPlayer.Y);
newPlayerWriter.Write(newPlayer.Z);
newPlayerWriter.Write(newPlayer.angleX);
newPlayerWriter.Write(newPlayer.angleY);
newPlayerWriter.Write(newPlayer.angleZ);
using (Message newPlayerMessage = Message.Create(0, newPlayerWriter))
{
foreach (IClient c in ClientManager.GetAllClients().Where(x => x != e.Client))
{
c.SendMessage(newPlayerMessage, SendMode.Reliable);
}
}
}
}
/// <summary>
/// Login with the specified username and password.
/// </summary>
/// <param name="username">The username.</param>
/// <param name="password">The password.</param>
public static void Login(string username, string password)
{
//Stop people from simply spamming the server
if (string.IsNullOrEmpty (username) || string.IsNullOrEmpty (password))
return;
//Build the data to send
using( DarkRiftWriter writer = new DarkRiftWriter() )
{
writer.Write(username);
writer.Write(SecurityHelper.GetHash(password, hashType));
//Choose the connection to use
if( connection == null )
{
if( DarkRiftAPI.isConnected )
{
//Send via DarkRiftAPI
DarkRiftAPI.SendMessageToServer(
tag,
loginSubject,
writer
);
BindIfNotBound();
}
else
{
//Called if you try to login whilst not connected to a server
Debug.LogError("[LoginPlugin] You can't login if you're not connected to a server! (Do you mean to use DarkRiftAPI?)");
}
}
else
{
if( connection.isConnected )
{
//Send via DarkRiftConnection
connection.SendMessageToServer(
tag,
loginSubject,
writer
);
BindIfNotBound();
}
else
{
//Called if you try to login whilst not connected to a server
Debug.LogError("[LoginPlugin] You can't login if you're not connected to a server!");
}
}
}
}
private void OnMessageReceived(object sender, MessageReceivedEventArgs e)
{
var message = e.Message as TagSubjectMessage;
if (message == null || message.Tag != Tags.GameServer)
{
return;
}
var client = (Client)sender;
// Identify Player
if (message.Subject == GameServerSubjects.IdentifyPlayer)
{
var reader = message.GetReader();
var mainId = reader.ReadUInt32();
var player = ServerManager.Instance.PendingPlayers.FirstOrDefault(p => p.Id == mainId);
if (player == null)
{
Debug.Log("Failed to identify player");
client.SendMessage(new TagSubjectMessage(Tags.GameServer, GameServerSubjects.IdentifyPlayerFailed, new DarkRiftWriter()), SendMode.Reliable);
return;
}
ServerManager.Instance.Server.Dispatcher.InvokeAsync(() =>
{
ServerManager.Instance.PendingPlayers.Remove(player);
ServerManager.Instance.Players[client] = player;
ServerManager.Instance.Players[client].Id = client.GlobalID;
foreach (var cl in ServerManager.Instance.Players.Keys)
{
var writer = new DarkRiftWriter();
if (cl == client)
{
// Let player know who's already in the game
foreach (var pl in ServerManager.Instance.Players.Values)
{
writer.Write(pl);
}
client.SendMessage(
new TagSubjectMessage(Tags.GameServer, GameServerSubjects.IdentifyPlayer, writer),
SendMode.Reliable);
}
else
{
// Let others know who joined
writer.Write(player);
cl.SendMessage(
new TagSubjectMessage(Tags.GameServer, GameServerSubjects.PlayerJoined, writer),
SendMode.Reliable);
}
}
_text.text = "Connected: " + ServerManager.Instance.Players.Count + "/" + ServerManager.Instance.PendingPlayers.Count + ServerManager.Instance.Players.Count;
if (ServerManager.Instance.PendingPlayers.Count == 0)
{
_voting.SetActive(true);
}
});
}
////////////////////////////// For faster testing only! /////////////////////////
if (message.Subject == GameServerSubjects.TestModeSLA)
{
ServerManager.Instance.Players[client] = new Player(client.GlobalID, "AwesomeName", PlayerColor.Green);
var writer = new DarkRiftWriter();
writer.Write(ServerManager.Instance.Players[client]);
client.SendMessage(new TagSubjectMessage(Tags.GameServer, GameServerSubjects.IdentifyPlayer, writer), SendMode.Reliable);
ServerManager.Instance.Server.Dispatcher.InvokeWait(() =>
{
_voting.SetActive(true);
}
);
}
////////////////////////////////////////////////////////////////////////////////
}
void SendMessage(GameObject movingObject)
{
if (PlayerCreator.connected == false)
{
return;
}
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
Transform go = movingObject.transform.parent;
int objectIndex = -1;
for (int i = 0; i < go.childCount; i++)
{
if (go.GetChild(i).gameObject == movingObject)
{
objectIndex = i;
break;
}
}
writer.Write(objectIndex);
writer.Write(movingObject.transform.position.x);
writer.Write(movingObject.transform.position.z);
writer.Write(movingObject.transform.rotation.eulerAngles.y);
GameObject redLaserGun = GameObject.Find("RedLaserGun");
GameObject blueLaserGun = GameObject.Find("BlueLaserGun");
writer.Write(redLaserGun.transform.rotation.x);
writer.Write(redLaserGun.transform.rotation.y);
writer.Write(redLaserGun.transform.rotation.z);
writer.Write(redLaserGun.transform.rotation.w);
writer.Write(blueLaserGun.transform.rotation.x);
writer.Write(blueLaserGun.transform.rotation.y);
writer.Write(blueLaserGun.transform.rotation.z);
writer.Write(blueLaserGun.transform.rotation.w);
using (Message message = Message.Create(MOVEMENT_TAG, writer))
{
client.SendMessage(message, SendMode.Reliable);
}
}
}
public void Tick()
{
if (Hp < 100 && Game.Frame % 40 == 0)
{
Hp += 1;
}
if (Hp < 70 && Game.Frame % 300 == 0)
{
Blood.FireBlood(Transform.Position, Game, this);
}
else if (Hp < 45 && Game.Frame % 120 == 0)
{
Blood.FireBlood(Transform.Position, Game, this);
}
Vector2 oldPos = Transform.Position;
if (Grounded && Jumped)
{
Velocity.y += jumpStrenght;
}
Grounded = false;
Jumped = false;
Velocity.y -= gravity * Clock.DeltaTime;
Transform.Translate(new Vector2(0, Velocity.y * Clock.DeltaTime));
Collider CollidedMapObjectVert = Game.CollideWithMapReturnCollider(Collider);
if (CollidedMapObjectVert != null)
{
float ResetDistance = 0;
if (CollidedMapObjectVert.GetType() == typeof(BoxCollider))
{
ResetDistance = ((BoxCollider)CollidedMapObjectVert).Size.y / 2 + ((BoxCollider)Collider).Size.y / 2 + 0.001f;
}
else if (CollidedMapObjectVert.GetType() == typeof(BoxCollider))
{
ResetDistance = ((CircleCollider)CollidedMapObjectVert).Radius + ((BoxCollider)Collider).Size.y / 2 + 0.001f;
}
if (Velocity.y <= 0)
{
Transform.Translate(new Vector2(0, CollidedMapObjectVert.Transform.Position.y - Transform.Position.y + ResetDistance));
Grounded = true;
}
else
{
Transform.Translate(new Vector2(0, CollidedMapObjectVert.Transform.Position.y - Transform.Position.y - ResetDistance));
}
//Transform.Translate(new Vector2(0, -Velocity.y*Clock.DeltaTime));
//if (Velocity.y <= 0)
//{
// Grounded = true;
//}
Velocity.y = 0;
}
float walkVelocity = 0;
if (WalkL)
{
walkVelocity -= movementSpeed * Clock.DeltaTime;
}
if (WalkR)
{
walkVelocity += movementSpeed * Clock.DeltaTime;
}
Transform.Translate(new Vector2(Velocity.x * Clock.DeltaTime + walkVelocity, 0));
Collider CollidedMapObjectHor = Game.CollideWithMapReturnCollider(Collider);
if (CollidedMapObjectHor != null)
{
float ResetDistance = 0;
if (CollidedMapObjectHor.GetType() == typeof(BoxCollider))
{
ResetDistance = ((BoxCollider)CollidedMapObjectHor).Size.x / 2 + ((BoxCollider)Collider).Size.x / 2 + 0.001f;
}
else if (CollidedMapObjectHor.GetType() == typeof(CircleCollider))
{
ResetDistance = ((CircleCollider)CollidedMapObjectHor).Radius + ((BoxCollider)Collider).Size.x / 2 + 0.001f;
}
if (walkVelocity < 0)
{
Transform.Translate(new Vector2(CollidedMapObjectHor.Transform.Position.x - Transform.Position.x + ResetDistance, 0));
}
else
{
Transform.Translate(new Vector2(CollidedMapObjectHor.Transform.Position.x - Transform.Position.x - ResetDistance, 0));
}
//Transform.Translate(new Vector2(-Velocity.x * Clock.DeltaTime - walkVelocity, 0));
Velocity.x = 0;
}
if (/*oldPos != Transform.Position*/ true)
{
if (Game.IsEnlighted(Collider))
{
Game.UpdateMessage.AddCharacterPosUpdate(Owner.PlayerId, Transform.Position);
WasEnlighted = true;
}
else
{
DarkRiftWriter writer = DarkRiftWriter.Create();
if (WasEnlighted)
{
WasEnlighted = false;
writer.Write(Owner.PlayerId);
Game.SendMessageToAll(Message.Create((ushort)Tags.MakeInvisisble, writer));;
}
writer = DarkRiftWriter.Create();
writer.Write(Transform.Position.x);
writer.Write(Transform.Position.y);
Owner.Client.SendMessage(Message.Create((ushort)Tags.WalkInvisible, writer), SendMode.Reliable);
}
}
}
private void OnClientMessageReceived(object sender, MessageReceivedEventArgs e)
{
switch (e.Tag)
{
case (ushort)Tags.Tag.SET_NAME:
// new player registering
using (Message message = e.GetMessage()) {
using (DarkRiftReader reader = message.GetReader()) {
string name = reader.ReadString();
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("hey mister " + name);
Console.ForegroundColor = ConsoleColor.White;
PlayerModel newPlayer = new PlayerModel(e.Client, name);
if (pendingPlayer == null)
{
// new player is pending for a match
pendingPlayer = newPlayer;
}
else
{
// there is already a pending player. lets start a new match
MatchModel match = new MatchModel(pendingPlayer, newPlayer);
matches.Add(match.id, match);
// report clients of the new match
using (DarkRiftWriter writer = DarkRiftWriter.Create()) {
writer.Write(match.id);
writer.Write(match.CurrentPlayerClientID);
using (Message msg = Message.Create((ushort)Tags.Tag.GOT_MATCH, writer)) {
pendingPlayer.Client.SendMessage(msg, SendMode.Reliable);
newPlayer.Client.SendMessage(msg, SendMode.Reliable);
}
}
pendingPlayer = null;
}
}
}
break;
case (ushort)Tags.Tag.SLATE_TAKEN:
using (Message message = e.GetMessage()) {
using (DarkRiftReader reader = message.GetReader()) {
ushort matchId = reader.ReadUInt16();
ushort slateIndex = reader.ReadUInt16();
if (matches.ContainsKey(matchId))
{
MatchModel match = matches[matchId];
match.PlayerTakesSlate(slateIndex, e.Client);
if (match.MatchOver)
{
// match is over
Console.WriteLine($"match over. had: {matches.Count} matches");
matches.Remove(matchId);
Console.WriteLine($"match over. now have: {matches.Count} matches");
}
}
}
}
break;
}
}
/// <summary>
/// When a client connects to the DarkRift server
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ClientConnected(object sender, ClientConnectedEventArgs e)
{
//Make user subscribe to these methods
e.Client.MessageReceived += MessageReceived;
Player newPlayer = new Player(e.Client.ID);
//First player to join gets to be party leader
if (players.Count == 0)
{
LobbyLeader = newPlayer;
using (DarkRiftWriter lobbyLeaderWriter = DarkRiftWriter.Create())
{
//Filler
lobbyLeaderWriter.Write(e.Client.ID);
using (Message playerMessage = Message.Create(Tags.UserLeaderTag, lobbyLeaderWriter))
e.Client.SendMessage(playerMessage, SendMode.Reliable);
}
}
//Add to Dictionary
players.Add(e.Client, newPlayer);
//Tell all other users that a new user has joined
using (DarkRiftWriter newPlayerWriter = DarkRiftWriter.Create())
{
newPlayerWriter.Write(newPlayer.ID);
newPlayerWriter.Write(newPlayer.name);
using (Message newPlayerMessage = Message.Create(Tags.newUserConnectedTag, newPlayerWriter))
{
foreach (IClient client in serverReference.Server.ClientManager.GetAllClients())
{
if (client.ID != e.Client.ID)
{
Debug.Log("New client join and sending this to all users");
client.SendMessage(newPlayerMessage, SendMode.Reliable);
}
}
}
}
//Return all users already on server to client that just connected
using (DarkRiftWriter playerWriter = DarkRiftWriter.Create())
{
//First write back the number of players
playerWriter.Write(numOfPlayers);
//Then write back their id so they know who they are
playerWriter.Write(e.Client.ID);
//Then send back all player id and names
foreach (Player player in players.Values)
{
playerWriter.Write(player.ID);
playerWriter.Write(player.name);
}
using (Message playerMessage = Message.Create(Tags.UserConnectedTag, playerWriter))
e.Client.SendMessage(playerMessage, SendMode.Reliable);
}
}
private void OnClientMessageReceived(object sender, MessageReceivedEventArgs e)
{
switch (e.Tag)
{
case (ushort)Tags.Tag.SET_NAME:
using (Message message = e.GetMessage())
{
using (DarkRiftReader reader = message.GetReader())
{
string name = reader.ReadString();
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Hey Mr " + name, ConsoleColor.Red);
Console.ForegroundColor = ConsoleColor.White;
PlayerModel newPlayer = new PlayerModel(e.Client, name);
if (pendingPlayer == null)
{
pendingPlayer = newPlayer;
}
else
{
MatchModel match = new MatchModel(pendingPlayer, newPlayer);
matches.Add(match.id, match);
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(match.id);
using (Message msg = Message.Create((ushort)Tags.Tag.GOT_MTACH, writer))
{
pendingPlayer.Client.SendMessage(msg, SendMode.Reliable);
newPlayer.Client.SendMessage(msg, SendMode.Reliable);
}
}
pendingPlayer = null;
}
}
}
break;
case (ushort)Tags.Tag.SLATE_TAKEN:
using (Message message = e.GetMessage())
{
using (DarkRiftReader reader = message.GetReader())
{
ushort matchId = reader.ReadUInt16();
ushort slateIndex = reader.ReadUInt16();
if (matches.ContainsKey(matchId))
{
MatchModel match = matches[matchId];
match.PlayerTakesSlate(slateIndex, e.Client);
}
}
}
break;
}
}
// Update is called once per frame
void Update()
{
Vector3 moveDirection = mainCameraTransform.right * Input.GetAxis("Horizontal") + mainCameraTransform.forward * Input.GetAxis("Vertical");
moveDirection.y = 0f;
moveDirection.Normalize();
PlayerObject po = gameObject.GetComponent <PlayerObject>();
if (Input.GetButtonDown("Jump") && moveDirection != Vector3.zero)
{
float costPerDash = dashFoodCost * (dashTime / Time.deltaTime);
Debug.Log(costPerDash);
if (po.foodLevel >= costPerDash)
{
dashing = true;
StartCoroutine(DashTimer());
}
else
{
// Do some animation to indicate that the player is exhausted
}
}
if (dashing)
{
po.foodLevel -= dashFoodCost;
rb.velocity = moveDirection * dashSpeed;
}
else
{
rb.velocity = moveDirection * moveSpeed;
}
player.SetMovePosition(transform.localPosition);
lastMoveVector = moveDirection;
if (transform.forward.normalized != lastMoveVector.normalized)
{
transform.forward = Vector3.RotateTowards(transform.forward, lastMoveVector, 10 * Time.deltaTime, 0.0f);
Debug.DrawRay(transform.position, lastMoveVector, Color.red);
}
player.SetRotation(transform.rotation.eulerAngles);
//This checks if we have moved far enough from server position to send another update
if (Vector3.Distance(lastPosition, transform.localPosition) > moveDistance)
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
//The parentCarID field is updated from the TrainCarTracker script.
writer.Write(parentCarID);
writer.Write(transform.localPosition.x);
writer.Write(transform.localPosition.y);
writer.Write(transform.localPosition.z);
Vector3 rotation = transform.rotation.eulerAngles;
writer.Write(rotation.x);
writer.Write(rotation.y);
writer.Write(rotation.z);
using (Message message = Message.Create(MOVEMENT_TAG, writer))
client.SendMessage(message, SendMode.Unreliable);
}
lastPosition = transform.localPosition;
}
}
public void WriteByteTest()
{
// WHEN I write a byte to the writer
writer.Write((byte)5);
// AND I convert the writer to a Buffer
IMessageBuffer buffer = writer.ToBuffer();
// THEN the buffer is as expected
AssertExtensions.AreEqualAndNotShorter(new byte[] { 5 }, buffer.Buffer);
Assert.AreEqual(0, buffer.Offset);
Assert.AreEqual(1, buffer.Count);
// AND the writer has advanced its pointers
Assert.AreEqual(1, writer.Position);
Assert.AreEqual(1, writer.Length);
}
void MovementMessageReceived(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == Tags.ClientNameRequestTag)
{
using (DarkRiftReader reader = message.GetReader())
{
ClientConnected(sender, e);
}
}
if (message.Tag == Tags.MovePlayerTag)
{
using (DarkRiftReader reader = message.GetReader())
{
float newX = reader.ReadSingle();
float newY = reader.ReadSingle();
Player player = players[e.Client];
player.X = newX;
player.Y = newY;
AgarFoodManager foodManager = PluginManager.GetPluginByType <AgarFoodManager>();
foreach (FoodItem food in foodManager.foodItems)
{
if (Math.Pow(player.X - food.X, 2) + Math.Pow(player.Y - food.Y, 2) < Math.Pow(player.Radius, 2))
{
player.Radius += food.Radius;
SendRadiusUpdate(player);
foodManager.Eat(food);
}
}
foreach (Player p in players.Values)
{
if (p != player && Math.Pow(player.X - p.X, 2) + Math.Pow(player.Y - p.Y, 2) < Math.Pow(player.Radius, 2))
{
player.Radius += p.Radius;
SendRadiusUpdate(player);
Kill(p);
}
}
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(player.ID);
writer.Write(player.X);
writer.Write(player.Y);
message.Serialize(writer);
}
foreach (IClient c in ClientManager.GetAllClients().Where(x => x != e.Client))
{
c.SendMessage(message, e.SendMode);
}
}
}
}
}
void JoinRoom(MessageReceivedEventArgs e, ushort hostID, bool useRelay, string localIP)
{
LeaveRoom(e.Client);
for (int i = 0; i < rooms.Count; i++)
{
if (rooms[i].Host.ID == hostID)
{
if (rooms[i].Clients.Count <= rooms[i].MaxPlayers)
{
rooms[i].Clients.Add(e.Client);
if (rooms[i].ForceRelay || useRelay)
{
// Tell both the host that this client connected and tell the client we successfully connected to the room
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(e.Client.ID);
using (Message sendConnectedMessage = Message.Create((ushort)OpCodes.ServerJoined, writer))
{
rooms[i].Host.SendMessage(sendConnectedMessage, SendMode.Reliable);
e.Client.SendMessage(sendConnectedMessage, SendMode.Reliable);
}
}
}
else
{
// Tell the client the hosts information so they can attempt a direct connection
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
if (e.Client.RemoteEndPoints.FirstOrDefault().Address.ToString() == rooms[i].Host.RemoteEndPoints.FirstOrDefault().Address.ToString())
{
writer.Write(localIP == rooms[i].ServerLocalIP ? "127.0.0.1" : rooms[i].ServerLocalIP);
}
else
{
writer.Write(rooms[i].Host.RemoteEndPoints.FirstOrDefault().Address.ToString());
}
using (Message sendServerInfo = Message.Create((ushort)OpCodes.ServerConnectionData, writer))
{
e.Client.SendMessage(sendServerInfo, SendMode.Reliable);
}
}
}
}
else
{
// Rooms full, tell the client requesting to join that they have been disconnected.
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
using (Message sendDisconnectedMessage = Message.Create((ushort)OpCodes.ServerLeft, writer))
{
for (int x = 0; x < rooms[i].Clients.Count; x++)
{
e.Client.SendMessage(sendDisconnectedMessage, SendMode.Reliable);
}
}
}
}
return;
}
}
}
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.
}
}
private void MessageReceived(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
using (DarkRiftReader r = message.GetReader())
{
if (message.Tag == UDRMS_Tags.getLobbyMatchs)
{
GetLobbyRequestAndSend(e, r);
}
if (message.Tag == UDRMS_Tags.connectLobbyMatch)
{
ushort matchToJoin = r.ReadUInt16();
bool canJoin = matchs[matchToJoin].AddPlayerToMatch(players[e.Client]);
matchs[matchToJoin].JoinMatch(e.Client, canJoin);
}
if (message.Tag == UDRMS_Tags.createLobbyMatch)
{
foreach (Lobby_Match match in matchs.Values)
{
if (match.matchOwner == players[e.Client])
{
//TODO: With Host is Already created a Match Destroy Current Match
return;
}
}
CreateMatch(players[e.Client], maxPlayersPerMatch);
}
if (message.Tag == UDRMS_Tags.refreshLobbyMatchs)
{
using (DarkRiftWriter w = DarkRiftWriter.Create())
{
ushort totalLobbyPages = GetLobbyPages();
w.Write(totalLobbyPages);
using (Message m = Message.Create(UDRMS_Tags.refreshLobbyMatchs, w))
e.Client.SendMessage(m, SendMode.Reliable);
}
}
if (message.Tag == UDRMS_Tags.getLobbyMatchInfo)
{
Lobby_Player lobby_Player = players[e.Client];
if (lobby_Player.getCurrentMatch() != null)
{
//TODO: connect to match
Lobby_Match.SendToPlayerLobbyMatchInformation(lobby_Player);
}
else
{
//TODO: Send Player to Lobby or Do Nothing or Send Refresh
}
}
if (message.Tag == UDRMS_Tags.LoginInfo)
{
string playerName = r.ReadString();
players[e.Client].playerName = playerName;
//TODO: Can Login
bool canLogin = true;
using (DarkRiftWriter w = DarkRiftWriter.Create())
{
w.Write(canLogin);
using (Message m = Message.Create(UDRMS_Tags.LoginInfo, w))
e.Client.SendMessage(m, SendMode.Reliable);
}
}
}
}
}
public override void ClientConnect(string address)
{
ushort hostID = 0;
if (!Available() || !ushort.TryParse(address, out hostID))
{
Debug.Log("Not connected to relay or address is not a proper ID!");
OnClientDisconnected?.Invoke();
return;
}
if (isClient || isServer)
{
Debug.Log("Cannot connect while hosting/already connected.");
return;
}
// Make sure the client is authenticated before trying to join a room.
int timeOut = 0;
while (true)
{
timeOut++;
drClient.Dispatcher.ExecuteDispatcherTasks();
if (isAuthenticated || timeOut >= 100)
{
break;
}
if (Application.platform != RuntimePlatform.WebGLPlayer)
{
System.Threading.Thread.Sleep(100);
}
}
if (timeOut >= 100 && !isAuthenticated)
{
Debug.Log("Failed to authenticate in time with backend! Make sure your secret key and IP/port are correct.");
OnClientDisconnected?.Invoke();
return;
}
isClient = true;
isConnected = false;
directConnected = false;
// Tell the server we want to join a room
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(hostID);
// If we dont support direct connections, tell it to force use the relay.
writer.Write(directConnectModule == null);
writer.Write(GetLocalIPAddress());
using (Message sendJoinMessage = Message.Create((ushort)OpCodes.JoinServer, writer))
drClient.Client.SendMessage(sendJoinMessage, SendMode.Reliable);
}
if (directConnectModule != null)
{
StartCoroutine(WaitForConnecting(hostID));
}
}
void LaunchGame()
{
if (!gameStarted)
{
//Message to tell all players about train
using (DarkRiftWriter trainWriter = DarkRiftWriter.Create())
{
trainWriter.Write(testTrain.Cars.Count);
for (int i = 0; i < testTrain.Cars.Count; i++)
{
trainWriter.Write(testTrain.Cars[i].ID);
trainWriter.Write(testTrain.Cars[i].CarType);
}
using (Message trainMessage = Message.Create(TRAIN_TAG, trainWriter))
{
foreach (IClient client in ClientManager.GetAllClients())
{
client.SendMessage(trainMessage, SendMode.Reliable);
}
}
}
//Message to tell new player about interactable objects
using (DarkRiftWriter objectWriter = DarkRiftWriter.Create())
{
objectWriter.Write(objects.Count);
foreach (InteractableObject obj in objects.Values)
{
objectWriter.Write(obj.ID);
objectWriter.Write(obj.objectType);
objectWriter.Write(obj.X);
objectWriter.Write(obj.Y);
objectWriter.Write(obj.Z);
objectWriter.Write(obj.angleX);
objectWriter.Write(obj.angleY);
objectWriter.Write(obj.angleZ);
}
using (Message objectMessage = Message.Create(OBJECT_TAG, objectWriter))
{
foreach (IClient client in ClientManager.GetAllClients())
{
client.SendMessage(objectMessage, SendMode.Reliable);
}
}
}
//Mesage to tell client that connected about all players
using (DarkRiftWriter playerWriter = DarkRiftWriter.Create())
{
foreach (Player player in players.Values)
{
playerWriter.Write(player.ID);
playerWriter.Write(player.parentCarID);
playerWriter.Write(player.X);
playerWriter.Write(player.Y);
playerWriter.Write(player.Z);
playerWriter.Write(player.angleX);
playerWriter.Write(player.angleY);
playerWriter.Write(player.angleZ);
}
using (Message playerMessage = Message.Create(SPAWN_TAG, playerWriter))
{
foreach (IClient client in ClientManager.GetAllClients())
{
client.SendMessage(playerMessage, SendMode.Reliable);
}
}
}
}
gameStarted = true;
}
IEnumerator WaitForConnecting(ushort host)
{
float currentTime = 0;
while (currentTime < directConnectTimeout)
{
currentTime += Time.deltaTime;
if (!string.IsNullOrEmpty(directConnectAddress))
{
directConnectModule.JoinServer(directConnectAddress);
currentTime = 0;
break;
}
if (isConnected)
{
if (showDebugLogs)
{
Debug.Log("Stopping direct connect attempt. Server doesnt support direct connect and used relay.");
}
yield break;
}
yield return(new WaitForEndOfFrame());
}
if (currentTime > 0)
{
// Waiting for info timed out, just use relay and connect.
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(host);
writer.Write(true);
writer.Write("0.0.0.0");
using (Message sendJoinMessage = Message.Create((ushort)OpCodes.JoinServer, writer))
drClient.Client.SendMessage(sendJoinMessage, SendMode.Reliable);
}
if (showDebugLogs)
{
Debug.Log("Failed to receive IP from server, falling back to relay.");
}
}
else
{
if (showDebugLogs)
{
Debug.Log($"Received server connection info, attempting direct connection to {directConnectAddress}...");
}
while (currentTime < directConnectTimeout)
{
currentTime += Time.deltaTime;
if (isConnected)
{
if (showDebugLogs)
{
Debug.Log("Direct connect successful!");
}
yield break;
}
yield return(new WaitForEndOfFrame());
}
directConnectModule.ClientDisconnect();
// Force join the server using relay since direct connect failed.
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(host);
writer.Write(true);
writer.Write("0.0.0.0");
using (Message sendJoinMessage = Message.Create((ushort)OpCodes.JoinServer, writer))
drClient.Client.SendMessage(sendJoinMessage, SendMode.Reliable);
}
if (showDebugLogs)
{
Debug.Log("Failed to direct connect, falling back to relay.");
}
}
}
public static void Write(this DarkRiftWriter writer, Vector3 v)
{
writer.Write(v.x);
writer.Write(v.y);
writer.Write(v.z);
}
public override void ServerStart()
{
if (!Available())
{
Debug.Log("Not connected to relay, server failed to start!");
return;
}
if (isClient || isServer)
{
Debug.Log("Cannot connect while hosting/already connected.");
return;
}
isServer = true;
isConnected = false;
currentMemberID = 1;
connectedRelayClients = new BiDictionary <ushort, int>();
connectedDirectClients = new BiDictionary <int, int>();
// Wait to make sure we are authenticated with the server before actually trying to request creating a room.
int timeOut = 0;
while (true)
{
timeOut++;
drClient.Dispatcher.ExecuteDispatcherTasks();
if (isAuthenticated || timeOut >= 100)
{
break;
}
if (Application.platform != RuntimePlatform.WebGLPlayer)
{
System.Threading.Thread.Sleep(100);
}
}
if (timeOut >= 100)
{
Debug.Log("Failed to authenticate in time with backend! Make sure your secret key and IP/port are correct.");
return;
}
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(maxServerPlayers);
writer.Write(serverName);
writer.Write(showOnServerList);
writer.Write(extraServerData);
// If we are forcing relay traffic, or we dont have the direct connect module, tell it to only use relay. If not, tell it we can try direct connections.
writer.Write(forceRelayTraffic ? true : directConnectModule == null ? true : false);
writer.Write(GetLocalIPAddress());
using (Message sendStartMessage = Message.Create((ushort)OpCodes.CreateRoom, writer))
drClient.Client.SendMessage(sendStartMessage, SendMode.Reliable);
}
if (!forceRelayTraffic && directConnectModule != null)
{
directConnectModule.StartServer();
}
// Wait until server is actually ready or 10 seconds have passed and server failed
timeOut = 0;
while (true)
{
timeOut++;
drClient.Dispatcher.ExecuteDispatcherTasks();
if (isConnected || timeOut >= 100)
{
break;
}
if (!useWebsockets)
{
System.Threading.Thread.Sleep(100);
}
}
// Webgl cant actually do a thread.sleep so the timeout is kinda invalid. Oh well :P
if (timeOut >= 100 && !useWebsockets)
{
Debug.LogError("Failed to create the server on the relay. Are you connected? Double check the secret key and IP/port.");
}
}
/// <summary>
/// Logs out the user from the server.
/// </summary>
public static void Logout()
{
//Build the data to send
using(DarkRiftWriter writer = new DarkRiftWriter())
{
writer.Write(0);
//Choose the connection to use
if( connection == null )
{
if( DarkRiftAPI.isConnected )
{
//Send via DarkRiftAPI
DarkRiftAPI.SendMessageToServer(
tag,
logoutSubject,
writer
);
BindIfNotBound();
}
else
{
//Called if you try to login whilst not connected to a server
Debug.LogError("[LoginPlugin] You can't logout if you're not connected to a server! (Do you mean to use DarkRiftAPI?)");
}
}
else
{
if( connection.isConnected )
{
//Send via DarkRiftConnection
connection.SendMessageToServer(
tag,
logoutSubject,
writer
);
BindIfNotBound();
}
else
{
//Called if you try to login whilst not connected to a server
Debug.LogError("[LoginPlugin] You can't logout if you're not connected to a server!");
}
}
}
}
/// <summary>
/// Serializes <see cref="Vector3" /> into <see cref="DarkRiftWriter" />.
/// </summary>
/// <param name="writer">Writer to write into.</param>
/// <param name="vector">Vector to serialize.</param>
public static void SerializeVector3(DarkRiftWriter writer, Vector3 vector)
{
writer.Write(vector.x);
writer.Write(vector.y);
writer.Write(vector.z);
}
private void OnClientMessageReceived(object sender, MessageReceivedEventArgs e)
{
switch (e.Tag)
{
case (ushort)tags.Tag.SET_NAME:
// Registering new player
using (Message message = e.GetMessage())
{
using (DarkRiftReader reader = message.GetReader())
{
string name = reader.ReadString();
Console.WriteLine("Hello " + name, ConsoleColor.Green);
Player newPlayer = new Player(e.Client, name);
if (pendingPlayer == null)
{
// Player is waiting for a match
pendingPlayer = newPlayer;
}
else
{
// start a new match if there's a player waiting
Match match = new Match(pendingPlayer, newPlayer);
matches.Add(match.id, match);
Console.WriteLine("The match has been added and its ID is: " + match.id);
// send a message that match has been found
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(match.id);
Console.WriteLine("The match has been wrote and its ID is: " + match.id);
using (Message connectedMessage = Message.Create((ushort)tags.Tag.MATCH_CONNECTED, writer))
{
//Reliable TCP
//Unreliable UDP
pendingPlayer.Client.SendMessage(connectedMessage, SendMode.Reliable);
newPlayer.Client.SendMessage(connectedMessage, SendMode.Reliable);
Console.WriteLine("The messages have been sent and the match ID is: " + match.id);
}
}
pendingPlayer = null;
}
}
}
break;
case (ushort)tags.Tag.SPACE_TAKEN:
using (Message message = e.GetMessage())
{
using (DarkRiftReader reader = message.GetReader())
{
ushort matchId = reader.ReadUInt16();
ushort spaceTaken = reader.ReadUInt16();
if (matches.ContainsKey(matchId))
{
Match match = matches[matchId];
match.PlayerSpaceClicked(spaceTaken, e.Client);
}
}
}
break;
}
}
/// <summary>
/// Writes an angle in radiant as 2 bytes
/// </summary>
public static void WriteAngle(this DarkRiftWriter writer, float angle)
{
ushort a = (ushort)(angle * 10430);
writer.Write(a);
}
private void DarkRift_OnMessageReceived(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage())
using (DarkRiftReader reader = message.GetReader()) {
if (InGameClientAccountMap.ContainsKey(e.Client))
{
//valid, joined player
if (ServerGameManager.Instance.GameState.currentState == GameStates.GAME_IN_PROGRESS)
{
//game is in progress
if (message.Tag == NetworkTags.Command)
{
ServerEntityManager.Instance.HandleCommand(reader.ReadSerializable <EntityCommand>(), InGameClientAccountMap[e.Client].PlayFabId);
}
else if (message.Tag == NetworkTags.Construction)
{
ServerEntityManager.Instance.SpawnStructure(ServerGameManager.Instance.GameState.GetPlayer(InGameClientAccountMap[e.Client].PlayFabId),
reader.ReadString(),
new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()));
}
else if (message.Tag == NetworkTags.PlayerEvent)
{
ServerEntityManager.Instance.SpawnPlayerEvent(ServerGameManager.Instance.GameState.GetPlayer(InGameClientAccountMap[e.Client].PlayFabId),
reader.ReadString(),
new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()));
}
else if (message.Tag == NetworkTags.ChatMessage)
{
string messageText = reader.ReadString();
using (DarkRiftWriter writer = DarkRiftWriter.Create()) {
writer.Write(InGameClientAccountMap[e.Client].PlayFabId);
writer.Write(messageText);
using (Message response = Message.Create(NetworkTags.ChatMessage, writer)) {
e.Client.SendMessage(response, SendMode.Reliable);
}
}
}
else if (message.Tag == NetworkTags.UnitList)
{
List <PlayerUnit> playerUnits = ServerEntityManager.Instance.GetUsablePlayerUnits(InGameClientAccountMap[e.Client].PlayFabId);
if (playerUnits == null)
{
playerUnits = DatabaseManager.GetPlayerUnits(InGameClientAccountMap[e.Client].PlayFabId);
ServerEntityManager.Instance.SetPlayerUnits(InGameClientAccountMap[e.Client].PlayFabId, playerUnits);
}
using (DarkRiftWriter writer = DarkRiftWriter.Create()) {
foreach (PlayerUnit playerUnit in playerUnits)
{
writer.Write(playerUnit);
}
using (Message response = Message.Create(NetworkTags.UnitList, writer)) {
e.Client.SendMessage(response, SendMode.Reliable);
}
}
}
else if (message.Tag == NetworkTags.SquadSelection)
{
List <SelectedPlayerUnit> selectedUnits = new List <SelectedPlayerUnit>();
while (reader.Position < reader.Length)
{
selectedUnits.Add(reader.ReadSerializable <SelectedPlayerUnit>());
}
ServerEntityManager.Instance.SpawnPlayerSquad(ServerGameManager.Instance.GameState.GetPlayer(InGameClientAccountMap[e.Client].PlayFabId), selectedUnits);
}
}
}
else if (LobbyClientAccountMap.ContainsKey(e.Client))
{
if (message.Tag == NetworkTags.FullUnitList)
{
List <PlayerUnit> playerUnits = DatabaseManager.GetPlayerUnits(LobbyClientAccountMap[e.Client].PlayFabId);
using (DarkRiftWriter writer = DarkRiftWriter.Create()) {
foreach (PlayerUnit playerUnit in playerUnits)
{
writer.Write(playerUnit);
}
using (Message response = Message.Create(NetworkTags.FullUnitList, writer)) {
e.Client.SendMessage(response, SendMode.Reliable);
}
}
}
else if (message.Tag == NetworkTags.CustomizedUnits)
{
List <SelectedPlayerUnit> customizedUnits = new List <SelectedPlayerUnit>();
while (reader.Position < reader.Length)
{
customizedUnits.Add(reader.ReadSerializable <SelectedPlayerUnit>());
}
foreach (SelectedPlayerUnit customizedUnit in customizedUnits)
{
DatabaseManager.SavePlayerUnit(LobbyClientAccountMap[e.Client].PlayFabId, customizedUnit);
}
}
}
if (message.Tag == NetworkTags.Connection)
{
//Matchmaker join request from a client, submit ticket to PlayFab
string matchmakerTicket = reader.ReadString();
tempTicketMap.Add(matchmakerTicket, e.Client);
ServerPlayFabManager.Instance.RedeemMatchmakerTicket(matchmakerTicket);
}
else if (message.Tag == NetworkTags.JoinGame)
{
UserJoinGame(e.Client);
}
}
}
public static void WriteEquipSlot(this DarkRiftWriter writer, EquipSlot slot)
{
writer.Write((uint)slot);
}
