Example #1
0
        public static IEnumerable <Thing> MultiSelectableThingsInScreenRectDistinct(Rect rect)
        {
            CellRect mapRect = ThingSelectionUtility.GetMapRect(rect);

            ThingSelectionUtility.yieldedThings.Clear();
            try
            {
                foreach (IntVec3 c in mapRect)
                {
                    if (c.InBounds(Find.CurrentMap))
                    {
                        List <Thing> cellThings = Find.CurrentMap.thingGrid.ThingsListAt(c);
                        if (cellThings != null)
                        {
                            for (int i = 0; i < cellThings.Count; i++)
                            {
                                Thing t = cellThings[i];
                                if (ThingSelectionUtility.SelectableByMapClick(t) && !t.def.neverMultiSelect && !ThingSelectionUtility.yieldedThings.Contains(t))
                                {
                                    yield return(t);
                                }
                            }
                        }
                    }
                }
            }
            finally
            {
                base.< > __Finally0();
            }
        }
Example #2
0
        public static IEnumerable <Thing> MultiSelectableThingsInScreenRectDistinct(Rect rect)
        {
            CellRect mapRect = ThingSelectionUtility.GetMapRect(rect);

            ThingSelectionUtility.yieldedThings.Clear();
            foreach (IntVec3 item in mapRect)
            {
                if (item.InBounds(Find.VisibleMap))
                {
                    List <Thing> cellThings = Find.VisibleMap.thingGrid.ThingsListAt(item);
                    if (cellThings != null)
                    {
                        for (int i = 0; i < cellThings.Count; i++)
                        {
                            Thing t = cellThings[i];
                            if (ThingSelectionUtility.SelectableByMapClick(t) && !t.def.neverMultiSelect && !ThingSelectionUtility.yieldedThings.Contains(t))
                            {
                                yield return(t);

                                /*Error: Unable to find new state assignment for yield return*/;
                            }
                        }
                    }
                }
            }
            yield break;
IL_01a1:
            /*Error near IL_01a2: Unexpected return in MoveNext()*/;
        }
 public bool CanTarget(TargetInfo targ)
 {
     if (this.validator != null && !this.validator(targ))
     {
         return(false);
     }
     if (targ.Thing == null)
     {
         return(this.canTargetLocations);
     }
     if (this.neverTargetDoors && targ.Thing.def.IsDoor)
     {
         return(false);
     }
     if (this.onlyTargetDamagedThings && targ.Thing.HitPoints == targ.Thing.MaxHitPoints)
     {
         return(false);
     }
     if (this.onlyTargetFlammables && !targ.Thing.FlammableNow)
     {
         return(false);
     }
     if (this.mustBeSelectable && !ThingSelectionUtility.SelectableByMapClick(targ.Thing))
     {
         return(false);
     }
     if (this.targetSpecificThing != null && targ.Thing == this.targetSpecificThing)
     {
         return(true);
     }
     if (this.canTargetFires && targ.Thing.def == ThingDefOf.Fire)
     {
         return(true);
     }
     if (this.canTargetPawns && targ.Thing.def.category == ThingCategory.Pawn)
     {
         if (((Pawn)targ.Thing).Downed)
         {
             if (this.neverTargetIncapacitated)
             {
                 return(false);
             }
         }
         else if (this.onlyTargetIncapacitatedPawns)
         {
             return(false);
         }
         return(this.onlyTargetFactions == null || this.onlyTargetFactions.Contains(targ.Thing.Faction));
     }
     if (this.canTargetBuildings && targ.Thing.def.category == ThingCategory.Building)
     {
         return((!this.onlyTargetThingsAffectingRegions || targ.Thing.def.AffectsRegions) && (this.onlyTargetFactions == null || this.onlyTargetFactions.Contains(targ.Thing.Faction)));
     }
     return(this.canTargetItems && (!this.mapObjectTargetsMustBeAutoAttackable || targ.Thing.def.isAutoAttackableMapObject));
 }
Example #4
0
        public static IEnumerable <object> SelectableObjectsAt(IntVec3 c, Map map)
        {
            List <Thing> thingList = c.GetThingList(map);

            for (int i = 0; i < thingList.Count; i++)
            {
                Thing t = thingList[i];
                if (ThingSelectionUtility.SelectableByMapClick(t))
                {
                    yield return(t);
                }
            }
            Zone z = map.zoneManager.ZoneAt(c);

            if (z != null)
            {
                yield return(z);
            }
        }
Example #5
0
        public static IEnumerable <object> SelectableObjectsAt(IntVec3 c, Map map)
        {
            List <Thing> thingList = c.GetThingList(map);

            for (int i = 0; i < thingList.Count; i++)
            {
                Thing t = thingList[i];
                if (ThingSelectionUtility.SelectableByMapClick(t))
                {
                    yield return((object)t);

                    /*Error: Unable to find new state assignment for yield return*/;
                }
            }
            Zone z = map.zoneManager.ZoneAt(c);

            if (z != null)
            {
                yield return((object)z);

                /*Error: Unable to find new state assignment for yield return*/;
            }
        }
Example #6
0
 public bool CanTarget(TargetInfo targ)
 {
     if (validator != null && !validator(targ))
     {
         return(false);
     }
     if (targ.Thing == null)
     {
         return(canTargetLocations);
     }
     if (neverTargetDoors && targ.Thing.def.IsDoor)
     {
         return(false);
     }
     if (onlyTargetDamagedThings && targ.Thing.HitPoints == targ.Thing.MaxHitPoints)
     {
         return(false);
     }
     if (onlyTargetFlammables && !targ.Thing.FlammableNow)
     {
         return(false);
     }
     if (mustBeSelectable && !ThingSelectionUtility.SelectableByMapClick(targ.Thing))
     {
         return(false);
     }
     if (targetSpecificThing != null && targ.Thing == targetSpecificThing)
     {
         return(true);
     }
     if (canTargetFires && targ.Thing.def == ThingDefOf.Fire)
     {
         return(true);
     }
     if (canTargetPawns && targ.Thing.def.category == ThingCategory.Pawn)
     {
         Pawn pawn = (Pawn)targ.Thing;
         if (pawn.Downed)
         {
             if (neverTargetIncapacitated)
             {
                 return(false);
             }
         }
         else if (onlyTargetIncapacitatedPawns)
         {
             return(false);
         }
         if (onlyTargetFactions != null && !onlyTargetFactions.Contains(targ.Thing.Faction))
         {
             return(false);
         }
         if (pawn.NonHumanlikeOrWildMan())
         {
             if (pawn.Faction == Faction.OfMechanoids)
             {
                 if (!canTargetMechs)
                 {
                     return(false);
                 }
             }
             else if (!canTargetAnimals)
             {
                 return(false);
             }
         }
         if (!pawn.NonHumanlikeOrWildMan() && !canTargetHumans)
         {
             return(false);
         }
         if (onlyTargetControlledPawns && !pawn.IsColonistPlayerControlled)
         {
             return(false);
         }
         if (onlyTargetColonists && (!pawn.IsColonist || pawn.HostFaction != null))
         {
             return(false);
         }
         if (onlyTargetPrisonersOfColony && !pawn.IsPrisonerOfColony)
         {
             return(false);
         }
         if (onlyTargetPsychicSensitive && pawn.GetStatValue(StatDefOf.PsychicSensitivity) <= 0f)
         {
             return(false);
         }
         if (neverTargetHostileFaction && !pawn.IsPrisonerOfColony)
         {
             Faction factionOrExtraMiniOrHomeFaction = pawn.FactionOrExtraMiniOrHomeFaction;
             if (factionOrExtraMiniOrHomeFaction != null && factionOrExtraMiniOrHomeFaction.HostileTo(Faction.OfPlayer))
             {
                 return(false);
             }
         }
         return(true);
     }
     if (canTargetBuildings && targ.Thing.def.category == ThingCategory.Building)
     {
         if (onlyTargetThingsAffectingRegions && !targ.Thing.def.AffectsRegions)
         {
             return(false);
         }
         if (onlyTargetFactions != null && !onlyTargetFactions.Contains(targ.Thing.Faction))
         {
             return(false);
         }
         return(true);
     }
     if (canTargetItems)
     {
         if (mapObjectTargetsMustBeAutoAttackable && !targ.Thing.def.isAutoAttackableMapObject)
         {
             return(false);
         }
         if (thingCategory == ThingCategory.None || thingCategory == targ.Thing.def.category)
         {
             return(true);
         }
     }
     return(false);
 }