コード例 #1
0
            internal bool <> m__0(Region x)
            {
                FacilitiesUtility.visited.Add(x);
                List <Thing> list = x.ListerThings.ThingsInGroup(ThingRequestGroup.BuildingArtificial);

                for (int i = 0; i < list.Count; i++)
                {
                    if (!FacilitiesUtility.processed.Contains(list[i]))
                    {
                        FacilitiesUtility.processed.Add(list[i]);
                        CompFacility             compFacility             = list[i].TryGetComp <CompFacility>();
                        CompAffectedByFacilities compAffectedByFacilities = list[i].TryGetComp <CompAffectedByFacilities>();
                        if (compFacility != null)
                        {
                            compFacility.Notify_LOSBlockerSpawnedOrDespawned();
                            this.facilitiesProcessed++;
                        }
                        if (compAffectedByFacilities != null)
                        {
                            compAffectedByFacilities.Notify_LOSBlockerSpawnedOrDespawned();
                            this.affectedByFacilitiesProcessed++;
                        }
                    }
                }
                return(this.facilitiesProcessed >= this.facilitiesToProcess && this.affectedByFacilitiesProcessed >= this.affectedByFacilitiesToProcess);
            }
コード例 #2
0
        public bool CanPotentiallyLinkTo(ThingDef facilityDef, IntVec3 facilityPos, Rot4 facilityRot)
        {
            if (!CompAffectedByFacilities.CanPotentiallyLinkTo_Static(facilityDef, facilityPos, facilityRot, this.parent.def, this.parent.Position, this.parent.Rotation))
            {
                return(false);
            }
            if (!this.IsPotentiallyValidFacilityForMe(facilityDef, facilityPos, facilityRot))
            {
                return(false);
            }
            int  num  = 0;
            bool flag = false;

            for (int i = 0; i < this.linkedFacilities.Count; i++)
            {
                if (this.linkedFacilities[i].def == facilityDef)
                {
                    num++;
                    if (this.IsBetter(facilityDef, facilityPos, facilityRot, this.linkedFacilities[i]))
                    {
                        flag = true;
                        break;
                    }
                }
            }
            if (flag)
            {
                return(true);
            }
            CompProperties_Facility compProperties = facilityDef.GetCompProperties <CompProperties_Facility>();

            return(num + 1 <= compProperties.maxSimultaneous);
        }
コード例 #3
0
        private void FacilityChanged()
        {
            CompFacility             compFacility             = this.TryGetComp <CompFacility>();
            CompAffectedByFacilities compAffectedByFacilities = this.TryGetComp <CompAffectedByFacilities>();

            compFacility?.Notify_ThingChanged();
            compAffectedByFacilities?.Notify_ThingChanged();
        }
コード例 #4
0
 public bool IsValidFacilityForMe(Thing facility)
 {
     if (!CompAffectedByFacilities.IsPotentiallyValidFacilityForMe_Static(facility, base.parent.def, base.parent.Position, base.parent.Rotation))
     {
         return(false);
     }
     return(true);
 }
コード例 #5
0
            public bool MoveNext()
            {
                uint num = (uint)this.$PC;

                this.$PC = -1;
                bool flag = false;

                switch (num)
                {
                case 0u:
                    if (!this.parent.Spawned)
                    {
                        return(false);
                    }
                    potentialThings = CompAffectedByFacilities.PotentialThingsToLinkTo(this.parent.def, this.parent.Position, this.parent.Rotation, this.parent.Map);
                    enumerator      = potentialThings.GetEnumerator();
                    num             = 4294967293u;
                    break;

                case 1u:
                    break;

                default:
                    return(false);
                }
                try
                {
                    switch (num)
                    {
                    }
                    while (enumerator.MoveNext())
                    {
                        th = enumerator.Current;
                        if (base.CanLinkTo(th))
                        {
                            this.$current = th;
                            if (!this.$disposing)
                            {
                                this.$PC = 1;
                            }
                            flag = true;
                            return(true);
                        }
                    }
                }
                finally
                {
                    if (!flag)
                    {
                        if (enumerator != null)
                        {
                            enumerator.Dispose();
                        }
                    }
                }
                this.$PC = -1;
                return(false);
            }
コード例 #6
0
        public static void DrawLinesToPotentialThingsToLinkTo(ThingDef myDef, IntVec3 myPos, Rot4 myRot, Map map)
        {
            Vector3 a = Gen.TrueCenter(myPos, myRot, myDef.size, myDef.Altitude);

            foreach (Thing item in CompAffectedByFacilities.PotentialThingsToLinkTo(myDef, myPos, myRot, map))
            {
                GenDraw.DrawLineBetween(a, item.TrueCenter());
            }
        }
コード例 #7
0
        public static IEnumerable <Thing> PotentialThingsToLinkTo(ThingDef myDef, IntVec3 myPos, Rot4 myRot, Map map)
        {
            _003CPotentialThingsToLinkTo_003Ec__Iterator1 _003CPotentialThingsToLinkTo_003Ec__Iterator = (_003CPotentialThingsToLinkTo_003Ec__Iterator1) /*Error near IL_0034: stateMachine*/;

            CompAffectedByFacilities.alreadyReturnedCount.Clear();
            CompProperties_AffectedByFacilities myProps = myDef.GetCompProperties <CompProperties_AffectedByFacilities>();

            if (myProps.linkableFacilities != null)
            {
                IEnumerable <Thing> candidates = Enumerable.Empty <Thing>();
                for (int i = 0; i < myProps.linkableFacilities.Count; i++)
                {
                    candidates = candidates.Concat(map.listerThings.ThingsOfDef(myProps.linkableFacilities[i]));
                }
                Vector3 myTrueCenter = Gen.TrueCenter(myPos, myRot, myDef.size, myDef.Altitude);
                IOrderedEnumerable <Thing> sortedCandidates = (from x in candidates
                                                               orderby Vector3.Distance(myTrueCenter, x.TrueCenter())
                                                               select x).ThenBy(delegate(Thing x)
                {
                    IntVec3 position2 = x.Position;
                    return(position2.x);
                }).ThenBy(delegate(Thing x)
                {
                    IntVec3 position = x.Position;
                    return(position.z);
                });
                foreach (Thing item in sortedCandidates)
                {
                    if (CompAffectedByFacilities.CanPotentiallyLinkTo_Static(item, myDef, myPos, myRot))
                    {
                        CompProperties_Facility facilityProps = item.def.GetCompProperties <CompProperties_Facility>();
                        if (CompAffectedByFacilities.alreadyReturnedCount.ContainsKey(item.def))
                        {
                            if (CompAffectedByFacilities.alreadyReturnedCount[item.def] < facilityProps.maxSimultaneous)
                            {
                                goto IL_0232;
                            }
                            continue;
                        }
                        CompAffectedByFacilities.alreadyReturnedCount.Add(item.def, 0);
                        goto IL_0232;
                    }
                    continue;
IL_0232:
                    Dictionary <ThingDef, int> dictionary;
                    ThingDef def;
                    (dictionary = CompAffectedByFacilities.alreadyReturnedCount)[def = item.def] = dictionary[def] + 1;
                    yield return(item);

                    /*Error: Unable to find new state assignment for yield return*/;
                }
            }
            yield break;
IL_02b1:
            /*Error near IL_02b2: Unexpected return in MoveNext()*/;
        }
コード例 #8
0
ファイル: CompFacility.cs プロジェクト: potsh/RimWorld
 private bool AmIActiveForAnyone()
 {
     for (int i = 0; i < linkedBuildings.Count; i++)
     {
         CompAffectedByFacilities compAffectedByFacilities = linkedBuildings[i].TryGetComp <CompAffectedByFacilities>();
         if (compAffectedByFacilities.IsFacilityActive(parent))
         {
             return(true);
         }
     }
     return(false);
 }
コード例 #9
0
 public static bool CanPotentiallyLinkTo_Static(Thing facility, ThingDef myDef, IntVec3 myPos, Rot4 myRot)
 {
     if (!CompAffectedByFacilities.CanPotentiallyLinkTo_Static(facility.def, facility.Position, facility.Rotation, myDef, myPos, myRot))
     {
         return(false);
     }
     if (!CompAffectedByFacilities.IsPotentiallyValidFacilityForMe_Static(facility, myDef, myPos, myRot))
     {
         return(false);
     }
     return(true);
 }
        public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot, Color ghostCol, Thing thing = null)
        {
            Map currentMap = Find.CurrentMap;

            if (def.HasComp(typeof(CompAffectedByFacilities)))
            {
                CompAffectedByFacilities.DrawLinesToPotentialThingsToLinkTo(def, center, rot, currentMap);
            }
            else
            {
                CompFacility.DrawLinesToPotentialThingsToLinkTo(def, center, rot, currentMap);
            }
        }
コード例 #11
0
        public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot)
        {
            Map visibleMap = Find.VisibleMap;

            if (def.HasComp(typeof(CompAffectedByFacilities)))
            {
                CompAffectedByFacilities.DrawLinesToPotentialThingsToLinkTo(def, center, rot, visibleMap);
            }
            else
            {
                CompFacility.DrawLinesToPotentialThingsToLinkTo(def, center, rot, visibleMap);
            }
        }
コード例 #12
0
        private void FacilityChanged()
        {
            CompFacility             compFacility             = this.TryGetComp <CompFacility>();
            CompAffectedByFacilities compAffectedByFacilities = this.TryGetComp <CompAffectedByFacilities>();

            if (compFacility != null)
            {
                compFacility.Notify_ThingChanged();
            }
            if (compAffectedByFacilities != null)
            {
                compAffectedByFacilities.Notify_ThingChanged();
            }
        }
コード例 #13
0
        private float DrawResearchBenchRequirements(ResearchProjectDef project, Rect rect)
        {
            float xMin = rect.xMin;
            float yMin = rect.yMin;

            if (project.requiredResearchBuilding != null)
            {
                bool       present = false;
                List <Map> maps    = Find.Maps;
                for (int i = 0; i < maps.Count; i++)
                {
                    if (maps[i].listerBuildings.allBuildingsColonist.Find((Building x) => x.def == project.requiredResearchBuilding) != null)
                    {
                        present = true;
                        break;
                    }
                }
                Widgets.LabelCacheHeight(ref rect, "RequiredResearchBench".Translate() + ":");
                rect.xMin += 6f;
                rect.yMin += rect.height;
                SetPrerequisiteStatusColor(present, project);
                rect.height = Text.CalcHeight(project.requiredResearchBuilding.LabelCap, rect.width - 24f - 6f);
                Widgets.HyperlinkWithIcon(rect, new Dialog_InfoCard.Hyperlink(project.requiredResearchBuilding));
                rect.yMin += rect.height + 4f;
                GUI.color  = Color.white;
                rect.xMin  = xMin;
            }
            if (!project.requiredResearchFacilities.NullOrEmpty())
            {
                Widgets.LabelCacheHeight(ref rect, "RequiredResearchBenchFacilities".Translate() + ":");
                rect.yMin += rect.height;
                Building_ResearchBench   building_ResearchBench = FindBenchFulfillingMostRequirements(project.requiredResearchBuilding, project.requiredResearchFacilities);
                CompAffectedByFacilities bestMatchingBench      = null;
                if (building_ResearchBench != null)
                {
                    bestMatchingBench = building_ResearchBench.TryGetComp <CompAffectedByFacilities>();
                }
                rect.xMin += 6f;
                for (int j = 0; j < project.requiredResearchFacilities.Count; j++)
                {
                    DrawResearchBenchFacilityRequirement(project.requiredResearchFacilities[j], bestMatchingBench, project, ref rect);
                    rect.yMin += rect.height;
                }
                rect.yMin += 4f;
            }
            GUI.color = Color.white;
            rect.xMin = xMin;
            return(rect.yMin - yMin);
        }
コード例 #14
0
ファイル: CompFacility.cs プロジェクト: potsh/RimWorld
 public override void PostDrawExtraSelectionOverlays()
 {
     for (int i = 0; i < linkedBuildings.Count; i++)
     {
         CompAffectedByFacilities compAffectedByFacilities = linkedBuildings[i].TryGetComp <CompAffectedByFacilities>();
         if (compAffectedByFacilities.IsFacilityActive(parent))
         {
             GenDraw.DrawLineBetween(parent.TrueCenter(), linkedBuildings[i].TrueCenter());
         }
         else
         {
             GenDraw.DrawLineBetween(parent.TrueCenter(), linkedBuildings[i].TrueCenter(), CompAffectedByFacilities.InactiveFacilityLineMat);
         }
     }
 }
コード例 #15
0
 public static void NotifyFacilitiesAboutChangedLOSBlockers(List <Region> affectedRegions)
 {
     if (FacilitiesUtility.working)
     {
         Log.Warning("Tried to update facilities while already updating.");
     }
     else
     {
         FacilitiesUtility.working = true;
         try
         {
             FacilitiesUtility.visited.Clear();
             for (int i = 0; i < affectedRegions.Count; i++)
             {
                 if (!FacilitiesUtility.visited.Contains(affectedRegions[i]))
                 {
                     RegionTraverser.BreadthFirstTraverse(affectedRegions[i], (Region from, Region r) => !FacilitiesUtility.visited.Contains(r), delegate(Region x)
                     {
                         FacilitiesUtility.visited.Add(x);
                         List <Thing> list = x.ListerThings.ThingsInGroup(ThingRequestGroup.BuildingArtificial);
                         for (int j = 0; j < list.Count; j++)
                         {
                             CompFacility compFacility = list[j].TryGetComp <CompFacility>();
                             CompAffectedByFacilities compAffectedByFacilities = list[j].TryGetComp <CompAffectedByFacilities>();
                             if (compFacility != null)
                             {
                                 compFacility.Notify_LOSBlockerSpawnedOrDespawned();
                             }
                             if (compAffectedByFacilities != null)
                             {
                                 compAffectedByFacilities.Notify_LOSBlockerSpawnedOrDespawned();
                             }
                         }
                         return(false);
                     }, FacilitiesUtility.RegionsToSearch, RegionType.Set_Passable);
                 }
             }
         }
         finally
         {
             FacilitiesUtility.working = false;
             FacilitiesUtility.visited.Clear();
         }
     }
 }
コード例 #16
0
        private float DrawResearchBenchRequirements(ResearchProjectDef project, Rect rect)
        {
            float yMin = rect.yMin;

            if (project.requiredResearchBuilding != null)
            {
                bool       present = false;
                List <Map> maps    = Find.Maps;
                int        num     = 0;
                while (num < maps.Count)
                {
                    if (maps[num].listerBuildings.allBuildingsColonist.Find((Building x) => x.def == project.requiredResearchBuilding) == null)
                    {
                        num++;
                        continue;
                    }
                    present = true;
                    break;
                }
                Widgets.LabelCacheHeight(ref rect, "RequiredResearchBench".Translate() + ":", true, false);
                rect.yMin += rect.height;
                this.SetPrerequisiteStatusColor(present, project);
                Widgets.LabelCacheHeight(ref rect, "  " + project.requiredResearchBuilding.LabelCap, true, false);
                rect.yMin += rect.height;
                GUI.color  = Color.white;
            }
            if (!project.requiredResearchFacilities.NullOrEmpty())
            {
                Widgets.LabelCacheHeight(ref rect, "RequiredResearchBenchFacilities".Translate() + ":", true, false);
                rect.yMin += rect.height;
                Building_ResearchBench   building_ResearchBench = this.FindBenchFulfillingMostRequirements(project.requiredResearchBuilding, project.requiredResearchFacilities);
                CompAffectedByFacilities bestMatchingBench      = null;
                if (building_ResearchBench != null)
                {
                    bestMatchingBench = building_ResearchBench.TryGetComp <CompAffectedByFacilities>();
                }
                for (int i = 0; i < project.requiredResearchFacilities.Count; i++)
                {
                    this.DrawResearchBenchFacilityRequirement(project.requiredResearchFacilities[i], bestMatchingBench, project, ref rect);
                    rect.yMin += 15f;
                }
            }
            GUI.color = Color.white;
            return(rect.yMin - yMin);
        }
コード例 #17
0
        private bool IsPotentiallyValidFacilityForMe(ThingDef facilityDef, IntVec3 facilityPos, Rot4 facilityRot)
        {
            if (!CompAffectedByFacilities.IsPotentiallyValidFacilityForMe_Static(facilityDef, facilityPos, facilityRot, this.parent.def, this.parent.Position, this.parent.Rotation, this.parent.Map))
            {
                return(false);
            }
            CompProperties_Facility compProperties = facilityDef.GetCompProperties <CompProperties_Facility>();

            if (compProperties.canLinkToMedBedsOnly)
            {
                Building_Bed building_Bed = this.parent as Building_Bed;
                if (building_Bed == null || !building_Bed.Medical)
                {
                    return(false);
                }
            }
            return(true);
        }
コード例 #18
0
ファイル: CompFacility.cs プロジェクト: potsh/RimWorld
        public static void DrawLinesToPotentialThingsToLinkTo(ThingDef myDef, IntVec3 myPos, Rot4 myRot, Map map)
        {
            CompProperties_Facility compProperties = myDef.GetCompProperties <CompProperties_Facility>();
            Vector3 a = GenThing.TrueCenter(myPos, myRot, myDef.size, myDef.Altitude);

            for (int i = 0; i < compProperties.linkableBuildings.Count; i++)
            {
                foreach (Thing item in map.listerThings.ThingsOfDef(compProperties.linkableBuildings[i]))
                {
                    CompAffectedByFacilities compAffectedByFacilities = item.TryGetComp <CompAffectedByFacilities>();
                    if (compAffectedByFacilities != null && compAffectedByFacilities.CanPotentiallyLinkTo(myDef, myPos, myRot))
                    {
                        GenDraw.DrawLineBetween(a, item.TrueCenter());
                        compAffectedByFacilities.DrawRedLineToPotentiallySupplantedFacility(myDef, myPos, myRot);
                    }
                }
            }
        }
コード例 #19
0
        public static IEnumerable <Thing> PotentialThingsToLinkTo(ThingDef myDef, IntVec3 myPos, Rot4 myRot, Map map)
        {
            CompAffectedByFacilities.alreadyReturnedCount.Clear();
            CompProperties_AffectedByFacilities myProps = myDef.GetCompProperties <CompProperties_AffectedByFacilities>();

            if (myProps.linkableFacilities == null)
            {
                yield break;
            }
            IEnumerable <Thing> candidates = Enumerable.Empty <Thing>();

            for (int i = 0; i < myProps.linkableFacilities.Count; i++)
            {
                candidates = candidates.Concat(map.listerThings.ThingsOfDef(myProps.linkableFacilities[i]));
            }
            Vector3 myTrueCenter = GenThing.TrueCenter(myPos, myRot, myDef.size, myDef.Altitude);
            IOrderedEnumerable <Thing> sortedCandidates = from x in candidates
                                                          orderby Vector3.Distance(myTrueCenter, x.TrueCenter()), x.Position.x, x.Position.z
            select x;

            foreach (Thing th in sortedCandidates)
            {
                if (CompAffectedByFacilities.CanPotentiallyLinkTo_Static(th, myDef, myPos, myRot))
                {
                    CompProperties_Facility facilityProps = th.def.GetCompProperties <CompProperties_Facility>();
                    if (CompAffectedByFacilities.alreadyReturnedCount.ContainsKey(th.def))
                    {
                        if (CompAffectedByFacilities.alreadyReturnedCount[th.def] >= facilityProps.maxSimultaneous)
                        {
                            continue;
                        }
                    }
                    else
                    {
                        CompAffectedByFacilities.alreadyReturnedCount.Add(th.def, 0);
                    }
                    Dictionary <ThingDef, int> dictionary;
                    ThingDef def;
                    (dictionary = CompAffectedByFacilities.alreadyReturnedCount)[def = th.def] = dictionary[def] + 1;
                    yield return(th);
                }
            }
            yield break;
        }
コード例 #20
0
        private void DrawResearchBenchFacilityRequirement(ThingDef requiredFacility, CompAffectedByFacilities bestMatchingBench, ResearchProjectDef project, ref Rect rect)
        {
            Thing thing  = null;
            Thing thing2 = null;

            if (bestMatchingBench != null)
            {
                thing  = bestMatchingBench.LinkedFacilitiesListForReading.Find((Thing x) => x.def == requiredFacility);
                thing2 = bestMatchingBench.LinkedFacilitiesListForReading.Find((Thing x) => x.def == requiredFacility && bestMatchingBench.IsFacilityActive(x));
            }
            SetPrerequisiteStatusColor(thing2 != null, project);
            string text = requiredFacility.LabelCap;

            if (thing != null && thing2 == null)
            {
                text = text + " (" + "InactiveFacility".Translate() + ")";
            }
            Widgets.LabelCacheHeight(ref rect, "  " + text);
        }
コード例 #21
0
        private void DrawResearchBenchFacilityRequirement(ThingDef requiredFacility, CompAffectedByFacilities bestMatchingBench, ResearchProjectDef project, ref Rect rect)
        {
            Thing thing  = null;
            Thing thing2 = null;

            if (bestMatchingBench != null)
            {
                thing  = bestMatchingBench.LinkedFacilitiesListForReading.Find((Thing x) => x.def == requiredFacility);
                thing2 = bestMatchingBench.LinkedFacilitiesListForReading.Find((Thing x) => x.def == requiredFacility && bestMatchingBench.IsFacilityActive(x));
            }
            SetPrerequisiteStatusColor(thing2 != null, project);
            string text = requiredFacility.LabelCap;

            if (thing != null && thing2 == null)
            {
                text += " (" + "InactiveFacility".Translate() + ")";
            }
            rect.height = Text.CalcHeight(text, rect.width - 24f - 6f);
            Widgets.HyperlinkWithIcon(rect, new Dialog_InfoCard.Hyperlink(requiredFacility), text);
        }
コード例 #22
0
ファイル: CompFacility.cs プロジェクト: potsh/RimWorld
        private void LinkToNearbyBuildings()
        {
            UnlinkAll();
            CompProperties_Facility props = Props;

            if (props.linkableBuildings != null)
            {
                for (int i = 0; i < props.linkableBuildings.Count; i++)
                {
                    foreach (Thing item in parent.Map.listerThings.ThingsOfDef(props.linkableBuildings[i]))
                    {
                        CompAffectedByFacilities compAffectedByFacilities = item.TryGetComp <CompAffectedByFacilities>();
                        if (compAffectedByFacilities != null && compAffectedByFacilities.CanLinkTo(parent))
                        {
                            linkedBuildings.Add(item);
                            compAffectedByFacilities.Notify_NewLink(parent);
                        }
                    }
                }
            }
        }
コード例 #23
0
        private void LinkToNearbyBuildings()
        {
            this.UnlinkAll();
            CompProperties_Facility props = this.Props;

            if (props.linkableBuildings == null)
            {
                return;
            }
            for (int i = 0; i < props.linkableBuildings.Count; i++)
            {
                foreach (Thing current in this.parent.Map.listerThings.ThingsOfDef(props.linkableBuildings[i]))
                {
                    CompAffectedByFacilities compAffectedByFacilities = current.TryGetComp <CompAffectedByFacilities>();
                    if (compAffectedByFacilities != null && compAffectedByFacilities.CanLinkTo(this.parent))
                    {
                        this.linkedBuildings.Add(current);
                        compAffectedByFacilities.Notify_NewLink(this.parent);
                    }
                }
            }
        }
コード例 #24
0
        private float GetResearchBenchRequirementsScore(Building_ResearchBench bench, List <ThingDef> requiredFacilities)
        {
            float num = 0f;

            for (int i = 0; i < requiredFacilities.Count; i++)
            {
                CompAffectedByFacilities benchComp = bench.GetComp <CompAffectedByFacilities>();
                if (benchComp != null)
                {
                    List <Thing> linkedFacilitiesListForReading = benchComp.LinkedFacilitiesListForReading;
                    if (linkedFacilitiesListForReading.Find((Thing x) => x.def == requiredFacilities[i] && benchComp.IsFacilityActive(x)) != null)
                    {
                        num += 1f;
                    }
                    else if (linkedFacilitiesListForReading.Find((Thing x) => x.def == requiredFacilities[i]) != null)
                    {
                        num += 0.6f;
                    }
                }
            }
            return(num);
        }
コード例 #25
0
        public virtual float GetValueUnfinalized(StatRequest req, bool applyPostProcess = true)
        {
            if (!stat.supressDisabledError && Prefs.DevMode && IsDisabledFor(req.Thing))
            {
                Log.ErrorOnce($"Attempted to calculate value for disabled stat {stat}; this is meant as a consistency check, either set the stat to neverDisabled or ensure this pawn cannot accidentally use this stat (thing={req.Thing.ToStringSafe()})", 75193282 + stat.index);
            }
            float num  = GetBaseValueFor(req);
            Pawn  pawn = req.Thing as Pawn;

            if (pawn != null)
            {
                if (pawn.skills != null)
                {
                    if (stat.skillNeedOffsets != null)
                    {
                        for (int i = 0; i < stat.skillNeedOffsets.Count; i++)
                        {
                            num += stat.skillNeedOffsets[i].ValueFor(pawn);
                        }
                    }
                }
                else
                {
                    num += stat.noSkillOffset;
                }
                if (stat.capacityOffsets != null)
                {
                    for (int j = 0; j < stat.capacityOffsets.Count; j++)
                    {
                        PawnCapacityOffset pawnCapacityOffset = stat.capacityOffsets[j];
                        num += pawnCapacityOffset.GetOffset(pawn.health.capacities.GetLevel(pawnCapacityOffset.capacity));
                    }
                }
                if (pawn.story != null)
                {
                    for (int k = 0; k < pawn.story.traits.allTraits.Count; k++)
                    {
                        num += pawn.story.traits.allTraits[k].OffsetOfStat(stat);
                    }
                }
                List <Hediff> hediffs = pawn.health.hediffSet.hediffs;
                for (int l = 0; l < hediffs.Count; l++)
                {
                    HediffStage curStage = hediffs[l].CurStage;
                    if (curStage != null)
                    {
                        float num2 = curStage.statOffsets.GetStatOffsetFromList(stat);
                        if (num2 != 0f && curStage.statOffsetEffectMultiplier != null)
                        {
                            num2 *= pawn.GetStatValue(curStage.statOffsetEffectMultiplier);
                        }
                        num += num2;
                    }
                }
                if (pawn.apparel != null)
                {
                    for (int m = 0; m < pawn.apparel.WornApparel.Count; m++)
                    {
                        num += StatOffsetFromGear(pawn.apparel.WornApparel[m], stat);
                    }
                }
                if (pawn.equipment != null && pawn.equipment.Primary != null)
                {
                    num += StatOffsetFromGear(pawn.equipment.Primary, stat);
                }
                if (pawn.story != null)
                {
                    for (int n = 0; n < pawn.story.traits.allTraits.Count; n++)
                    {
                        num *= pawn.story.traits.allTraits[n].MultiplierOfStat(stat);
                    }
                }
                for (int num3 = 0; num3 < hediffs.Count; num3++)
                {
                    HediffStage curStage2 = hediffs[num3].CurStage;
                    if (curStage2 != null)
                    {
                        float num4 = curStage2.statFactors.GetStatFactorFromList(stat);
                        if (Math.Abs(num4 - 1f) > float.Epsilon && curStage2.statFactorEffectMultiplier != null)
                        {
                            num4 = ScaleFactor(num4, pawn.GetStatValue(curStage2.statFactorEffectMultiplier));
                        }
                        num *= num4;
                    }
                }
                num *= pawn.ageTracker.CurLifeStage.statFactors.GetStatFactorFromList(stat);
            }
            if (req.StuffDef != null)
            {
                if (num > 0f || stat.applyFactorsIfNegative)
                {
                    num *= req.StuffDef.stuffProps.statFactors.GetStatFactorFromList(stat);
                }
                num += req.StuffDef.stuffProps.statOffsets.GetStatOffsetFromList(stat);
            }
            if (req.ForAbility && stat.statFactors != null)
            {
                for (int num5 = 0; num5 < stat.statFactors.Count; num5++)
                {
                    num *= req.AbilityDef.statBases.GetStatValueFromList(stat.statFactors[num5], 1f);
                }
            }
            if (req.HasThing)
            {
                CompAffectedByFacilities compAffectedByFacilities = req.Thing.TryGetComp <CompAffectedByFacilities>();
                if (compAffectedByFacilities != null)
                {
                    num += compAffectedByFacilities.GetStatOffset(stat);
                }
                if (stat.statFactors != null)
                {
                    for (int num6 = 0; num6 < stat.statFactors.Count; num6++)
                    {
                        num *= req.Thing.GetStatValue(stat.statFactors[num6]);
                    }
                }
                if (pawn != null)
                {
                    if (pawn.skills != null)
                    {
                        if (stat.skillNeedFactors != null)
                        {
                            for (int num7 = 0; num7 < stat.skillNeedFactors.Count; num7++)
                            {
                                num *= stat.skillNeedFactors[num7].ValueFor(pawn);
                            }
                        }
                    }
                    else
                    {
                        num *= stat.noSkillFactor;
                    }
                    if (stat.capacityFactors != null)
                    {
                        for (int num8 = 0; num8 < stat.capacityFactors.Count; num8++)
                        {
                            PawnCapacityFactor pawnCapacityFactor = stat.capacityFactors[num8];
                            float factor = pawnCapacityFactor.GetFactor(pawn.health.capacities.GetLevel(pawnCapacityFactor.capacity));
                            num = Mathf.Lerp(num, num * factor, pawnCapacityFactor.weight);
                        }
                    }
                    if (pawn.Inspired)
                    {
                        num += pawn.InspirationDef.statOffsets.GetStatOffsetFromList(stat);
                        num *= pawn.InspirationDef.statFactors.GetStatFactorFromList(stat);
                    }
                }
            }
            return(num);
        }
コード例 #26
0
 private static bool IsPotentiallyValidFacilityForMe_Static(Thing facility, ThingDef myDef, IntVec3 myPos, Rot4 myRot)
 {
     return(CompAffectedByFacilities.IsPotentiallyValidFacilityForMe_Static(facility.def, facility.Position, facility.Rotation, myDef, myPos, myRot, facility.Map));
 }
コード例 #27
0
        public virtual string GetExplanationUnfinalized(StatRequest req, ToStringNumberSense numberSense)
        {
            StringBuilder stringBuilder = new StringBuilder();
            float         baseValueFor  = this.GetBaseValueFor(req.Def);

            if (baseValueFor != 0f)
            {
                stringBuilder.AppendLine("StatsReport_BaseValue".Translate() + ": " + this.stat.ValueToString(baseValueFor, numberSense));
                stringBuilder.AppendLine();
            }
            Pawn pawn = req.Thing as Pawn;

            if (pawn != null)
            {
                if (pawn.skills != null)
                {
                    if (this.stat.skillNeedOffsets != null)
                    {
                        stringBuilder.AppendLine("StatsReport_Skills".Translate());
                        for (int i = 0; i < this.stat.skillNeedOffsets.Count; i++)
                        {
                            SkillNeed skillNeed = this.stat.skillNeedOffsets[i];
                            int       level     = pawn.skills.GetSkill(skillNeed.skill).Level;
                            float     val       = skillNeed.ValueFor(pawn);
                            stringBuilder.AppendLine(string.Concat(new object[]
                            {
                                "    ",
                                skillNeed.skill.LabelCap,
                                " (",
                                level,
                                "): ",
                                val.ToStringSign(),
                                this.ValueToString(val, false, ToStringNumberSense.Absolute)
                            }));
                        }
                        stringBuilder.AppendLine();
                    }
                }
                else if (this.stat.noSkillOffset != 0f)
                {
                    stringBuilder.AppendLine("StatsReport_Skills".Translate());
                    stringBuilder.AppendLine(string.Concat(new string[]
                    {
                        "    ",
                        "default".Translate().CapitalizeFirst(),
                        " : ",
                        this.stat.noSkillOffset.ToStringSign(),
                        this.ValueToString(this.stat.noSkillOffset, false, ToStringNumberSense.Absolute)
                    }));
                    stringBuilder.AppendLine();
                }
                if (this.stat.capacityOffsets != null)
                {
                    stringBuilder.AppendLine((!"StatsReport_Health".CanTranslate()) ? "StatsReport_HealthFactors".Translate() : "StatsReport_Health".Translate());
                    foreach (PawnCapacityOffset current in from hfa in this.stat.capacityOffsets
                             orderby hfa.capacity.listOrder
                             select hfa)
                    {
                        string text   = current.capacity.GetLabelFor(pawn).CapitalizeFirst();
                        float  level2 = pawn.health.capacities.GetLevel(current.capacity);
                        float  offset = current.GetOffset(pawn.health.capacities.GetLevel(current.capacity));
                        string text2  = this.ValueToString(offset, false, ToStringNumberSense.Absolute);
                        string text3  = Mathf.Min(level2, current.max).ToStringPercent() + ", " + "HealthOffsetScale".Translate(new object[]
                        {
                            current.scale.ToString() + "x"
                        });
                        if (current.max < 999f)
                        {
                            text3 = text3 + ", " + "HealthFactorMaxImpact".Translate(new object[]
                            {
                                current.max.ToStringPercent()
                            });
                        }
                        stringBuilder.AppendLine(string.Concat(new string[]
                        {
                            "    ",
                            text,
                            ": ",
                            offset.ToStringSign(),
                            text2,
                            " (",
                            text3,
                            ")"
                        }));
                    }
                    stringBuilder.AppendLine();
                }
                if (pawn.RaceProps.intelligence >= Intelligence.ToolUser)
                {
                    if (pawn.story != null && pawn.story.traits != null)
                    {
                        List <Trait> list = (from tr in pawn.story.traits.allTraits
                                             where tr.CurrentData.statOffsets != null && tr.CurrentData.statOffsets.Any((StatModifier se) => se.stat == this.stat)
                                             select tr).ToList <Trait>();
                        List <Trait> list2 = (from tr in pawn.story.traits.allTraits
                                              where tr.CurrentData.statFactors != null && tr.CurrentData.statFactors.Any((StatModifier se) => se.stat == this.stat)
                                              select tr).ToList <Trait>();
                        if (list.Count > 0 || list2.Count > 0)
                        {
                            stringBuilder.AppendLine("StatsReport_RelevantTraits".Translate());
                            for (int j = 0; j < list.Count; j++)
                            {
                                Trait  trait = list[j];
                                string valueToStringAsOffset = trait.CurrentData.statOffsets.First((StatModifier se) => se.stat == this.stat).ValueToStringAsOffset;
                                stringBuilder.AppendLine("    " + trait.LabelCap + ": " + valueToStringAsOffset);
                            }
                            for (int k = 0; k < list2.Count; k++)
                            {
                                Trait  trait2           = list2[k];
                                string toStringAsFactor = trait2.CurrentData.statFactors.First((StatModifier se) => se.stat == this.stat).ToStringAsFactor;
                                stringBuilder.AppendLine("    " + trait2.LabelCap + ": " + toStringAsFactor);
                            }
                            stringBuilder.AppendLine();
                        }
                    }
                    if (StatWorker.RelevantGear(pawn, this.stat).Any <Thing>())
                    {
                        stringBuilder.AppendLine("StatsReport_RelevantGear".Translate());
                        if (pawn.apparel != null)
                        {
                            for (int l = 0; l < pawn.apparel.WornApparel.Count; l++)
                            {
                                Apparel gear = pawn.apparel.WornApparel[l];
                                stringBuilder.AppendLine(StatWorker.InfoTextLineFromGear(gear, this.stat));
                            }
                        }
                        if (pawn.equipment != null && pawn.equipment.Primary != null)
                        {
                            stringBuilder.AppendLine(StatWorker.InfoTextLineFromGear(pawn.equipment.Primary, this.stat));
                        }
                        stringBuilder.AppendLine();
                    }
                }
                bool          flag    = false;
                List <Hediff> hediffs = pawn.health.hediffSet.hediffs;
                for (int m = 0; m < hediffs.Count; m++)
                {
                    HediffStage curStage = hediffs[m].CurStage;
                    if (curStage != null)
                    {
                        float statOffsetFromList = curStage.statOffsets.GetStatOffsetFromList(this.stat);
                        if (statOffsetFromList != 0f)
                        {
                            if (!flag)
                            {
                                stringBuilder.AppendLine("StatsReport_RelevantHediffs".Translate());
                                flag = true;
                            }
                            stringBuilder.AppendLine("    " + hediffs[m].LabelBase.CapitalizeFirst() + ": " + this.ValueToString(statOffsetFromList, false, ToStringNumberSense.Offset));
                            stringBuilder.AppendLine();
                        }
                    }
                }
                float statFactorFromList = pawn.ageTracker.CurLifeStage.statFactors.GetStatFactorFromList(this.stat);
                if (statFactorFromList != 1f)
                {
                    stringBuilder.AppendLine(string.Concat(new string[]
                    {
                        "StatsReport_LifeStage".Translate(),
                        " (",
                        pawn.ageTracker.CurLifeStage.label,
                        "): ",
                        statFactorFromList.ToStringByStyle(ToStringStyle.PercentZero, ToStringNumberSense.Factor)
                    }));
                    stringBuilder.AppendLine();
                }
            }
            if (req.StuffDef != null)
            {
                if (baseValueFor > 0f || this.stat.applyFactorsIfNegative)
                {
                    float statFactorFromList2 = req.StuffDef.stuffProps.statFactors.GetStatFactorFromList(this.stat);
                    if (statFactorFromList2 != 1f)
                    {
                        stringBuilder.AppendLine(string.Concat(new string[]
                        {
                            "StatsReport_Material".Translate(),
                            " (",
                            req.StuffDef.LabelCap,
                            "): ",
                            statFactorFromList2.ToStringByStyle(ToStringStyle.PercentZero, ToStringNumberSense.Factor)
                        }));
                        stringBuilder.AppendLine();
                    }
                }
                float statOffsetFromList2 = req.StuffDef.stuffProps.statOffsets.GetStatOffsetFromList(this.stat);
                if (statOffsetFromList2 != 0f)
                {
                    stringBuilder.AppendLine(string.Concat(new string[]
                    {
                        "StatsReport_Material".Translate(),
                        " (",
                        req.StuffDef.LabelCap,
                        "): ",
                        statOffsetFromList2.ToStringByStyle(this.stat.toStringStyle, ToStringNumberSense.Offset)
                    }));
                    stringBuilder.AppendLine();
                }
            }
            CompAffectedByFacilities compAffectedByFacilities = req.Thing.TryGetComp <CompAffectedByFacilities>();

            if (compAffectedByFacilities != null)
            {
                compAffectedByFacilities.GetStatsExplanation(this.stat, stringBuilder);
            }
            if (this.stat.statFactors != null)
            {
                stringBuilder.AppendLine("StatsReport_OtherStats".Translate());
                for (int n = 0; n < this.stat.statFactors.Count; n++)
                {
                    StatDef statDef = this.stat.statFactors[n];
                    stringBuilder.AppendLine("    " + statDef.LabelCap + ": x" + statDef.Worker.GetValue(req, true).ToStringPercent());
                }
                stringBuilder.AppendLine();
            }
            if (pawn != null)
            {
                if (pawn.skills != null)
                {
                    if (this.stat.skillNeedFactors != null)
                    {
                        stringBuilder.AppendLine("StatsReport_Skills".Translate());
                        for (int num = 0; num < this.stat.skillNeedFactors.Count; num++)
                        {
                            SkillNeed skillNeed2 = this.stat.skillNeedFactors[num];
                            int       level3     = pawn.skills.GetSkill(skillNeed2.skill).Level;
                            stringBuilder.AppendLine(string.Concat(new object[]
                            {
                                "    ",
                                skillNeed2.skill.LabelCap,
                                " (",
                                level3,
                                "): x",
                                skillNeed2.ValueFor(pawn).ToStringPercent()
                            }));
                        }
                        stringBuilder.AppendLine();
                    }
                }
                else if (this.stat.noSkillFactor != 1f)
                {
                    stringBuilder.AppendLine("StatsReport_Skills".Translate());
                    stringBuilder.AppendLine("    " + "default".Translate().CapitalizeFirst() + " : x" + this.stat.noSkillFactor.ToStringPercent());
                    stringBuilder.AppendLine();
                }
                if (this.stat.capacityFactors != null)
                {
                    stringBuilder.AppendLine((!"StatsReport_Health".CanTranslate()) ? "StatsReport_HealthFactors".Translate() : "StatsReport_Health".Translate());
                    if (this.stat.capacityFactors != null)
                    {
                        foreach (PawnCapacityFactor current2 in from hfa in this.stat.capacityFactors
                                 orderby hfa.capacity.listOrder
                                 select hfa)
                        {
                            string text4  = current2.capacity.GetLabelFor(pawn).CapitalizeFirst();
                            float  factor = current2.GetFactor(pawn.health.capacities.GetLevel(current2.capacity));
                            string text5  = factor.ToStringPercent();
                            string text6  = "HealthFactorPercentImpact".Translate(new object[]
                            {
                                current2.weight.ToStringPercent()
                            });
                            if (current2.max < 999f)
                            {
                                text6 = text6 + ", " + "HealthFactorMaxImpact".Translate(new object[]
                                {
                                    current2.max.ToStringPercent()
                                });
                            }
                            if (current2.allowedDefect != 0f)
                            {
                                text6 = text6 + ", " + "HealthFactorAllowedDefect".Translate(new object[]
                                {
                                    (1f - current2.allowedDefect).ToStringPercent()
                                });
                            }
                            stringBuilder.AppendLine(string.Concat(new string[]
                            {
                                "    ",
                                text4,
                                ": x",
                                text5,
                                " (",
                                text6,
                                ")"
                            }));
                        }
                    }
                    stringBuilder.AppendLine();
                }
                if (pawn.Inspired)
                {
                    float statOffsetFromList3 = pawn.InspirationDef.statOffsets.GetStatOffsetFromList(this.stat);
                    if (statOffsetFromList3 != 0f)
                    {
                        stringBuilder.AppendLine("StatsReport_Inspiration".Translate(new object[]
                        {
                            pawn.Inspiration.def.LabelCap
                        }) + ": " + this.ValueToString(statOffsetFromList3, false, ToStringNumberSense.Offset));
                        stringBuilder.AppendLine();
                    }
                    float statFactorFromList3 = pawn.InspirationDef.statFactors.GetStatFactorFromList(this.stat);
                    if (statFactorFromList3 != 1f)
                    {
                        stringBuilder.AppendLine("StatsReport_Inspiration".Translate(new object[]
                        {
                            pawn.Inspiration.def.LabelCap
                        }) + ": " + statFactorFromList3.ToStringByStyle(ToStringStyle.PercentZero, ToStringNumberSense.Factor));
                        stringBuilder.AppendLine();
                    }
                }
            }
            return(stringBuilder.ToString().TrimEndNewlines());
        }
コード例 #28
0
        public virtual float GetValueUnfinalized(StatRequest req, bool applyPostProcess = true)
        {
            if (Prefs.DevMode && this.IsDisabledFor(req.Thing))
            {
                Log.ErrorOnce(string.Format("Attempted to calculate value for disabled stat {0}; this is meant as a consistency check, either set the stat to neverDisabled or ensure this pawn cannot accidentally use this stat (thing={1})", this.stat, req.Thing.ToStringSafe <Thing>()), 75193282 + (int)this.stat.index, false);
            }
            float num  = this.GetBaseValueFor(req.Def);
            Pawn  pawn = req.Thing as Pawn;

            if (pawn != null)
            {
                if (pawn.skills != null)
                {
                    if (this.stat.skillNeedOffsets != null)
                    {
                        for (int i = 0; i < this.stat.skillNeedOffsets.Count; i++)
                        {
                            num += this.stat.skillNeedOffsets[i].ValueFor(pawn);
                        }
                    }
                }
                else
                {
                    num += this.stat.noSkillOffset;
                }
                if (this.stat.capacityOffsets != null)
                {
                    for (int j = 0; j < this.stat.capacityOffsets.Count; j++)
                    {
                        PawnCapacityOffset pawnCapacityOffset = this.stat.capacityOffsets[j];
                        num += pawnCapacityOffset.GetOffset(pawn.health.capacities.GetLevel(pawnCapacityOffset.capacity));
                    }
                }
                if (pawn.story != null)
                {
                    for (int k = 0; k < pawn.story.traits.allTraits.Count; k++)
                    {
                        num += pawn.story.traits.allTraits[k].OffsetOfStat(this.stat);
                    }
                }
                List <Hediff> hediffs = pawn.health.hediffSet.hediffs;
                for (int l = 0; l < hediffs.Count; l++)
                {
                    HediffStage curStage = hediffs[l].CurStage;
                    if (curStage != null)
                    {
                        num += curStage.statOffsets.GetStatOffsetFromList(this.stat);
                    }
                }
                if (pawn.apparel != null)
                {
                    for (int m = 0; m < pawn.apparel.WornApparel.Count; m++)
                    {
                        num += StatWorker.StatOffsetFromGear(pawn.apparel.WornApparel[m], this.stat);
                    }
                }
                if (pawn.equipment != null && pawn.equipment.Primary != null)
                {
                    num += StatWorker.StatOffsetFromGear(pawn.equipment.Primary, this.stat);
                }
                if (pawn.story != null)
                {
                    for (int n = 0; n < pawn.story.traits.allTraits.Count; n++)
                    {
                        num *= pawn.story.traits.allTraits[n].MultiplierOfStat(this.stat);
                    }
                }
                num *= pawn.ageTracker.CurLifeStage.statFactors.GetStatFactorFromList(this.stat);
            }
            if (req.StuffDef != null)
            {
                if (num > 0f || this.stat.applyFactorsIfNegative)
                {
                    num *= req.StuffDef.stuffProps.statFactors.GetStatFactorFromList(this.stat);
                }
                num += req.StuffDef.stuffProps.statOffsets.GetStatOffsetFromList(this.stat);
            }
            if (req.HasThing)
            {
                CompAffectedByFacilities compAffectedByFacilities = req.Thing.TryGetComp <CompAffectedByFacilities>();
                if (compAffectedByFacilities != null)
                {
                    num += compAffectedByFacilities.GetStatOffset(this.stat);
                }
                if (this.stat.statFactors != null)
                {
                    for (int num2 = 0; num2 < this.stat.statFactors.Count; num2++)
                    {
                        num *= req.Thing.GetStatValue(this.stat.statFactors[num2], true);
                    }
                }
                if (pawn != null)
                {
                    if (pawn.skills != null)
                    {
                        if (this.stat.skillNeedFactors != null)
                        {
                            for (int num3 = 0; num3 < this.stat.skillNeedFactors.Count; num3++)
                            {
                                num *= this.stat.skillNeedFactors[num3].ValueFor(pawn);
                            }
                        }
                    }
                    else
                    {
                        num *= this.stat.noSkillFactor;
                    }
                    if (this.stat.capacityFactors != null)
                    {
                        for (int num4 = 0; num4 < this.stat.capacityFactors.Count; num4++)
                        {
                            PawnCapacityFactor pawnCapacityFactor = this.stat.capacityFactors[num4];
                            float factor = pawnCapacityFactor.GetFactor(pawn.health.capacities.GetLevel(pawnCapacityFactor.capacity));
                            num = Mathf.Lerp(num, num * factor, pawnCapacityFactor.weight);
                        }
                    }
                    if (pawn.Inspired)
                    {
                        num += pawn.InspirationDef.statOffsets.GetStatOffsetFromList(this.stat);
                        num *= pawn.InspirationDef.statFactors.GetStatFactorFromList(this.stat);
                    }
                }
            }
            return(num);
        }
コード例 #29
0
ファイル: FacilitiesUtility.cs プロジェクト: potsh/RimWorld
 public static void NotifyFacilitiesAboutChangedLOSBlockers(List <Region> affectedRegions)
 {
     if (affectedRegions.Any())
     {
         if (working)
         {
             Log.Warning("Tried to update facilities while already updating.");
         }
         else
         {
             working = true;
             try
             {
                 visited.Clear();
                 processed.Clear();
                 int facilitiesToProcess           = affectedRegions[0].Map.listerThings.ThingsInGroup(ThingRequestGroup.Facility).Count;
                 int affectedByFacilitiesToProcess = affectedRegions[0].Map.listerThings.ThingsInGroup(ThingRequestGroup.AffectedByFacilities).Count;
                 int facilitiesProcessed           = 0;
                 int affectedByFacilitiesProcessed = 0;
                 if (facilitiesToProcess > 0 && affectedByFacilitiesToProcess > 0)
                 {
                     for (int i = 0; i < affectedRegions.Count; i++)
                     {
                         if (!visited.Contains(affectedRegions[i]))
                         {
                             RegionTraverser.BreadthFirstTraverse(affectedRegions[i], (Region from, Region r) => !visited.Contains(r), delegate(Region x)
                             {
                                 visited.Add(x);
                                 List <Thing> list = x.ListerThings.ThingsInGroup(ThingRequestGroup.BuildingArtificial);
                                 for (int j = 0; j < list.Count; j++)
                                 {
                                     if (!processed.Contains(list[j]))
                                     {
                                         processed.Add(list[j]);
                                         CompFacility compFacility = list[j].TryGetComp <CompFacility>();
                                         CompAffectedByFacilities compAffectedByFacilities = list[j].TryGetComp <CompAffectedByFacilities>();
                                         if (compFacility != null)
                                         {
                                             compFacility.Notify_LOSBlockerSpawnedOrDespawned();
                                             facilitiesProcessed++;
                                         }
                                         if (compAffectedByFacilities != null)
                                         {
                                             compAffectedByFacilities.Notify_LOSBlockerSpawnedOrDespawned();
                                             affectedByFacilitiesProcessed++;
                                         }
                                     }
                                 }
                                 return(facilitiesProcessed >= facilitiesToProcess && affectedByFacilitiesProcessed >= affectedByFacilitiesToProcess);
                             }, RegionsToSearch);
                             if (facilitiesProcessed >= facilitiesToProcess && affectedByFacilitiesProcessed >= affectedByFacilitiesToProcess)
                             {
                                 break;
                             }
                         }
                     }
                 }
             }
             finally
             {
                 working = false;
                 visited.Clear();
                 processed.Clear();
             }
         }
     }
 }
コード例 #30
0
 public bool IsValidFacilityForMe(Thing facility)
 {
     return(CompAffectedByFacilities.IsPotentiallyValidFacilityForMe_Static(facility, this.parent.def, this.parent.Position, this.parent.Rotation));
 }