Beispiel #1
0
        public static void UpdateRemotePlayerDrone(NewDroneOrderPacket packet)
        {
            using (GetRemotePlayersModels(out var remotePlayersModels))
            {
                if (remotePlayersModels.TryGetValue(packet.PlayerId, out RemotePlayerModel player))
                {
                    //Setup drone of remote player based on the drone data
                    ref MechaDrone  drone      = ref player.PlayerInstance.mecha.drones[packet.DroneId];
                    MechaDroneLogic droneLogic = player.PlayerInstance.mecha.droneLogic;

                    drone.stage        = packet.Stage;
                    drone.targetObject = packet.Stage < 3 ? packet.EntityId : 0;
                    drone.movement     = droneLogic.player.mecha.droneMovement;
                    if (packet.Stage == 1)
                    {
                        drone.position = player.Movement.GetLastPosition().LocalPlanetPosition.ToVector3();
                    }
                    drone.target                    = (Vector3)MethodInvoker.GetHandler(AccessTools.Method(typeof(MechaDroneLogic), "_obj_hpos", new System.Type[] { typeof(int) })).Invoke(GameMain.mainPlayer.mecha.droneLogic, packet.EntityId);
                    drone.initialVector             = drone.position + drone.position.normalized * 4.5f + ((drone.target - drone.position).normalized + UnityEngine.Random.insideUnitSphere) * 1.5f;
                    drone.forward                   = drone.initialVector;
                    drone.progress                  = 0f;
                    player.MechaInstance.droneCount = GameMain.mainPlayer.mecha.droneCount;
                    player.MechaInstance.droneSpeed = GameMain.mainPlayer.mecha.droneSpeed;
                    if (packet.Stage == 3)
                    {
                        GameMain.mainPlayer.mecha.droneLogic.serving.Remove(packet.EntityId);
                    }
                }
            }
        public static void MechaDrone_Update_Postfix(MechaDrone __instance, ref int __result, PrebuildData[] prebuildPool, Vector3 playerPos, float dt, ref double energy, ref double energyChange, double energyRate)
        {
            if (__result == 1)  // If the Prebuild would normally complete...
            {
                int          prebuildId = -__instance.targetObject;
                PrebuildData prebuild   = prebuildPool[prebuildId];
                if (isDroneClearingPrebuild(prebuild))
                {
                    PlanetFactory factory = GameMain.mainPlayer.factory;

                    DroneClearingMissionData missionData = null;
                    for (int activeMissionIdx = 0; activeMissionIdx < activeMissions.Count; ++activeMissionIdx)
                    {
                        missionData = activeMissions[activeMissionIdx];
                        if (missionData.prebuildId == prebuildId)
                        {
                            if (missionData.mineAction.miningType == EObjectType.Entity)
                            {
                                // Clearing completed
                                activeMissions.RemoveAt(activeMissionIdx);
                                factory.RemovePrebuildData(prebuildId);
                            }
                            else
                            {
                                __result = 0;
                            }
                            return;
                        }
                    }

                    if (configCollectResourcesFlag)
                    {
                        missionData                       = new DroneClearingMissionData();
                        missionData.prebuildId            = prebuildId;
                        missionData.forward               = __instance.forward;
                        missionData.position              = __instance.position;
                        missionData.mineAction            = new DroneAction_Mine();
                        missionData.mineAction.player     = GameMain.mainPlayer;
                        missionData.mineAction.miningType = EObjectType.Vegetable;
                        missionData.mineAction.miningId   = prebuild.upEntity;
                        missionData.mineAction.miningTick = 0;
                        activeMissions.Add(missionData);
                    }
                    else
                    {
                        factory.RemovePrebuildData(prebuildId);
                        factory.RemoveVegeWithComponents(prebuild.upEntity);
                    }

                    __result = 0;
                    return;
                }
            }
        }
Beispiel #3
0
        public static void UpdateRemotePlayerDrone(NewDroneOrderPacket packet)
        {
            using (GetRemotePlayersModels(out var remotePlayersModels))
            {
                if (remotePlayersModels.TryGetValue(packet.PlayerId, out RemotePlayerModel player))
                {
                    //Setup drone of remote player based on the drone data
                    ref MechaDrone  drone      = ref player.PlayerInstance.mecha.drones[packet.DroneId];
                    MechaDroneLogic droneLogic = player.PlayerInstance.mecha.droneLogic;

                    drone.stage        = packet.Stage;
                    drone.targetObject = packet.Stage < 3 ? packet.EntityId : 0;
                    drone.movement     = droneLogic.player.mecha.droneMovement;
                    if (packet.Stage == 1)
                    {
                        drone.position = player.Movement.GetLastPosition().LocalPlanetPosition.ToVector3();
                    }
                    drone.target                    = (Vector3)MethodInvoker.GetHandler(AccessTools.Method(typeof(MechaDroneLogic), "_obj_hpos", new System.Type[] { typeof(int) })).Invoke(GameMain.mainPlayer.mecha.droneLogic, packet.EntityId);
                    drone.initialVector             = drone.position + drone.position.normalized * 4.5f + ((drone.target - drone.position).normalized + UnityEngine.Random.insideUnitSphere) * 1.5f;
                    drone.forward                   = drone.initialVector;
                    drone.progress                  = 0f;
                    player.MechaInstance.droneCount = GameMain.mainPlayer.mecha.droneCount;
                    player.MechaInstance.droneSpeed = GameMain.mainPlayer.mecha.droneSpeed;
                    Mecha myMecha = GameMain.mainPlayer.mecha;
                    if (packet.Stage == 3)
                    {
                        myMecha.droneLogic.serving.Remove(packet.EntityId);
                    }

                    if (drone.stage == 1 || drone.stage == 2)
                    {
                        //Check if target entity exists as Prebuild
                        if (GameMain.data.localPlanet.factory.prebuildPool.Length <= -packet.EntityId || GameMain.data.localPlanet.factory.prebuildPool[-packet.EntityId].id == 0)
                        {
                            return;
                        }

                        //Check target prebuild if it is same prebuild that I have. Sometimes it is same ID, but different prebuild
                        ref PrebuildData prebuildData = ref GameMain.data.localPlanet.factory.prebuildPool[-packet.EntityId];
                        if (prebuildData.pos.x != packet.EntityPos.x || prebuildData.pos.y != packet.EntityPos.y || prebuildData.pos.z != packet.EntityPos.z)
                        {
                            return;
                        }

                        //Check if my drone is already going there
                        if (!myMecha.droneLogic.serving.Contains(packet.EntityId))
                        {
                            myMecha.droneLogic.serving.Add(packet.EntityId);
                        }
                        else
                        {
                            //resolve conflict (two drones are going to the same building)
                            //find my drone that is going there
                            int priority = 0;
                            int droneId  = 0;
                            for (int i = 0; i < myMecha.droneCount; i++)
                            {
                                if (myMecha.drones[i].stage > 0 && myMecha.drones[i].targetObject == drone.targetObject)
                                {
                                    priority = DroneManager.DronePriorities[i];
                                    droneId  = i;
                                    break;
                                }
                            }

                            ref MechaDrone myDrone = ref myMecha.drones[droneId];
                            //for size comparison sqrMagnitude is fine, since sqrMagnitude, magnitude and the actual distance along the curve are all strictly monotonically increasing
                            float diff = (myDrone.position - myDrone.target).sqrMagnitude - (drone.position - drone.target).sqrMagnitude;
                            if (diff > 0 || (diff == 0 && packet.Priority > priority))
                            {
                                //my drone is further away (myMagnitude > otherMagnitude = difference positive) and has to return
                                myDrone.stage        = 3;
                                myDrone.targetObject = 0;
                            }
                            else
                            {
                                //their drone is further away (otherMagnitude > myMagnitude = difference negative) and has to return
                                drone.stage        = 3;
                                drone.targetObject = 0;
                            }
                        }
                    }
Beispiel #4
0
        public static void UpdateRemotePlayerDrone(NewDroneOrderPacket packet)
        {
            using (GetRemotePlayersModels(out var remotePlayersModels))
            {
                if (remotePlayersModels.TryGetValue(packet.PlayerId, out RemotePlayerModel player))
                {
                    //Setup drone of remote player based on the drone data
                    ref MechaDrone  drone      = ref player.PlayerInstance.mecha.drones[packet.DroneId];
                    MechaDroneLogic droneLogic = player.PlayerInstance.mecha.droneLogic;

                    drone.stage        = packet.Stage;
                    drone.targetObject = packet.Stage < 3 ? packet.EntityId : 0;
                    drone.movement     = droneLogic.player.mecha.droneMovement;
                    if (packet.Stage == 1)
                    {
                        drone.position = player.Movement.GetLastPosition().LocalPlanetPosition.ToVector3();
                    }
                    drone.target                    = (Vector3)MethodInvoker.GetHandler(AccessTools.Method(typeof(MechaDroneLogic), "_obj_hpos", new System.Type[] { typeof(int) })).Invoke(GameMain.mainPlayer.mecha.droneLogic, packet.EntityId);
                    drone.initialVector             = drone.position + drone.position.normalized * 4.5f + ((drone.target - drone.position).normalized + UnityEngine.Random.insideUnitSphere) * 1.5f;
                    drone.forward                   = drone.initialVector;
                    drone.progress                  = 0f;
                    player.MechaInstance.droneCount = GameMain.mainPlayer.mecha.droneCount;
                    player.MechaInstance.droneSpeed = GameMain.mainPlayer.mecha.droneSpeed;
                    Mecha myMecha = GameMain.mainPlayer.mecha;
                    if (packet.Stage == 3)
                    {
                        myMecha.droneLogic.serving.Remove(packet.EntityId);
                    }

                    if (drone.stage == 1 || drone.stage == 2)
                    {
                        //Check if my drone is already going there
                        if (!myMecha.droneLogic.serving.Contains(packet.EntityId))
                        {
                            myMecha.droneLogic.serving.Add(packet.EntityId);
                        }
                        else
                        {
                            //resolve conflict (two drones are going to the same building)
                            //find my drone that is going there
                            int priority = 0;
                            int droneId  = 0;
                            for (int i = 0; i < myMecha.droneCount; i++)
                            {
                                if (myMecha.drones[i].stage > 0 && myMecha.drones[i].targetObject == drone.targetObject)
                                {
                                    priority = DroneManager.DronePriorities[i];
                                    droneId  = i;
                                    break;
                                }
                            }
                            //compare, who's drone has higher priority
                            if (packet.Priority > priority)
                            {
                                //their drone won, my drone has to return
                                ref MechaDrone myDrone = ref myMecha.drones[droneId];
                                myDrone.stage        = 3;
                                myDrone.targetObject = 0;
                            }
                            else
                            {
                                //my drone won, their has to return
                                drone.stage        = 3;
                                drone.targetObject = 0;
                            }
                        }
                    }