示例#1
0
        public static IntVec3 TryFindValidTargetCell(ShipBase ship, IntVec3 targetCell, Map map)
        {
            IntVec3             result;
            TraverseParms       traverseParms = TraverseParms.For(TraverseMode.NoPassClosedDoors, Danger.Deadly, false);
            CellRect            occupiedRect  = GenAdj.OccupiedRect(targetCell, ship.Rotation, ship.def.Size);
            Predicate <IntVec3> baseValidator = (IntVec3 x) => x.Standable(map) && !(x.Roofed(map) && x.GetRoof(map).isThickRoof) && GenAdj.OccupiedRect(targetCell, ship.Rotation, ship.def.Size).InBounds(map);

            if (baseValidator(targetCell))
            {
                return(targetCell);
            }

            if (RCellFinder.TryFindRandomCellNearWith(targetCell, baseValidator, map, out result))
            {
                return(result);
            }
            Log.Warning("Could not find any valid cell.");
            return(CellFinder.RandomCell(map));
        }
示例#2
0
 public override void Destroy(DestroyMode mode = DestroyMode.Vanish)
 {
     RemoveAllOwners();
     foreach (IntVec3 c in GenAdj.CellsOccupiedBy(this))
     {
         // Change the terrain here back to quarried stone, removing the walls
         Map.terrainGrid.SetTerrain(c, QuarryDefOf.QRY_QuarriedGround);
     }
     if (!QuarrySettings.letterSent && !TutorSystem.AdaptiveTrainingEnabled)
     {
         Find.LetterStack.ReceiveLetter(Static.LetterLabel, Static.LetterText, QuarryDefOf.CuproLetter, new RimWorld.Planet.GlobalTargetInfo(Position, Map));
         QuarrySettings.letterSent = true;
     }
     if (TutorSystem.AdaptiveTrainingEnabled)
     {
         LessonAutoActivator.TeachOpportunity(QuarryDefOf.QRY_ReclaimingSoil, OpportunityType.GoodToKnow);
     }
     base.Destroy(mode);
 }
示例#3
0
        public override void PostSpawnSetup()
        {
            compPowerTrader = parent.TryGetComp <CompPowerTrader>();

            lastTickStagger++;
            tickStagger = lastTickStagger;

            cellIndex = tickStagger;
            cells     = GenAdj.CellsAdjacent8Way(parent).ToList();
            while (cellIndex > cells.Count)
            {
                cellIndex -= cells.Count;
            }

            if (quantumWarehouse != null)
            {
                compWarehouse = quantumWarehouse.TryGetComp <CompRTQuantumWarehouse>();
            }
        }
        // ===================== Main function =====================
        public override void Tick()
        {
            base.Tick();

            this.ticksSinceTakeOff++;
            if (this.ticksSinceTakeOff <= verticalTrajectoryDurationInTicks)
            {
                MoteMaker.ThrowDustPuff(GenAdj.CellsAdjacentCardinal(this.landingPadPosition, this.landingPadRotation, Util_ThingDefOf.LandingPad.Size).RandomElement(), this.Map, 3f * (1f - (float)this.ticksSinceTakeOff / (float)verticalTrajectoryDurationInTicks));
            }
            if (this.ticksSinceTakeOff == 1)
            {
                // Taking off sound.
                FlyingSpaceshipTakingOff.takingOffSound.PlayOneShot(new TargetInfo(this.Position, this.Map));
            }
            if (this.ticksSinceTakeOff >= verticalTrajectoryDurationInTicks + horizontalTrajectoryDurationInTicks)
            {
                this.Destroy();
            }
        }
示例#5
0
        private bool TrySpawnBatteryNear(IntVec3 position, Map map, Faction faction, out Building newBattery)
        {
            Predicate <IntVec3> extraValidator = null;

            if (this.spawnRoofOverNewBatteries)
            {
                extraValidator = delegate(IntVec3 x)
                {
                    CellRect.CellRectIterator iterator = GenAdj.OccupiedRect(x, Rot4.North, ThingDefOf.Battery.size).ExpandedBy(3).GetIterator();
                    while (!iterator.Done())
                    {
                        IntVec3 current = iterator.Current;
                        if (current.InBounds(map))
                        {
                            List <Thing> thingList = current.GetThingList(map);
                            for (int i = 0; i < thingList.Count; i++)
                            {
                                if (thingList[i].def.PlaceWorkers != null)
                                {
                                    if (thingList[i].def.PlaceWorkers.Any((PlaceWorker y) => y is PlaceWorker_NotUnderRoof))
                                    {
                                        return(false);
                                    }
                                }
                            }
                        }
                        iterator.MoveNext();
                    }
                    return(true);
                };
            }
            if (this.TrySpawnPowerTransmittingBuildingNear(position, map, faction, ThingDefOf.Battery, out newBattery, extraValidator))
            {
                float randomInRange = this.newBatteriesInitialStoredEnergyPctRange.RandomInRange;
                newBattery.GetComp <CompPowerBattery>().SetStoredEnergyPct(randomInRange);
                if (this.spawnRoofOverNewBatteries)
                {
                    this.SpawnRoofOver(newBattery);
                }
                return(true);
            }
            return(false);
        }
 private static IEnumerable <CompPower> ContiguousPowerBuildings(Building root)
 {
     closedSet.Clear();
     openSet.Clear();
     currentSet.Clear();
     openSet.Add(root);
     do
     {
         foreach (Building item in openSet)
         {
             closedSet.Add(item);
         }
         HashSet <Building> hashSet = currentSet;
         currentSet = openSet;
         openSet    = hashSet;
         openSet.Clear();
         foreach (Building item2 in currentSet)
         {
             foreach (IntVec3 item3 in GenAdj.CellsAdjacentCardinal(item2))
             {
                 if (!item3.InBounds(item2.Map))
                 {
                     continue;
                 }
                 List <Thing> thingList = item3.GetThingList(item2.Map);
                 for (int i = 0; i < thingList.Count; i++)
                 {
                     Building building = thingList[i] as Building;
                     if (building != null && building.TransmitsPowerNow && !openSet.Contains(building) && !currentSet.Contains(building) && !closedSet.Contains(building))
                     {
                         openSet.Add(building);
                         break;
                     }
                 }
             }
         }
     }while (openSet.Count > 0);
     CompPower[] result = closedSet.Select((Building b) => b.PowerComp).ToArray();
     closedSet.Clear();
     openSet.Clear();
     currentSet.Clear();
     return(result);
 }
        //public static bool CanBuildOnTerrain(BuildableDef entDef, IntVec3 c, Map map, Rot4 rot, Thing thingToIgnore = null)
        public static bool Prefix(ref bool __result, BuildableDef entDef, IntVec3 c, Map map, Rot4 rot, Thing thingToIgnore = null)
        {
            CellRect cellRect = GenAdj.OccupiedRect(c, rot, entDef.Size);

            cellRect.ClipInsideMap(map);
            CellRect.CellRectIterator iterator = cellRect.GetIterator();
            while (!iterator.Done())
            {
                if (iterator.Current.SupportsStructureType(map, TerrainDefOf.Bridge.terrainAffordanceNeeded) &&
                    TerrainDefOf.Bridge.affordances.Contains(entDef.terrainAffordanceNeeded))
                {
                    __result = true;
                    return(false);
                }
                iterator.MoveNext();
            }

            return(true);
        }
示例#8
0
        public override void DesignateSingleCell(IntVec3 c)
        {
            if (TutorSystem.TutorialMode && !TutorSystem.AllowAction(new EventPack(base.TutorTagDesignate, c)))
            {
                return;
            }
            if (DebugSettings.godMode || this.entDef.GetStatValueAbstract(StatDefOf.WorkToBuild, this.stuffDef) == 0f)
            {
                if (this.entDef is TerrainDef)
                {
                    base.Map.terrainGrid.SetTerrain(c, (TerrainDef)this.entDef);
                }
                else
                {
                    Thing thing = ThingMaker.MakeThing((ThingDef)this.entDef, this.stuffDef);
                    thing.SetFactionDirect(Faction.OfPlayer);
                    GenSpawn.Spawn(thing, c, base.Map, this.placingRot, WipeMode.Vanish, false);
                }
            }
            else
            {
                GenSpawn.WipeExistingThings(c, this.placingRot, this.entDef.blueprintDef, base.Map, DestroyMode.Deconstruct);
                GenConstruct.PlaceBlueprintForBuild(this.entDef, c, base.Map, this.placingRot, Faction.OfPlayer, this.stuffDef);
            }
            MoteMaker.ThrowMetaPuffs(GenAdj.OccupiedRect(c, this.placingRot, this.entDef.Size), base.Map);
            ThingDef thingDef = this.entDef as ThingDef;

            if (thingDef != null && thingDef.IsOrbitalTradeBeacon)
            {
                PlayerKnowledgeDatabase.KnowledgeDemonstrated(ConceptDefOf.BuildOrbitalTradeBeacon, KnowledgeAmount.Total);
            }
            if (TutorSystem.TutorialMode)
            {
                TutorSystem.Notify_Event(new EventPack(base.TutorTagDesignate, c));
            }
            if (this.entDef.PlaceWorkers != null)
            {
                for (int i = 0; i < this.entDef.PlaceWorkers.Count; i++)
                {
                    this.entDef.PlaceWorkers[i].PostPlace(base.Map, this.entDef, c, this.placingRot);
                }
            }
        }
示例#9
0
 private static IEnumerable <CompPipe> ContiguousPowerBuildings(Building root)
 {
     closedSet.Clear();
     openSet.Clear();
     currentSet.Clear();
     openSet.Add(root);
     do
     {
         foreach (Building item in openSet)
         {
             closedSet.Add(item);
         }
         HashSet <Building> hashSet = currentSet;
         currentSet = openSet;
         openSet    = hashSet;
         openSet.Clear();
         foreach (Building building in currentSet)
         {
             foreach (IntVec3 c in GenAdj.CellsAdjacentCardinal(building))
             {
                 if (c.InBounds(building.Map))
                 {
                     List <Thing> thingList = c.GetThingList(building.Map);
                     for (int i = 0; i < thingList.Count; i++)
                     {
                         Building building2 = thingList[i] as Building;
                         if (building2 != null && !PipeNetMaker.openSet.Contains(building2) && !PipeNetMaker.currentSet.Contains(building2) && !PipeNetMaker.closedSet.Contains(building2))
                         {
                             PipeNetMaker.openSet.Add(building2);
                             break;
                         }
                     }
                 }
             }
         }
     }while (openSet.Count > 0);
     CompPipe[] result = (from b in closedSet
                          select b.GetComp <CompPipe>()).ToArray <CompPipe>();
     closedSet.Clear();
     openSet.Clear();
     currentSet.Clear();
     return(result);
 }
        // Token: 0x06000027 RID: 39 RVA: 0x00002FDC File Offset: 0x000011DC
        public void damageBuildings(int amt)
        {
            IntVec3 intVec = GenAdj.RandomAdjacentCell8Way(this);
            bool    flag   = GenGrid.InBounds(intVec, base.Map);
            bool    flag2  = flag;

            if (flag2)
            {
                Building   firstBuilding = GridsUtility.GetFirstBuilding(intVec, base.Map);
                DamageInfo damageInfo;
                damageInfo = new DamageInfo(DamageDefOf.Burn, (float)amt, 0f, -1f, null, null, null, 0, null);
                bool flag3 = firstBuilding != null;
                bool flag4 = flag3;
                if (flag4)
                {
                    firstBuilding.TakeDamage(damageInfo);
                }
            }
        }
示例#11
0
        public override void CompTick()
        {
            this.tickProgress += 1;
            if (this.tickProgress > Props.ticksConversionRate)
            {
                Pawn pawn = this.parent as Pawn;
                if ((!pawn.Downed) && (pawn.Map != null))
                {
                    CellRect rect = GenAdj.OccupiedRect(pawn.Position, pawn.Rotation, IntVec2.One);
                    rect = rect.ExpandedBy(2);

                    foreach (IntVec3 current in rect.Cells)
                    {
                        if (current.InBounds(pawn.Map))
                        {
                            HashSet <Thing> hashSet = new HashSet <Thing>(current.GetThingList(pawn.Map));
                            if (hashSet != null)
                            {
                                Thing current2 = hashSet.FirstOrFallback();
                                if (current2 != null)
                                {
                                    if (current2.def.defName == Props.thingToAffect)
                                    {
                                        Thing thing = GenSpawn.Spawn(ThingDef.Named(Props.thingToTurnTo), current, pawn.Map, WipeMode.Vanish);
                                        current2.Destroy();
                                        break;
                                    }
                                    else if (current2.def.defName == Props.secondaryThingToAffect)
                                    {
                                        Thing thing = GenSpawn.Spawn(ThingDef.Named(Props.thingToTurnTo), current, pawn.Map, WipeMode.Vanish);
                                        current2.Destroy();
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }

                // FilthMaker.MakeFilth(this.parent.PositionHeld, this.parent.MapHeld, ThingDef.Named("GR_FilthMucus"), 1);
                this.tickProgress = 0;
            }
        }
示例#12
0
        public static void CheckSpawnBridgeUnder(ThingDef thingDef, IntVec3 c, Rot4 rot)
        {
            if (thingDef.category != ThingCategory.Building)
            {
                return;
            }
            Map      map      = BaseGen.globalSettings.map;
            CellRect cellRect = GenAdj.OccupiedRect(c, rot, thingDef.size);

            BaseGenUtility.bridgeCells.Clear();
            CellRect.CellRectIterator iterator = cellRect.GetIterator();
            while (!iterator.Done())
            {
                if (!iterator.Current.SupportsStructureType(map, thingDef.terrainAffordanceNeeded) && GenConstruct.CanBuildOnTerrain(TerrainDefOf.Bridge, iterator.Current, map, Rot4.North, null))
                {
                    BaseGenUtility.bridgeCells.Add(iterator.Current);
                }
                iterator.MoveNext();
            }
            if (!BaseGenUtility.bridgeCells.Any <IntVec3>())
            {
                return;
            }
            if (thingDef.size.x != 1 || thingDef.size.z != 1)
            {
                for (int i = BaseGenUtility.bridgeCells.Count - 1; i >= 0; i--)
                {
                    for (int j = 0; j < 8; j++)
                    {
                        IntVec3 intVec = BaseGenUtility.bridgeCells[i] + GenAdj.AdjacentCells[j];
                        if (!BaseGenUtility.bridgeCells.Contains(intVec) && intVec.InBounds(map) && !intVec.SupportsStructureType(map, thingDef.terrainAffordanceNeeded) && GenConstruct.CanBuildOnTerrain(TerrainDefOf.Bridge, intVec, map, Rot4.North, null))
                        {
                            BaseGenUtility.bridgeCells.Add(intVec);
                        }
                    }
                }
            }
            for (int k = 0; k < BaseGenUtility.bridgeCells.Count; k++)
            {
                map.terrainGrid.SetTerrain(BaseGenUtility.bridgeCells[k], TerrainDefOf.Bridge);
            }
        }
示例#13
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>();

            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);
                }
                return(false);
            }
            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);
        }
示例#14
0
        public override AcceptanceReport AllowsPlacing(BuildableDef checkingDef, IntVec3 loc, Rot4 rot, Map map, Thing thingToIgnore = null, Thing thing = null)
        {
            /*
             * 맵 이내여야함
             * 조리대 위치쪽도 맵이내여야함
             *
             */
            //GenThing.TrueCenter(loc, rot, checkingDef.Size, checkingDef.Altitude)

            AcceptanceReport result = false;

            CellRect cellRect = GenAdj.OccupiedRect(loc, rot, checkingDef.Size);

            bool needWallFlag = false;
            bool isInBound    = true;

            foreach (IntVec3 c in cellRect)
            {
                IntVec3 addonTarget = c - rot.FacingCell;

                if (!GenGrid.Impassable(c, map))
                {
                    result       = Translator.Translate("WallAttachment_WarningNeedWall");
                    needWallFlag = true;
                }
                if (!c.InBounds(map) || !addonTarget.InBounds(map))
                {
                    result    = "OutOfBounds".Translate();
                    isInBound = false;
                }
                if ((c.InNoBuildEdgeArea(map) || addonTarget.InNoBuildEdgeArea(map)) && !DebugSettings.godMode)
                {
                    result    = "TooCloseToMapEdge".Translate();
                    isInBound = false;
                }
            }
            if (!needWallFlag && isInBound)
            {
                result = true;
            }
            return(result);
        }
示例#15
0
 private static IEnumerable <CompPower> ContiguousPowerBuildings(Building root)
 {
     PowerNetMaker.closedSet.Clear();
     PowerNetMaker.currentSet.Clear();
     PowerNetMaker.openSet.Add(root);
     while (true)
     {
         foreach (Building item in PowerNetMaker.openSet)
         {
             PowerNetMaker.closedSet.Add(item);
         }
         HashSet <Building> hashSet = PowerNetMaker.currentSet;
         PowerNetMaker.currentSet = PowerNetMaker.openSet;
         PowerNetMaker.openSet    = hashSet;
         PowerNetMaker.openSet.Clear();
         foreach (Building item2 in PowerNetMaker.currentSet)
         {
             foreach (IntVec3 item3 in GenAdj.CellsAdjacentCardinal(item2))
             {
                 if (item3.InBounds(item2.Map))
                 {
                     List <Thing> thingList = item3.GetThingList(item2.Map);
                     for (int i = 0; i < thingList.Count; i++)
                     {
                         Building building = thingList[i] as Building;
                         if (building != null && building.TransmitsPowerNow && !PowerNetMaker.openSet.Contains(building) && !PowerNetMaker.currentSet.Contains(building) && !PowerNetMaker.closedSet.Contains(building))
                         {
                             PowerNetMaker.openSet.Add(building);
                             break;
                         }
                     }
                 }
             }
         }
         if (PowerNetMaker.openSet.Count <= 0)
         {
             break;
         }
     }
     return(from b in PowerNetMaker.closedSet
            select b.PowerComp);
 }
        public override AcceptanceReport AllowsPlacing(
            BuildableDef checkingDef,
            IntVec3 loc,
            Rot4 rot,
            Map map,
            Thing thingToIgnore = null
            )
        {
            var overlapsWithSomething = GenAdj.CellsAdjacent8Way(loc, rot, checkingDef.Size).
                                        Union(GenAdj.CellsOccupiedBy(loc, rot, checkingDef.Size)).
                                        SelectMany(cell => map.thingGrid.ThingsListAt(cell)).
                                        Any(thing => {
                if (
                    thing.TryGetComp <CompQSRStockpile>() != null ||
                    thing.TryGetComp <CompQSRWarehouse>() != null ||
                    thing.TryGetComp <CompQSRRelay>() != null
                    )
                {
                    return(true);
                }

                if (
                    thing.def.entityDefToBuild != null &&
                    thing.def.entityDefToBuild is ThingDef thingDef &&
                    thingDef.comps != null &&
                    thingDef.comps.Any(comp => Utils.QuantumCompClasses.Contains(comp.compClass))

                    )
                {
                    return(true);
                }

                return(false);
            });

            if (overlapsWithSomething)
            {
                return("PlaceWorker_QSRNoQSOverlap".Translate());
            }

            return(true);
        }
        // Token: 0x0600001B RID: 27 RVA: 0x000027AC File Offset: 0x000009AC
        public bool BestClosestPowerSource(Pawn pawn, Thing thing)
        {
            CompPower compPower;
            bool      flag  = thing.Faction == pawn.Faction && (compPower = thing.TryGetComp <CompPower>()) != null && compPower.PowerNet != null && compPower.PowerNet.CurrentStoredEnergy() > 50f && !thing.IsForbidden(pawn) && pawn.CanReserve(new LocalTargetInfo(thing), 1, -1, null, false) && thing.Position.InAllowedArea(pawn) && pawn.CanReach(new LocalTargetInfo(thing), PathEndMode.OnCell, Danger.Deadly, false, TraverseMode.ByPawn);
            bool      flag2 = !flag;
            bool      result;

            if (flag2)
            {
                result = false;
            }
            else
            {
                Building t        = thing as Building;
                IntVec3  position = thing.Position;
                bool     flag3    = position.Walkable(pawn.Map) && position.InAllowedArea(pawn) && pawn.CanReserve(new LocalTargetInfo(position), 1, -1, null, false) && pawn.CanReach(position, PathEndMode.OnCell, Danger.Deadly, false, TraverseMode.ByPawn);
                if (flag3)
                {
                    result = true;
                }
                else
                {
                    IEnumerable <IntVec3> source = GenAdj.CellsAdjacentCardinal(t);
                    Func <IntVec3, float> < > 9__0;
                    Func <IntVec3, float> keySelector;
                    if ((keySelector = < > 9__0) == null)
                    {
                        keySelector = (< > 9__0 = ((IntVec3 selector) => selector.DistanceTo(pawn.Position)));
                    }
                    foreach (IntVec3 intVec in source.OrderByDescending(keySelector))
                    {
                        bool flag4 = intVec.Walkable(pawn.Map) && intVec.InAllowedArea(pawn) && pawn.CanReserve(new LocalTargetInfo(intVec), 1, -1, null, false) && pawn.CanReach(intVec, PathEndMode.ClosestTouch, Danger.Deadly, false, TraverseMode.ByPawn);
                        if (flag4)
                        {
                            return(true);
                        }
                    }
                    result = false;
                }
            }
            return(result);
        }
示例#18
0
        private void DrawDebugPowerNets()
        {
            if (Current.ProgramState != ProgramState.Playing || Find.CurrentMap != map)
            {
                return;
            }
            int num = 0;

            foreach (PowerNet allNet in allNets)
            {
                foreach (CompPower item in allNet.transmitters.Concat(allNet.connectors))
                {
                    foreach (IntVec3 item2 in GenAdj.CellsOccupiedBy(item.parent))
                    {
                        CellRenderer.RenderCell(item2, (float)num * 0.44f);
                    }
                }
                num++;
            }
        }
示例#19
0
        // Token: 0x0600001D RID: 29 RVA: 0x00002B28 File Offset: 0x00000D28
        public void damageBuildings(int amt)
        {
            IntVec3 intVec = GenAdj.RandomAdjacentCell8Way(this);
            bool    flag   = GenGrid.InBounds(intVec, base.Map);
            bool    flag2  = flag;

            if (flag2)
            {
                Building   firstBuilding = GridsUtility.GetFirstBuilding(intVec, base.Map);
                DamageInfo damageInfo;
                damageInfo = new DamageInfo(XenomorphDefOf.RRY_AcidBurn, (float)amt, 0f, -1f, null, null, null, 0, null);
                bool flag3 = firstBuilding != null;
                bool flag4 = flag3;
                if (flag4)
                {
                    MoteMaker.ThrowDustPuff(firstBuilding.Position, base.Map, 0.2f);
                    firstBuilding.TakeDamage(damageInfo);
                }
            }
        }
 public override AcceptanceReport AllowsPlacing(BuildableDef def, IntVec3 center, Rot4 rot, Map map, Thing thingToIgnore = null, Thing thing = null)
 {
     foreach (IntVec3 c in GenAdj.OccupiedRect(center, rot, def.Size).ExpandedBy(1))
     {
         List <Thing> list = map.thingGrid.ThingsListAt(c);
         for (int i = 0; i < list.Count; i++)
         {
             Thing thing2 = list[i];
             if (thing2 != thingToIgnore && ((thing2.def.category == ThingCategory.Building && thing2.def.defName == "VFEV_Apiary") || ((thing2.def.IsBlueprint || thing2.def.IsFrame) && thing2.def.entityDefToBuild is ThingDef && ((ThingDef)thing2.def.entityDefToBuild).defName == "VFEV_Apiary")))
             {
                 return("APlaceWorker".Translate());
             }
         }
     }
     if (center.Roofed(map))
     {
         return("APlaceWorkerNoRoof".Translate());
     }
     return(true);
 }
示例#21
0
        public bool IsValidPositionForShipCrashSite(IntVec3 position)
        {
            ThingDef chunkDef = ThingDefOf.ShipChunk;

            if ((position.InBounds() == false) ||
                position.Fogged())
            {
                return(false);
            }
            foreach (IntVec3 chckedPosition in GenAdj.CellsOccupiedBy(position, Rot4.North, this.def.shipPart.size))
            {
                if ((chckedPosition.Standable() == false) ||
                    chckedPosition.Roofed() ||
                    chckedPosition.CanReachColony() == false)
                {
                    return(false);
                }
            }
            return(true);
        }
示例#22
0
        private void DrawDebugPowerNets()
        {
            if (Current.ProgramState != ProgramState.Playing)
            {
                return;
            }
            int num = 0;

            foreach (ShieldNet current in this.allNets)
            {
                foreach (CompShield current2 in current.transmitters.Concat(current.connectors))
                {
                    foreach (IntVec3 current3 in GenAdj.CellsOccupiedBy(current2.parent))
                    {
                        CellRenderer.RenderCell(current3, (float)num * 0.44f);
                    }
                }
                num++;
            }
        }
示例#23
0
 public static bool WipeExistingThings(IntVec3 thingPos, Rot4 thingRot, BuildableDef thingDef, Map map, DestroyMode mode)
 {
     if (thingDef?.Size != null)
     {
         foreach (IntVec3 c in GenAdj.CellsOccupiedBy(thingPos, thingRot, thingDef.Size))
         {
             foreach (Thing thing in map.thingGrid.ThingsAt(c).ToList <Thing>())
             {
                 if (thing?.def?.destroyable != null)
                 {
                     if (GenSpawn.SpawningWipes(thingDef, thing.def))
                     {
                         thing.Destroy(mode);
                     }
                 }
             }
         }
     }
     return(false);
 }
示例#24
0
        public Thing GetSameSpawned(IntVec3 at, Map map)
        {
            if (!at.InBounds(map))
            {
                return(null);
            }
            List <Thing> thingList = at.GetThingList(map);

            for (int i = 0; i < thingList.Count; i++)
            {
                CellRect lhs  = GenAdj.OccupiedRect(at, rot, thingList[i].def.Size);
                CellRect lhs2 = GenAdj.OccupiedRect(at, rot.Opposite, thingList[i].def.Size);
                CellRect rhs  = thingList[i].OccupiedRect();
                if ((lhs == rhs || lhs2 == rhs) && thingList[i].def == def && (stuff == null || thingList[i].Stuff == stuff) && (thingList[i].Rotation == rot || thingList[i].Rotation == rot.Opposite || !def.rotatable))
                {
                    return(thingList[i]);
                }
            }
            return(null);
        }
示例#25
0
        public override Thing GetSpawnedBlueprintOrFrame(IntVec3 at, Map map)
        {
            if (!at.InBounds(map))
            {
                return(null);
            }
            List <Thing> thingList = at.GetThingList(map);

            for (int i = 0; i < thingList.Count; i++)
            {
                CellRect lhs  = GenAdj.OccupiedRect(at, rot, thingList[i].def.Size);
                CellRect lhs2 = GenAdj.OccupiedRect(at, rot.Opposite, thingList[i].def.Size);
                CellRect rhs  = thingList[i].OccupiedRect();
                if ((lhs == rhs || lhs2 == rhs) && thingList[i].def.entityDefToBuild == def && (stuff == null || ((IConstructible)thingList[i]).EntityToBuildStuff() == stuff) && (thingList[i].Rotation == rot || thingList[i].Rotation == rot.Opposite || !def.rotatable))
                {
                    return(thingList[i]);
                }
            }
            return(null);
        }
        public override void PostSpawnSetup()
        {
            base.PostSpawnSetup();

            lastTickStagger++;
            tickStagger = lastTickStagger;

            compFlickable = parent.TryGetComp <CompFlickable>();
            if (compFlickable == null)
            {
                Log.Error("CompRTPowerSwitch could not get parent's CompFlickable!");
            }

            cellIndex = tickStagger;
            cells     = GenAdj.CellsAdjacentCardinal(parent).ToList();
            while (cellIndex > cells.Count)
            {
                cellIndex -= cells.Count;
            }
        }
        public override void Print(SectionLayer layer, Thing thing)
        {
            base.Print(layer, thing);

            // also print on cardinal neighbours if that neighbour transmits gas but is not linked itself
            // this draws 'connections' underneath gas users.
            foreach (var cell in GenAdj.CellsAdjacentCardinal(thing)
                     .Where(c => GenGrid.InBounds((IntVec3)c, thing.Map)))
            {
                var neighbour = cell.GetThingList(thing.Map)
                                .FirstOrDefault(t => t.TryGetComp <CompGas>(out _) &&
                                                !t.def.graphicData.Linked);
                if (neighbour != null)
                {
                    var mat = LinkedDrawMatFrom(thing, cell);
                    Printer_Plane.PrintPlane(layer, cell.ToVector3ShiftedWithAltitude(thing.def.Altitude),
                                             Vector2.one, mat);
                }
            }
        }
        public static void DrawBridgeCost(Designator_Build designator, Vector2 drawPos, float curY, ThingDef stuff)
        {
            DesignationDragger dragger  = Find.DesignatorManager.Dragger;
            int bridgeCount             = 0;
            IEnumerable <IntVec3> cells = dragger.Dragging ? dragger.DragCells :
                                          GenAdj.OccupiedRect(UI.MouseCell(), designator.PlacingRot(), designator.PlacingDef.Size).Cells;

            foreach (IntVec3 dragPos in cells)
            {
                if (PlaceBridges.NeedsBridge(designator.PlacingDef, dragPos, designator.Map, stuff))
                {
                    bridgeCount++;
                }
            }

            if (bridgeCount == 0)
            {
                return;
            }

            //could just say wood here, this is still assuming it costs only one thing.
            ThingDefCountClass bridgeCost = TerrainDefOf.Bridge.costList.First();

            Widgets.ThingIcon(new Rect(drawPos.x, drawPos.y + curY, 27f, 27f), bridgeCost.thingDef);

            int totalCost = bridgeCost.count * bridgeCount;

            string label = $"{totalCost} ({TerrainDefOf.Bridge.LabelCap})";

            //This doesn't account for normal building cost + under bridge cost, but what can you do
            if (designator.Map.resourceCounter.GetCount(bridgeCost.thingDef) < totalCost)
            {
                GUI.color = Color.red;
                label     = label + " (" + "NotEnoughStoredLower".Translate() + ")";
            }
            Text.Font   = GameFont.Small;
            Text.Anchor = TextAnchor.MiddleLeft;
            Widgets.Label(new Rect(drawPos.x + 29f, drawPos.y + curY, 999f, 29f), label);
            Text.Anchor = TextAnchor.UpperLeft;
            GUI.color   = Color.white;
        }
        public override void Resolve(ResolveParams rp)
        {
            ThingDef thingDef;

            if ((thingDef = rp.singleThingDef) == null)
            {
                thingDef = (from x in ThingSetMakerUtility.allGeneratableItems
                            where x.IsWeapon || x.IsMedicine || x.IsDrug
                            select x).RandomElement <ThingDef>();
            }
            ThingDef thingDef2             = thingDef;
            Rot4?    thingRot              = rp.thingRot;
            Rot4     rot                   = (thingRot == null) ? Rot4.North : thingRot.Value;
            IntVec3  zero                  = IntVec3.Zero;
            IntVec2  size                  = thingDef2.size;
            int?     fillWithThingsPadding = rp.fillWithThingsPadding;
            int      num                   = (fillWithThingsPadding == null) ? 0 : fillWithThingsPadding.Value;

            if (num < 0)
            {
                num = 0;
            }
            GenAdj.AdjustForRotation(ref zero, ref size, rot);
            if (size.x <= 0 || size.z <= 0)
            {
                Log.Error("Thing has 0 size.", false);
                return;
            }
            for (int i = rp.rect.minX; i <= rp.rect.maxX - size.x + 1; i += size.x + num)
            {
                for (int j = rp.rect.minZ; j <= rp.rect.maxZ - size.z + 1; j += size.z + num)
                {
                    ResolveParams resolveParams = rp;
                    resolveParams.rect           = new CellRect(i, j, size.x, size.z);
                    resolveParams.singleThingDef = thingDef2;
                    resolveParams.thingRot       = new Rot4?(rot);
                    BaseGen.symbolStack.Push("thing", resolveParams);
                }
            }
            BaseGen.symbolStack.Push("clear", rp);
        }
示例#30
0
        private void PodImpact()
        {
            for (int i = 0; i < 6; i++)
            {
                Vector3 spawnLoc = base.Position.ToVector3Shifted() + Gen.RandomHorizontalVector(1f);
                MoteMaker.ThrowDustPuff(spawnLoc, this.Map, 1.2f);
            }
            MoteMaker.ThrowLightningGlow(base.Position.ToVector3Shifted(), this.Map, 2f);
            MoteMaker.ThrowSmoke(base.Position.ToVector3Shifted(), this.Map, 1f);

            MeteorIncoming.ExplodeSound.PlayOneShot(new TargetInfo(base.Position, base.Map, false));
            foreach (IntVec3 current in GenAdj.CellsAdjacent8Way(this))
            {
                MoteMaker.ThrowAirPuffUp(base.Position.ToVector3Shifted(), this.Map);
            }
            GenSpawn.Spawn(this.contents.SingleContainedThing, base.Position, this.Map, base.Rotation);
            if (this.contents.SingleContainedThing is AlienQueen queen)
            {
                queen.health.AddHediff(PurpleIvyDefOf.PI_CrashlandedDowned);
                queen.health.AddHediff(PurpleIvyDefOf.PI_Regen);
                queen.recoveryTick = Find.TickManager.TicksGame + new IntRange(80000, 140000).RandomInRange;
                queen.canGuard     = true;
            }
            else if (this.contents.SingleContainedThing is Building_Meteorite meteorite)
            {
                foreach (var dir in GenRadial.RadialCellsAround(meteorite.Position, 5, true))
                {
                    if (GenGrid.InBounds(dir, meteorite.Map))
                    {
                        Thing thing = ThingMaker.MakeThing(PurpleIvyDefOf.PI_Spores, null);
                        GenSpawn.Spawn(thing, dir, meteorite.Map, 0);
                        var Spores = (PurpleGas)thing;
                        Spores.destroyTick  = Find.TickManager.TicksGame + new IntRange(160000, 180000).RandomInRange;
                        Spores.activeDamage = true;
                        meteorite.spores.Add(Spores);
                    }
                }
            }
            GenExplosion.DoExplosion(base.Position, this.Map, 5f, DamageDefOf.Bomb, this);
            this.Destroy(DestroyMode.Vanish);
        }