private void UpdateCoupleCockState(Message message, IClient sender)
{
if (worldTrains != null)
{
using (DarkRiftReader reader = message.GetReader())
{
TrainCouplerCockChange cockStateChanged = reader.ReadSerializable <TrainCouplerCockChange>();
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == cockStateChanged.TrainIdCoupler);
if (train == null)
{
train = new WorldTrain()
{
Guid = cockStateChanged.TrainIdCoupler,
};
worldTrains.Add(train);
}
if (cockStateChanged.IsCouplerFront)
{
train.IsFrontCouplerCockOpen = cockStateChanged.IsOpen;
}
else
{
train.IsRearCouplerCockOpen = cockStateChanged.IsOpen;
}
}
}
Logger.Trace("[SERVER] > TRAIN_COUPLE_COCK");
ReliableSendToOthers(message, sender);
}
public void ReceiveNetworkJunctionSwitch(Message message)
{
if (buffer.NotSyncedAddToBuffer(IsSynced, ReceiveNetworkJunctionSwitch, message))
{
return;
}
using (DarkRiftReader reader = message.GetReader())
{
Main.Log($"[CLIENT] < SWITCH_CHANGED");
while (reader.Position < reader.Length)
{
Switch switchInfo = reader.ReadSerializable <Switch>();
if (switchInfo.Id >= junctions.Length)
{
Main.Log($"Unidentified junction received. Skipping (ID: {switchInfo.Id})");
return;
}
Junction junction = junctions[switchInfo.Id];
if (switchInfo.SwitchToLeft && junction.selectedBranch == 0 || !switchInfo.SwitchToLeft && junction.selectedBranch == 1)
{
Main.Log($"Junction with ID {switchInfo.Id} already set to correct branch.");
return;
}
IsChangeByNetwork = true;
junction.Switch((Junction.SwitchMode)switchInfo.Mode);
IsChangeByNetwork = false;
}
}
}
private void OnCarDamage(Message message, IClient client)
{
using (DarkRiftReader reader = message.GetReader())
{
CarDamage damage = reader.ReadSerializable <CarDamage>();
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == damage.Guid);
if (train == null)
{
train = new WorldTrain()
{
Guid = damage.Guid,
};
worldTrains.Add(train);
}
switch (damage.DamageType)
{
case DamageType.Car:
train.CarHealth = damage.NewHealth;
train.CarHealthData = damage.Data;
break;
case DamageType.Cargo:
train.CargoHealth = damage.NewHealth;
break;
}
}
Logger.Trace("[SERVER] > TRAIN_DAMAGE");
ReliableSendToOthers(message, client);
}
public void WeaponUpdateMessageRecieved(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == Tags.WeaponFireStartTag || message.Tag == Tags.WeaponFireEndTag || message.Tag == Tags.WeaponActionTag)
{
using (DarkRiftReader reader = message.GetReader())
{
WeaponFireClientDTO data = reader.ReadSerializable <WeaponFireClientDTO>(); //Read the weapon fire dto off the stack
using (DarkRiftWriter fireStartWriter = DarkRiftWriter.Create())
{
WeaponFireServerDTO fireData = new WeaponFireServerDTO();
fireData.playerID = e.Client.ID;
fireData.fireNum = data.fireNum;
fireStartWriter.Write(fireData);
int extrastart = reader.Position;
int extralength = reader.Length - reader.Position;
byte[] rawExtradata = reader.ReadRaw(extralength);
fireStartWriter.WriteRaw(rawExtradata, 0, extralength); //Write the extra data from the message
//TODO: Think about security implications of sending raw data from client to all clients
using (Message fireStartMessage = Message.Create(message.Tag, fireStartWriter)) //Repeat the incoming tagname as all message bodies are the same
{
foreach (IClient client in worldManager.clients[e.Client].World.GetClients().Where(x => x != e.Client))
{
client.SendMessage(fireStartMessage, SendMode.Reliable);
}
}
}
}
}
}
}
private void OnJobDeptPaidMessage(Message message)
{
using (DarkRiftReader reader = message.GetReader())
{
Main.Log($"[CLIENT] < DEBT_JOB_PAID");
while (reader.Position < reader.Length)
{
IsChangeByNetwork = true;
DebtPaid data = reader.ReadSerializable <DebtPaid>();
if (data.isDestroyed)
{
StagedJobDebt debt = SingletonBehaviour <JobDebtController> .Instance.stagedJobsDebts.FirstOrDefault(t => t.ID == data.Id);
if (debt != null)
{
debt.Pay();
}
}
else
{
ExistingJobDebt debt = SingletonBehaviour <JobDebtController> .Instance.existingTrackedJobs.FirstOrDefault(t => t.ID == data.Id);
if (debt != null)
{
debt.Pay();
}
}
IsChangeByNetwork = false;
}
}
}
private void LocationUpdateMessage(Message message, IClient sender)
{
if (players.TryGetValue(sender, out Player player))
{
Location newLocation;
using (DarkRiftReader reader = message.GetReader())
{
newLocation = reader.ReadSerializable <Location>();
player.position = newLocation.Position;
if (newLocation.Rotation.HasValue)
{
player.rotation = newLocation.Rotation.Value;
}
}
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
newLocation.AproxPing = (int)(sender.RoundTripTime.SmoothedRtt / 2 * 1000);
writer.Write(newLocation);
using (Message outMessage = Message.Create((ushort)NetworkTags.PLAYER_LOCATION_UPDATE, writer))
foreach (IClient client in ClientManager.GetAllClients().Where(client => client != sender))
{
client.SendMessage(outMessage, SendMode.Unreliable);
}
}
}
}
private void SetSpawn(Message message)
{
using (DarkRiftReader reader = message.GetReader())
{
playerSpawn = reader.ReadSerializable <SetSpawn>();
}
}
private void MovementMessageReceived(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == Tags.MovePlayerTag)
{
// Read Player Coordinates From The Message
try
{
using (DarkRiftReader reader = message.GetReader())
{
// Get Player ID
Player player;
lock (players)
player = players[e.Client];
// Get Player Positions & Serialize it
Vec3 newPosition = reader.ReadSerializable <Vec3>();
Vec3 newRotation = reader.ReadSerializable <Vec3>();
lock (player)
{
//Update the player
player.Position = newPosition;
player.Rotation = newRotation;
//Serialize the whole player to the message so that we also include the ID
message.Serialize(player);
}
//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 movement message was received: " + ex.Message);
//Console.WriteLine(ex.InnerException);
//Console.WriteLine(ex.Data);
//Console.WriteLine(ex.StackTrace);
}
}
}
}
private void OnCarMUChange(Message message, IClient client)
{
using (DarkRiftReader reader = message.GetReader())
{
CarMUChange data = reader.ReadSerializable <CarMUChange>();
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == data.TrainId1);
if (!(train is null))
{
string value = "";
if (data.IsConnected)
{
value = data.TrainId2;
}
switch (train.CarType)
{
case TrainCarType.LocoShunter:
if (data.Train1IsFront)
{
train.MultipleUnit.IsFrontMUConnectedTo = value;
}
else
{
train.MultipleUnit.IsRearMUConnectedTo = value;
}
break;
}
}
if (data.IsConnected)
{
train = worldTrains.FirstOrDefault(t => t.Guid == data.TrainId2);
if (!(train is null))
{
string value = "";
if (data.IsConnected)
{
value = data.TrainId1;
}
switch (train.CarType)
{
case TrainCarType.LocoShunter:
if (data.Train2IsFront)
{
train.MultipleUnit.IsFrontMUConnectedTo = value;
}
else
{
train.MultipleUnit.IsRearMUConnectedTo = value;
}
break;
}
}
}
}
ReliableSendToOthers(message, client);
}
private void UpdateCoupledHoseState(Message message, IClient sender)
{
if (worldTrains != null)
{
using (DarkRiftReader reader = message.GetReader())
{
TrainCouplerHoseChange hoseStateChanged = reader.ReadSerializable <TrainCouplerHoseChange>();
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == hoseStateChanged.TrainIdC1);
if (train == null)
{
train = new WorldTrain()
{
Guid = hoseStateChanged.TrainIdC1,
};
worldTrains.Add(train);
}
if (hoseStateChanged.IsC1Front)
{
train.FrontCouplerHoseConnectedTo = hoseStateChanged.TrainIdC2;
}
else
{
train.RearCouplerHoseConnectedTo = hoseStateChanged.TrainIdC2;
}
if (hoseStateChanged.IsConnected)
{
train = worldTrains.FirstOrDefault(t => t.Guid == hoseStateChanged.TrainIdC2);
if (train == null)
{
train = new WorldTrain()
{
Guid = hoseStateChanged.TrainIdC2,
};
worldTrains.Add(train);
}
if (hoseStateChanged.IsC2Front)
{
train.FrontCouplerHoseConnectedTo = hoseStateChanged.TrainIdC1;
}
else
{
train.RearCouplerHoseConnectedTo = hoseStateChanged.TrainIdC1;
}
}
}
}
Logger.Trace("[SERVER] > TRAIN_COUPLE_HOSE");
ReliableSendToOthers(message, sender);
}
private void OnCargoChange(Message message, IClient client)
{
using (DarkRiftReader reader = message.GetReader())
{
TrainCargoChanged data = reader.ReadSerializable <TrainCargoChanged>();
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == data.Id);
train.CargoType = data.Type;
train.CargoAmount = data.Amount;
}
Logger.Trace("[SERVER] > TRAIN_CARGO_CHANGE");
ReliableSendToOthers(message, client);
}
private void OnAuthChange(Message message)
{
using (DarkRiftReader reader = message.GetReader())
{
CarsAuthChange authChange = reader.ReadSerializable <CarsAuthChange>();
List <IClient> sentTo = new List <IClient>();
IEnumerable <IClient> players = PluginManager.GetPluginByType <PlayerPlugin.PlayerPlugin>().GetPlayers();
foreach (string guid in authChange.Guids)
{
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == guid);
if (train != null)
{
if (!sentTo.Any(c => c.ID == train.AuthorityPlayerId))
{
IClient ocl = players.FirstOrDefault(c => c.ID == train.AuthorityPlayerId);
if (ocl != null)
{
if (ocl.ID != 0)
{
ocl.SendMessage(message, SendMode.Reliable);
}
sentTo.Add(ocl);
}
}
train.AuthorityPlayerId = authChange.PlayerId;
}
}
Logger.Trace("[SERVER] > TRAIN_AUTH_CHANGE");
IClient cl = players.FirstOrDefault(c => c.ID == authChange.PlayerId);
if (cl.ID != 0)
{
SendDelayedMessage(authChange, NetworkTags.TRAIN_AUTH_CHANGE, cl, (int)sentTo.OrderByDescending(c => c.RoundTripTime.SmoothedRtt).First().RoundTripTime.SmoothedRtt / 2 * 1000);
}
sentTo.Add(cl);
foreach (IClient client in players)
{
if (!sentTo.Any(c => c.ID == client.ID))
{
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(authChange);
using (Message msg = Message.Create((ushort)NetworkTags.TRAIN_AUTH_CHANGE, writer))
{
client.SendMessage(msg, SendMode.Reliable);
}
}
}
}
}
}
public void HandlePlayerInputFromReader(DarkRiftReader reader, ClientDataTags tag)
{
if (tag == ClientDataTags.MoveObject)
{
var data = reader.ReadSerializable <MovementData>();
networkEntity.rotation = data.rotation;
var maxDir = Mathf.Max(data.movementVector.x, data.movementVector.y, data.movementVector.z);
if (maxDir > 1f)
{
data.movementVector /= maxDir;
}
networkEntity.position += data.movementVector * speed * Time.fixedDeltaTime;
}
else if (tag == ClientDataTags.SetObjectPosition)
{
var data = reader.ReadSerializable <MovementData>();
networkEntity.rotation = data.rotation;
var movVector = (data.movementVector - networkEntity.position);
if (movVector.magnitude < snapMaxMagnitude)
{
networkEntity.position = data.movementVector;
}
}
}
private void OnTurntableReleaseAuth(Message message, IClient client)
{
using (DarkRiftReader reader = message.GetReader())
{
ReleaseAuthority info = reader.ReadSerializable <ReleaseAuthority>();
Turntable turntable = turntableStates.FirstOrDefault(t => t.Position == info.Position);
if (turntable != null)
{
turntable.playerAuthId = 0;
}
}
Logger.Trace("[SERVER] > TURNTABLE_AUTH_RELEASE");
ReliableSendToOthers(message, client);
}
private void ServerPlayerInitializer(Message message, IClient sender)
{
using (DarkRiftReader reader = message.GetReader())
{
NPlayer player = reader.ReadSerializable <NPlayer>();
if (playerConnecting != null)
{
buffer.AddToBuffer(InitializePlayer, player, sender);
return;
}
pingSendTimer.Stop();
InitializePlayer(player, sender);
}
}