Пример #1
0
        public void GainFilth(ThingDef filthDef, IEnumerable <string> sources)
        {
            if (filthDef.filth.terrainSourced)
            {
                lastTerrainFilthDef = filthDef;
            }
            Filth filth = null;

            for (int i = 0; i < carriedFilth.Count; i++)
            {
                if (carriedFilth[i].def == filthDef)
                {
                    filth = carriedFilth[i];
                    break;
                }
            }
            if (filth != null)
            {
                if (filth.CanBeThickened)
                {
                    filth.ThickenFilth();
                    filth.AddSources(sources);
                }
            }
            else
            {
                Filth filth2 = (Filth)ThingMaker.MakeThing(filthDef);
                filth2.AddSources(sources);
                carriedFilth.Add(filth2);
            }
        }
Пример #2
0
        private void TryPickupFilth()
        {
            TerrainDef terrDef = pawn.Map.terrainGrid.TerrainAt(pawn.Position);

            if (terrDef.generatedFilth != null)
            {
                for (int num = carriedFilth.Count - 1; num >= 0; num--)
                {
                    if (carriedFilth[num].def.filth.terrainSourced && carriedFilth[num].def != terrDef.generatedFilth)
                    {
                        ThinCarriedFilth(carriedFilth[num]);
                    }
                }
                Filth filth = (from f in carriedFilth
                               where f.def == terrDef.generatedFilth
                               select f).FirstOrDefault();
                if (filth == null || filth.thickness < 1)
                {
                    GainFilth(terrDef.generatedFilth);
                    FilthMonitor.Notify_FilthAccumulated();
                }
            }
            List <Thing> thingList = pawn.Position.GetThingList(pawn.Map);

            for (int num2 = thingList.Count - 1; num2 >= 0; num2--)
            {
                Filth filth2 = thingList[num2] as Filth;
                if (filth2 != null && filth2.CanFilthAttachNow)
                {
                    GainFilth(filth2.def, filth2.sources);
                    filth2.ThinFilth();
                }
            }
        }
Пример #3
0
 public void Notify_FilthSpawned(Filth f)
 {
     if (map.areaManager.Home[f.Position])
     {
         filthInHomeArea.Add(f);
     }
 }
Пример #4
0
        public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
        {
            if (pawn.Faction != Faction.OfPlayer)
            {
                return(false);
            }
            Filth filth = t as Filth;

            if (filth == null)
            {
                return(false);
            }
            if (!((Area)filth.Map.areaManager.Home)[filth.Position])
            {
                return(false);
            }
            LocalTargetInfo target = t;

            if (!pawn.CanReserve(target, 1, -1, null, forced))
            {
                return(false);
            }
            if (filth.TicksSinceThickened < this.MinTicksSinceThickened)
            {
                return(false);
            }
            return(true);
        }
 public void Notify_HomeAreaChanged(IntVec3 c)
 {
     if (this.map.areaManager.Home[c])
     {
         List <Thing> thingList = c.GetThingList(this.map);
         for (int i = 0; i < thingList.Count; i++)
         {
             Filth filth = thingList[i] as Filth;
             if (filth != null)
             {
                 this.filthInHomeArea.Add(filth);
             }
         }
     }
     else
     {
         for (int j = this.filthInHomeArea.Count - 1; j >= 0; j--)
         {
             if (this.filthInHomeArea[j].Position == c)
             {
                 this.filthInHomeArea.RemoveAt(j);
             }
         }
     }
 }
Пример #6
0
        private void TryPickupFilth()
        {
            TerrainDef terrDef = this.pawn.Map.terrainGrid.TerrainAt(this.pawn.Position);

            if (terrDef.generatedFilth != null)
            {
                for (int i = this.carriedFilth.Count - 1; i >= 0; i--)
                {
                    if (this.carriedFilth[i].def.filth.terrainSourced && this.carriedFilth[i].def != terrDef.generatedFilth)
                    {
                        this.ThinCarriedFilth(this.carriedFilth[i]);
                    }
                }
                Filth filth = (from f in this.carriedFilth
                               where f.def == terrDef.generatedFilth
                               select f).FirstOrDefault <Filth>();
                if (filth == null || filth.thickness < 1)
                {
                    this.GainFilth(terrDef.generatedFilth);
                    FilthMonitor.Notify_FilthAccumulated();
                }
            }
            List <Thing> thingList = this.pawn.Position.GetThingList(this.pawn.Map);

            for (int j = thingList.Count - 1; j >= 0; j--)
            {
                Filth filth2 = thingList[j] as Filth;
                if (filth2 != null && filth2.CanFilthAttachNow)
                {
                    this.GainFilth(filth2.def, filth2.sources);
                    filth2.ThinFilth();
                }
            }
        }
 private void DropCarriedFilth(Filth f)
 {
     if (FilthMaker.TryMakeFilth(pawn.Position, pawn.Map, f.def, f.sources, AdditionalFilthSourceFlags))
     {
         ThinCarriedFilth(f);
     }
 }
Пример #8
0
        public void GainFilth(ThingDef filthDef, IEnumerable <string> sources)
        {
            Filth filth = null;

            for (int i = 0; i < this.carriedFilth.Count; i++)
            {
                if (this.carriedFilth[i].def == filthDef)
                {
                    filth = this.carriedFilth[i];
                    break;
                }
            }
            if (filth != null)
            {
                if (filth.CanBeThickened)
                {
                    filth.ThickenFilth();
                    filth.AddSources(sources);
                }
            }
            else
            {
                Filth filth2 = (Filth)ThingMaker.MakeThing(filthDef, null);
                filth2.AddSources(sources);
                this.carriedFilth.Add(filth2);
            }
        }
        public void GainFilth(ThingDef filthDef, IEnumerable <string> sources)
        {
            Filth filth = null;
            int   num   = 0;

            while (num < this.carriedFilth.Count)
            {
                if (this.carriedFilth[num].def != filthDef)
                {
                    num++;
                    continue;
                }
                filth = this.carriedFilth[num];
                break;
            }
            if (filth != null)
            {
                if (filth.CanBeThickened)
                {
                    filth.ThickenFilth();
                    filth.AddSources(sources);
                }
            }
            else
            {
                Filth filth2 = (Filth)ThingMaker.MakeThing(filthDef, null);
                filth2.AddSources(sources);
                this.carriedFilth.Add(filth2);
            }
        }
 public void Notify_FilthSpawned(Filth f)
 {
     if (((Area)this.map.areaManager.Home)[f.Position])
     {
         this.filthInHomeArea.Add(f);
     }
 }
Пример #11
0
        public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
        {
            bool result;

            if (pawn.Faction != Faction.OfPlayer)
            {
                result = false;
            }
            else
            {
                Filth filth = t as Filth;
                if (filth == null)
                {
                    result = false;
                }
                else if (!filth.Map.areaManager.Home[filth.Position])
                {
                    result = false;
                }
                else
                {
                    LocalTargetInfo target = t;
                    result = (pawn.CanReserve(target, 1, -1, null, forced) && filth.TicksSinceThickened >= this.MinTicksSinceThickened);
                }
            }
            return(result);
        }
Пример #12
0
 public void Notify_HomeAreaChanged(IntVec3 c)
 {
     if (map.areaManager.Home[c])
     {
         List <Thing> thingList = c.GetThingList(map);
         for (int i = 0; i < thingList.Count; i++)
         {
             Filth filth = thingList[i] as Filth;
             if (filth != null)
             {
                 filthInHomeArea.Add(filth);
             }
         }
     }
     else
     {
         for (int num = filthInHomeArea.Count - 1; num >= 0; num--)
         {
             if (filthInHomeArea[num].Position == c)
             {
                 filthInHomeArea.RemoveAt(num);
             }
         }
     }
 }
        private void TryPickupFilth()
        {
            TerrainDef terrDef = this.pawn.Map.terrainGrid.TerrainAt(this.pawn.Position);

            if (terrDef.terrainFilthDef != null)
            {
                for (int num = this.carriedFilth.Count - 1; num >= 0; num--)
                {
                    if (this.carriedFilth[num].def.filth.terrainSourced && this.carriedFilth[num].def != terrDef.terrainFilthDef)
                    {
                        this.ThinCarriedFilth(this.carriedFilth[num]);
                    }
                }
                Filth filth = (from f in this.carriedFilth
                               where f.def == terrDef.terrainFilthDef
                               select f).FirstOrDefault();
                if (filth == null || filth.thickness < 1)
                {
                    this.GainFilth(terrDef.terrainFilthDef);
                }
            }
            List <Thing> thingList = this.pawn.Position.GetThingList(this.pawn.Map);

            for (int num2 = thingList.Count - 1; num2 >= 0; num2--)
            {
                Filth filth2 = thingList[num2] as Filth;
                if (filth2 != null && filth2.CanFilthAttachNow)
                {
                    this.GainFilth(filth2.def, filth2.sources);
                    filth2.ThinFilth();
                }
            }
        }
 private void ThinCarriedFilth(Filth f)
 {
     f.ThinFilth();
     if (f.thickness <= 0)
     {
         this.carriedFilth.Remove(f);
     }
 }
 public void Notify_FilthDespawned(Filth f)
 {
     for (int i = 0; i < filthInHomeArea.Count; i++)
     {
         if (filthInHomeArea[i] == f)
         {
             filthInHomeArea.RemoveAt(i);
             break;
         }
     }
 }
 public void Notify_FilthDespawned(Filth f)
 {
     for (int i = 0; i < this.filthInHomeArea.Count; i++)
     {
         if (this.filthInHomeArea[i] == f)
         {
             this.filthInHomeArea.RemoveAt(i);
             return;
         }
     }
 }
        protected override IEnumerable <Toil> MakeNewToils()
        {
            Toil initExtractTargetFromQueue = Toils_JobTransforms.ClearDespawnedNullOrForbiddenQueuedTargets(TargetIndex.A);

            yield return(initExtractTargetFromQueue);

            yield return(Toils_JobTransforms.SucceedOnNoTargetInQueue(TargetIndex.A));

            yield return(Toils_JobTransforms.ExtractNextTargetFromQueue(TargetIndex.A));

            yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).JumpIfDespawnedOrNullOrForbidden(TargetIndex.A, initExtractTargetFromQueue).JumpIfOutsideHomeArea(TargetIndex.A, initExtractTargetFromQueue));

            Toil clean = new Toil();

            clean.initAction = delegate
            {
                cleaningWorkDone          = 0f;
                totalCleaningWorkDone     = 0f;
                totalCleaningWorkRequired = Filth.def.filth.cleaningWorkToReduceThickness * (float)Filth.thickness;
            };
            clean.tickAction = delegate
            {
                Filth filth = Filth;
                cleaningWorkDone      += 1f;
                totalCleaningWorkDone += 1f;
                if (cleaningWorkDone > filth.def.filth.cleaningWorkToReduceThickness)
                {
                    filth.ThinFilth();
                    cleaningWorkDone = 0f;
                    if (filth.Destroyed)
                    {
                        clean.actor.records.Increment(RecordDefOf.MessesCleaned);
                        ReadyForNextToil();
                    }
                }
            };
            clean.defaultCompleteMode = ToilCompleteMode.Never;
            clean.WithEffect(EffecterDefOf.Clean, TargetIndex.A);
            clean.WithProgressBar(TargetIndex.A, () => totalCleaningWorkDone / totalCleaningWorkRequired, interpolateBetweenActorAndTarget: true);
            clean.PlaySustainerOrSound(delegate
            {
                ThingDef def = Filth.def;
                return((!def.filth.cleaningSound.NullOrUndefined()) ? def.filth.cleaningSound : SoundDefOf.Interact_CleanFilth);
            });
            clean.JumpIfDespawnedOrNullOrForbidden(TargetIndex.A, initExtractTargetFromQueue);
            clean.JumpIfOutsideHomeArea(TargetIndex.A, initExtractTargetFromQueue);
            yield return(clean);

            yield return(Toils_Jump.Jump(initExtractTargetFromQueue));
        }
Пример #18
0
 private void TryDropFilth()
 {
     if (this.carriedFilth.Count != 0)
     {
         for (int i = this.carriedFilth.Count - 1; i >= 0; i--)
         {
             Filth filth = this.carriedFilth[i];
             if (filth.CanDropAt(this.pawn.Position, this.pawn.Map))
             {
                 this.DropCarriedFilth(this.carriedFilth[i]);
                 FilthMonitor.Notify_FilthDropped();
             }
         }
     }
 }
Пример #19
0
 private void TryDropFilth()
 {
     if (carriedFilth.Count != 0)
     {
         for (int num = carriedFilth.Count - 1; num >= 0; num--)
         {
             Filth filth = carriedFilth[num];
             if (filth.CanDropAt(pawn.Position, pawn.Map))
             {
                 DropCarriedFilth(carriedFilth[num]);
                 FilthMonitor.Notify_FilthDropped();
             }
         }
     }
 }
Пример #20
0
        private static bool MakeFilth(IntVec3 c, Map map, ThingDef filthDef, IEnumerable <string> sources, bool shouldPropagate)
        {
            Filth filth = (Filth)(from t in c.GetThingList(map)
                                  where t.def == filthDef
                                  select t).FirstOrDefault <Thing>();
            bool result;

            if (!c.Walkable(map) || (filth != null && !filth.CanBeThickened))
            {
                if (shouldPropagate)
                {
                    List <IntVec3> list = GenAdj.AdjacentCells8WayRandomized();
                    for (int i = 0; i < 8; i++)
                    {
                        IntVec3 c2 = c + list[i];
                        if (c2.InBounds(map))
                        {
                            if (FilthMaker.MakeFilth(c2, map, filthDef, sources, false))
                            {
                                return(true);
                            }
                        }
                    }
                }
                if (filth != null)
                {
                    filth.AddSources(sources);
                }
                result = false;
            }
            else
            {
                if (filth != null)
                {
                    filth.ThickenFilth();
                    filth.AddSources(sources);
                }
                else
                {
                    Filth filth2 = (Filth)ThingMaker.MakeThing(filthDef, null);
                    filth2.AddSources(sources);
                    GenSpawn.Spawn(filth2, c, map, WipeMode.Vanish);
                }
                FilthMonitor.Notify_FilthSpawned();
                result = true;
            }
            return(result);
        }
Пример #21
0
 public override bool HasJobOnThing(Pawn pawn, Thing t)
 {
     if (pawn.Faction != Faction.OfColony)
     {
         return(false);
     }
     RimWorld.Filth filth = t as RimWorld.Filth;
     if (filth == null)
     {
         return(false);
     }
     if (!Find.AreaCleaning[filth.Position] || !ReservationUtility.CanReserveAndReach(pawn, t, PathEndMode.ClosestTouch, DangerUtility.NormalMaxDanger(pawn), 1))
     {
         return(false);
     }
     return(filth.TicksSinceThickened >= minTicksSinceThickened);
 }
Пример #22
0
        public void Notify_FilthDespawned(Filth f)
        {
            int num = 0;

            while (true)
            {
                if (num >= filthInHomeArea.Count)
                {
                    return;
                }
                if (filthInHomeArea[num] == f)
                {
                    break;
                }
                num++;
            }
            filthInHomeArea.RemoveAt(num);
        }
Пример #23
0
        public static void RemoveAllFilth(IntVec3 c, Map map)
        {
            FilthMaker.toBeRemoved.Clear();
            List <Thing> thingList = c.GetThingList(map);

            for (int i = 0; i < thingList.Count; i++)
            {
                Filth filth = thingList[i] as Filth;
                if (filth != null)
                {
                    FilthMaker.toBeRemoved.Add(filth);
                }
            }
            for (int j = 0; j < FilthMaker.toBeRemoved.Count; j++)
            {
                FilthMaker.toBeRemoved[j].Destroy(DestroyMode.Vanish);
            }
            FilthMaker.toBeRemoved.Clear();
        }
        public void Notify_FilthDespawned(Filth f)
        {
            int num = 0;

            while (true)
            {
                if (num < this.filthInHomeArea.Count)
                {
                    if (this.filthInHomeArea[num] != f)
                    {
                        num++;
                        continue;
                    }
                    break;
                }
                return;
            }
            this.filthInHomeArea.RemoveAt(num);
        }
Пример #25
0
        private static bool TryMakeFilth(IntVec3 c, Map map, ThingDef filthDef, IEnumerable <string> sources, bool shouldPropagate, FilthSourceFlags additionalFlags = FilthSourceFlags.None)
        {
            Filth filth = (Filth)(from t in c.GetThingList(map)
                                  where t.def == filthDef
                                  select t).FirstOrDefault();

            if (!c.Walkable(map) || (filth != null && !filth.CanBeThickened))
            {
                if (shouldPropagate)
                {
                    List <IntVec3> list = GenAdj.AdjacentCells8WayRandomized();
                    for (int i = 0; i < 8; i++)
                    {
                        IntVec3 c2 = c + list[i];
                        if (c2.InBounds(map) && TryMakeFilth(c2, map, filthDef, sources, shouldPropagate: false))
                        {
                            return(true);
                        }
                    }
                }
                filth?.AddSources(sources);
                return(false);
            }
            if (filth != null)
            {
                filth.ThickenFilth();
                filth.AddSources(sources);
            }
            else
            {
                if (!CanMakeFilth(c, map, filthDef, additionalFlags))
                {
                    return(false);
                }
                Filth obj = (Filth)ThingMaker.MakeThing(filthDef);
                obj.AddSources(sources);
                GenSpawn.Spawn(obj, c, map);
            }
            FilthMonitor.Notify_FilthSpawned();
            return(true);
        }
        public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
        {
            Filth filth = t as Filth;

            if (filth == null)
            {
                return(false);
            }
            if (!filth.Map.areaManager.Home[filth.Position])
            {
                return(false);
            }
            if (!pawn.CanReserve(t, 1, -1, null, forced))
            {
                return(false);
            }
            if (filth.TicksSinceThickened < MinTicksSinceThickened)
            {
                return(false);
            }
            return(true);
        }
Пример #27
0
        private static bool MakeFilth(IntVec3 c, Map map, ThingDef filthDef, IEnumerable <string> sources, bool shouldPropagate)
        {
            Filth filth = (Filth)(from t in c.GetThingList(map)
                                  where t.def == filthDef
                                  select t).FirstOrDefault();

            if (c.Walkable(map) && (filth == null || filth.CanBeThickened))
            {
                if (filth != null)
                {
                    filth.ThickenFilth();
                    filth.AddSources(sources);
                }
                else
                {
                    Filth filth2 = (Filth)ThingMaker.MakeThing(filthDef, null);
                    filth2.AddSources(sources);
                    GenSpawn.Spawn(filth2, c, map);
                }
                return(true);
            }
            if (shouldPropagate)
            {
                List <IntVec3> list = GenAdj.AdjacentCells8WayRandomized();
                for (int i = 0; i < 8; i++)
                {
                    IntVec3 c2 = c + list[i];
                    if (c2.InBounds(map) && FilthMaker.MakeFilth(c2, map, filthDef, sources, false))
                    {
                        return(true);
                    }
                }
            }
            if (filth != null)
            {
                filth.AddSources(sources);
            }
            return(false);
        }
 private void DropCarriedFilth(Filth f)
 {
     this.ThinCarriedFilth(f);
     FilthMaker.MakeFilth(this.pawn.Position, this.pawn.Map, f.def, f.sources);
 }
Пример #29
0
        private void DoCellSteadyEffects(IntVec3 c)
        {
            Room room  = c.GetRoom(map, RegionType.Set_All);
            bool flag  = map.roofGrid.Roofed(c);
            bool flag2 = room?.UsesOutdoorTemperature ?? false;

            if ((room == null) | flag2)
            {
                if (outdoorMeltAmount > 0f)
                {
                    map.snowGrid.AddDepth(c, 0f - outdoorMeltAmount);
                }
                if (!flag && snowRate > 0.001f)
                {
                    AddFallenSnowAt(c, 0.046f * map.weatherManager.SnowRate);
                }
            }
            if (room != null)
            {
                bool         protectedByEdifice = ProtectedByEdifice(c, map);
                TerrainDef   terrain            = c.GetTerrain(map);
                List <Thing> thingList          = c.GetThingList(map);
                for (int i = 0; i < thingList.Count; i++)
                {
                    Thing thing = thingList[i];
                    Filth filth = thing as Filth;
                    if (filth != null)
                    {
                        if (!flag && thing.def.filth.rainWashes && Rand.Chance(rainRate))
                        {
                            filth.ThinFilth();
                        }
                        if (filth.DisappearAfterTicks != 0 && filth.TicksSinceThickened > filth.DisappearAfterTicks)
                        {
                            filth.Destroy();
                        }
                    }
                    else
                    {
                        TryDoDeteriorate(thing, flag, flag2, protectedByEdifice, terrain);
                    }
                }
                if (!flag2)
                {
                    float temperature = room.Temperature;
                    if (temperature > 0f)
                    {
                        float num = MeltAmountAt(temperature);
                        if (num > 0f)
                        {
                            map.snowGrid.AddDepth(c, 0f - num);
                        }
                        if (room.RegionType.Passable() && temperature > AutoIgnitionTemperatureRange.min)
                        {
                            float value = Rand.Value;
                            if (value < AutoIgnitionTemperatureRange.InverseLerpThroughRange(temperature) * 0.7f && Rand.Chance(FireUtility.ChanceToStartFireIn(c, map)))
                            {
                                FireUtility.TryStartFireIn(c, map, 0.1f);
                            }
                            if (value < 0.33f)
                            {
                                MoteMaker.ThrowHeatGlow(c, map, 2.3f);
                            }
                        }
                    }
                }
            }
            map.gameConditionManager.DoSteadyEffects(c, map);
        }
Пример #30
0
 internal bool <> m__0(Filth f)
 {
     return(f.def == this.terrDef.generatedFilth);
 }