public void ProcessPacket(DysonSphereRemoveFramePacket packet, NebulaConnection conn)
{
Log.Info($"Processing DysonSphere Remove Frame notification for system {GameMain.data.galaxy.stars[packet.StarIndex].name} (Index: {GameMain.data.galaxy.stars[packet.StarIndex].index})");
DysonSphere_Manager.IncomingDysonSpherePacket = true;
DysonSphereLayer dsl = GameMain.data.dysonSpheres[packet.StarIndex]?.GetLayer(packet.LayerId);
if (DysonSphere_Manager.CanRemoveFrame(packet.FrameId, dsl))
{
dsl.RemoveDysonFrame(packet.FrameId);
}
DysonSphere_Manager.IncomingDysonSpherePacket = false;
}
public override void ProcessPacket(ILSEnergyConsumeNotification packet, NebulaConnection conn)
{
if (GameMain.data.galacticTransport.stationPool.Length > packet.stationGId && GameMain.data.galacticTransport.stationPool[packet.stationGId] != null)
{
StationComponent stationComponent = GameMain.data.galacticTransport.stationPool[packet.stationGId];
stationComponent.energy -= packet.cost;
if (stationComponent.energy < 0)
{
stationComponent.energy = 0;
}
}
}
public override void ProcessPacket(DysonSphereStatusPacket packet, NebulaConnection conn)
{
DysonSphere dysonSphere = GameMain.data.dysonSpheres[packet.StarIndex];
if (IsHost || dysonSphere == null)
{
return;
}
dysonSphere.grossRadius = packet.GrossRadius;
dysonSphere.energyReqCurrentTick = packet.EnergyReqCurrentTick;
dysonSphere.energyGenCurrentTick = packet.EnergyGenCurrentTick;
}
private void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo)
{
IsConnected = false;
serverConnection = null;
InGamePopup.ShowWarning(
"Connection Lost",
$"You have been disconnect of the server.\nReason{disconnectInfo.Reason}",
"Quit", "Reconnect",
() => { LocalPlayer.LeaveGame(); },
() => { Reconnect(); });
}
public void ProcessPacket(GameHistoryRemoveTechPacket packet, NebulaConnection conn)
{
Player player = playerManager.GetPlayer(conn);
if (player != null)
{
GameDataHistoryManager.IsIncommingRequest = true;
GameMain.history.RemoveTechInQueue(packet.Index);
GameDataHistoryManager.IsIncommingRequest = false;
playerManager.SendPacketToOtherPlayers(packet, player);
}
}
public void ProcessPacket(DysonSphereRemoveShellPacket packet, NebulaConnection conn)
{
Log.Info($"Processing DysonSphere remove shell notification for system {GameMain.data.galaxy.stars[packet.StarIndex].name} (Index: {GameMain.data.galaxy.stars[packet.StarIndex].index})");
using (DysonSphere_Manager.IncomingDysonSpherePacket.On())
{
DysonSphereLayer dsl = GameMain.data.dysonSpheres[packet.StarIndex]?.GetLayer(packet.LayerId);
if (DysonSphere_Manager.CanRemoveShell(packet.ShellId, dsl))
{
dsl.RemoveDysonShell(packet.ShellId);
}
}
}
public override void ProcessPacket(ConnectToSpraycoaterPacket packet, NebulaConnection conn)
{
using (Multiplayer.Session.Factories.IsIncomingRequest.On())
{
CargoTraffic cargoTraffic = GameMain.galaxy.PlanetById(packet.PlanetId)?.factory?.cargoTraffic;
if (cargoTraffic == null)
{
return;
}
cargoTraffic.ConnectToSpraycoater(packet.SpraycoaterId, packet.CargoBeltId, packet.IncBeltId);
}
}
public void ProcessPacket(PlanetBroadcastPacket packet, NebulaConnection conn)
{
Player player = playerManager.GetPlayer(conn);
if (player != null)
{
//Forward packet to other users
playerManager.SendRawPacketToPlanet(packet.PacketObject, packet.PlanetId, conn);
//Forward packet to the host
MultiplayerHostSession.Instance.PacketProcessor.EnqueuePacketForProcessing(packet.PacketObject, conn);
}
}
public void ProcessPacket(PlayerAnimationUpdate packet, NebulaConnection conn)
{
Player player = playerManager.GetPlayer(conn);
if (player != null)
{
packet.PlayerId = player.Id;
playerManager.SendPacketToOtherPlayers(packet, player, DeliveryMethod.Unreliable);
SimulatedWorld.UpdateRemotePlayerAnimation(packet);
}
}
public void ProcessPacket(DysonSphereAddLayerPacket packet, NebulaConnection conn)
{
Log.Info($"Processing DysonSphere Add Layer notification for system {GameMain.data.galaxy.stars[packet.StarIndex].name} (Index: {GameMain.data.galaxy.stars[packet.StarIndex].index})");
Player player = playerManager.GetPlayer(conn);
if (player != null)
{
playerManager.SendPacketToOtherPlayers(packet, player);
using (DysonSphere_Manager.IncomingDysonSpherePacket.On())
GameMain.data.dysonSpheres[packet.StarIndex]?.AddLayer(packet.OrbitRadius, DataStructureExtensions.ToQuaternion(packet.OrbitRotation), packet.OrbitAngularSpeed);
}
}
private void ClientSocket_OnClose(object sender, CloseEventArgs e)
{
IsConnected = false;
serverConnection = null;
UnityDispatchQueue.RunOnMainThread(() =>
{
// If the client is Quitting by himself, we don't have to inform him of his disconnection.
if (e.Code == (ushort)DisconnectionReason.ClientRequestedDisconnect)
{
return;
}
if (e.Code == (ushort)DisconnectionReason.ModVersionMismatch)
{
InGamePopup.ShowWarning(
"Mod Version Mismatch",
$"Your Nebula Multiplayer Mod is not the same as the Host version.\nMake sure to use the same version.",
"OK",
OnDisconnectPopupCloseBeforeGameLoad);
return;
}
if (e.Code == (ushort)DisconnectionReason.GameVersionMismatch)
{
InGamePopup.ShowWarning(
"Game Version Mismatch",
$"Your version of the game is not the same as the one used by the Host.\nMake sure to use the same version.",
"OK",
OnDisconnectPopupCloseBeforeGameLoad);
return;
}
if (SimulatedWorld.IsGameLoaded)
{
InGamePopup.ShowWarning(
"Connection Lost",
$"You have been disconnect of the server.\n{e.Reason}",
"Quit", "Reconnect",
() => { LocalPlayer.LeaveGame(); },
() => { Reconnect(); });
}
else
{
InGamePopup.ShowWarning(
"Server Unavailable",
$"Could not reach the server, please try again later.",
"OK",
OnDisconnectPopupCloseBeforeGameLoad);
}
});
}
public void ProcessPacket(SyncComplete packet, NebulaConnection conn)
{
Player player = playerManager.GetSyncingPlayer(conn);
if (player == null)
{
Log.Warn("Received a SyncComplete packet, but no player is joining.");
return;
}
// Should these be locked together?
int syncingCount;
using (playerManager.GetSyncingPlayers(out var syncingPlayers))
{
bool removed = syncingPlayers.Remove(player.Connection);
syncingCount = syncingPlayers.Count;
}
using (playerManager.GetConnectedPlayers(out var connectedPlayers))
{
connectedPlayers.Add(player.Connection, player);
}
// Load overriden Planet and Star names
foreach (StarData s in GameMain.galaxy.stars)
{
if (!string.IsNullOrEmpty(s.overrideName))
{
player.SendPacket(new NameInputPacket(s.overrideName, s.id, LocalPlayer.PlayerId));
}
foreach (PlanetData p in s.planets)
{
if (!string.IsNullOrEmpty(p.overrideName))
{
player.SendPacket(new NameInputPacket(p.overrideName, p.id, LocalPlayer.PlayerId));
}
}
}
// Since the player is now connected, we can safely spawn his player model
SimulatedWorld.SpawnRemotePlayerModel(player.Data);
if (syncingCount == 0)
{
var inGamePlayersDatas = playerManager.GetAllPlayerDataIncludingHost();
playerManager.SendPacketToAllPlayers(new SyncComplete(inGamePlayersDatas));
SimulatedWorld.OnAllPlayersSyncCompleted();
}
}
public override void ProcessPacket(DysonSpherePaintCellsPacket packet, NebulaConnection conn)
{
DysonSphere sphere = GameMain.data.dysonSpheres[packet.StarIndex];
if (sphere == null)
{
return;
}
using (Multiplayer.Session.DysonSpheres.IsIncomingRequest.On())
{
DysonSphereLayer layer = sphere.GetLayer(packet.LayerId);
if (layer == null)
{
Multiplayer.Session.DysonSpheres.HandleDesync(packet.StarIndex, conn);
return;
}
// UIDEPaintingbox.OpenGrid()
Color32[] cellColors;
if (layer.cellColors != null)
{
Assert.True(layer.cellColors.Length == packet.CellCount);
cellColors = layer.cellColors;
}
else
{
cellColors = new Color32[packet.CellCount];
}
// UIDysonPaintingGrid.PaintCells()
Color32 paint = packet.Paint.ToColor32();
for (int i = 0; i < packet.CursorCells.Length; i++)
{
int cid = packet.CursorCells[i];
if (cid >= 0)
{
Color32 color = cellColors[cid];
color.a -= (color.a <= 127) ? (byte)0 : (byte)127;
color.a *= 2;
Color32 color2 = Color32.Lerp(color, paint, packet.Strength);
color2.a /= 2;
color2.a += ((paint.a > 0) ? (packet.SuperBrightMode ? (byte)127 : (byte)0) : (byte)0);
cellColors[cid] = color2;
}
}
layer.SetPaintingData(cellColors);
}
if (IsHost)
{
Multiplayer.Session.DysonSpheres.SendPacketToDysonSphereExcept(packet, packet.StarIndex, conn);
}
}
public void ProcessPacket(StatisticUpdateDataPacket packet, NebulaConnection conn)
{
StatisticalSnapShot snapshot;
StatisticsManager.IsIncommingRequest = true;
using (BinaryUtils.Reader reader = new BinaryUtils.Reader(packet.StatisticsBinaryData))
{
ref FactoryProductionStat[] productionStats = ref GameMain.statistics.production.factoryStatPool;
int numOfSnapshots = reader.BinaryReader.ReadInt32();
for (int i = 0; i < numOfSnapshots; i++)
{
//Clear all current statistical data
for (int a = 0; a < GameMain.statistics.production.factoryStatPool.Length; a++)
{
GameMain.statistics.production.factoryStatPool[a]?.ClearRegisters();
}
//Load new snapshot
snapshot = new StatisticalSnapShot(reader.BinaryReader);
for (int factoryId = 0; factoryId < snapshot.ProductionChangesPerFactory.Length; factoryId++)
{
if (productionStats[factoryId] == null)
{
productionStats[factoryId] = new FactoryProductionStat();
productionStats[factoryId].Init();
}
for (int changeId = 0; changeId < snapshot.ProductionChangesPerFactory[factoryId].Count; changeId++)
{
if (snapshot.ProductionChangesPerFactory[factoryId][changeId].IsProduction)
{
productionStats[factoryId].productRegister[snapshot.ProductionChangesPerFactory[factoryId][changeId].ProductId] += snapshot.ProductionChangesPerFactory[factoryId][changeId].Amount;
}
else
{
productionStats[factoryId].consumeRegister[snapshot.ProductionChangesPerFactory[factoryId][changeId].ProductId] += snapshot.ProductionChangesPerFactory[factoryId][changeId].Amount;
}
}
//Import power system statistics
productionStats[factoryId].powerGenRegister = snapshot.PowerGenerationRegister[factoryId];
productionStats[factoryId].powerConRegister = snapshot.PowerConsumptionRegister[factoryId];
productionStats[factoryId].powerChaRegister = snapshot.PowerChargingRegister[factoryId];
productionStats[factoryId].powerDisRegister = snapshot.PowerDischargingRegister[factoryId];
//Import fake energy stored values
StatisticsManager.PowerEnergyStoredData = snapshot.EnergyStored;
//Import Research statistics
productionStats[factoryId].hashRegister = snapshot.HashRegister[factoryId];
}
GameMain.statistics.production.GameTick(snapshot.CapturedGameTick);
}
}
public void RegisterPlayer(NebulaConnection nebulaConnection, ushort playerId)
{
using (instance.GetRequestors(out var requestors))
{
requestors.Add(playerId, nebulaConnection);
}
if (!IsStatisticsNeeded)
{
ClearCapturedData();
IsStatisticsNeeded = true;
}
}
public void ProcessPacket(DysonSphereAddShellPacket packet, NebulaConnection conn)
{
Player player = playerManager.GetPlayer(conn);
if (player != null)
{
playerManager.SendPacketToOtherPlayers(packet, player);
using (DysonSphere_Manager.IncomingDysonSpherePacket.On())
{
GameMain.data.dysonSpheres[packet.StarIndex]?.GetLayer(packet.LayerId)?.NewDysonShell(packet.ProtoId, new List <int>(packet.NodeIds));
}
}
}
public Player PlayerConnected(NebulaConnection conn)
{
// TODO: Load old player state if we have one. We generate a random one for now.
ushort playerId = GetNextAvailablePlayerId();
Float3 randomColor = new Float3(Random.value, Random.value, Random.value);
PlayerData playerData = new PlayerData(playerId, randomColor);
Player newPlayer = new Player(conn, playerData);
pendingPlayers.Add(conn, newPlayer);
return(newPlayer);
}
public void ProcessPacket(NewSetInserterPickTargetPacket packet, NebulaConnection conn)
{
PlanetFactory factory = GameMain.data.factories[packet.FactoryIndex];
if (factory != null)
{
FactoryManager.TargetPlanet = factory.planetId;
factory.WriteObjectConn(packet.ObjId, 1, false, packet.OtherObjId, -1);
factory.factorySystem.SetInserterPickTarget(packet.InserterId, packet.OtherObjId, packet.Offset);
factory.entityPool[packet.ObjId].pos = packet.PointPos.ToVector3();
FactoryManager.TargetPlanet = FactoryManager.PLANET_NONE;
}
}
public void ProcessPacket(SyncComplete packet, NebulaConnection conn)
{
// Everyone is now connected, we can safely spawn the player model of all the other players that are currently connected
foreach (var playerData in packet.AllPlayers)
{
if (playerData.PlayerId != LocalPlayer.PlayerId)
{
SimulatedWorld.SpawnRemotePlayerModel(playerData);
}
}
SimulatedWorld.OnAllPlayersSyncCompleted();
}
public void ProcessPacket(PasteEntitySettingUpdate packet, NebulaConnection conn)
{
if (GameMain.data.factories[packet.FactoryIndex] != null)
{
EntitySettingDesc backup = EntitySettingDesc.clipboard;
EntitySettingDesc.clipboard = packet.GetEntitySettings();
using (FactoryManager.EventFromServer.On())
{
GameMain.data.factories[packet.FactoryIndex].PasteEntitySetting(packet.EntityId);
}
EntitySettingDesc.clipboard = backup;
}
}
public override void ProcessPacket(PlayerUpdateLocalStarId packet, NebulaConnection conn)
{
if (IsClient)
{
return;
}
INebulaPlayer player = playerManager.GetPlayer(conn);
if (player != null)
{
player.Data.LocalStarId = packet.StarId;
}
}
public void ProcessPacket(DysonSwarmRemoveOrbitPacket packet, NebulaConnection conn)
{
Player player = playerManager.GetPlayer(conn);
if (player != null)
{
playerManager.SendPacketToOtherPlayers(packet, player);
using (DysonSphere_Manager.IncomingDysonSwarmPacket.On())
{
GameMain.data.dysonSpheres[packet.StarIndex]?.swarm?.RemoveOrbit(packet.OrbitId);
}
}
}
public void ProcessPacket(DysonSwarmRemoveOrbitPacket packet, NebulaConnection conn)
{
Log.Info($"Processing DysonSwarm Remove Orbit notification for system {GameMain.data.galaxy.stars[packet.StarIndex].name} (Index: {GameMain.data.galaxy.stars[packet.StarIndex].index})");
Player player = playerManager.GetPlayer(conn);
if (player != null)
{
playerManager.SendPacketToOtherPlayers(packet, player);
DysonSphere_Manager.IncomingDysonSwarmPacket = true;
GameMain.data.dysonSpheres[packet.StarIndex]?.swarm?.RemoveOrbit(packet.OrbitId);
DysonSphere_Manager.IncomingDysonSwarmPacket = false;
}
}
public void ProcessPacket(DysonSwarmAddOrbitPacket packet, NebulaConnection conn)
{
Player player = playerManager.GetPlayer(conn);
if (player != null)
{
playerManager.SendPacketToOtherPlayers(packet, player);
using (DysonSphere_Manager.IncomingDysonSwarmPacket.On())
{
GameMain.data.dysonSpheres[packet.StarIndex]?.swarm?.NewOrbit(packet.Radius, DataStructureExtensions.ToQuaternion(packet.Rotation));
}
}
}
public override void ProcessPacket(GameHistoryDataRequest packet, NebulaConnection conn)
{
if (IsClient)
{
return;
}
using (BinaryUtils.Writer writer = new BinaryUtils.Writer())
{
GameMain.history.Export(writer.BinaryWriter);
conn.SendPacket(new GameHistoryDataResponse(writer.CloseAndGetBytes()));
}
}
public override void ProcessPacket(PasteBuildingSettingUpdate packet, NebulaConnection conn)
{
if (GameMain.galaxy.PlanetById(packet.PlanetId)?.factory != null)
{
BuildingParameters backup = BuildingParameters.clipboard;
BuildingParameters.clipboard = packet.GetBuildingSettings();
using (FactoryManager.IsIncomingRequest.On())
{
GameMain.galaxy.PlanetById(packet.PlanetId).factory.PasteBuildingSetting(packet.ObjectId);
}
BuildingParameters.clipboard = backup;
}
}
public void ProcessPacket(NewSetInserterInsertTargetPacket packet, NebulaConnection conn)
{
PlanetFactory factory = GameMain.galaxy.PlanetById(packet.PlanetId)?.factory;
if (factory != null)
{
FactoryManager.TargetPlanet = factory.planetId;
factory.WriteObjectConn(packet.ObjId, 1, false, packet.OtherObjId, -1);
factory.factorySystem.SetInserterInsertTarget(packet.InserterId, packet.OtherObjId, packet.Offset);
factory.factorySystem.inserterPool[packet.InserterId].pos2 = packet.PointPos.ToVector3();
FactoryManager.TargetPlanet = FactoryManager.PLANET_NONE;
}
}
public static void RemoveSubscriber(int stationGId, NebulaConnection player)
{
List <NebulaConnection> players;
if (StationUISubscribers.TryGetValue(stationGId, out players))
{
StationUISubscribers[stationGId].Remove(player);
if (StationUISubscribers[stationGId].Count == 0)
{
StationUISubscribers.Remove(stationGId);
}
}
}
public Player PlayerConnected(NebulaConnection conn)
{
//Generate new data for the player
ushort playerId = GetNextAvailablePlayerId();
Float3 randomColor = new Float3(Random.value, Random.value, Random.value);
PlayerData playerData = new PlayerData(playerId, -1, randomColor);
Player newPlayer = new Player(conn, playerData);
pendingPlayers.Add(conn, newPlayer);
return(newPlayer);
}
public void ProcessPacket(DysonSwarmAddOrbitPacket packet, NebulaConnection conn)
{
Log.Info($"Processing DysonSwarm New Orbit notification for system {GameMain.data.galaxy.stars[packet.StarIndex].name} (Index: {GameMain.data.galaxy.stars[packet.StarIndex].index})");
Player player = playerManager.GetPlayer(conn);
if (player != null)
{
playerManager.SendPacketToOtherPlayers(packet, player);
DysonSphere_Manager.IncomingDysonSwarmPacket = true;
GameMain.data.dysonSpheres[packet.StarIndex]?.swarm?.NewOrbit(packet.Radius, DataStructureExtensions.ToUnity(packet.Rotation));
DysonSphere_Manager.IncomingDysonSwarmPacket = false;
}
}
