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);
}
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);
}
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 UpdateTrainRerail(Message message, IClient sender)
{
if (worldTrains != null)
{
using (DarkRiftReader reader = message.GetReader())
{
TrainRerail data = reader.ReadSerializable <TrainRerail>();
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == data.Guid);
if (train == null)
{
train = new WorldTrain()
{
Guid = data.Guid,
};
worldTrains.Add(train);
}
train.Bogies[0] = new TrainBogie()
{
TrackName = data.Bogie1TrackName,
PositionAlongTrack = data.Bogie1PositionAlongTrack,
Derailed = false
};
train.Bogies[train.Bogies.Length - 1] = new TrainBogie()
{
TrackName = data.Bogie2TrackName,
PositionAlongTrack = data.Bogie2PositionAlongTrack,
Derailed = false
};
train.Position = data.Position;
train.Forward = data.Forward;
train.Rotation = data.Rotation;
train.CarHealth = data.CarHealth;
train.CargoHealth = data.CargoHealth;
if (train.IsLoco)
{
train.Throttle = 0;
train.Sander = 0;
train.Brake = 0;
train.IndepBrake = 1;
train.Reverser = 0f;
if (train.Shunter != null)
{
train.Shunter.IsEngineOn = false;
train.Shunter.IsMainFuseOn = false;
train.Shunter.IsSideFuse1On = false;
train.Shunter.IsSideFuse2On = false;
}
}
}
}
Logger.Trace("[SERVER] > TRAIN_RERAIL");
ReliableSendToOthers(message, sender);
}
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);
}
}
}
}
}
}
private void UpdateTrainLever(Message message, IClient sender)
{
if (worldTrains != null)
{
using (DarkRiftReader reader = message.GetReader())
{
TrainLever lever = reader.ReadSerializable <TrainLever>();
//Logger.Trace($"Setting serverTrainState lever: [{lever.TrainId}] {lever.Lever}: {lever.Value}");
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == lever.TrainId);
if (train == null)
{
train = new WorldTrain()
{
Guid = lever.TrainId,
IsLoco = true
};
worldTrains.Add(train);
Logger.Trace($"Train not found adding new one");
}
if (train.CarType == TrainCarType.LocoShunter)
{
switch (lever.Lever)
{
case Levers.Brake:
case Levers.IndependentBrake:
case Levers.Reverser:
case Levers.Sander:
case Levers.Throttle:
UpdateMULevers(train, lever);
break;
default:
UpdateLeverTrain(train, lever);
break;
}
}
else
{
UpdateLeverTrain(train, lever);
}
}
}
Logger.Trace("[SERVER] > TRAIN_LEVER");
ReliableSendToOthers(message, sender);
}
private void UpdateMULevers(WorldTrain train, TrainLever lever, string prevGuid = "")
{
if (train == null)
{
return;
}
UpdateLeverTrain(train, lever);
if (train.MultipleUnit.IsFrontMUConnectedTo != "" && train.MultipleUnit.IsFrontMUConnectedTo != prevGuid)
{
UpdateMULevers(worldTrains.FirstOrDefault(t => t.Guid == train.MultipleUnit.IsFrontMUConnectedTo), lever, train.Guid);
}
if (train.MultipleUnit.IsRearMUConnectedTo != "" && train.MultipleUnit.IsFrontMUConnectedTo != prevGuid)
{
UpdateMULevers(worldTrains.FirstOrDefault(t => t.Guid == train.MultipleUnit.IsRearMUConnectedTo), lever, train.Guid);
}
}
private void OnCarRemovalMessage(Message message, IClient sender)
{
using (DarkRiftReader reader = message.GetReader())
{
CarRemoval carRemoval = reader.ReadSerializable <CarRemoval>();
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == carRemoval.Guid);
if (train == null)
{
train = new WorldTrain()
{
Guid = carRemoval.Guid,
};
worldTrains.Add(train);
}
train.IsRemoved = true;
}
Logger.Trace("[SERVER] > TRAIN_REMOVAL");
ReliableSendToOthers(message, sender);
}
private bool CheckTrainsetMismatchesAuthority(ushort id)
{
foreach (TrainCar car in trainCar.trainset.cars)
{
// If train logic car not set
if (car.logicCar == null)
{
continue;
}
// Get the server state
WorldTrain state = SingletonBehaviour <NetworkTrainManager> .Instance.GetServerStateById(car.CarGUID);
if (state.AuthorityPlayerId != id)
{
return(true);
}
}
return(false);
}
private void UpdateTrainSwitch(Message message, IClient sender)
{
using (DarkRiftReader reader = message.GetReader())
{
TrainCarChange carChange = reader.ReadSerializable <TrainCarChange>();
if (carChange.TrainId != "")
{
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == carChange.TrainId);
if (train == null)
{
train = new WorldTrain()
{
Guid = carChange.TrainId
};
worldTrains.Add(train);
}
}
}
Logger.Trace("[SERVER] > TRAIN_SWITCH");
ReliableSendToOthers(message, sender);
}
private void UpdateTrainPosition(Message message, IClient sender)
{
bool isReliable = false;
if (worldTrains != null)
{
using (DarkRiftReader reader = message.GetReader())
{
TrainLocation[] datas = reader.ReadSerializables <TrainLocation>();
foreach (TrainLocation data in datas)
{
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == data.TrainId);
if (data.Timestamp <= train.updatedAt)
{
continue;
}
train.Position = data.Position;
train.Rotation = data.Rotation;
train.Forward = data.Forward;
train.Bogies = data.Bogies;
train.IsStationary = data.IsStationary;
train.updatedAt = data.Timestamp;
isReliable = train.IsStationary;
}
}
}
//Logger.Trace("[SERVER] > TRAIN_LOCATION_UPDATE");
if (!isReliable)
{
UnreliableSendToOthers(message, sender);
}
else
{
ReliableSendToOthers(message, sender);
}
}
private void UpdateTrainDerailed(Message message, IClient sender)
{
if (worldTrains != null)
{
using (DarkRiftReader reader = message.GetReader())
{
TrainDerail data = reader.ReadSerializable <TrainDerail>();
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == data.TrainId);
if (train == null)
{
train = new WorldTrain()
{
Guid = data.TrainId,
};
worldTrains.Add(train);
}
train.Bogies[0] = new TrainBogie()
{
TrackName = data.Bogie1TrackName,
PositionAlongTrack = data.Bogie1PositionAlongTrack,
Derailed = data.IsBogie1Derailed
};
train.Bogies[train.Bogies.Length - 1] = new TrainBogie()
{
TrackName = data.Bogie2TrackName,
PositionAlongTrack = data.Bogie2PositionAlongTrack,
Derailed = data.IsBogie2Derailed
};
train.CarHealth = data.CarHealth;
train.CargoHealth = data.CargoHealth;
}
}
Logger.Trace("[SERVER] > TRAIN_DERAIL");
ReliableSendToOthers(message, sender);
}
private static void Prefix(TrainCar ___train)
{
if (NetworkManager.IsClient() && SingletonBehaviour <NetworkTrainManager> .Exists)
{
NetworkTrainManager net = SingletonBehaviour <NetworkTrainManager> .Instance;
//foreach(Bogie bogie in ___train.Bogies)
//{
// bogie.RefreshBogiePoints();
//}
WorldTrain state = net.GetServerStateById(___train.CarGUID);
if (state != null)
{
state.Shunter.IsEngineOn = false;
state.Shunter.IsMainFuseOn = false;
state.Shunter.IsSideFuse1On = false;
state.Shunter.IsSideFuse2On = false;
state.Sander = 0;
state.Throttle = 0;
state.Reverser = 0;
state.Brake = 0;
state.IndepBrake = 1;
}
}
}
private void UpdateLeverTrain(WorldTrain train, TrainLever lever)
{
switch (lever.Lever)
{
case Levers.Throttle:
train.Throttle = lever.Value;
break;
case Levers.Brake:
train.Brake = lever.Value;
break;
case Levers.IndependentBrake:
Logger.Trace($"Changed independent brake of {train.Guid}");
train.IndepBrake = lever.Value;
break;
case Levers.Sander:
train.Sander = lever.Value;
break;
case Levers.Reverser:
train.Reverser = lever.Value;
break;
}
switch (train.CarType)
{
case TrainCarType.LocoShunter:
if (train.Shunter == null)
{
train.Shunter = new Shunter();
}
Shunter shunter = train.Shunter;
switch (lever.Lever)
{
case Levers.MainFuse:
shunter.IsMainFuseOn = lever.Value == 1;
if (lever.Value == 0)
{
shunter.IsEngineOn = false;
}
break;
case Levers.SideFuse_1:
shunter.IsSideFuse1On = lever.Value == 1;
if (lever.Value == 0)
{
shunter.IsEngineOn = false;
}
break;
case Levers.SideFuse_2:
shunter.IsSideFuse2On = lever.Value == 1;
if (lever.Value == 0)
{
shunter.IsEngineOn = false;
}
break;
case Levers.FusePowerStarter:
if (shunter.IsSideFuse1On && shunter.IsSideFuse2On && shunter.IsMainFuseOn && lever.Value == 1)
{
shunter.IsEngineOn = true;
}
else if (lever.Value == 0)
{
shunter.IsEngineOn = false;
}
break;
}
break;
}
}
private void Update()
{
if (!SingletonBehaviour <NetworkPlayerManager> .Exists || !SingletonBehaviour <NetworkTrainManager> .Exists || SingletonBehaviour <NetworkTrainManager> .Instance.IsDisconnecting)
{
return;
}
if (serverState == null)
{
serverState = SingletonBehaviour <NetworkTrainManager> .Instance.GetServerStateById(trainCar.CarGUID);
return;
}
if (NetworkManager.IsHost())
{
if (trainCar.trainset.firstCar == trainCar || trainCar.trainset.lastCar == trainCar)
{
// This is to simulate impact
GainAndReleaseAuthorityOfTrainsInRangeOfCurrent();
}
//CheckAuthorityChange();
}
//if(trainAudio == null)
//{
// trainAudio = trainCar.GetComponentInChildren<TrainAudio>();
// return;
//}
bool willLocalPlayerGetAuthority = localPlayer.Id == serverState.AuthorityPlayerId;
//if (!(hasLocalPlayerAuthority || (willLocalPlayerGetAuthority && !hasLocalPlayerAuthority)))
//{
// trainAudio.frictionAudio?.Stop();
// foreach (BogieAudioController bogieAudio in bogieAudios)
// {
// bogieAudio.SetLOD(AudioLOD.NONE);
// }
//}
try
{
if (willLocalPlayerGetAuthority && !hasLocalPlayerAuthority)
{
Main.Log($"Car {trainCar.CarGUID}: Changing authority [GAINED]");
if (!trainCar.IsInteriorLoaded)
{
trainCar.LoadInterior();
}
trainCar.keepInteriorLoaded = true;
SetAuthority(true);
}
else if (!willLocalPlayerGetAuthority && hasLocalPlayerAuthority)
{
Main.Log($"Car {trainCar.CarGUID}: Changing authority [RELEASED]");
SetAuthority(false);
newPos = transform.position - WorldMover.currentMove;
newRot = transform.rotation;
trainCar.keepInteriorLoaded = false;
}
}
catch (Exception ex)
{
Main.Log($"NetworkTrainPosSync threw an exception while changing authority: {ex.Message} inner exception: {ex.InnerException}");
}
//if (!hasLocalPlayerAuthority)
//{
// trainCar.rb.MovePosition(newPos);
// trainCar.rb.MoveRotation(newRot);
//}
}
private void UpdateCouplingState(Message message, IClient sender, bool isCoupled)
{
if (worldTrains != null)
{
using (DarkRiftReader reader = message.GetReader())
{
TrainCouplingChange coupledChanged = reader.ReadSerializable <TrainCouplingChange>();
WorldTrain train = worldTrains.FirstOrDefault(t => t.Guid == coupledChanged.TrainIdC1);
if (train == null)
{
train = new WorldTrain()
{
Guid = coupledChanged.TrainIdC1,
};
worldTrains.Add(train);
}
if (isCoupled)
{
if (coupledChanged.IsC1Front)
{
train.FrontCouplerCoupledTo = coupledChanged.TrainIdC2;
}
else
{
train.RearCouplerCoupledTo = coupledChanged.TrainIdC2;
}
}
else
{
if (coupledChanged.IsC1Front)
{
train.FrontCouplerCoupledTo = "";
}
else
{
train.RearCouplerCoupledTo = "";
}
}
train = worldTrains.FirstOrDefault(t => t.Guid == coupledChanged.TrainIdC2);
if (train == null)
{
train = new WorldTrain()
{
Guid = coupledChanged.TrainIdC2,
};
worldTrains.Add(train);
}
if (isCoupled)
{
if (coupledChanged.IsC2Front)
{
train.FrontCouplerCoupledTo = coupledChanged.TrainIdC1;
}
else
{
train.RearCouplerCoupledTo = coupledChanged.TrainIdC1;
}
}
else
{
if (coupledChanged.IsC2Front)
{
train.FrontCouplerCoupledTo = "";
}
else
{
train.RearCouplerCoupledTo = "";
}
}
}
}
Logger.Trace($"[SERVER] > {(isCoupled ? "TRAIN_COUPLE" : "TRAIN_UNCOUPLE")}");
ReliableSendToOthers(message, sender);
}
