예제 #1
0
        public MessageController()
        {
            //Initiating messages
            Messages.rocketFiredMsg = ModNetworking.CreateMessageType(DataType.Block);
            Messages.rocketTargetBlockBehaviourMsg = ModNetworking.CreateMessageType(DataType.Block, DataType.Block);
            Messages.rocketTargetEntityMsg         = ModNetworking.CreateMessageType(DataType.Entity, DataType.Block);
            Messages.rocketTargetNullMsg           = ModNetworking.CreateMessageType(DataType.Block);
            Messages.rocketRayToHostMsg            = ModNetworking.CreateMessageType(DataType.Vector3, DataType.Vector3, DataType.Block);
            Messages.rocketHighExploPosition       = ModNetworking.CreateMessageType(DataType.Vector3, DataType.Single);
            Messages.rocketLockOnMeMsg             = ModNetworking.CreateMessageType(DataType.Block, DataType.Integer);
            Messages.rocketLostTargetMsg           = ModNetworking.CreateMessageType(DataType.Block);

            //Initiating callbacks
            ModNetworking.Callbacks[Messages.rocketHighExploPosition] += (Message msg) =>
            {
                if (StatMaster.isClient)
                {
                    Vector3 position            = (Vector3)msg.GetData(0);
                    float   bombExplosiveCharge = (float)msg.GetData(1);
                    int     levelBombCategory   = 4;
                    int     levelBombID         = 5001;
                    float   radius      = 7f;
                    float   power       = 3600f;
                    float   torquePower = 100000f;
                    float   upPower     = 0.25f;
                    try
                    {
                        GameObject bomb = UnityEngine.Object.Instantiate(PrefabMaster.LevelPrefabs[levelBombCategory].GetValue(levelBombID).gameObject);
                        bomb.transform.position = position;
                        ExplodeOnCollide bombControl = bomb.GetComponent <ExplodeOnCollide>();
                        bomb.transform.localScale = Vector3.one * bombExplosiveCharge;
                        bombControl.radius        = radius * bombExplosiveCharge;
                        bombControl.power         = power * bombExplosiveCharge;
                        bombControl.torquePower   = torquePower * bombExplosiveCharge;
                        bombControl.upPower       = upPower;
                        bombControl.Explodey();
                    }
                    catch { }
                }
            };

            ModNetworking.Callbacks[Messages.rocketFiredMsg] += (Message msg) =>
            {
                Block       rocketBlock = (Block)msg.GetData(0);
                TimedRocket rocket      = rocketBlock.GameObject.GetComponent <TimedRocket>();
                RocketsController.Instance.UpdateRocketFiredStatus(rocket);

                RadarScript radar = rocketBlock.GameObject.GetComponentInChildren <RadarScript>();
                radar.Switch = true;
            };

//            ModNetworking.Callbacks[Messages.rocketTargetBlockBehaviourMsg] += (Message msg) =>
//            {
//#if DEBUG
//                Debug.Log("Receive block target");
//#endif
//                Block rocketBlock = (Block)msg.GetData(1);
//                RadarScript radar = rocketBlock.GameObject.GetComponentInChildren<RadarScript>();

//                Block target = ((Block)msg.GetData(0));

//                radar.SetTarget(new Target(target.InternalObject));
//                //radar.target.transform = ((Block)msg.GetData(0)).GameObject.transform;
//                //radar.target.collider = radar.target.transform.GetComponentInChildren<Collider>(true);

//            };

//            ModNetworking.Callbacks[Messages.rocketTargetEntityMsg] += (Message msg) =>
//            {
//#if DEBUG
//                Debug.Log("Receive entity target");
//#endif
//                Block rocketBlock = (Block)msg.GetData(1);
//                RadarScript radar = rocketBlock.GameObject.GetComponentInChildren<RadarScript>();

//                GenericEntity target = ((GenericEntity)msg.GetData(0));

//                radar.SetTarget(new Target(target));

//                //radar.target.transform = ((Entity)msg.GetData(0)).GameObject.transform;
//                //radar.target.collider = radar.target.transform.GetComponentInChildren<Collider>(true);
//            };

            ModNetworking.Callbacks[Messages.rocketTargetNullMsg] += (Message msg) =>
            {
#if DEBUG
                Debug.Log("Clear Target");
#endif
                Block rocketBlock = (Block)msg.GetData(0);
                if (rocketBlock == null)
                {
                    return;
                }

                RadarScript radar = rocketBlock.GameObject.GetComponentInChildren <RadarScript>();
                if (radar == null)
                {
                    return;
                }

                radar.ClearTarget();
                //radar.target.transform = null;
                //radar.target.collider = null;
            };

            ModNetworking.Callbacks[Messages.rocketRayToHostMsg] += (Message msg) =>
            {
                Block       rocketBlock = (Block)msg.GetData(2);
                RadarScript radar       = rocketBlock.GameObject.GetComponentInChildren <RadarScript>();
                radar.rayFromClient         = new Ray((Vector3)msg.GetData(0), (Vector3)msg.GetData(1));
                radar.receivedRayFromClient = true;
            };

            ModNetworking.Callbacks[Messages.rocketLockOnMeMsg] += (Message msg) =>
            {
                Block rocketBlock     = (Block)msg.GetData(0);
                int   targetMachineID = (int)msg.GetData(1);
                RocketsController.Instance.UpdateRocketTarget(rocketBlock.InternalObject, targetMachineID);
            };
            ModNetworking.Callbacks[Messages.rocketLostTargetMsg] += (Message msg) =>
            {
                Block rocketBlock = (Block)msg.GetData(0);
                if (rocketBlock == null)
                {
                    return;
                }

                RocketsController.Instance.RemoveRocketTarget(rocketBlock.InternalObject);
            };
        }
        public override void SimulateUpdateAlways_EnhancementEnable()
        {
            if (gameObject.activeInHierarchy)
            {
                if (!GroupFireKey.Ignored)
                {
                    if ((GroupFireKey.IsHeld || GroupFireKey.EmulationHeld()) && !StatMaster.isClient)
                    {
                        if (!RocketsController.Instance.launchStarted)
                        {
                            StartCoroutine(RocketsController.Instance.LaunchRocketFromGroup(rocket.ParentMachine.PlayerID, GroupFireKey.GetKey(0)));
                        }
                    }
                }

                if (radar != null)
                {
                    if (!StatMaster.isClient)
                    {
                        radar.Switch = rocket.hasFired;
                    }

                    if (GuidedRocketToggle.IsActive)
                    {
                        //When toggle auto aim key is released, change the auto aim status
                        if (ManualOverrideKey.IsReleased || ManualOverrideKey.EmulationReleased())
                        {
                            if (radar.RadarType == RadarScript.RadarTypes.ActiveRadar)
                            {
                                //radar.meshRenderer.enabled = radar.canBeOverridden && ShowRadarToggle.IsActive && radar.Switch;
                                radar.DisplayRadarZone = radar.canBeOverridden && ShowRadarToggle.IsActive && radar.Switch;
                                //radar.meshCollider.enabled = radar.canBeOverridden && radar.Switch;
                                radar.canBeOverridden = !radar.canBeOverridden;
                                if (!radar.canBeOverridden)
                                {
                                    radar.ClearTarget(false);
                                }
                            }
                        }

                        if (LockTargetKey.IsPressed || LockTargetKey.EmulationPressed())
                        {
                            if (radar.RadarType == RadarScript.RadarTypes.ActiveRadar)
                            {
                                if (radar.canBeOverridden)
                                {
                                    radar.SetTargetManual();
                                }
                                else
                                {
                                    //保留重新搜索目标的能力
                                    radar.ClearTarget(false);
                                }
                            }
                        }
                    }
                }

                if (rocket.hasFired)
                {
                    //Let rocket controller know the rocket is fired
                    SendRocketFired();

                    if (!rocket.hasExploded)
                    {
                        if (GuidedRocketToggle.IsActive)
                        {
                            //Activate aerodynamic effect
                            guideController.enableAerodynamicEffect = StabilityToggle.IsActive;

                            //Record the launch time for the guide delay
                            if (!launchTimeRecorded)
                            {
                                launchTimeRecorded = true;
                                launchTime         = Time.time;
                            }

                            //Rocket can be triggered after the time elapsed after firing is greater than guide delay
                            if (Time.time - launchTime >= GuideDelaySlider.Value + 0.15f && TorqueSlider.Value > 0)
                            {
                                guideController.Switch = true;
                            }

                            //Proximity fuse behaviour
                            if (ProximityFuzeToggle.IsActive)
                            {
                                if (radar.TargetDistance <= ProximityFuzeRangeSlider.Value + 1f)
                                {
                                    StartCoroutine(RocketExplode());
                                }
                            }
                        }
                    }
                }

                if (rocket.hasExploded && !rocketExploMsgSent)
                {
                    Destroy(radarObject);
                    Destroy(guideObject);

                    if (HighExploToggle.IsActive)
                    {
                        StartCoroutine(RocketExplode());
                    }

                    try
                    {
                        if (RocketsController.Instance.playerGroupedRockets.TryGetValue(StatMaster.isMP ? rocket.ParentMachine.PlayerID : 0, out Dictionary <KeyCode, HashSet <TimedRocket> > groupedRockets))
                        {
                            if (groupedRockets.TryGetValue(GroupFireKey.GetKey(0), out HashSet <TimedRocket> rockets))
                            {
                                rockets.Remove(rocket);
                            }
                        }
                    }
                    catch { }
                    rocketExploMsgSent = true;
                }

                if (!NoSmokeToggle.IsActive)
                {
                    var em = smokeTrail.emission;
                    var r  = em.rate;
                    r.constant = /*TrailSmokeEmissionConstant*/ trailSmokePropertise.EmissionConstant;
                    em.rate    = r;
                    smokeTrail.startLifetime = /*TrailSmokeLifetime*/ trailSmokePropertise.Lifetime;
                    smokeTrail.startSize     = /*TrailSmokeSize*/ trailSmokePropertise.Size;
                }
            }
        }