// Token: 0x06000046 RID: 70 RVA: 0x00003300 File Offset: 0x00001500
            public override void ProcessInput(Event ev)
            {
                base.ProcessInput(ev);
                bool flag = this.multiVerb != null;

                if (flag)
                {
                    this.multiVerb.currentVerbIndex = this.index;
                    Targeter targeter    = Find.Targeter;
                    bool     isTargeting = targeter.IsTargeting;
                    if (isTargeting)
                    {
                        bool flag2 = this.verb.CasterIsPawn && targeter.targetingSource != null && targeter.targetingSource == this.verb.verbProps;
                        if (flag2)
                        {
                            Pawn casterPawn = this.verb.CasterPawn;
                            bool flag3      = !targeter.IsPawnTargeting(casterPawn);
                            if (flag3)
                            {
                                targeter.targetingSourceAdditionalPawns.Add(casterPawn);
                            }
                        }
                        else
                        {
                            List <Pawn> collection = new List <Pawn>(targeter.targetingSourceAdditionalPawns);
                            targeter.BeginTargeting(this.verb);
                            targeter.targetingSourceAdditionalPawns.AddRange(collection);
                        }
                    }
                    Log.Message(this.defaultLabel + "; index=" + this.index, false);
                }
            }
            public virtual void ProcessInput(Event ev)
            {
                base.ProcessInput(ev);
                if (this.multiVerb == null)
                {
                    return;
                }
                this.multiVerb.currentVerbIndex = this.index;
                Targeter targeter = Find.get_Targeter();

                if (targeter.get_IsTargeting())
                {
                    if (this.verb.get_CasterIsPawn() && targeter.targetingVerb != null && ((Verb)targeter.targetingVerb).verbProps == this.verb.verbProps)
                    {
                        Pawn casterPawn = this.verb.get_CasterPawn();
                        if (!targeter.IsPawnTargeting(casterPawn))
                        {
                            ((List <Pawn>)targeter.targetingVerbAdditionalPawns).Add(casterPawn);
                        }
                    }
                    else
                    {
                        List <Pawn> pawnList = new List <Pawn>((IEnumerable <Pawn>)targeter.targetingVerbAdditionalPawns);
                        targeter.BeginTargeting(this.verb);
                        ((List <Pawn>)targeter.targetingVerbAdditionalPawns).AddRange((IEnumerable <Pawn>)pawnList);
                    }
                }
                Log.Message(this.defaultLabel.ToString() + "; index=" + (object)this.index, false);
            }
Exemplo n.º 3
0
        public bool ChoseWorldTarget(GlobalTargetInfo target)
        {
            if (!target.IsValid)
            {
                Messages.Message("SWeaponTargetInvalid".Translate(), MessageTypeDefOf.RejectInput, true);
                return(false);
            }

            /*
             * int num = Find.WorldGrid.TraversalDistanceBetween(base.Map.Tile, target.Tile, true, int.MaxValue);
             * if (this.MaxLaunchDistance < 200 && num > this.MaxLaunchDistance)
             * {
             *  Messages.Message("MissileRangeBad".Translate(), MessageTypeDefOf.RejectInput, true);
             *  return false;
             * }
             */
            MapParent mapParent = target.WorldObject as MapParent;

            if (mapParent != null && mapParent.HasMap)
            {
                Map map = mapParent.Map;
                Current.Game.CurrentMap = map;
                Targeter targeter           = Find.Targeter;
                Action   actionWhenFinished = delegate
                {
                    if (Find.Maps.Contains(base.Map))
                    {
                        Current.Game.CurrentMap = base.Map;
                    }
                };

                /*
                 * int range = 0;
                 * switch (getType()) {
                 *  case SuperWeaponType.Soviet:range = 56;break;
                 *  case SuperWeaponType.Allied: range = 30; break;
                 *  default:range=10;break;
                 * }
                 */

                Texture2D ic = ContentFinder <Texture2D> .Get("ra2/World/ra2_SuperWeaponIcon_" + getType());

                TargetingParameters tg = new TargetingParameters();
                tg.canTargetLocations = true;
                tg.canTargetItems     = true;
                tg.canTargetBuildings = true;
                tg.canTargetPawns     = true;
                tg.canTargetFires     = true;
                targeter.BeginTargeting(tg, delegate(LocalTargetInfo x)
                {
                    //GenDraw.DrawRadiusRing(UI.MouseCell(), range);
                    this.TryLaunch(x.ToGlobalTargetInfo(map));
                }, null, actionWhenFinished, ic);
                return(true);
            }
            this.TryLaunch(target);
            return(true);
        }
        private bool ChoseWorldTarget(GlobalTargetInfo target)
        {
            bool result;

            if (!this.ReadyToTransport)
            {
                result = true;
            }
            else if (!target.IsValid)
            {
                Messages.Message("MessageTransportPodsDestinationIsInvalid".Translate(), MessageTypeDefOf.RejectInput);
                result = false;
            }
            else
            {
                MapParent mapParent = target.WorldObject as MapParent;
                if (mapParent != null && mapParent.HasMap)
                {
                    Map myMap = this.parent.Map;
                    Map map   = mapParent.Map;
                    Current.Game.CurrentMap = map;
                    Targeter targeter           = Find.Targeter;
                    Action   actionWhenFinished = delegate()
                    {
                        if (Find.Maps.Contains(myMap))
                        {
                            Current.Game.CurrentMap = myMap;
                        }
                    };
                    TargetingParameters targetParams = new TargetingParameters
                    {
                        canTargetPawns     = true,
                        canTargetItems     = false,
                        canTargetSelf      = false,
                        canTargetLocations = false,
                        canTargetBuildings = false,
                        canTargetFires     = false
                    };
                    targeter.BeginTargeting(targetParams, delegate(LocalTargetInfo x)
                    {
                        if (this.ReadyToTransport)
                        {
                            this.TryTransport(x.ToGlobalTargetInfo(map));
                        }
                    }, null, actionWhenFinished, CompTeleporter.TargeterMouseAttachment);
                    result = true;
                }
                else
                {
                    Messages.Message("RD_YouCannotLock".Translate(), MessageTypeDefOf.RejectInput);                     //"You cannot lock onto anything there."
                    result = false;
                }
            }
            return(result);
        }
Exemplo n.º 5
0
        private bool ChoseWorldTarget(GlobalTargetInfo target)
        {
            if (this.parentLandedShip != null)
            {
                this.parentLandedShip.isTargeting = true;
            }
            this.isTargeting = true;
            int tile;

            if (this.parentLandedShip != null)
            {
                tile = this.parentLandedShip.Tile;
            }
            else
            {
                tile = this.Map.Tile;
            }
            bool canBomb = true;

            if (!target.IsValid)
            {
                Messages.Message("MessageTransportPodsDestinationIsInvalid".Translate(), MessageSound.RejectInput);
                return(false);
            }
            if (this.LaunchAsFleet)
            {
                List <int> distances = new List <int>();
                for (int i = 0; i < DropShipUtility.currentShipTracker.ShipsInFleet(this.fleetID).Count; i++)
                {
                    ShipBase ship = DropShipUtility.currentShipTracker.ShipsInFleet(this.fleetID)[i];
                    if (ship.compShip.cargoLoadingActive)
                    {
                        Messages.Message("MessageFleetLaunchImpossible".Translate(), MessageSound.RejectInput);
                        return(false);
                    }
                    int num = (Find.WorldGrid.TraversalDistanceBetween(tile, target.Tile));
                    if (num > ship.MaxLaunchDistanceEverPossible(true))
                    {
                        Messages.Message("MessageFleetLaunchImpossible".Translate(), MessageSound.RejectInput);
                        return(false);
                    }
                    if (!(2 * num > ship.MaxLaunchDistanceEverPossible(true)))
                    {
                        canBomb = false;
                    }
                }
            }
            else
            {
                int num = Find.WorldGrid.TraversalDistanceBetween(tile, target.Tile);

                if (num > this.MaxLaunchDistanceEverPossible(this.LaunchAsFleet))
                {
                    Messages.Message("MessageTransportPodsDestinationIsTooFar".Translate(new object[]
                    {
                        CompLaunchable.FuelNeededToLaunchAtDist((float)num).ToString("0.#")
                    }), MessageSound.RejectInput);
                    return(false);
                }
                if (!(2 * num > this.MaxLaunchDistanceEverPossible(true)))
                {
                    canBomb = false;
                }
            }

            MapParent mapParent = target.WorldObject as MapParent;

            if (mapParent != null && mapParent.HasMap)
            {
                Map myMap = this.Map;
                Map map   = mapParent.Map;
                Current.Game.VisibleMap = map;
                Targeter targeter           = Find.Targeter;
                Action   actionWhenFinished = delegate
                {
                    if (Find.Maps.Contains(myMap))
                    {
                        Current.Game.VisibleMap = myMap;
                    }
                };
                targeter.BeginTargeting(TargetingParameters.ForDropPodsDestination(), delegate(LocalTargetInfo x)
                {
                    if (!this.ReadyForTakeoff || this.LaunchAsFleet && DropShipUtility.currentShipTracker.ShipsInFleet(this.fleetID).Any(s => !s.ReadyForTakeoff))
                    {
                        return;
                    }
                    this.TryLaunch(x.ToGlobalTargetInfo(map), PawnsArriveMode.Undecided, TravelingShipArrivalAction.EnterMapFriendly);
                }, null, actionWhenFinished, DropShipUtility.TargeterShipAttachment);
                return(true);
            }

            if (target.WorldObject is Settlement || target.WorldObject is Site)
            {
                Find.WorldTargeter.closeWorldTabWhenFinished = false;
                MapParent localMapParent    = target.WorldObject as MapParent;
                List <FloatMenuOption> list = new List <FloatMenuOption>();
                if (!target.WorldObject.Faction.HostileTo(Faction.OfPlayer))
                {
                    list.Add(new FloatMenuOption("VisitSettlement".Translate(new object[]
                    {
                        target.WorldObject.Label
                    }), delegate
                    {
                        if (!this.ReadyForTakeoff || this.LaunchAsFleet && DropShipUtility.currentShipTracker.ShipsInFleet(this.fleetID).Any(s => !s.ReadyForTakeoff))
                        {
                            return;
                        }
                        this.TryLaunch(target, PawnsArriveMode.Undecided, TravelingShipArrivalAction.StayOnWorldMap);
                        CameraJumper.TryHideWorld();
                    }, MenuOptionPriority.Default, null, null, 0f, null, null));
                }
                list.Add(new FloatMenuOption("DropAtEdge".Translate(), delegate
                {
                    if (!this.ReadyForTakeoff || this.LaunchAsFleet && DropShipUtility.currentShipTracker.ShipsInFleet(this.fleetID).Any(s => !s.ReadyForTakeoff))
                    {
                        return;
                    }
                    this.TryLaunch(target, PawnsArriveMode.EdgeDrop, TravelingShipArrivalAction.EnterMapFriendly);
                    CameraJumper.TryHideWorld();
                }, MenuOptionPriority.Default, null, null, 0f, null, null));
                //list.Add(new FloatMenuOption("DropInCenter".Translate(), delegate
                //{
                //    if (!this.ReadyForTakeoff || this.LaunchAsFleet && DropShipUtility.currentShipTracker.ShipsInFleet(this.fleetID).Any(s => !s.ReadyForTakeoff))
                //    {
                //        return;
                //    }
                //    this.TryLaunch(target, PawnsArriveMode.CenterDrop, TravelingShipArrivalAction.EnterMapFriendly);
                //    CameraJumper.TryHideWorld();
                //}, MenuOptionPriority.Default, null, null, 0f, null, null));

                list.Add(new FloatMenuOption("AttackFactionBaseAerial".Translate(), delegate
                {
                    if (!this.ReadyForTakeoff || this.LaunchAsFleet && DropShipUtility.currentShipTracker.ShipsInFleet(this.fleetID).Any(s => !s.ReadyForTakeoff))
                    {
                        return;
                    }
                    this.TryLaunch(target, PawnsArriveMode.CenterDrop, TravelingShipArrivalAction.EnterMapAssault);
                    CameraJumper.TryHideWorld();
                }, MenuOptionPriority.Default, null, null, 0f, null, null));


                if (canBomb && (DropShipUtility.currentShipTracker.ShipsInFleet(this.fleetID).Any(x => x.installedTurrets.Any(y => y.Key.slotType == WeaponSystemType.Bombing && y.Value != null))) || this.loadedBombs.Any())
                {
                    list.Add(new FloatMenuOption("BombFactionBase".Translate(), delegate
                    {
                        if (!this.ReadyForTakeoff || this.LaunchAsFleet && DropShipUtility.currentShipTracker.ShipsInFleet(this.fleetID).Any(s => !s.ReadyForTakeoff))
                        {
                            return;
                        }
                        this.performBombingRun = true;
                        this.TryLaunch(target, PawnsArriveMode.CenterDrop, TravelingShipArrivalAction.BombingRun);
                        CameraJumper.TryHideWorld();
                    }, MenuOptionPriority.Default, null, null, 0f, null, null));
                }


                Find.WindowStack.Add(new FloatMenu(list));
                return(true);
            }
            if (Find.World.Impassable(target.Tile))
            {
                Messages.Message("MessageTransportPodsDestinationIsInvalid".Translate(), MessageSound.RejectInput);
                return(false);
            }

            this.TryLaunch(target, PawnsArriveMode.Undecided, TravelingShipArrivalAction.StayOnWorldMap);
            return(true);
        }
Exemplo n.º 6
0
 // RimWorld.Targeter
 public static bool ProcessInputEvents_PreFix(Targeter __instance, Func <LocalTargetInfo, bool> ___targetValidator,
                                              bool ___playSoundOnAction, ref bool ___needsStopTargetingCall)
 {
     if (__instance.targetingSource is Verb_UseAbility v)
     {
         if (v.UseAbilityProps.AbilityTargetCategory == AbilityTargetCategory.TargetSelf)
         {
             var caster = v.Caster;
             v.Ability.TryCastAbility(AbilityContext.Player, caster);
             if (___playSoundOnAction)
             {
                 SoundDefOf.Tick_High.PlayOneShotOnCamera();
             }
             __instance.StopTargeting();
             Event.current.Use();
             return(false);
         }
         targeterConfirmStillValidMethod(__instance);
         if (!__instance.IsTargeting)
         {
             return(false);
         }
         if (Event.current.type == EventType.MouseDown && Event.current.button == 0)
         {
             var target = targeterCurrentTargetUnderMouseMethod(__instance, false);
             ___needsStopTargetingCall = true;
             if (!v.ValidateTarget(target))
             {
                 Event.current.Use();
                 return(false);
             }
             if (___targetValidator != null)
             {
                 if (___targetValidator(target))
                 {
                     v.Ability.TryCastAbility(AbilityContext.Player, target);
                 }
                 else
                 {
                     ___needsStopTargetingCall = false;
                 }
             }
             else if (target.IsValid)
             {
                 v.Ability.TryCastAbility(AbilityContext.Player, target);
             }
             if (___playSoundOnAction)
             {
                 SoundDefOf.Tick_High.PlayOneShotOnCamera(null);
             }
             if (v.DestinationSelector != null)
             {
                 __instance.BeginTargeting(v.DestinationSelector, v);
             }
             else if (v.MultiSelect && Event.current.shift)
             {
                 __instance.BeginTargeting(v);
             }
             else if (__instance.targetingSourceParent != null && __instance.targetingSourceParent.MultiSelect && Event.current.shift)
             {
                 __instance.BeginTargeting(__instance.targetingSourceParent);
             }
             if (___needsStopTargetingCall)
             {
                 __instance.StopTargeting();
             }
             Event.current.Use();
             return(false);
         }
     }
     return(true);
 }
        private bool ChoseWorldTarget(GlobalTargetInfo target)
        {
            Cthulhu.Utility.DebugReport("ChooseWorldTarget Called");
            if (!this.LoadingInProgressOrReadyToLaunch)
            {
                return(true);
            }
            if (!target.IsValid)
            {
                Messages.Message("MessageTransportPodsDestinationIsInvalid".Translate(), MessageTypeDefOf.RejectInput);
                return(false);
            }
            int num = Find.WorldGrid.TraversalDistanceBetween(this.parent.Map.Tile, target.Tile);

            if (num > this.MaxLaunchDistance)
            {
                //Messages.Message("MessageTransportPodsDestinationIsTooFar".Translate(new object[]
                //{
                //    CompLaunchable.FuelNeededToLaunchAtDist((float)num).ToString("0.#")
                //}), MessageTypeDefOf.RejectInput);
                return(false);
            }
            MapParent mapParent = target.WorldObject as MapParent;

            if (mapParent != null && mapParent.HasMap)
            {
                Map myMap = this.parent.Map;
                Map map   = mapParent.Map;
                Current.Game.CurrentMap = map;
                Targeter arg_139_0 = Find.Targeter;

                void ActionWhenFinished()
                {
                    if (Find.Maps.Contains(myMap))
                    {
                        Current.Game.CurrentMap = myMap;
                    }
                }

                arg_139_0.BeginTargeting(TargetingParameters.ForDropPodsDestination(), delegate(LocalTargetInfo x)
                {
                    if (!this.LoadingInProgressOrReadyToLaunch)
                    {
                        Cthulhu.Utility.DebugReport("ChooseTarget Exited - LoadingInProgressOrReadyToLaunch");
                        return;
                    }
                    this.TryLaunch(x.ToGlobalTargetInfo(map), PawnsArrivalModeDefOf.EdgeDrop, false);
                }, null, ActionWhenFinished, CompLaunchablePawn.TargeterMouseAttachment);
                return(true);
            }
            if (target.WorldObject is Settlement && target.WorldObject.Faction != Faction.OfPlayer)
            {
                Find.WorldTargeter.closeWorldTabWhenFinished = false;
                List <FloatMenuOption> list = new List <FloatMenuOption>();
                if (!target.WorldObject.Faction.HostileTo(Faction.OfPlayer))
                {
                    list.Add(new FloatMenuOption("VisitFactionBase".Translate(
                                                     target.WorldObject.Label
                                                     ), delegate
                    {
                        if (!this.LoadingInProgressOrReadyToLaunch)
                        {
                            return;
                        }
                        this.TryLaunch(target, PawnsArrivalModeDefOf.EdgeDrop, false);
                        CameraJumper.TryHideWorld();
                    }, MenuOptionPriority.Default, null, null, 0f, null, null));
                }
                list.Add(new FloatMenuOption("DropAtEdge".Translate(), delegate
                {
                    if (!this.LoadingInProgressOrReadyToLaunch)
                    {
                        return;
                    }
                    this.TryLaunch(target, PawnsArrivalModeDefOf.EdgeDrop, true);
                    CameraJumper.TryHideWorld();
                }, MenuOptionPriority.Default, null, null, 0f, null, null));
                list.Add(new FloatMenuOption("DropInCenter".Translate(), delegate
                {
                    if (!this.LoadingInProgressOrReadyToLaunch)
                    {
                        return;
                    }
                    this.TryLaunch(target, PawnsArrivalModeDefOf.CenterDrop, true);
                    CameraJumper.TryHideWorld();
                }, MenuOptionPriority.Default, null, null, 0f, null, null));
                Find.WindowStack.Add(new FloatMenu(list));
                return(true);
            }
            else // if (Find.World.Impassable(target.Tile))
            {
                Messages.Message("MessageTransportPodsDestinationIsInvalid".Translate(), MessageTypeDefOf.RejectInput);
                return(false);
            }
            //this.TryLaunch(target, PawnsArrivalModeDefOf.Undecided, false);
            //return true;
        }