public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as PlayerConnectionBaseMsgData;
if (msgData == null)
{
return;
}
var playerName = msgData.PlayerName;
switch (msgData.PlayerConnectionMessageType)
{
case PlayerConnectionMessageType.Join:
SystemsContainer.Get <ChatSystem>().Queuer.QueueChannelMessage(SettingsSystem.ServerSettings.ConsoleIdentifier, "", $"{playerName} has joined the server");
break;
case PlayerConnectionMessageType.Leave:
SystemsContainer.Get <WarpSystem>().RemovePlayer(playerName);
SystemsContainer.Get <StatusSystem>().RemovePlayer(playerName);
SystemsContainer.Get <ChatSystem>().Queuer.QueueRemovePlayer(playerName);
SystemsContainer.Get <ChatSystem>().Queuer.QueueChannelMessage(SettingsSystem.ServerSettings.ConsoleIdentifier, "", $"{playerName} has left the server");
break;
}
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as ModMsgData;
if (msgData == null)
{
return;
}
var modName = msgData.ModName;
var modData = msgData.Data;
lock (System.EventLock)
{
if (System.UpdateQueue.ContainsKey(modName))
{
System.UpdateQueue[modName].Enqueue(modData);
}
if (System.FixedUpdateQueue.ContainsKey(modName))
{
System.FixedUpdateQueue[modName].Enqueue(modData);
}
if (System.RegisteredRawMods.ContainsKey(modName))
{
System.RegisteredRawMods[modName](modData);
}
}
}
public virtual void EnqueueMessage(IMessageData msg)
{
if (Enabled)
{
MessageHandler.IncomingMessages.Enqueue(msg);
}
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as VesselPositionMsgData;
if (msgData == null)
{
return;
}
var update = new VesselPositionUpdate(msgData);
var vesselId = update.VesselId;
if (!System.CurrentVesselUpdate.TryGetValue(update.VesselId, out var existingPositionUpdate))
{
System.CurrentVesselUpdate[vesselId] = update;
//If we got a position update, add it to the vessel IDs updated and the current vessel dictionary, after we've added it to the CurrentVesselUpdate dictionary
System.UpdateVesselPositionOnNextFixedUpdate(vesselId);
}
else
{
if (existingPositionUpdate.SentTime < update.SentTime)
{
//If there's an existing update, copy the body and vessel objects so they don't have to be looked up later.
System.SetBodyAndVesselOnNewUpdate(existingPositionUpdate, update);
System.CurrentVesselUpdate[vesselId] = update;
//If we got a position update, add it to the vessel IDs updated and the current vessel dictionary, after we've added it to the CurrentVesselUpdate dictionary
System.UpdateVesselPositionOnNextFixedUpdate(vesselId);
}
}
}
public override void HandleMessage(ClientStructure client, IMessageData messageData)
{
var message = messageData as HandshakeBaseMsgData;
switch (message?.HandshakeMessageType)
{
case HandshakeMessageType.Request:
SetAndSendHandshakeChallangeMessage(client);
break;
case HandshakeMessageType.Response:
var data = (HandshakeResponseMsgData)message;
try
{
HandshakeHandler.HandleHandshakeResponse(client, data);
}
catch (Exception e)
{
LunaLog.Debug($"Error in HANDSHAKE_REQUEST from {data.PlayerName}: {e}");
HandshakeSystemSender.SendHandshakeReply(client, HandshakeReply.MalformedHandshake, "Malformed handshake");
}
break;
default:
throw new NotImplementedException("Warp Type not implemented");
}
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as VesselBaseMsgData;
if (msgData == null)
{
return;
}
switch (msgData.VesselMessageType)
{
case VesselMessageType.ListReply:
HandleVesselList((VesselListReplyMsgData)messageData);
break;
case VesselMessageType.VesselsReply:
HandleVesselResponse((VesselsReplyMsgData)messageData);
break;
case VesselMessageType.Proto:
HandleVesselProto((VesselProtoMsgData)messageData);
break;
default:
LunaLog.LogError($"[LMP]: Cannot handle messages of type: {msgData.VesselMessageType} in VesselProtoMessageHandler");
break;
}
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as PlayerConnectionBaseMsgData;
if (msgData == null)
{
return;
}
var playerName = msgData.PlayerName;
switch (msgData.PlayerConnectionMessageType)
{
case PlayerConnectionMessageType.JOIN:
ChatSystem.Singleton.Queuer.QueueChannelMessage(SettingsSystem.ServerSettings.ConsoleIdentifier, "", playerName + " has joined the server");
break;
case PlayerConnectionMessageType.LEAVE:
WarpSystem.Singleton.RemovePlayer(playerName);
StatusSystem.Singleton.RemovePlayer(playerName);
ChatSystem.Singleton.Queuer.QueueRemovePlayer(playerName);
ChatSystem.Singleton.Queuer.QueueChannelMessage(SettingsSystem.ServerSettings.ConsoleIdentifier, "", playerName + " has left the server");
break;
}
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as AdminBaseMsgData;
if (msgData == null) return;
switch (msgData.AdminMessageType)
{
case AdminMessageType.LIST_REPLY:
{
var data = (AdminListReplyMsgData)messageData;
foreach (var adminName in data.Admins)
System.RegisterServerAdmin(adminName);
MainSystem.Singleton.NetworkState = ClientState.ADMINS_SYNCED;
}
break;
case AdminMessageType.ADD:
{
var data = (AdminAddMsgData)messageData;
System.RegisterServerAdmin(data.PlayerName);
}
break;
case AdminMessageType.REMOVE:
{
var data = (AdminRemoveMsgData)messageData;
System.UnregisterServerAdmin(data.PlayerName);
}
break;
}
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as ScenarioBaseMsgData;
if (msgData?.ScenarioMessageType == ScenarioMessageType.Data)
{
var data = ((ScenarioDataMsgData)messageData).ScenarioNameData;
foreach (var scenario in data)
{
var scenarioNode = ConfigNodeSerializer.Deserialize(scenario.Value);
if (scenarioNode != null)
{
var entry = new ScenarioEntry
{
ScenarioName = scenario.Key,
ScenarioNode = scenarioNode
};
System.ScenarioQueue.Enqueue(entry);
}
else
{
LunaLog.LogError($"[LMP]: Scenario data has been lost for {scenario.Key}");
ScreenMessages.PostScreenMessage($"Scenario data has been lost for {scenario.Key}", 5f, ScreenMessageStyle.UPPER_CENTER);
}
}
MainSystem.NetworkState = ClientState.ScneariosSynced;
}
}
public override void HandleMessage(ClientStructure client, IMessageData messageData)
{
var data = (GroupBaseMsgData)messageData;
switch (data.GroupMessageType)
{
case GroupMessageType.ListRequest:
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <GroupListResponseMsgData>();
msgData.Groups = GroupSystem.Groups.Values.ToArray();
msgData.GroupsCount = msgData.Groups.Length;
MessageQueuer.SendToClient <GroupSrvMsg>(client, msgData);
break;
case GroupMessageType.CreateGroup:
GroupSystem.CreateGroup(client.PlayerName, ((GroupCreateMsgData)data).GroupName);
break;
case GroupMessageType.RemoveGroup:
GroupSystem.RemoveGroup(client.PlayerName, ((GroupRemoveMsgData)data).GroupName);
break;
case GroupMessageType.GroupUpdate:
GroupSystem.UpdateGroup(client.PlayerName, ((GroupUpdateMsgData)data).Group);
break;
}
}
public override void HandleMessage(ClientStructure client, IMessageData messageData)
{
var message = messageData as VesselBaseMsgData;
switch (message?.VesselMessageType)
{
case VesselMessageType.LIST_REQUEST:
HandleVesselListRequest(client);
break;
case VesselMessageType.VESSELS_REQUEST:
HandleVesselsRequest(client, messageData);
break;
case VesselMessageType.PROTO:
HandleVesselProto(client, message);
break;
case VesselMessageType.REMOVE:
HandleVesselRemove(client, message);
break;
case VesselMessageType.CHANGE:
MessageQueuer.RelayMessage <VesselSrvMsg>(client, message);
break;
case VesselMessageType.UPDATE:
VesselRelaySystem.HandleVesselMessage(client, message);
break;
default:
throw new NotImplementedException("Warp Type not implemented");
}
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as VesselPositionMsgData;
if (msgData == null)
{
return;
}
var update = new VesselPositionAltUpdate(msgData);
var vesselId = update.VesselId;
if (!VesselPositionAltSystem.CurrentVesselUpdate.TryGetValue(update.VesselId, out var existingPositionUpdate))
{
VesselPositionAltSystem.CurrentVesselUpdate.TryAdd(vesselId, update);
}
else
{
if (existingPositionUpdate.SentTime < update.SentTime)
{
update.Vessel = VesselPositionAltSystem.CurrentVesselUpdate[vesselId].Vessel;
update.Body = VesselPositionAltSystem.CurrentVesselUpdate[vesselId].Body;
VesselPositionAltSystem.CurrentVesselUpdate[vesselId] = update;
}
}
}
/// <summary>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <returns></returns>
public T CreateNew <T>(IMessageData data) where T : IMessageBase, new()
{
var msg = new T();
msg.SetData(data);
return(msg);
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as VesselDockMsgData;
if (msgData == null)
{
return;
}
LunaLog.Log("[LMP]: Docking message received!");
if (FlightGlobals.ActiveVessel?.id == msgData.WeakVesselId)
{
LunaLog.Log("[LMP]: Docking NOT detected. We DON'T OWN the dominant vessel");
SystemsContainer.Get <VesselRemoveSystem>().AddToKillList(FlightGlobals.ActiveVessel, true);
SystemsContainer.Get <VesselSwitcherSystem>().SwitchToVessel(msgData.DominantVesselId);
}
if (FlightGlobals.ActiveVessel?.id == msgData.DominantVesselId && !VesselCommon.IsSpectating)
{
var newProto = VesselSerializer.DeserializeVessel(msgData.FinalVesselData);
if (VesselCommon.ProtoVesselHasChanges(FlightGlobals.ActiveVessel.protoVessel, newProto))
{
LunaLog.Log("[LMP]: Docking NOT detected. We OWN the dominant vessel");
//We own the dominant vessel and dind't detected the docking event so we need to reload our OWN vessel
//so if we send our own protovessel later, we send the updated definition
SystemsContainer.Get <VesselProtoSystem>().VesselLoader.ReloadVessel(newProto);
}
}
//Some other 2 players docked so just remove the weak vessel.
SystemsContainer.Get <VesselRemoveSystem>().AddToKillList(FlightGlobals.FindVessel(msgData.WeakVesselId), true);
SystemsContainer.Get <VesselProtoSystem>().HandleVesselProtoData(msgData.FinalVesselData, msgData.DominantVesselId);
}
private static void HandleVesselsRequest(ClientStructure client, IMessageData messageData)
{
var sendVesselCount = 0;
var cachedVesselCount = 0;
var clientRequested = (messageData as VesselsRequestMsgData)?.RequestList ?? new string[0];
var vesselList = new List <KeyValuePair <string, byte[]> >();
foreach (var file in FileHandler.GetFilesInPath(Path.Combine(ServerContext.UniverseDirectory, "Vessels")))
{
var vesselId = Path.GetFileNameWithoutExtension(file);
var vesselData = FileHandler.ReadFile(file);
var vesselObject = Common.CalculateSha256Hash(vesselData);
if (clientRequested.Contains(vesselObject))
{
sendVesselCount++;
vesselList.Add(new KeyValuePair <string, byte[]>(vesselId, vesselData));
}
else
{
cachedVesselCount++;
}
}
MessageQueuer.SendToClient <VesselSrvMsg>(client, new VesselsReplyMsgData {
VesselsData = vesselList.ToArray()
});
LunaLog.Debug($"Sending {client.PlayerName} {sendVesselCount} vessels, cached: {cachedVesselCount}...");
}
public void CreatePacket(BinaryWriter writer, IMessageData message)
{
MessageDataProfile m = (MessageDataProfile)message;
writer.Write(m.Nick);
writer.Write(m.Honor);
}
public override void HandleMessage(ClientStructure client, IMessageData messageData)
{
var message = messageData as KerbalBaseMsgData;
switch (message?.KerbalMessageType)
{
case KerbalMessageType.Request:
var kerbalFiles = FileHandler.GetFilesInPath(Path.Combine(ServerContext.UniverseDirectory, "Kerbals"));
var kerbalsData = kerbalFiles.Select(k => new KeyValuePair<string, byte[]>(Path.GetFileNameWithoutExtension(k),
FileHandler.ReadFile(k)));
LunaLog.Debug($"Sending {client.PlayerName} {kerbalFiles.Length} kerbals...");
var newMessageData = new KerbalReplyMsgData
{
KerbalsData = kerbalsData.ToArray()
};
MessageQueuer.SendToClient<KerbalSrvMsg>(client, newMessageData);
break;
case KerbalMessageType.Proto:
var data = (KerbalProtoMsgData)message;
LunaLog.Debug($"Saving kerbal {data.KerbalName} from {client.PlayerName}");
var path = Path.Combine(ServerContext.UniverseDirectory, "Kerbals", $"{data.KerbalName}.txt");
FileHandler.WriteToFile(path, data.KerbalData);
MessageQueuer.RelayMessage<KerbalSrvMsg>(client, data);
break;
default:
throw new NotImplementedException("Kerbal type not implemented");
}
}
/// <summary>
/// Method to retrieve a new message
/// </summary>
/// <typeparam name="T">Message type</typeparam>
/// <param name="data">Message data implementation</param>
/// <returns>New message with the specified data</returns>
public T CreateNew <T>(IMessageData data) where T : class, IMessageBase
{
var msg = MessageStore.GetMessage <T>();
msg.SetData(data);
return(msg);
}
public override void HandleMessage(ClientStructure client, IMessageData message)
{
var data = (LockBaseMsgData)message;
switch (data.LockMessageType)
{
case LockMessageType.ListRequest:
LockSystemSender.SendAllLocks(client);
break;
case LockMessageType.Acquire:
var acquireData = (LockAcquireMsgData)message;
if (acquireData.PlayerName == client.PlayerName)
{
LockSystemSender.SendLockAquireMessage(acquireData.LockName, acquireData.PlayerName,
acquireData.Force);
}
break;
case LockMessageType.Release:
var releaseData = (LockReleaseMsgData)message;
if (releaseData.PlayerName == client.PlayerName)
{
LockSystemSender.SendLockReleaseMessage(releaseData.LockName, releaseData.PlayerName);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public UnpackerState CreateMessageData(ref IMessageData message, Packet packet)
{
message = null;
if (!packet.IsReady)
{
return(UnpackerState.NotReady);
}
if (packet.Size < sizeof(MessageID))
{
return(UnpackerState.SizeOut);
}
using (MemoryStream stream = new MemoryStream(packet.GetData()))
{
if (!stream.CanRead)
{
throw new SystemException("haha");
}
using (BinaryReader reader = new BinaryReader(stream))
{
MessageID type = reader.ReadByte();
IUnpackerMessage unpacker = _register.Find(type);
if (unpacker == null)
{
return(UnpackerState.NotFoundType);
}
return(unpacker.CreateMessageData(ref message, reader, packet.Size));
}
}
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as KerbalBaseMsgData;
if (msgData == null)
{
return;
}
switch (msgData.KerbalMessageType)
{
case KerbalMessageType.Reply:
HandleKerbalReply(msgData as KerbalReplyMsgData);
break;
case KerbalMessageType.Proto:
//TODO: If a player connects and sends this type of message while still starting the game, the game crashes.
//There should be a buffer for this messages so they are processed once the system is enabled
HandleKerbalProto(msgData as KerbalProtoMsgData);
break;
default:
LunaLog.LogError("[LMP]: Invalid Kerbal message type");
break;
}
}
public override void HandleMessage(ClientStructure client, IMessageData messageData)
{
var baseMsg = (FacilityBaseMsgData)messageData;
switch (baseMsg.FacilityMessageType)
{
case FacilityMessageType.Upgrade:
var upgradeMsg = (FacilityUpgradeMsgData)messageData;
LunaLog.Normal($"{client.PlayerName} UPGRADED facility {upgradeMsg.ObjectId} to level: {upgradeMsg.Level}");
break;
case FacilityMessageType.Repair:
LunaLog.Normal($"{client.PlayerName} REPAIRED facility {baseMsg.ObjectId}");
break;
case FacilityMessageType.Collapse:
LunaLog.Normal($"{client.PlayerName} DESTROYED facility {baseMsg.ObjectId}");
break;
default:
throw new ArgumentOutOfRangeException();
}
//We don't do anything on the server side with this messages so just relay them.
MessageQueuer.RelayMessage <FacilitySrvMsg>(client, messageData);
}
protected void SendToNetwork(IMessageData data, IMessageAddress address = null)
{
IMessage m = new MessageRealization(data, address);
ICommand c = new CommandSendMessageNetwork(m);
_scenario.Set(c);
}
private static T GenerateMessage <T>(IMessageData data) where T : IServerMessageBase, new()
{
var newMessage = ServerContext.ServerMessageFactory.CreateNew <T>();
newMessage.SetData(data);
return(newMessage);
}
/// <summary>
/// Sends a message to the given client
/// </summary>
public static void SendToClient <T>(ClientStructure client, IMessageData data) where T : class, IServerMessageBase
{
if (data == null)
{
return;
}
client?.SendMessageQueue.Enqueue(GenerateMessage <T>(data));
}
/// <summary>
/// Sends a message to all the clients except the one given as parameter that are in the same subspace
/// </summary>
public static void RelayMessageToSubspace <T>(ClientStructure exceptClient, IMessageData data) where T : class, IServerMessageBase
{
if (data == null)
{
return;
}
RelayMessageToSubspace <T>(exceptClient, data, exceptClient.Subspace);
}
/// <summary>
/// Sends a message to all the clients except the one given as parameter that are in the subspace given as parameter
/// </summary>
public static void RelayMessageToSubspace <T>(ClientStructure exceptClient, IMessageData data, int subspace) where T : IServerMessageBase, new()
{
var newMessage = GenerateMessage <T>(data);
foreach (var otherClient in ServerContext.Clients.Values.Where(c => !Equals(c, exceptClient) && c.Subspace == subspace))
{
SendToClient(otherClient, newMessage);
}
}
public void CreatePacket(ref Packet packet, IMessageData message)
{
packet = null;
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, message);
packet = new Packet(stream.ToArray());
}
}
/// <summary>
/// Sends a message to all the clients in the given subspace
/// </summary>
public static void SendMessageToSubspace <T>(IMessageData data, int subspace) where T : IServerMessageBase, new()
{
var newMessage = GenerateMessage <T>(data);
foreach (var otherClient in ServerContext.Clients.Values.Where(c => c.Subspace == subspace))
{
SendToClient(otherClient, newMessage);
}
}
public void HandleMessage(IMessageData messageData)
{
var msgData = messageData as FlagBaseMsgData;
if (msgData == null)
{
return;
}
switch (msgData.FlagMessageType)
{
case FlagMessageType.LIST:
{
var data = (FlagListMsgData)messageData;
var serverFlagFiles = data.FlagFileNames;
var serverFlagOwners = data.FlagOwners;
var serverFlagShaSums = data.FlagShaSums;
for (var i = 0; i < serverFlagFiles.Length; i++)
{
var fi = new FlagInfo
{
Owner = serverFlagOwners[i],
ShaSum = serverFlagShaSums[i]
};
System.ServerFlags[Path.GetFileNameWithoutExtension(serverFlagFiles[i])] = fi;
}
System.SyncComplete = true;
//Check if we need to upload the flag
System.FlagChangeEvent = true;
}
break;
case FlagMessageType.FLAG_DATA:
{
var data = (FlagDataMsgData)messageData;
var frm = new FlagRespondMessage
{
FlagInfo = { Owner = data.OwnerPlayerName },
FlagName = data.FlagName,
FlagData = data.FlagData
};
frm.FlagInfo.ShaSum = Common.CalculateSha256Hash(frm.FlagData);
System.NewFlags.Enqueue(frm);
}
break;
case FlagMessageType.DELETE_FILE:
{
var data = (FlagDeleteMsgData)messageData;
var flagName = data.FlagName;
var flagFile = CommonUtil.CombinePaths(System.FlagPath, flagName);
DeleteFlag(flagFile);
}
break;
}
}
