public void ProcessPacket(DysonSphereRemoveNodePacket packet, NebulaConnection conn)
{
Log.Info($"Processing DysonSphere Remove Node 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 (dsl != null)
{
int num = 0;
DysonNode dysonNode = dsl.nodePool[packet.NodeId];
//Remove all frames that are part of the node
while (dysonNode.frames.Count > 0)
{
dsl.RemoveDysonFrame(dysonNode.frames[0].id);
if (num++ > 4096)
{
Assert.CannotBeReached();
break;
}
}
//Remove all shells that are part of the node
while (dysonNode.shells.Count > 0)
{
dsl.RemoveDysonShell(dysonNode.shells[0].id);
if (num++ > 4096)
{
Assert.CannotBeReached();
break;
}
}
dsl.RemoveDysonNode(packet.NodeId);
}
}
}
public override void ProcessPacket(DysonSphereRemoveNodePacket packet, NebulaConnection conn)
{
bool valid = true;
if (IsHost)
{
Player player = playerManager.GetPlayer(conn);
if (player != null)
{
playerManager.SendPacketToOtherPlayers(packet, player);
}
else
{
valid = false;
}
}
if (valid)
{
using (DysonSphereManager.IsIncomingRequest.On())
{
DysonSphereLayer dsl = GameMain.data.dysonSpheres[packet.StarIndex]?.GetLayer(packet.LayerId);
if (dsl != null)
{
int num = 0;
DysonNode dysonNode = dsl.nodePool[packet.NodeId];
//Remove all frames that are part of the node
while (dysonNode.frames.Count > 0)
{
dsl.RemoveDysonFrame(dysonNode.frames[0].id);
if (num++ > 4096)
{
Assert.CannotBeReached();
break;
}
}
//Remove all shells that are part of the node
while (dysonNode.shells.Count > 0)
{
dsl.RemoveDysonShell(dysonNode.shells[0].id);
if (num++ > 4096)
{
Assert.CannotBeReached();
break;
}
}
dsl.RemoveDysonNode(packet.NodeId);
}
}
}
}
public override void ProcessPacket(DysonSphereColorChangePacket 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;
}
Color32 color = packet.Color.ToColor32();
switch (packet.Type)
{
case DysonSphereColorChangePacket.ComponentType.Node:
DysonNode node = packet.Index < layer.nodeCursor ? layer.nodePool[packet.Index] : null;
if (node != null)
{
node.color = color;
sphere.UpdateColor(node);
}
break;
case DysonSphereColorChangePacket.ComponentType.Frame:
DysonFrame frame = packet.Index < layer.frameCursor ? layer.framePool[packet.Index] : null;
if (frame != null)
{
frame.color = color;
sphere.UpdateColor(frame);
}
break;
case DysonSphereColorChangePacket.ComponentType.Shell:
DysonShell shell = packet.Index < layer.shellCursor ? layer.shellPool[packet.Index] : null;
if (shell != null)
{
shell.color = color;
}
break;
}
}
if (IsHost)
{
Multiplayer.Session.DysonSpheres.SendPacketToDysonSphereExcept(packet, packet.StarIndex, conn);
}
}
public static void ExportBP(this DysonNode _this, BinaryWriter w)
{
w.Write(_this.id);
w.Write(_this.protoId);
w.Write(_this.layerId);
w.Write(_this.use);
w.Write(_this.reserved);
w.Write(_this.pos.x);
w.Write(_this.pos.y);
w.Write(_this.pos.z);
w.Write(_this.spMax);
w.Write(_this.rid);
w.Write(_this.frameTurn);
w.Write(_this.shellTurn);
}
public static void ImportBP(this DysonNode _this, BinaryReader r)
{
_this.SetEmpty();
_this.id = r.ReadInt32();
_this.protoId = r.ReadInt32();
_this.layerId = r.ReadInt32();
_this.use = r.ReadBoolean();
_this.reserved = r.ReadBoolean();
_this.pos.x = r.ReadSingle();
_this.pos.y = r.ReadSingle();
_this.pos.z = r.ReadSingle();
_this.spMax = r.ReadInt32();
_this.rid = r.ReadInt32();
_this.frameTurn = r.ReadInt32();
_this.shellTurn = r.ReadInt32();
_this.RecalcSpReq();
_this.RecalcCpReq();
}
private static bool Check(DysonSphereLayer layer, DysonSphereRemoveNodePacket packet)
{
if (packet.NodeId < 1 || packet.NodeId >= layer.nodeCursor)
{
return(false);
}
DysonNode node = layer.nodePool[packet.NodeId];
if (node == null)
{
//Sender and receiver are in the same state, so it's ok to pass
return(true);
}
//Make sure that shells and frames connected to the node are removed first.
if (node.frames.Count > 0)
{
return(false);
}
return(true);
}
public static void UIDysonPanel_OnUpdate_Postfix(UIDysonPanel __instance)
{
if (cellValue != null)
{
var dysonSphere = __instance.viewDysonSphere;
if (dysonSphere != null)
{
// Structure Progress
structValue.GetComponentInChildren <Text>().text = $"{dysonSphere.totalConstructedPoint} / {dysonSphere.totalStructurePoint}";
// Cell Progress
int totalCp = 0, cpOrdered = 0, totalCpMax = 0;
for (int i = 1; i < dysonSphere.layersIdBased.Length; i++)
{
if (dysonSphere.layersIdBased[i] != null && dysonSphere.layersIdBased[i].id == i)
{
for (int j = 1; j < dysonSphere.layersIdBased[i].nodeCursor; j++)
{
DysonNode dysonNode = dysonSphere.layersIdBased[i].nodePool[j];
if (dysonNode != null && dysonNode.id == j)
{
totalCp += dysonNode.totalCp;
cpOrdered += dysonNode.cpOrdered;
totalCpMax += dysonNode.totalCpMax;
}
}
}
}
cellValue.GetComponentInChildren <Text>().text = $"{totalCp}/{cpOrdered}/{totalCpMax}";
}
else
{
structValue.GetComponentInChildren <Text>().text = "-";
cellValue.GetComponentInChildren <Text>().text = "-";
}
}
}
public static void SendNodePacket(DysonNode node)
{
int starIndex = UIRoot.instance.uiGame.dysonEditor.selection.viewStar.index;
Multiplayer.Session.Network.SendPacket(new DysonSphereColorChangePacket(starIndex, node.layerId, node.color, DysonSphereColorChangePacket.ComponentType.Node, node.id));
}
public static void ImportBP(this DysonShell _this, BinaryReader r, DysonSphere dysonSphere)
{
_this.SetEmpty();
r.ReadInt32();
_this.id = r.ReadInt32();
_this.protoId = r.ReadInt32();
_this.layerId = r.ReadInt32();
_this.randSeed = r.ReadInt32();
int num = r.ReadInt32();
for (int i = 0; i < num; i++)
{
Vector3 item = default(Vector3);
item.x = r.ReadSingle();
item.y = r.ReadSingle();
item.z = r.ReadSingle();
_this.polygon.Add(item);
}
int num2 = r.ReadInt32();
for (int j = 0; j < num2; j++)
{
int num3 = r.ReadInt32();
DysonNode dysonNode = dysonSphere.FindNode(_this.layerId, num3);
Assert.NotNull(dysonNode);
if (dysonNode != null)
{
_this.nodeIndexMap[num3] = _this.nodes.Count;
_this.nodes.Add(dysonNode);
if (!dysonNode.shells.Contains(_this))
{
dysonNode.shells.Add(_this);
}
}
}
Assert.True(_this.nodeIndexMap.Count == _this.nodes.Count);
int count = _this.nodes.Count;
for (int k = 0; k < count; k++)
{
int index = k;
int index2 = (k + 1) % count;
DysonFrame dysonFrame = DysonNode.FrameBetween(_this.nodes[index], _this.nodes[index2]);
Assert.NotNull(dysonFrame);
_this.frames.Add(dysonFrame);
}
_this.vertexCount = r.ReadInt32();
_this.triangleCount = r.ReadInt32();
int num4 = r.ReadInt32();
_this.verts = new Vector3[num4];
for (int l = 0; l < num4; l++)
{
_this.verts[l].x = r.ReadSingle();
_this.verts[l].y = r.ReadSingle();
_this.verts[l].z = r.ReadSingle();
}
num4 = r.ReadInt32();
_this.pqArr = new IntVector2[num4];
for (int m = 0; m < num4; m++)
{
_this.pqArr[m].x = r.ReadInt32();
_this.pqArr[m].y = r.ReadInt32();
}
num4 = r.ReadInt32();
_this.tris = new int[num4];
for (int n = 0; n < num4; n++)
{
_this.tris[n] = r.ReadInt32();
}
num4 = r.ReadInt32();
_this.vAdjs = new int[num4];
for (int num5 = 0; num5 < num4; num5++)
{
_this.vAdjs[num5] = r.ReadInt32();
}
num4 = r.ReadInt32();
_this.vertAttr = new int[num4];
for (int num6 = 0; num6 < num4; num6++)
{
_this.vertAttr[num6] = r.ReadInt32();
}
Assert.True(_this.vertAttr.Length == _this.verts.Length);
num4 = r.ReadInt32();
_this.vertsq = new int[num4];
for (int num7 = 0; num7 < num4; num7++)
{
_this.vertsq[num7] = r.ReadInt32();
}
Assert.True(_this.vertsq.Length == _this.verts.Length);
num4 = r.ReadInt32();
_this.vertsqOffset = new int[num4];
for (int num8 = 0; num8 < num4; num8++)
{
_this.vertsqOffset[num8] = r.ReadInt32();
}
Assert.True(_this.vertsqOffset.Length == _this.nodes.Count + 1);
num4 = r.ReadInt32();
_this.nodecps = new int[num4];
Assert.True(_this.nodecps.Length == _this.nodes.Count + 1);
num4 = r.ReadInt32();
_this.vertcps = new uint[num4];
num4 = r.ReadInt32();
_this.vertRecycleCursor = r.ReadInt32();
_this.vertRecycle = new int[num4];
for (int num11 = 0; num11 < _this.vertRecycleCursor; num11++)
{
_this.vertRecycle[num11] = r.ReadInt32();
}
Assert.True(_this.vertRecycle.Length == _this.verts.Length);
_this.GenerateGeometryOnImport();
}
public static void ImportBP(this DysonSphereLayer _this, BinaryReader r)
{
r.ReadInt32();
_this.id = r.ReadInt32();
_this.orbitRadius = r.ReadSingle();
_this.orbitRotation.x = r.ReadSingle();
_this.orbitRotation.y = r.ReadSingle();
_this.orbitRotation.z = r.ReadSingle();
_this.orbitRotation.w = r.ReadSingle();
_this.orbitAngularSpeed = r.ReadSingle();
_this.currentAngle = r.ReadSingle();
_this.currentRotation.x = r.ReadSingle();
_this.currentRotation.y = r.ReadSingle();
_this.currentRotation.z = r.ReadSingle();
_this.currentRotation.w = r.ReadSingle();
_this.nextRotation.x = r.ReadSingle();
_this.nextRotation.y = r.ReadSingle();
_this.nextRotation.z = r.ReadSingle();
_this.nextRotation.w = r.ReadSingle();
_this.gridMode = r.ReadInt32();
_this.ResetNew();
int num = r.ReadInt32();
Traverse.Create(_this).Method("SetNodeCapacity", num).GetValue();
_this.nodeCursor = r.ReadInt32();
_this.nodeRecycleCursor = r.ReadInt32();
for (int i = 1; i < _this.nodeCursor; i++)
{
int num2 = r.ReadInt32();
if (num2 != 0)
{
Assert.True(num2 == i);
DysonNode dysonNode = new DysonNode();
dysonNode.ImportBP(r);
Assert.True(dysonNode.id == i);
if (dysonNode.id != i || num2 != i)
{
throw new Exception($"node id doesn't match! {dysonNode.id} and {num2}");
}
_this.nodePool[i] = dysonNode;
}
}
for (int j = 0; j < _this.nodeRecycleCursor; j++)
{
_this.nodeRecycle[j] = r.ReadInt32();
}
num = r.ReadInt32();
Traverse.Create(_this).Method("SetFrameCapacity", num).GetValue();
_this.frameCursor = r.ReadInt32();
_this.frameRecycleCursor = r.ReadInt32();
for (int k = 1; k < _this.frameCursor; k++)
{
int num3 = r.ReadInt32();
if (num3 != 0)
{
Assert.True(num3 == k);
DysonFrame dysonFrame = new DysonFrame();
dysonFrame.ImportBP(r, _this.dysonSphere);
Assert.True(dysonFrame.id == k);
if (dysonFrame.id != k || num3 != k)
{
throw new Exception("frame id doesn't match!");
}
_this.framePool[k] = dysonFrame;
}
}
for (int l = 0; l < _this.frameRecycleCursor; l++)
{
_this.frameRecycle[l] = r.ReadInt32();
}
num = r.ReadInt32();
Traverse.Create(_this).Method("SetShellCapacity", num).GetValue();
_this.shellCursor = r.ReadInt32();
_this.shellRecycleCursor = r.ReadInt32();
for (int m = 1; m < _this.shellCursor; m++)
{
int num4 = r.ReadInt32();
if (num4 != 0)
{
Assert.True(num4 == m);
DysonShell dysonShell = new DysonShell(_this);
dysonShell.ImportBP(r, _this.dysonSphere);
Assert.True(dysonShell.id == m);
if (dysonShell.id != m || num4 != m)
{
throw new Exception("shell id doesn't match!");
}
_this.shellPool[m] = dysonShell;
}
}
for (int n = 0; n < _this.shellRecycleCursor; n++)
{
_this.shellRecycle[n] = r.ReadInt32();
}
for (int num5 = 1; num5 < _this.nodeCursor; num5++)
{
if (_this.nodePool[num5] != null && _this.nodePool[num5].id == num5)
{
_this.nodePool[num5].RecalcSpReq();
_this.nodePool[num5].RecalcCpReq();
}
}
}
public static bool DysonShell_Import_Prefix(DysonShell __instance, BinaryReader r, DysonSphere dysonSphere)
{
__instance.SetEmpty();
var version = r.PeekChar();
if (version != SAVE_FIX_VERSION)
{
Debug.Log($"Using native import {version}");
return(true);
}
Debug.Log($"Using smart import {version}");
r.ReadChar();
__instance.id = r.ReadInt32();
__instance.protoId = r.ReadInt32();
__instance.layerId = r.ReadInt32();
__instance.randSeed = r.ReadInt32();
int num = r.ReadInt32();
for (int i = 0; i < num; i++)
{
Vector3 item = default(Vector3);
item.x = r.ReadSingle();
item.y = r.ReadSingle();
item.z = r.ReadSingle();
__instance.polygon.Add(item);
}
int num2 = r.ReadInt32();
for (int j = 0; j < num2; j++)
{
int num3 = r.ReadInt32();
DysonNode dysonNode = dysonSphere.FindNode(__instance.layerId, num3);
Assert.NotNull(dysonNode);
if (dysonNode != null)
{
__instance.nodeIndexMap[num3] = __instance.nodes.Count;
__instance.nodes.Add(dysonNode);
if (!dysonNode.shells.Contains(__instance))
{
dysonNode.shells.Add(__instance);
}
}
}
Assert.True(__instance.nodeIndexMap.Count == __instance.nodes.Count);
int count = __instance.nodes.Count;
for (int k = 0; k < count; k++)
{
int index = k;
int index2 = (k + 1) % count;
DysonFrame dysonFrame = DysonNode.FrameBetween(__instance.nodes[index], __instance.nodes[index2]);
Assert.NotNull(dysonFrame);
__instance.frames.Add(dysonFrame);
}
var vertexCount = r.ReadInt32();
var triangleCount = r.ReadInt32();
int vertsLength = r.ReadInt32();
var pqArrLength = r.ReadInt32();
var trisLength = r.ReadInt32();
var vAdjsLength = r.ReadInt32();
var vertAttrLength = r.ReadInt32();
var vertsqLength = r.ReadInt32();
var vertsqOffsetLength = r.ReadInt32();
__instance.GenerateGeometry();
// Verify that generated geometry is 'at least' formally correct from a counting point of view
Assert.True(vertexCount == __instance.vertexCount);
Assert.True(triangleCount == __instance.triangleCount);
Assert.True(vertsLength == __instance.verts.Length);
Assert.True(pqArrLength == __instance.pqArr.Length);
Assert.True(trisLength == __instance.tris.Length);
Assert.True(vAdjsLength == __instance.vAdjs.Length);
Assert.True(vertAttrLength == __instance.vertAttr.Length);
Assert.True(vertsqLength == __instance.vertsq.Length);
Assert.True(vertsqOffsetLength == __instance.verts.Length);
Assert.True(__instance.vertAttr.Length == __instance.verts.Length);
Assert.True(__instance.vertsq.Length == __instance.verts.Length);
Assert.True(__instance.vertsqOffset.Length == __instance.nodes.Count + 1);
// Restore nodecps, vertcps and vertRecycle from save
var num4 = r.ReadInt32();
__instance.nodecps = new int[num4];
for (int num9 = 0; num9 < num4; num9++)
{
__instance.nodecps[num9] = r.ReadInt32();
}
Assert.True(__instance.nodecps.Length == __instance.nodes.Count + 1);
num4 = r.ReadInt32();
__instance.vertcps = new uint[num4];
for (int num10 = 0; num10 < num4; num10++)
{
__instance.vertcps[num10] = r.ReadUInt32();
}
num4 = r.ReadInt32();
__instance.vertRecycleCursor = r.ReadInt32();
__instance.vertRecycle = new int[num4];
for (int num11 = 0; num11 < __instance.vertRecycleCursor; num11++)
{
__instance.vertRecycle[num11] = r.ReadInt32();
}
Assert.True(__instance.vertRecycle.Length == __instance.verts.Length);
Array.Resize(ref __instance.vertcps, __instance.vertexCount);
__instance.SyncCellBuffer();
return(false);
}
