Exemple #1
0
        private static bool Prefix(Site ___site, PawnsArrivalModeDef ___arrivalMode, List <ActiveDropPodInfo> pods)
        {
            if (___site.parts == null)
            {
                return(true);
            }

            foreach (var part in ___site.parts)
            {
                if (part.def != MFI_DefOf.MFI_HuntersLodgePart)
                {
                    continue;
                }

                var lookTarget    = TransportPodsArrivalActionUtility.GetLookTarget(pods);
                var num           = !___site.HasMap;
                var orGenerateMap = GetOrGenerateMapUtility.GetOrGenerateMap(___site.Tile,
                                                                             ___site.PreferredMapSize, null);
                if (num)
                {
                    Find.TickManager.Notify_GeneratedPotentiallyHostileMap();
                    PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(orGenerateMap.mapPawns.AllPawns,
                                                                             "LetterRelatedPawnsInMapWherePlayerLanded".Translate(Faction.OfPlayer.def.pawnsPlural),
                                                                             LetterDefOf.NeutralEvent, true);
                }

                Messages.Message("MessageTransportPodsArrived".Translate(), lookTarget,
                                 MessageTypeDefOf.TaskCompletion);
                ___arrivalMode.Worker.TravelingTransportPodsArrived(pods, orGenerateMap);
                return(false);
            }

            return(true);
        }
 public WagerIncidentHelper(IncidentCategoryDef categoryDef, IncidentDef incidentDef, RaidStrategyDef raidStrat, PawnsArrivalModeDef arrivalMode)
 {
     this.categoryDef   = categoryDef;
     this.incidentDef   = incidentDef;
     raidStratDef       = raidStrat;
     pawnArrivalModeDef = arrivalMode;
 }
Exemple #3
0
        internal void Arrive(IntVec3 targetCell, ShipArrivalAction arrivalAction, PawnsArrivalModeDef mapArrivalMode)
        {
            if (this.IsPlayerControlled && arrivalAction != ShipArrivalAction.BombingRun)
            {
                Messages.Message("MessageShipsArrived".Translate(), this, MessageTypeDefOf.NeutralEvent);
            }

            if (arrivalAction == ShipArrivalAction.EnterMapAssault || arrivalAction == ShipArrivalAction.EnterMapFriendly)
            {
                MapParent parent = Find.WorldObjects.MapParentAt(this.Tile);
                if (parent != null)
                {
                    Map map = parent.Map;
                    if (map == null)
                    {
                        LongEventHandler.QueueLongEvent(delegate
                        {
                            MapGeneratorDef def = WorldShipUtility.GetMapGeneratorDefForObject(parent);
                            map        = MapGenerator.GenerateMap(Find.World.info.initialMapSize, parent, MapGeneratorDefOf.Base_Faction);
                            targetCell = IntVec3.Zero;
                        }, "GeneratingMap", true, new Action <Exception>(GameAndMapInitExceptionHandlers.ErrorWhileGeneratingMap));
                    }
                    LongEventHandler.QueueLongEvent(delegate
                    {
                        WorldShipUtility.EnterMapWithShip(this, map, targetCell, arrivalAction, mapArrivalMode);
                    }, "SpawningColonists", true, new Action <Exception>(GameAndMapInitExceptionHandlers.ErrorWhileGeneratingMap));
                }
            }
            else if (arrivalAction == ShipArrivalAction.BombingRun)
            {
                if (BombingUtility.TryBombWorldTarget(this.Tile, this))
                {
                }
            }
        }
        protected override void RunInt()
        {
            Slate slate = QuestGen.slate;
            PawnsArrivalModeDef pawnsArrivalModeDef = this.arrivalMode.GetValue(slate) ?? PawnsArrivalModeDefOf.EdgeWalkIn;

            // this line is the only thing changed (we are using custom QuestPart)
            var pawnsArrive = new Kyrun.Reunion.QuestPart_PawnsArrive();

            pawnsArrive.inSignal = (QuestGenUtility.HardcodedSignalWithQuestID(this.inSignal.GetValue(slate)) ?? QuestGen.slate.Get <string>("inSignal", null, false));
            pawnsArrive.pawns.AddRange(this.pawns.GetValue(slate));
            pawnsArrive.arrivalMode = pawnsArrivalModeDef;
            pawnsArrive.joinPlayer  = this.joinPlayer.GetValue(slate);
            pawnsArrive.mapParent   = QuestGen.slate.Get <Map>("map", null, false).Parent;
            if (pawnsArrivalModeDef.walkIn)
            {
                pawnsArrive.spawnNear = (this.walkInSpot.GetValue(slate) ?? (QuestGen.slate.Get <IntVec3?>("walkInSpot", null, false) ?? IntVec3.Invalid));
            }
            if (!this.customLetterLabel.GetValue(slate).NullOrEmpty() || this.customLetterLabelRules.GetValue(slate) != null)
            {
                QuestGen.AddTextRequest("root", delegate(string x)
                {
                    pawnsArrive.customLetterLabel = x;
                }, QuestGenUtility.MergeRules(this.customLetterLabelRules.GetValue(slate), this.customLetterLabel.GetValue(slate), "root"));
            }
            if (!this.customLetterText.GetValue(slate).NullOrEmpty() || this.customLetterTextRules.GetValue(slate) != null)
            {
                QuestGen.AddTextRequest("root", delegate(string x)
                {
                    pawnsArrive.customLetterText = x;
                }, QuestGenUtility.MergeRules(this.customLetterTextRules.GetValue(slate), this.customLetterText.GetValue(slate), "root"));
            }
            QuestGen.quest.AddPart(pawnsArrive);
        }
Exemple #5
0
        public override void TimerEnd()
        {
            if (Pawns == null || Map == null)
            {
                return;
            }

            for (int i = 0; i < Pawns.Count; i++)
            {
                Pawn p = Pawns[i];
                if (p == null)
                {
                    Pawns.RemoveAt(i);
                }
            }

            IncidentParms parms = new IncidentParms
            {
                target  = Map,
                faction = GssRaids.GssFaction
            };

            PawnsArrivalModeDef pawnsArrivalMode = GssRaids.ResolveRaidArriveMode(parms);

            pawnsArrivalMode.Worker.Arrive(Pawns, parms);

            RaidStrategyDef raidStrategy = GssRaids.ResolveRaidStrategy();

            raidStrategy.Worker.MakeLords(parms, Pawns);

            Find.LetterStack.ReceiveLetter("DarkNet_RaidArriveTitle".Translate(), "DarkNet_RaidArriveDesc".Translate(GssRaids.GssFaction.Name), LetterDefOf.ThreatBig, new LookTargets(parms.spawnCenter, Map));
        }
        private void TryLaunch(GlobalTargetInfo target, PawnsArrivalModeDef arriveMode, bool attackOnArrival)
        {
            Cthulhu.Utility.DebugReport("TryLaunch Called");
            if (!this.parent.Spawned)
            {
                Log.Error("Tried to launch " + this.parent + ", but it's unspawned.");
                return;
            }
            List <CompTransporterPawn> transportersInGroup = this.TransportersInGroup;

            if (transportersInGroup == null)
            {
                Log.Error("Tried to launch " + this.parent + ", but it's not in any group.");
                return;
            }
            if (!this.LoadingInProgressOrReadyToLaunch)
            {
                Cthulhu.Utility.DebugReport("TryLaunch Failed");
                return;
            }
            Map map = this.parent.Map;
            int num = Find.WorldGrid.TraversalDistanceBetween(map.Tile, target.Tile);

            if (num > this.MaxLaunchDistance)
            {
                Cthulhu.Utility.DebugReport("TryLaunch Failed #2");
                return;
            }
            this.Transporter.TryRemoveLord(map);
            int groupID = this.Transporter.groupID;

            for (int i = 0; i < transportersInGroup.Count; i++)
            {
                Cthulhu.Utility.DebugReport("Transporter Outspawn Attempt");
                CompTransporterPawn compTransporter = transportersInGroup[i];
                Cthulhu.Utility.DebugReport("Transporter Outspawn " + compTransporter.parent.Label);
                PawnFlyersLeaving pawnFlyerLeaving = (PawnFlyersLeaving)ThingMaker.MakeThing(PawnFlyerDef.leavingDef, null);
                pawnFlyerLeaving.groupID         = groupID;
                pawnFlyerLeaving.pawnFlyer       = this.parent as PawnFlyer;
                pawnFlyerLeaving.destinationTile = target.Tile;
                pawnFlyerLeaving.destinationCell = target.Cell;
                pawnFlyerLeaving.arriveMode      = arriveMode;
                pawnFlyerLeaving.attackOnArrival = attackOnArrival;
                ThingOwner innerContainer = compTransporter.GetDirectlyHeldThings();
                pawnFlyerLeaving.Contents = new ActiveDropPodInfo();
                innerContainer.TryTransferAllToContainer(pawnFlyerLeaving.Contents.innerContainer);
                //pawnFlyerLeaving.Contents.innerContainer. //TryAddMany(innerContainer);
                innerContainer.Clear();
                compTransporter.CleanUpLoadingVars(map);
                compTransporter.parent.DeSpawn();
                pawnFlyerLeaving.Contents.innerContainer.TryAdd(compTransporter.parent);
                GenSpawn.Spawn(pawnFlyerLeaving, compTransporter.parent.Position, map);
            }
        }
Exemple #7
0
        public static void SendRaidImmediately(Map map, float points, bool notify = true)
        {
            float totalPower = points;
            List <PawnKindDef> selectedKinds = new List <PawnKindDef>();

            while (totalPower > 0)
            {
                PawnKindDef selected = PawnKinds.RandomElementByWeight(x => x.Value).Key;

                selectedKinds.Add(selected);
                totalPower -= selected.combatPower;
            }

            if (selectedKinds.Count == 0)
            {
                return;
            }

            List <Pawn> outPawns = new List <Pawn>();

            foreach (PawnKindDef kind in selectedKinds)
            {
                PawnGenerationRequest request = new PawnGenerationRequest(kind, GssFaction, PawnGenerationContext.NonPlayer, -1, forceGenerateNewPawn: false, newborn: false, allowDead: false, allowDowned: false, canGeneratePawnRelations: true, mustBeCapableOfViolence: true, 1f, forceAddFreeWarmLayerIfNeeded: false, allowGay: true, true, false, certainlyBeenInCryptosleep: false, forceRedressWorldPawnIfFormerColonist: false, worldPawnFactionDoesntMatter: false);
                Pawn pawn = PawnGenerator.GeneratePawn(request);
                outPawns.Add(pawn);

                Find.WorldPawns.PassToWorld(pawn);
            }

            if (outPawns.Count == 0)
            {
                return;
            }

            IncidentParms parms = new IncidentParms
            {
                target  = map,
                faction = GssFaction
            };

            PawnsArrivalModeDef pawnsArrivalMode = ResolveRaidArriveMode(parms);

            pawnsArrivalMode.Worker.Arrive(outPawns, parms);

            RaidStrategyDef raidStrategy = ResolveRaidStrategy();

            raidStrategy.Worker.MakeLords(parms, outPawns);

            if (notify)
            {
                Find.LetterStack.ReceiveLetter("DarkNet_RaidSendedTitle".Translate(), "DarkNet_RaidSendedDesc".Translate(GssFaction.Name), LetterDefOf.ThreatBig);
            }
        }
 public ShipBase_Traveling(ShipBase ship, RimWorld.Planet.GlobalTargetInfo target, PawnsArrivalModeDef arriveMode, ShipArrivalAction arrivalAction = ShipArrivalAction.StayOnWorldMap, bool leavingForTarget = true)
 {
     this.containingShip   = ship;
     this.def              = ship.compShip.sProps.LeavingShipDef;
     this.def.size         = ship.def.size;
     this.def.graphicData  = ship.def.graphicData;
     this.destinationTile  = target.Tile;
     this.destinationCell  = target.Cell;
     this.pawnArriveMode   = arriveMode;
     this.leavingForTarget = leavingForTarget;
     this.Rotation         = ship.Rotation;
     this.arrivalAction    = arrivalAction;
 }
Exemple #9
0
 public static float AdjustedRaidPoints(float points, PawnsArrivalModeDef raidArrivalMode, RaidStrategyDef raidStrategy, Faction faction, PawnGroupKindDef groupKind)
 {
     if (raidArrivalMode.pointsFactorCurve != null)
     {
         points *= raidArrivalMode.pointsFactorCurve.Evaluate(points);
     }
     if (raidStrategy.pointsFactorCurve != null)
     {
         points *= raidStrategy.pointsFactorCurve.Evaluate(points);
     }
     points = Mathf.Max(points, raidStrategy.Worker.MinimumPoints(faction, groupKind) * 1.05f);
     return(points);
 }
Exemple #10
0
        public static void PawnsArrive(this Quest quest, IEnumerable <Pawn> pawns, string inSignal = null, MapParent mapParent = null, PawnsArrivalModeDef arrivalMode = null, bool joinPlayer = false, IntVec3?walkInSpot = null, string customLetterLabel = null, string customLetterText = null, RulePack customLetterLabelRules = null, RulePack customLetterTextRules = null, bool isSingleReward = false, bool rewardDetailsHidden = false)
        {
            _ = QuestGen.slate;
            PawnsArrivalModeDef   pawnsArrivalModeDef = arrivalMode ?? PawnsArrivalModeDefOf.EdgeWalkIn;
            QuestPart_PawnsArrive pawnsArrive         = new QuestPart_PawnsArrive();

            pawnsArrive.inSignal = QuestGenUtility.HardcodedSignalWithQuestID(inSignal) ?? QuestGen.slate.Get <string>("inSignal");
            pawnsArrive.pawns.AddRange(pawns);
            pawnsArrive.arrivalMode = pawnsArrivalModeDef;
            pawnsArrive.joinPlayer  = joinPlayer;
            pawnsArrive.mapParent   = mapParent ?? QuestGen.slate.Get <Map>("map").Parent;
            if (pawnsArrivalModeDef.walkIn)
            {
                pawnsArrive.spawnNear = walkInSpot ?? QuestGen.slate.Get <IntVec3?>("walkInSpot") ?? IntVec3.Invalid;
            }
            if (!customLetterLabel.NullOrEmpty() || customLetterLabelRules != null)
            {
                QuestGen.AddTextRequest("root", delegate(string x)
                {
                    pawnsArrive.customLetterLabel = x;
                }, QuestGenUtility.MergeRules(customLetterLabelRules, customLetterLabel, "root"));
            }
            if (!customLetterText.NullOrEmpty() || customLetterTextRules != null)
            {
                QuestGen.AddTextRequest("root", delegate(string x)
                {
                    pawnsArrive.customLetterText = x;
                }, QuestGenUtility.MergeRules(customLetterTextRules, customLetterText, "root"));
            }
            QuestGen.quest.AddPart(pawnsArrive);
            if (!isSingleReward)
            {
                return;
            }
            QuestPart_Choice questPart_Choice = new QuestPart_Choice();

            questPart_Choice.inSignalChoiceUsed = pawnsArrive.inSignal;
            QuestPart_Choice.Choice choice = new QuestPart_Choice.Choice();
            choice.questParts.Add(pawnsArrive);
            foreach (Pawn pawn in pawnsArrive.pawns)
            {
                choice.rewards.Add(new Reward_Pawn
                {
                    pawn          = pawn,
                    detailsHidden = rewardDetailsHidden
                });
            }
            questPart_Choice.choices.Add(choice);
            QuestGen.quest.AddPart(questPart_Choice);
        }
        protected override void RunInt()
        {
            Slate slate = QuestGen.slate;
            PawnsArrivalModeDef   pawnsArrivalModeDef = arrivalMode.GetValue(slate) ?? PawnsArrivalModeDefOf.EdgeWalkIn;
            QuestPart_PawnsArrive pawnsArrive         = new QuestPart_PawnsArrive();

            pawnsArrive.inSignal = QuestGenUtility.HardcodedSignalWithQuestID(inSignal.GetValue(slate)) ?? QuestGen.slate.Get <string>("inSignal");
            pawnsArrive.pawns.AddRange(pawns.GetValue(slate));
            pawnsArrive.arrivalMode = pawnsArrivalModeDef;
            pawnsArrive.joinPlayer  = joinPlayer.GetValue(slate);
            pawnsArrive.mapParent   = QuestGen.slate.Get <Map>("map").Parent;
            if (pawnsArrivalModeDef.walkIn)
            {
                pawnsArrive.spawnNear = walkInSpot.GetValue(slate) ?? QuestGen.slate.Get <IntVec3?>("walkInSpot") ?? IntVec3.Invalid;
            }
            if (!customLetterLabel.GetValue(slate).NullOrEmpty() || customLetterLabelRules.GetValue(slate) != null)
            {
                QuestGen.AddTextRequest("root", delegate(string x)
                {
                    pawnsArrive.customLetterLabel = x;
                }, QuestGenUtility.MergeRules(customLetterLabelRules.GetValue(slate), customLetterLabel.GetValue(slate), "root"));
            }
            if (!customLetterText.GetValue(slate).NullOrEmpty() || customLetterTextRules.GetValue(slate) != null)
            {
                QuestGen.AddTextRequest("root", delegate(string x)
                {
                    pawnsArrive.customLetterText = x;
                }, QuestGenUtility.MergeRules(customLetterTextRules.GetValue(slate), customLetterText.GetValue(slate), "root"));
            }
            QuestGen.quest.AddPart(pawnsArrive);
            if (!isSingleReward.GetValue(slate))
            {
                return;
            }
            QuestPart_Choice questPart_Choice = new QuestPart_Choice();

            questPart_Choice.inSignalChoiceUsed = pawnsArrive.inSignal;
            QuestPart_Choice.Choice choice = new QuestPart_Choice.Choice();
            choice.questParts.Add(pawnsArrive);
            foreach (Pawn pawn in pawnsArrive.pawns)
            {
                choice.rewards.Add(new Reward_Pawn
                {
                    pawn          = pawn,
                    detailsHidden = rewardDetailsHidden.GetValue(slate)
                });
            }
            questPart_Choice.choices.Add(choice);
            QuestGen.quest.AddPart(questPart_Choice);
        }
Exemple #12
0
        public static bool RaidPossible(float points, PawnsArrivalModeDef arrival, RaidStrategyDef strategy = null, Faction faction = null)
        {
            var raidEnemy = new IncidentWorker_RaidEnemy();

            raidEnemy.def = IncidentDefOf.RaidEnemy;
            return(raidEnemy.CanFireNow(new IncidentParms
            {
                target = Helper.AnyPlayerMap,
                points = Math.Max(StorytellerUtility.DefaultThreatPointsNow(Helper.AnyPlayerMap), points),
                raidArrivalMode = arrival,
                raidStrategy = strategy == null ? RaidStrategyDefOf.ImmediateAttack : strategy,
                faction = faction
            }));
        }
Exemple #13
0
        public static void Raid(float points, PawnsArrivalModeDef arrival, RaidStrategyDef strategy = null, Faction faction = null)
        {
            if (points < 0)
            {
                return;
            }
            var raidEnemy = new IncidentWorker_RaidEnemy();

            raidEnemy.def = IncidentDefOf.RaidEnemy;
            raidEnemy.TryExecute(new IncidentParms
            {
                target          = Helper.AnyPlayerMap,
                points          = Math.Max(StorytellerUtility.DefaultThreatPointsNow(Helper.AnyPlayerMap), points),
                raidArrivalMode = arrival,
                raidStrategy    = strategy == null ? RaidStrategyDefOf.ImmediateAttack : strategy,
                faction         = faction
            });
        }
Exemple #14
0
 public void SetDestination(int destTile, IntVec3 destinationCell, ShipArrivalAction arrivalAction, PawnsArrivalModeDef pawnsArrivalMode)
 {
     if (this.worldPath != null)
     {
         this.worldPath.Dispose();
     }
     this._destinationTile = destTile;
     this._destinationCell = destinationCell;
     this._startTile       = this._worldShip.Tile;
     this.drawTileStart    = this._startTile;
     this.worldPath        = DropShipUtility.CurrentShipTracker.WorldShipPathFinder.FindPath(_startTile, _destinationTile, this._worldShip, (int)this.MinTicksPerTile);
     this.status           = WorldShipPatherStatus.Travelling;
     this.moving           = true;
     this._arrivalAction   = arrivalAction;
     this._mapArrivalMode  = pawnsArrivalMode;
     this.currentTileTraversalTicksLeft = this.MinTicksPerTile;
     this._worldShip.IsTargeting        = false;
 }
Exemple #15
0
        public void SendHelp(IncidentParms parms)
        {
            if (alreadyHelped)
            {
                return;
            }

            PawnGroupMakerParms pawnGroupMakerParms = new PawnGroupMakerParms
            {
                faction   = SignedFaction.Faction,
                groupKind = PawnGroupKindDefOf.Combat,
                points    = (int)fightersLevel
            };

            List <Pawn> pawns = new List <Pawn>();
            int         count = Rand.Range(3, 5);

            foreach (var p in PawnGroupMakerUtility.GeneratePawns(pawnGroupMakerParms))
            {
                if (pawns.Count == count)
                {
                    break;
                }

                pawns.Add(p);
            }

            PawnsArrivalModeDef pawnsArrivalMode = PawnsArrivalModeDef;

            pawnsArrivalMode.Worker.Arrive(pawns, parms);

            foreach (var pawn in pawns)
            {
                pawn.SetFaction(OwnerFaction.Faction);

                pawnsData.Add(pawn);
            }

            alreadyHelped = true;
            leaveTicks    = Find.TickManager.TicksGame + 60000;

            Find.LetterStack.ReceiveLetter("DefenseContractComp_HelpTitle".Translate(), "DefenseContractComp_HelpDesc".Translate(SignedFaction.Faction.Name), LetterDefOf.PositiveEvent);
        }
Exemple #16
0
 public void TryLaunch(RimWorld.Planet.GlobalTargetInfo target, PawnsArrivalModeDef arriveMode, ShipArrivalAction arrivalAction, bool launchedAsSingleShip = false)
 {
     this.timeToLiftoff = 0;
     if (this.parentWorldShip == null)
     {
         this.shipState = ShipState.Outgoing;
         ShipBase_Traveling travelingShip = new ShipBase_Traveling(this, target, arriveMode, arrivalAction);
         Map     curMap = this.Map;
         IntVec3 curPos = this.Position;
         this.DeSpawn();
         GenSpawn.Spawn(travelingShip, curPos, curMap, this.Rotation, WipeMode.Vanish);
         if (this.LaunchAsFleet)
         {
             foreach (ShipBase current in DropShipUtility.CurrentShipTracker.ShipsInFleet(this.fleetID))
             {
                 if (current != this && current.Spawned)
                 {
                     current.shipState = ShipState.Outgoing;
                     ShipBase_Traveling travelingShip2 = new ShipBase_Traveling(current, target, arriveMode, arrivalAction);
                     Map     shipMap = current.Map;
                     IntVec3 shipPos = current.Position;
                     current.DeSpawn();
                     GenSpawn.Spawn(travelingShip2, shipPos, shipMap, current.Rotation, WipeMode.Vanish);
                 }
             }
         }
     }
     else
     {
         //      Find.WorldSelector.Select(parentLandedShip);
         //WorldShipUtility.LaunchLandedFleet(this.parentWorldShip, target.Tile, target.Cell, arriveMode, arrivalAction);
         this.parentWorldShip.Launch(target.Tile, target.Cell, arrivalAction, arriveMode);
         //this.parentShipCached = null;
         //Find.MainTabsRoot.SetCurrentTab(MainButtonDefOf.World, false);
     }
 }
 public ByakheeArrivalAction_VisitSite(Site site, PawnsArrivalModeDef arrivalMode)
 {
     this.site        = site;
     this.arrivalMode = arrivalMode;
 }
        // Token: 0x06000088 RID: 136 RVA: 0x00004224 File Offset: 0x00002424
        public static void Postfix()
        {
            //	Log.Message("GenerateImpliedDefs_PreResolve");

            PawnGroupKindDef pawnGroupKindDef = new PawnGroupKindDef();

            pawnGroupKindDef.defName     = "Hive_OgsOld_ExtraHives";
            pawnGroupKindDef.workerClass = typeof(PawnGroupKindWorker_Normal);
            DefGenerator.AddImpliedDef <PawnGroupKindDef>(pawnGroupKindDef);

            pawnGroupKindDef             = new PawnGroupKindDef();
            pawnGroupKindDef.defName     = "Tunneler_OgsOld_ExtraHives";
            pawnGroupKindDef.workerClass = typeof(PawnGroupKindWorker_Normal);
            DefGenerator.AddImpliedDef <PawnGroupKindDef>(pawnGroupKindDef);

            PawnsArrivalModeDef pawnsArrivalModeDef = new PawnsArrivalModeDef();

            pawnsArrivalModeDef.defName        = "EdgeTunnelIn_OgsOld_ExtraHives";
            pawnsArrivalModeDef.textEnemy      = "A group of {0} from {1} have tunneled in nearby.";
            pawnsArrivalModeDef.textFriendly   = "A group of friendly {0} from {1} have tunneled in nearby.";
            pawnsArrivalModeDef.textWillArrive = "{0_pawnsPluralDef} will tunnel in.";
            pawnsArrivalModeDef.workerClass    = typeof(OgsOld_ExtraHives.PawnsArrivalModeWorker_EdgeTunnel);

            /*
             * pawnsArrivalModeDef.selectionWeightCurve = new SimpleCurve();
             * pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(300f,0f));
             * pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(700f,0.3f));
             */
            DefGenerator.AddImpliedDef <PawnsArrivalModeDef>(pawnsArrivalModeDef);

            pawnsArrivalModeDef                = new PawnsArrivalModeDef();
            pawnsArrivalModeDef.defName        = "EdgeTunnelInGroups_OgsOld_ExtraHives";
            pawnsArrivalModeDef.textEnemy      = "Several separate groups of {0} from {1} have tunneled in nearby.";
            pawnsArrivalModeDef.textFriendly   = "Several separate groups of friendly {0} from {1} have tunneled in nearby.";
            pawnsArrivalModeDef.textWillArrive = "Several separate groups of {0_pawnsPluralDef} will tunnel in.";
            pawnsArrivalModeDef.workerClass    = typeof(OgsOld_ExtraHives.PawnsArrivalModeWorker_EdgeTunnelGroups);

            /*
             * pawnsArrivalModeDef.selectionWeightCurve = new SimpleCurve();
             * pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(100f, 0f));
             * pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(300f, 0.2f));
             * pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(700f, 0.5f));
             * pawnsArrivalModeDef.pointsFactorCurve = new SimpleCurve();
             * pawnsArrivalModeDef.pointsFactorCurve.Add(new CurvePoint(0f, 0.9f));
             */
            DefGenerator.AddImpliedDef <PawnsArrivalModeDef>(pawnsArrivalModeDef);

            pawnsArrivalModeDef                = new PawnsArrivalModeDef();
            pawnsArrivalModeDef.defName        = "CenterTunnelIn_OgsOld_ExtraHives";
            pawnsArrivalModeDef.textEnemy      = "A group of {0} from {1} have tunneled in right on top of you!";
            pawnsArrivalModeDef.textFriendly   = "A group of friendly {0} from {1} have tunneled in right on top of you!";
            pawnsArrivalModeDef.textWillArrive = "{0_pawnsPluralDef} will tunnel in right on top of you.";
            pawnsArrivalModeDef.workerClass    = typeof(OgsOld_ExtraHives.PawnsArrivalModeWorker_CenterTunnel);

            /*
             * pawnsArrivalModeDef.selectionWeightCurve = new SimpleCurve();
             * pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(300f, 0.0f));
             * pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(1000f, 3.5f));
             * pawnsArrivalModeDef.pointsFactorCurve = new SimpleCurve();
             * pawnsArrivalModeDef.pointsFactorCurve.Add(new CurvePoint(0f, 0.75f));
             * pawnsArrivalModeDef.pointsFactorCurve.Add(new CurvePoint(5000f, 0.5f));
             */
            DefGenerator.AddImpliedDef <PawnsArrivalModeDef>(pawnsArrivalModeDef);

            pawnsArrivalModeDef                = new PawnsArrivalModeDef();
            pawnsArrivalModeDef.defName        = "RandomTunnelIn_OgsOld_ExtraHives";
            pawnsArrivalModeDef.textEnemy      = "A group of {0} from {1} have tunneled in. They are scattered all over the area!";
            pawnsArrivalModeDef.textFriendly   = "A group of friendly {0} from {1} have tunneled in. They are scattered all over the area!";
            pawnsArrivalModeDef.textWillArrive = "{0_pawnsPluralDef} will tunnel in.";
            pawnsArrivalModeDef.workerClass    = typeof(OgsOld_ExtraHives.PawnsArrivalModeWorker_RandomTunnel);

            /*
             * pawnsArrivalModeDef.selectionWeightCurve = new SimpleCurve();
             * pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(300f, 0f));
             * pawnsArrivalModeDef.selectionWeightCurve.Add(new CurvePoint(1000f, 1.9f));
             * pawnsArrivalModeDef.pointsFactorCurve = new SimpleCurve();
             * pawnsArrivalModeDef.pointsFactorCurve.Add(new CurvePoint(0f, 0.7f));
             * pawnsArrivalModeDef.pointsFactorCurve.Add(new CurvePoint(5000f, 0.45f));
             */
            DefGenerator.AddImpliedDef <PawnsArrivalModeDef>(pawnsArrivalModeDef);

            ThingDef thingDef = new ThingDef();

            thingDef.defName                   = "InfestedMeteoriteIncoming_OgsOld_ExtraHives";
            thingDef.category                  = ThingCategory.Ethereal;
            thingDef.thingClass                = typeof(Skyfaller);
            thingDef.useHitPoints              = false;
            thingDef.drawOffscreen             = true;
            thingDef.tickerType                = TickerType.Normal;
            thingDef.altitudeLayer             = AltitudeLayer.Skyfaller;
            thingDef.drawerType                = DrawerType.RealtimeOnly;
            thingDef.skyfaller                 = new SkyfallerProperties();
            thingDef.label                     = "meteorite (incoming)";
            thingDef.size                      = new IntVec2(3, 3);
            thingDef.graphicData               = new GraphicData();
            thingDef.graphicData.texPath       = "Things/Skyfaller/Meteorite";
            thingDef.graphicData.graphicClass  = typeof(Graphic_Single);
            thingDef.graphicData.shaderType    = ShaderTypeDefOf.Transparent;
            thingDef.graphicData.drawSize      = new Vector2(10, 10);
            thingDef.skyfaller.shadowSize      = new Vector2(3, 3);
            thingDef.skyfaller.explosionRadius = 4;
            thingDef.skyfaller.explosionDamage = DamageDefOf.Bomb;
            thingDef.skyfaller.rotateGraphicTowardsDirection = true;
            thingDef.skyfaller.speed = 1.2f;
            DefGenerator.AddImpliedDef <ThingDef>(thingDef);

            thingDef               = new ThingDef();
            thingDef.defName       = "Tunneler_OgsOld_ExtraHives";
            thingDef.category      = ThingCategory.Ethereal;
            thingDef.thingClass    = typeof(OgsOld_ExtraHives.TunnelRaidSpawner);
            thingDef.useHitPoints  = false;
            thingDef.drawOffscreen = true;
            thingDef.alwaysFlee    = true;
            thingDef.tickerType    = TickerType.Normal;
            thingDef.altitudeLayer = AltitudeLayer.Skyfaller;
            thingDef.drawerType    = DrawerType.RealtimeOnly;
            thingDef.label         = "tunnel (incoming)";
            thingDef.size          = new IntVec2(1, 1);
            DefGenerator.AddImpliedDef <ThingDef>(thingDef);



            //PawnsArrivalModeDef

            /*
             * thingDef = new ThingDef();
             * thingDef.defName = "Hive_OgsOld_ExtraHives";
             * thingDef.category = ThingCategory.Ethereal;
             * thingDef.thingClass = typeof(OgsOld_ExtraHives.TunnelRaidSpawner);
             * thingDef.useHitPoints = false;
             * thingDef.drawOffscreen = true;
             * thingDef.alwaysFlee = true;
             * thingDef.tickerType = TickerType.Normal;
             * thingDef.altitudeLayer = AltitudeLayer.Skyfaller;
             * thingDef.drawerType = DrawerType.RealtimeOnly;
             * thingDef.label = "tunnel (incoming)";
             * thingDef.size = new IntVec2(3,3);
             * DefGenerator.AddImpliedDef<ThingDef>(thingDef);
             *
             */

            //RuleDef

            RuleDef ruleDef;

            ruleDef           = new RuleDef();
            ruleDef.defName   = "OgsOld_ExtraHives_HiveBaseMaker";
            ruleDef.symbol    = "OgsOld_ExtraHives_HiveBaseMaker";
            ruleDef.resolvers = new List <SymbolResolver>();
            ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_Hivebase());
            DefGenerator.AddImpliedDef <RuleDef>(ruleDef);

            ruleDef           = new RuleDef();
            ruleDef.defName   = "OgsOld_ExtraHives_HiveMoundMaker";
            ruleDef.symbol    = "OgsOld_ExtraHives_HiveMoundMaker";
            ruleDef.resolvers = new List <SymbolResolver>();
            ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_HiveBaseMoundMaker());
            DefGenerator.AddImpliedDef <RuleDef>(ruleDef);

            ruleDef           = new RuleDef();
            ruleDef.defName   = "OgsOld_ExtraHives_HiveClearChamber";
            ruleDef.symbol    = "OgsOld_ExtraHives_HiveClearChamber";
            ruleDef.resolvers = new List <SymbolResolver>();
            ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_ClearChamber());
            DefGenerator.AddImpliedDef <RuleDef>(ruleDef);

            ruleDef           = new RuleDef();
            ruleDef.defName   = "OgsOld_ExtraHives_HiveInterals";
            ruleDef.symbol    = "OgsOld_ExtraHives_HiveInterals";
            ruleDef.resolvers = new List <SymbolResolver>();
            ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_HiveInternals());
            DefGenerator.AddImpliedDef <RuleDef>(ruleDef);

            ruleDef           = new RuleDef();
            ruleDef.defName   = "OgsOld_ExtraHives_HiveOutdoorLighting";
            ruleDef.symbol    = "OgsOld_ExtraHives_HiveOutdoorLighting";
            ruleDef.resolvers = new List <SymbolResolver>();
            ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_OutdoorLightingHivebase());
            DefGenerator.AddImpliedDef <RuleDef>(ruleDef);

            ruleDef           = new RuleDef();
            ruleDef.defName   = "OgsOld_ExtraHives_HiveRandomCorpse";
            ruleDef.symbol    = "OgsOld_ExtraHives_HiveRandomCorpse";
            ruleDef.resolvers = new List <SymbolResolver>();
            ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_RandomCorpse());
            DefGenerator.AddImpliedDef <RuleDef>(ruleDef);

            ruleDef           = new RuleDef();
            ruleDef.defName   = "OgsOld_ExtraHives_HiveRandomDamage";
            ruleDef.symbol    = "OgsOld_ExtraHives_HiveRandomDamage";
            ruleDef.resolvers = new List <SymbolResolver>();
            ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_RandomDamage());
            DefGenerator.AddImpliedDef <RuleDef>(ruleDef);

            ruleDef           = new RuleDef();
            ruleDef.defName   = "OgsOld_ExtraHives_HiveRandomHives";
            ruleDef.symbol    = "OgsOld_ExtraHives_HiveRandomHives";
            ruleDef.resolvers = new List <SymbolResolver>();
            ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_RandomHives());
            DefGenerator.AddImpliedDef <RuleDef>(ruleDef);

            ruleDef           = new RuleDef();
            ruleDef.defName   = "OgsOld_ExtraHives_PawnGroup";
            ruleDef.symbol    = "OgsOld_ExtraHives_PawnGroup";
            ruleDef.resolvers = new List <SymbolResolver>();
            ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_PawnHiveGroup());
            DefGenerator.AddImpliedDef <RuleDef>(ruleDef);

            ruleDef           = new RuleDef();
            ruleDef.defName   = "OgsOld_ExtraHives_Pawn";
            ruleDef.symbol    = "OgsOld_ExtraHives_Pawn";
            ruleDef.resolvers = new List <SymbolResolver>();
            ruleDef.resolvers.Add(new OgsOld_ExtraHives.GenStuff.SymbolResolver_SingleHivePawn());
            DefGenerator.AddImpliedDef <RuleDef>(ruleDef);
        }
Exemple #19
0
        public static void Settle(WorldShip worldShip, bool settlePermanent = false)
        {
            Faction             faction     = worldShip.Faction;
            PawnsArrivalModeDef arrivalMode = PawnsArrivalModeDefOf.CenterDrop;

            if (faction != Faction.OfPlayer)
            {
                Log.Error("Cannot settle with non-player faction.");
                return;
            }
            MapParent newWorldObject;
            Map       mapToDropIn = null;

            if (settlePermanent)
            {
                newWorldObject = SettleUtility.AddNewHome(worldShip.Tile, faction);
            }
            else
            {
                newWorldObject = Find.WorldObjects.MapParentAt(worldShip.Tile);
                if (newWorldObject == null)
                {
                    newWorldObject = (ShipDropSite)WorldObjectMaker.MakeWorldObject(ShipNamespaceDefOfs.ShipDropSite);
                    newWorldObject.SetFaction(faction);
                    newWorldObject.Tile = worldShip.Tile;
                    Find.WorldObjects.Add(newWorldObject);
                }
            }
            LongEventHandler.QueueLongEvent(delegate
            {
                IntVec3 vec3;
                if (settlePermanent)
                {
                    vec3        = Find.World.info.initialMapSize;
                    mapToDropIn = MapGenerator.GenerateMap(vec3, newWorldObject, MapGeneratorDefOf.Base_Player, null, null);
                }
                else if (newWorldObject != null)
                {
                    if (newWorldObject.HasMap)
                    {
                        arrivalMode = PawnsArrivalModeDefOf.EdgeDrop;
                        mapToDropIn = newWorldObject.Map;
                    }
                    else
                    {
                        Site site   = newWorldObject as Site;
                        mapToDropIn = GetOrGenerateMapUtility.GetOrGenerateMap(worldShip.Tile, site == null ? Find.World.info.initialMapSize : SiteCoreWorker.MapSize, newWorldObject.def);
                        arrivalMode = PawnsArrivalModeDefOf.EdgeDrop;
                    }
                }
                else
                {
                    vec3        = new IntVec3(100, 1, 100);
                    mapToDropIn = MapGenerator.GenerateMap(vec3, newWorldObject, MapGeneratorDefOf.Base_Player, null, null);
                }
                if (mapToDropIn == null)
                {
                    Log.Error("Failed to generate Map for Ship Dropdown");
                    return;
                }

                Current.Game.CurrentMap = mapToDropIn;
            }, "GeneratingMap", true, new Action <Exception>(GameAndMapInitExceptionHandlers.ErrorWhileGeneratingMap));
            LongEventHandler.QueueLongEvent(delegate
            {
                Map map = newWorldObject.Map;
                WorldShipUtility.EnterMapWithShip(worldShip, map, IntVec3.Zero, ShipArrivalAction.EnterMapFriendly, arrivalMode);
                Find.CameraDriver.JumpToCurrentMapLoc(map.Center);
                Find.MainTabsRoot.EscapeCurrentTab(false);
            }, "SpawningColonists", true, new Action <Exception>(GameAndMapInitExceptionHandlers.ErrorWhileGeneratingMap));
        }
Exemple #20
0
        public static void SendRaid(Faction faction, Map map, float points, int arrivalTime, PawnsArrivalModeDef pawnsArrivalModeDef = null, RaidStrategyDef raidStrategyDef = null)
        {
            int @int = Rand.Int;

            IncidentParms raidParms = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.ThreatBig, map);

            raidParms.forced               = true;
            raidParms.faction              = faction;
            raidParms.points               = points;
            raidParms.pawnGroupMakerSeed   = @int;
            raidParms.generateFightersOnly = true;

            if (raidStrategyDef != null)
            {
                raidParms.raidStrategy = raidStrategyDef;
            }
            else
            {
                ResolveRaidStrategy(raidParms, PawnGroupKindDefOf.Combat);
            }

            if (pawnsArrivalModeDef != null)
            {
                raidParms.raidArrivalMode = pawnsArrivalModeDef;
            }
            else
            {
                ResolveRaidArriveMode(raidParms);
            }

            Find.Storyteller.incidentQueue.Add(IncidentDefOf.RaidEnemy, Find.TickManager.TicksGame + arrivalTime, raidParms);
        }
        public static IntVec3 GetCellForArrivalMode(ShipBase ship, IntVec3 targetCell, Map map, PawnsArrivalModeDef pawnsArrivalMode)
        {
            if (targetCell != IntVec3.Zero)
            {
                return(TryFindValidTargetCell(ship, targetCell, map));
            }
            else if (pawnsArrivalMode == PawnsArrivalModeDefOf.CenterDrop)
            {
                return(CenterCell(map));
            }
            else if (pawnsArrivalMode == PawnsArrivalModeDefOf.EdgeDrop)
            {
                return(DistantCell(map));
            }

            return(IntVec3.Zero);
        }
        private static void Enter(WorldShip worldShip, Map map, IntVec3 targetCell, ShipArrivalAction arrivalAction, PawnsArrivalModeDef pawnsArrivalMode)
        {
            List <ShipBase> ships = worldShip.WorldShipData.Select(x => x.Ship).ToList();
            IntVec3         cell  = GetCellForArrivalMode(worldShip.WorldShipData[0].Ship, targetCell, map, pawnsArrivalMode);

            DropShipUtility.DropShipGroups(cell, map, ships, arrivalAction, worldShip.WorldShipData.Count == 1);
            if (worldShip.Spawned)
            {
                worldShip.WorldShipData.Clear();
                Find.WorldObjects.Remove(worldShip);
            }
        }
 public static void EnterMapWithShip(WorldShip worldShip, Map map, IntVec3 targetCell, ShipArrivalAction arrivalAction, PawnsArrivalModeDef pawnsArrivalMode)
 {
     TravelingShipsUtility.Enter(worldShip, map, targetCell, arrivalAction, pawnsArrivalMode);
 }
Exemple #24
0
        public static void Raid(this Quest quest, Map map, float points, Faction faction, string inSignalLeave = null, string customLetterLabel = null, string customLetterText = null, RulePack customLetterLabelRules = null, RulePack customLetterTextRules = null, IntVec3?walkInSpot = null, string tag = null, string inSignal = null, string rootSymbol = "root", PawnsArrivalModeDef raidArrivalMode = null)
        {
            QuestPart_Incident questPart_Incident = new QuestPart_Incident();

            questPart_Incident.debugLabel = "raid";
            questPart_Incident.incident   = IncidentDefOf.RaidEnemy;
            IncidentParms incidentParms = new IncidentParms();

            incidentParms.forced             = true;
            incidentParms.target             = map;
            incidentParms.points             = Mathf.Max(points, faction.def.MinPointsToGeneratePawnGroup(PawnGroupKindDefOf.Combat));
            incidentParms.faction            = faction;
            incidentParms.pawnGroupMakerSeed = Rand.Int;
            incidentParms.inSignalEnd        = inSignalLeave;
            incidentParms.questTag           = QuestGenUtility.HardcodedTargetQuestTagWithQuestID(tag);
            incidentParms.raidArrivalMode    = raidArrivalMode;
            if (!customLetterLabel.NullOrEmpty() || customLetterLabelRules != null)
            {
                QuestGen.AddTextRequest(rootSymbol, delegate(string x)
                {
                    incidentParms.customLetterLabel = x;
                }, QuestGenUtility.MergeRules(customLetterLabelRules, customLetterLabel, rootSymbol));
            }
            if (!customLetterText.NullOrEmpty() || customLetterTextRules != null)
            {
                QuestGen.AddTextRequest(rootSymbol, delegate(string x)
                {
                    incidentParms.customLetterText = x;
                }, QuestGenUtility.MergeRules(customLetterTextRules, customLetterText, rootSymbol));
            }
            IncidentWorker_Raid obj = (IncidentWorker_Raid)questPart_Incident.incident.Worker;

            obj.ResolveRaidStrategy(incidentParms, PawnGroupKindDefOf.Combat);
            obj.ResolveRaidArriveMode(incidentParms);
            if (incidentParms.raidArrivalMode.walkIn)
            {
                incidentParms.spawnCenter = walkInSpot ?? QuestGen.slate.Get <IntVec3?>("walkInSpot") ?? IntVec3.Invalid;
            }
            PawnGroupMakerParms defaultPawnGroupMakerParms = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(PawnGroupKindDefOf.Combat, incidentParms);

            defaultPawnGroupMakerParms.points = IncidentWorker_Raid.AdjustedRaidPoints(defaultPawnGroupMakerParms.points, incidentParms.raidArrivalMode, incidentParms.raidStrategy, defaultPawnGroupMakerParms.faction, PawnGroupKindDefOf.Combat);
            IEnumerable <PawnKindDef> pawnKinds = PawnGroupMakerUtility.GeneratePawnKindsExample(defaultPawnGroupMakerParms);

            questPart_Incident.SetIncidentParmsAndRemoveTarget(incidentParms);
            questPart_Incident.inSignal = inSignal ?? QuestGen.slate.Get <string>("inSignal");
            QuestGen.quest.AddPart(questPart_Incident);
            QuestGen.AddQuestDescriptionRules(new List <Rule>
            {
                new Rule_String("raidPawnKinds", PawnUtility.PawnKindsToLineList(pawnKinds, "  - ", ColoredText.ThreatColor)),
                new Rule_String("raidArrivalModeInfo", incidentParms.raidArrivalMode.textWillArrive.Formatted(faction))
            });
        }
Exemple #25
0
 private static bool isDropType(PawnsArrivalModeDef def)
 {
     // Any arrival mode requiring Industrial tech level is a drop pod type
     // May not be true for mods
     return(def.minTechLevel >= TechLevel.Industrial);
 }
        private static void ExecuteRaidWithSpecifics()
        {
            StorytellerComp        storytellerComp = Find.Storyteller.storytellerComps.First((StorytellerComp x) => x is StorytellerComp_OnOffCycle || x is StorytellerComp_RandomMain);
            IncidentParms          parms           = storytellerComp.GenerateParms(IncidentCategoryDefOf.ThreatBig, Find.CurrentMap);
            List <DebugMenuOption> list            = new List <DebugMenuOption>();

            foreach (Faction allFaction in Find.FactionManager.AllFactions)
            {
                Faction             localFac     = allFaction;
                float               localPoints  = default(float);
                RaidStrategyDef     localStrat   = default(RaidStrategyDef);
                PawnsArrivalModeDef localArrival = default(PawnsArrivalModeDef);
                list.Add(new DebugMenuOption(localFac.Name + " (" + localFac.def.defName + ")", DebugMenuOptionMode.Action, delegate
                {
                    parms.faction = localFac;
                    List <DebugMenuOption> list2 = new List <DebugMenuOption>();
                    foreach (float item in DebugActionsUtility.PointsOptions(extended: true))
                    {
                        localPoints = item;
                        list2.Add(new DebugMenuOption(item + " points", DebugMenuOptionMode.Action, delegate
                        {
                            parms.points = localPoints;
                            List <DebugMenuOption> list3 = new List <DebugMenuOption>();
                            foreach (RaidStrategyDef allDef in DefDatabase <RaidStrategyDef> .AllDefs)
                            {
                                localStrat  = allDef;
                                string text = localStrat.defName;
                                if (!localStrat.Worker.CanUseWith(parms, PawnGroupKindDefOf.Combat))
                                {
                                    text += " [NO]";
                                }
                                list3.Add(new DebugMenuOption(text, DebugMenuOptionMode.Action, delegate
                                {
                                    parms.raidStrategy           = localStrat;
                                    List <DebugMenuOption> list4 = new List <DebugMenuOption>
                                    {
                                        new DebugMenuOption("-Random-", DebugMenuOptionMode.Action, delegate
                                        {
                                            DoRaid(parms);
                                        })
                                    };
                                    foreach (PawnsArrivalModeDef allDef2 in DefDatabase <PawnsArrivalModeDef> .AllDefs)
                                    {
                                        localArrival = allDef2;
                                        string text2 = localArrival.defName;
                                        if (!localArrival.Worker.CanUseWith(parms) || !localStrat.arriveModes.Contains(localArrival))
                                        {
                                            text2 += " [NO]";
                                        }
                                        list4.Add(new DebugMenuOption(text2, DebugMenuOptionMode.Action, delegate
                                        {
                                            parms.raidArrivalMode = localArrival;
                                            DoRaid(parms);
                                        }));
                                    }
                                    Find.WindowStack.Add(new Dialog_DebugOptionListLister(list4));
                                }));
                            }
                            Find.WindowStack.Add(new Dialog_DebugOptionListLister(list3));
                        }));
                    }
                    Find.WindowStack.Add(new Dialog_DebugOptionListLister(list2));
                }));
            }
            Find.WindowStack.Add(new Dialog_DebugOptionListLister(list));
        }
 public TransportPodsArrivalAction_VisitSite(Site site, PawnsArrivalModeDef arrivalMode)
 {
     this.site        = site;
     this.arrivalMode = arrivalMode;
 }
 public TransportPodsArrivalAction_VisitRuins(MapParent site, PawnsArrivalModeDef arrivalMode)
 {
     this.site        = site;
     this.arrivalMode = arrivalMode;
 }
Exemple #29
0
 public TransportPodsArrivalAction_AttackSettlement(SettlementBase settlement, PawnsArrivalModeDef arrivalMode)
 {
     this.settlement  = settlement;
     this.arrivalMode = arrivalMode;
 }
Exemple #30
0
 public ByakheeArrivalAction_AttackSettlement(Settlement settlement, PawnsArrivalModeDef arrivalMode)
 {
     this.settlement  = settlement;
     this.arrivalMode = arrivalMode;
 }