public static void EditOrbit_Prefix(DysonSwarm __instance, int orbitId, float radius, Quaternion rotation)
{
if (Multiplayer.IsActive && !Multiplayer.Session.DysonSpheres.IncomingDysonSwarmPacket)
{
Multiplayer.Session.Network.SendPacket(new DysonSwarmEditOrbitPacket(__instance.starData.index, orbitId, radius, rotation));
}
}
public static void UpdateBulletBuffer(DysonSwarm __instance)
{
if (__instance.bulletBuffer != null)
{
__instance.bulletBuffer.Release();
}
__instance.bulletBuffer = new ComputeBuffer(__instance.bulletCapacity, 112, ComputeBufferType.Default);
}
public static void AddBullet_Postfix(DysonSwarm __instance, SailBullet bullet, int orbitId)
{
//Host is sending correction / authorization packet to correct constants of the generated bullet
if (SimulatedWorld.Initialized && LocalPlayer.IsMasterClient)
{
LocalPlayer.SendPacket(new DysonSphereBulletCorrectionPacket(__instance.starData.index, bullet.id, bullet.uEndVel, bullet.uEnd));
}
}
public static bool RemoveOrbit_Prefix(DysonSwarm __instance, int orbitId)
{
//Notify others that orbit for Dyson Swarm was deleted
if (!DysonSphere_Manager.IncomingDysonSwarmPacket)
{
LocalPlayer.SendPacket(new DysonSwarmRemoveOrbitPacket(__instance.starData.index, orbitId));
}
return(true);
}
public static bool NewOrbit_Prefix(DysonSwarm __instance, int __result, float radius, Quaternion rotation)
{
//Notify others that orbit for Dyson Swarm was created
if (!DysonSphere_Manager.IncomingDysonSwarmPacket)
{
LocalPlayer.SendPacket(new DysonSwarmAddOrbitPacket(__instance.starData.index, radius, rotation));
}
return(true);
}
public static bool DysonSwarm_AddSolarSail_Prefix(DysonSwarm __instance, DysonSail ss, int orbitId, long expiryTime)
{
if (executeNow || __instance.sailRecycleCursor > 0 || __instance.sailCursor < __instance.sailCapacity - 1)
{
// use default method if notifyNow is true or if the operation doesn't require a resize
return(true);
}
addedDysonSwarmSails.Add(Tuple.Create(__instance, ss, orbitId, expiryTime));
return(false);
}
public static void SetOrbitColor_Prefix(DysonSwarm __instance, int orbitId, Vector4 hsva)
{
if (Multiplayer.IsActive && !Multiplayer.Session.DysonSpheres.IncomingDysonSwarmPacket)
{
if (storedHsva != hsva)
{
Multiplayer.Session.Network.SendPacket(new DysonSwarmEditOrbitPacket(__instance.starData.index, orbitId, hsva));
storedHsva = hsva;
}
}
}
public static bool IsOrbitReachable(EjectorComponent ejector, DysonSwarm swarm, AstroPose[] astroPoses, int orbitId)
{
if (!IsOrbitValid(orbitId, swarm))
{
return(false);
}
int planetIndex = ejector.planetId / 100 * 100;
float num4 = ejector.localAlt + ejector.pivotY + (ejector.muzzleY - ejector.pivotY) / Mathf.Max(0.1f, Mathf.Sqrt(1f - ejector.localDir.y * ejector.localDir.y));
Vector3 vector = new Vector3(ejector.localPosN.x * num4, ejector.localPosN.y * num4, ejector.localPosN.z * num4);
VectorLF3 vectorLF = astroPoses[ejector.planetId].uPos + Maths.QRotateLF(astroPoses[ejector.planetId].uRot, vector);
Quaternion q = astroPoses[ejector.planetId].uRot * ejector.localRot;
VectorLF3 uPos = astroPoses[planetIndex].uPos;
VectorLF3 b = uPos - vectorLF;
VectorLF3 vectorLF2 = uPos + VectorLF3.Cross(swarm.orbits[orbitId].up, b).normalized *(double)swarm.orbits[orbitId].radius;
VectorLF3 vec = vectorLF2 - vectorLF;
var targetDist = vec.magnitude;
vec.x /= targetDist;
vec.y /= targetDist;
vec.z /= targetDist;
Vector3 vector2 = Maths.QInvRotate(q, vec);
if ((double)vector2.y < 0.08715574 || vector2.y > 0.8660254f)
{
return(false);
}
for (int i = planetIndex + 1; i <= ejector.planetId + 2; i++)
{
if (i != ejector.planetId)
{
double num5 = (double)astroPoses[i].uRadius;
if (num5 > 1.0)
{
VectorLF3 vectorLF3 = astroPoses[i].uPos - vectorLF;
double num6 = vectorLF3.x * vectorLF3.x + vectorLF3.y * vectorLF3.y + vectorLF3.z * vectorLF3.z;
double num7 = vectorLF3.x * vec.x + vectorLF3.y * vec.y + vectorLF3.z * vec.z;
if (num7 > 0.0)
{
double num8 = num6 - num7 * num7;
num5 += 120.0;
if (num8 < num5 * num5)
{
return(false);
}
}
}
}
}
return(true);
}
public static void SetOrbitEnable_Prefix(DysonSwarm __instance, int orbitId, bool enabled)
{
if (!Multiplayer.IsActive)
{
return;
}
//Notify others that orbit for Dyson Swarm was enabled/disabled
if (!Multiplayer.Session.DysonSpheres.IncomingDysonSwarmPacket)
{
Multiplayer.Session.Network.SendPacket(new DysonSwarmRemoveOrbitPacket(__instance.starData.index, orbitId, enabled ? SwarmRemoveOrbitEvent.Enable : SwarmRemoveOrbitEvent.Disable));
}
}
public static void RemoveOrbit_Prefix(DysonSwarm __instance, int orbitId)
{
if (!Multiplayer.IsActive)
{
return;
}
//If local is the author and not in the process of importing blueprint
if (!Multiplayer.Session.DysonSpheres.IncomingDysonSwarmPacket && !Multiplayer.Session.DysonSpheres.InBlueprint)
{
Multiplayer.Session.Network.SendPacket(new DysonSwarmRemoveOrbitPacket(__instance.starData.index, orbitId, SwarmRemoveOrbitEvent.Remove));
}
}
public static void NewOrbit_Prefix(DysonSwarm __instance, float radius, Quaternion rotation)
{
if (!Multiplayer.IsActive)
{
return;
}
//If local is the author and not in the process of importing blueprint
if (!Multiplayer.Session.DysonSpheres.IncomingDysonSwarmPacket && !Multiplayer.Session.DysonSpheres.InBlueprint)
{
int orbitId = NebulaWorld.Universe.DysonSphereManager.QueryOrbitId(__instance);
Multiplayer.Session.Network.SendPacket(new DysonSwarmAddOrbitPacket(__instance.starData.index, orbitId, radius, rotation));
}
}
public static bool IsOrbitValid(int orbitId, DysonSwarm swarm)
{
return(orbitId > 0 && orbitId < swarm.orbitCursor && swarm.orbits[orbitId].id == orbitId && swarm.orbits[orbitId].enabled);
}
public static void EjectorComponent_InternalUpdate_Postfix(ref EjectorComponent __instance, DysonSwarm swarm, AstroPose[] astroPoses)
{
var ejectorUID = GetEjectorUID(__instance);
if (ejectorUID % BATCH_COUNT != batch)
{
return;
}
ManagedEjector managedEjector = GetOrCreateManagedEjector(ejectorUID, __instance.orbitId);
if (!IsOrbitValid(managedEjector.originalOrbitId, swarm))
{
managedEjector.originalOrbitId = 0;
}
if (__instance.orbitId != managedEjector.originalOrbitId && IsOrbitReachable(__instance, swarm, astroPoses, managedEjector.originalOrbitId))
{
// by default we try to check if the original orbit is available
SetOrbit(ref __instance, managedEjector.originalOrbitId);
}
else if (
(__instance.targetState == EjectorComponent.ETargetState.AngleLimit ||
__instance.targetState == EjectorComponent.ETargetState.Blocked ||
(__instance.targetState == EjectorComponent.ETargetState.None && forceRetargeting.Value))
&& swarm.orbitCursor > 1)
{
// if the current orbit is not reachable activate auto targeting
var testOrbit = __instance.orbitId;
var orbitsCount = swarm.orbitCursor;
while (--orbitsCount > 0)
{
testOrbit++;
if (testOrbit >= swarm.orbitCursor)
{
testOrbit = 1;
if (ignoreOrbit1.Value)
{
continue;
}
}
if (IsOrbitReachable(__instance, swarm, astroPoses, testOrbit))
{
SetOrbit(ref __instance, testOrbit);
return;
}
}
// no alternative orbit has been found. set the original as default
SetOrbit(ref __instance, managedEjector.originalOrbitId);
}
}
