public void ProcessPacket(PowerTowerUserLoadingRequest packet, NebulaConnection conn)
{
PlanetFactory factory = GameMain.galaxy.PlanetById(packet.PlanetId)?.factory;
if (factory != null && factory.powerSystem != null)
{
PowerNetwork pNet = factory.powerSystem.netPool[packet.NetId];
if (packet.Charging)
{
PowerTowerManager.AddExtraDemand(packet.PlanetId, packet.NetId, packet.NodeId, packet.PowerAmount);
}
else
{
PowerTowerManager.RemExtraDemand(packet.PlanetId, packet.NetId, packet.NodeId);
}
LocalPlayer.SendPacketToStar(new PowerTowerUserLoadingResponse(packet.PlanetId,
packet.NetId,
packet.NodeId,
packet.PowerAmount,
pNet.energyCapacity,
pNet.energyRequired,
pNet.energyServed,
pNet.energyAccumulated,
pNet.energyExchanged,
packet.Charging),
GameMain.galaxy.PlanetById(packet.PlanetId).star.id);
}
}
public void ProcessPacket(PowerTowerUserLoadingResponse packet, NebulaConnection conn)
{
PlanetFactory factory = GameMain.galaxy.PlanetById(packet.PlanetId)?.factory;
if (factory != null && factory.powerSystem != null)
{
PowerNetwork pNet = factory.powerSystem.netPool[packet.NetId];
if (packet.Charging)
{
PowerTowerManager.AddExtraDemand(packet.PlanetId, packet.NetId, packet.NodeId, packet.PowerAmount);
if (PowerTowerManager.DidRequest(packet.PlanetId, packet.NetId, packet.NodeId))
{
int baseDemand = factory.powerSystem.nodePool[packet.NodeId].workEnergyPerTick - factory.powerSystem.nodePool[packet.NodeId].idleEnergyPerTick;
float mult = factory.powerSystem.networkServes[packet.NetId];
PowerTowerManager.PlayerChargeAmount = (int)(mult * (float)baseDemand);
}
}
else
{
PowerTowerManager.RemExtraDemand(packet.PlanetId, packet.NetId, packet.NodeId);
}
pNet.energyCapacity = packet.EnergyCapacity;
pNet.energyRequired = packet.EnergyRequired;
pNet.energyAccumulated = packet.EnergyAccumulated;
pNet.energyExchanged = packet.EnergyExchanged;
pNet.energyServed = packet.EnergyServed;
}
}
public static bool RemoveNodeComponent(PowerSystem __instance, int id)
{
if (SimulatedWorld.Initialized)
{
// as the destruct is synced accross players this event is too
// and as such we can safely remove power demand for every player
PowerNodeComponent pComp = __instance.nodePool[id];
PowerTowerManager.RemExtraDemand(__instance.planet.id, pComp.networkId, id);
}
return(true);
}
public static void PowerSystem_GameTick_Postfix(PowerSystem __instance, long time, bool isActive, bool isMultithreadMode)
{
if (SimulatedWorld.Initialized)
{
for (int i = 1; i < __instance.netCursor; i++)
{
PowerNetwork pNet = __instance.netPool[i];
pNet.energyRequired += PowerTowerManager.GetExtraDemand(__instance.planet.id, i);
}
PowerTowerManager.GivePlayerPower();
PowerTowerManager.UpdateAllAnimations(__instance.planet.id);
}
}
public static IEnumerable <CodeInstruction> PowerSystem_GameTick_Transpiler(IEnumerable <CodeInstruction> instructions)
{
instructions = new CodeMatcher(instructions)
.MatchForward(true,
new CodeMatch(OpCodes.Ldarg_0),
new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(PowerSystem), "nodePool")),
new CodeMatch(OpCodes.Ldloc_S),
new CodeMatch(OpCodes.Ldelema),
new CodeMatch(OpCodes.Ldarg_0),
new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(PowerSystem), "nodePool")),
new CodeMatch(OpCodes.Ldloc_S),
new CodeMatch(OpCodes.Ldelema),
new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(PowerNodeComponent), "workEnergyPerTick")),
new CodeMatch(OpCodes.Stfld, AccessTools.Field(typeof(PowerNodeComponent), "requiredEnergy")))
.Advance(1)
.InsertAndAdvance(new CodeInstruction(OpCodes.Ldarg_0))
.InsertAndAdvance(new CodeInstruction(OpCodes.Ldloc_S, 58))
.InsertAndAdvance(new CodeInstruction(OpCodes.Ldloc_S, 22))
.Insert(HarmonyLib.Transpilers.EmitDelegate <PlayerChargesAtTower>((PowerSystem _this, int powerNodeId, int powerNetId) =>
{
if (SimulatedWorld.Initialized)
{
if (!LocalPlayer.IsMasterClient)
{
_this.nodePool[powerNodeId].requiredEnergy = _this.nodePool[powerNodeId].idleEnergyPerTick; // this gets added onto the known required energy by PowerTowerManager and PowerSystem_Patch
if (PowerTowerManager.AddRequested(_this.planet.id, powerNetId, powerNodeId, true, false))
{
LocalPlayer.SendPacket(new PowerTowerUserLoadingRequest(_this.planet.id, powerNetId, powerNodeId, _this.nodePool[powerNodeId].workEnergyPerTick, true));
}
}
else
{
PowerNetwork pNet = _this.netPool[powerNetId];
if (PowerTowerManager.AddRequested(_this.planet.id, powerNetId, powerNodeId, true, false))
{
PowerTowerManager.AddExtraDemand(_this.planet.id, powerNetId, powerNodeId, _this.nodePool[powerNodeId].workEnergyPerTick);
LocalPlayer.SendPacketToLocalStar(new PowerTowerUserLoadingResponse(_this.planet.id, powerNetId, powerNodeId, _this.nodePool[powerNodeId].workEnergyPerTick,
pNet.energyCapacity,
pNet.energyRequired,
pNet.energyServed,
pNet.energyAccumulated,
pNet.energyExchanged,
true));
}
}
}
}))
// now search for where its set back to idle after player leaves radius / has charged fully
.MatchForward(true,
new CodeMatch(OpCodes.Ldarg_0),
new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(PowerSystem), "nodePool")),
new CodeMatch(OpCodes.Ldloc_S),
new CodeMatch(OpCodes.Ldelema),
new CodeMatch(OpCodes.Ldarg_0),
new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(PowerSystem), "nodePool")),
new CodeMatch(OpCodes.Ldloc_S),
new CodeMatch(OpCodes.Ldelema),
new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(PowerNodeComponent), "idleEnergyPerTick")),
new CodeMatch(OpCodes.Stfld, AccessTools.Field(typeof(PowerNodeComponent), "requiredEnergy")))
.Repeat(matcher =>
{
matcher
.Advance(1)
.InsertAndAdvance(new CodeInstruction(OpCodes.Ldarg_0))
.InsertAndAdvance(new CodeInstruction(OpCodes.Ldloc_S, 58))
.InsertAndAdvance(new CodeInstruction(OpCodes.Ldloc_S, 22))
.Insert(HarmonyLib.Transpilers.EmitDelegate <PlayerChargesAtTower>((PowerSystem _this, int powerNodeId, int powerNetId) =>
{
if (SimulatedWorld.Initialized)
{
if (!LocalPlayer.IsMasterClient)
{
if (PowerTowerManager.AddRequested(_this.planet.id, powerNetId, powerNodeId, false, false))
{
LocalPlayer.SendPacket(new PowerTowerUserLoadingRequest(_this.planet.id, powerNetId, powerNodeId, _this.nodePool[powerNodeId].workEnergyPerTick, false));
}
}
else
{
PowerNetwork pNet = _this.netPool[powerNetId];
if (PowerTowerManager.AddRequested(_this.planet.id, powerNetId, powerNodeId, false, false))
{
PowerTowerManager.RemExtraDemand(_this.planet.id, powerNetId, powerNodeId);
LocalPlayer.SendPacketToLocalStar(new PowerTowerUserLoadingResponse(_this.planet.id, powerNetId, powerNodeId, _this.nodePool[powerNodeId].workEnergyPerTick,
pNet.energyCapacity,
pNet.energyRequired,
pNet.energyServed,
pNet.energyAccumulated,
pNet.energyExchanged,
false));
}
}
}
}));
})
.InstructionEnumeration();
return(instructions);
}
