Beispiel #1
0
            internal void <> m__3()
            {
                Pawn                t        = this.caravan.PawnsListForReading[0];
                Faction             faction  = this.faction;
                Faction             ofPlayer = Faction.OfPlayer;
                FactionRelationKind kind     = FactionRelationKind.Hostile;
                string              reason   = "GoodwillChangedReason_AttackedCaravan".Translate();

                faction.TrySetRelationKind(ofPlayer, kind, true, reason, new GlobalTargetInfo?(t));
                Map     map = CaravanIncidentUtility.GetOrGenerateMapForIncident(this.caravan, new IntVec3(100, 1, 100), WorldObjectDefOf.AttackedNonPlayerCaravan);
                IntVec3 playerSpot;
                IntVec3 enemySpot;

                MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out playerSpot, out enemySpot);
                CaravanEnterMapUtility.Enter(this.caravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(playerSpot, map, 12, null), CaravanDropInventoryMode.DoNotDrop, true);
                List <Pawn> list = this.metCaravan.PawnsListForReading.ToList <Pawn>();

                CaravanEnterMapUtility.Enter(this.metCaravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(enemySpot, map, 12, null), CaravanDropInventoryMode.DoNotDrop, false);
                LordMaker.MakeNewLord(this.faction, new LordJob_DefendAttackedTraderCaravan(list[0].Position), map, list);
                Find.TickManager.CurTimeSpeed = TimeSpeed.Paused;
                CameraJumper.TryJumpAndSelect(t);
                PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(list, "LetterRelatedPawnsGroupGeneric".Translate(new object[]
                {
                    Faction.OfPlayer.def.pawnsPlural
                }), LetterDefOf.NeutralEvent, true, true);
            }
        public void SetPlace(CaravanAI caravanAI, Caravan playerCaravan, IntVec3 mapSize)
        {
            MapSize = mapSize;

            this.caravanAI = caravanAI;
            aiFaction      = caravanAI.Faction;
            aiTarget       = caravanAI.pather.Destination;
            aiAction       = caravanAI.pather.ArrivalAction;

            this.playerCaravan = playerCaravan;
            List <Pawn> aiPawns = new List <Pawn>(caravanAI.pawns);

            caravanAI.Tile     = Tile;
            playerCaravan.Tile = Tile;

            Map map = GetOrGenerateMap(Tile, MapSize, null);

            Find.TickManager.Notify_GeneratedPotentiallyHostileMap();

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 first, out IntVec3 second);

            CaravanEnterMapUtility.Enter(caravanAI, map, x => CellFinder.RandomSpawnCellForPawnNear(first, map), CaravanDropInventoryMode.DoNotDrop);
            CaravanEnterMapUtility.Enter(playerCaravan, map, x => CellFinder.RandomSpawnCellForPawnNear(second, map), CaravanDropInventoryMode.DoNotDrop);

            LordJob lordJob = new LordJob_AssaultColony(caravanAI.Faction, canKidnap: true, canTimeoutOrFlee: false);

            LordMaker.MakeNewLord(caravanAI.Faction, lordJob, map, aiPawns);

            winner = CaravanBattleWinner.None;

            Find.LetterStack.ReceiveLetter("CaravanBattlePlacePlace_BattleStarted".Translate(), "CaravanBattlePlacePlace_BattleDescription".Translate(playerCaravan.Name, caravanAI.Name), LetterDefOf.ThreatBig);
        }
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            if (parms.target is Map)
            {
                return(IncidentDefOf.TravelerGroup.Worker.TryExecute(parms));
            }
            Caravan caravan = (Caravan)parms.target;

            if (!TryFindFaction(out Faction faction))
            {
                return(false);
            }
            CameraJumper.TryJumpAndSelect(caravan);
            List <Pawn> pawns                = GenerateCaravanPawns(faction);
            Caravan     metCaravan           = CaravanMaker.MakeCaravan(pawns, faction, -1, addToWorldPawnsIfNotAlready: false);
            string      text                 = "CaravanMeeting".Translate(caravan.Name, faction.Name, PawnUtility.PawnKindsToCommaList(metCaravan.PawnsListForReading, useAnd: true)).CapitalizeFirst();
            DiaNode     diaNode              = new DiaNode(text);
            Pawn        bestPlayerNegotiator = BestCaravanPawnUtility.FindBestNegotiator(caravan);

            if (metCaravan.CanTradeNow)
            {
                DiaOption diaOption = new DiaOption("CaravanMeeting_Trade".Translate());
                diaOption.action = delegate
                {
                    Find.WindowStack.Add(new Dialog_Trade(bestPlayerNegotiator, metCaravan));
                    PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(metCaravan.Goods.OfType <Pawn>(), "LetterRelatedPawnsTradingWithOtherCaravan".Translate(Faction.OfPlayer.def.pawnsPlural), LetterDefOf.NeutralEvent);
                };
                if (bestPlayerNegotiator == null)
                {
                    diaOption.Disable("CaravanMeeting_TradeIncapable".Translate());
                }
                diaNode.options.Add(diaOption);
            }
            DiaOption diaOption2 = new DiaOption("CaravanMeeting_Attack".Translate());

            diaOption2.action = delegate
            {
                LongEventHandler.QueueLongEvent(delegate
                {
                    Pawn t                   = caravan.PawnsListForReading[0];
                    Faction faction3         = faction;
                    Faction ofPlayer         = Faction.OfPlayer;
                    FactionRelationKind kind = FactionRelationKind.Hostile;
                    string reason            = "GoodwillChangedReason_AttackedCaravan".Translate();
                    faction3.TrySetRelationKind(ofPlayer, kind, canSendLetter: true, reason, t);
                    Map map = CaravanIncidentUtility.GetOrGenerateMapForIncident(caravan, new IntVec3(100, 1, 100), WorldObjectDefOf.AttackedNonPlayerCaravan);
                    MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 playerSpot, out IntVec3 enemySpot);
                    CaravanEnterMapUtility.Enter(caravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(playerSpot, map, 12), CaravanDropInventoryMode.DoNotDrop, draftColonists: true);
                    List <Pawn> list = metCaravan.PawnsListForReading.ToList();
                    CaravanEnterMapUtility.Enter(metCaravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(enemySpot, map, 12));
                    LordMaker.MakeNewLord(faction, new LordJob_DefendAttackedTraderCaravan(list[0].Position), map, list);
                    Find.TickManager.Notify_GeneratedPotentiallyHostileMap();
                    CameraJumper.TryJumpAndSelect(t);
                    PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(list, "LetterRelatedPawnsGroupGeneric".Translate(Faction.OfPlayer.def.pawnsPlural), LetterDefOf.NeutralEvent, informEvenIfSeenBefore: true);
                }, "GeneratingMapForNewEncounter", doAsynchronously: false, null);
        public Map SetupCaravanAttackMap(Caravan caravan, List <Pawn> faction1, List <Pawn> faction2)
        {
            int num = 140;
            Map map = CaravanIncidentUtility.GetOrGenerateMapForIncident(caravan, new IntVec3(num, 1, num), WorldObjectDefOf.Ambush);

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 playerStartingSpot, out IntVec3 second);
            CaravanEnterMapUtility.Enter(caravan, map, (Pawn x) => CellFinder.RandomSpawnCellForPawnNear(playerStartingSpot, map), CaravanDropInventoryMode.DoNotDrop, draftColonists: true);

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out second, out IntVec3 third);
            SpawnEnemies(second, third, faction1, faction2, map);

            PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(faction1, "LetterRelatedPawnsGroupGeneric".Translate(Faction.OfPlayer.def.pawnsPlural), LetterDefOf.NeutralEvent, informEvenIfSeenBefore: true);
            return(map);
        }
Beispiel #5
0
        public static void BeginArenaFight(List <PawnKindDef> lhs, List <PawnKindDef> rhs, Action <ArenaResult> callback)
        {
            MapParent mapParent = (MapParent)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Debug_Arena);

            mapParent.Tile = TileFinder.RandomSettlementTileFor(Faction.OfPlayer, mustBeAutoChoosable: true, (int tile) => lhs.Concat(rhs).Any((PawnKindDef pawnkind) => Find.World.tileTemperatures.SeasonAndOutdoorTemperatureAcceptableFor(tile, pawnkind.race)));
            mapParent.SetFaction(Faction.OfPlayer);
            Find.WorldObjects.Add(mapParent);
            Map orGenerateMap = GetOrGenerateMapUtility.GetOrGenerateMap(mapParent.Tile, new IntVec3(50, 1, 50), null);

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(orGenerateMap, out IntVec3 first, out IntVec3 second);
            List <Pawn> lhs2      = SpawnPawnSet(orGenerateMap, lhs, first, Faction.OfAncients);
            List <Pawn> rhs2      = SpawnPawnSet(orGenerateMap, rhs, second, Faction.OfAncientsHostile);
            DebugArena  component = mapParent.GetComponent <DebugArena>();

            component.lhs      = lhs2;
            component.rhs      = rhs2;
            component.callback = callback;
        }
Beispiel #6
0
        public static void Camp(Caravan caravan)
        {
            float  PawnScore  = CaravanPawnsCountScore(caravan);
            string randomSeed = new System.Random().Next(1, 99999999).ToString();
            int    CampSize   = new System.Random().Next(SetUpCampSettings.allowedSizeRange.min, SetUpCampSettings.allowedSizeRange.max);
            //float num4 = Mathf.Max(PawnScore * EnemyPointsPerCaravanPawnsScoreRange.RandomInRange, 45f);
            Pawn pawn = caravan.PawnsListForReading[0];

            tmpCaravanPawns.Clear();
            tmpCaravanPawns.AddRange(caravan.PawnsListForReading);
            Map map = GenerateNewMapWithSeed(caravan, new IntVec3(CampSize, 1, CampSize), randomSeed);

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 playerStartingSpot, out IntVec3 intVec);
            CaravanEnterMapUtility.Enter(caravan, map, (Pawn x) => CellFinder.RandomSpawnCellForPawnNear(playerStartingSpot, map, 4), 0, true);
            tmpCaravanPawns.Clear();
            CameraJumper.TryJumpAndSelect(pawn);
            Find.TickManager.CurTimeSpeed = 0;
            Messages.Message("SetUpCampFormedCamp".Translate(), MessageTypeDefOf.PositiveEvent);
        }
Beispiel #7
0
        public static void BeginArenaFight(List <PawnKindDef> lhs, List <PawnKindDef> rhs, Action <ArenaResult> callback)
        {
            MapParent mapParent = (MapParent)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Debug_Arena);

            mapParent.Tile = TileFinder.RandomFactionBaseTileFor(Faction.OfPlayer, true, (int tile) => lhs.Concat(rhs).Any((PawnKindDef pawnkind) => Find.World.tileTemperatures.SeasonAndOutdoorTemperatureAcceptableFor(tile, pawnkind.race)));
            mapParent.SetFaction(Faction.OfPlayer);
            Find.WorldObjects.Add(mapParent);
            Map     orGenerateMap = GetOrGenerateMapUtility.GetOrGenerateMap(mapParent.Tile, new IntVec3(50, 1, 50), null);
            IntVec3 spot          = default(IntVec3);
            IntVec3 spot2         = default(IntVec3);

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(orGenerateMap, out spot, out spot2);
            List <Pawn> lhs2      = ArenaUtility.SpawnPawnSet(orGenerateMap, lhs, spot, Faction.OfSpacer);
            List <Pawn> rhs2      = ArenaUtility.SpawnPawnSet(orGenerateMap, rhs, spot2, Faction.OfSpacerHostile);
            DebugArena  component = ((WorldObject)mapParent).GetComponent <DebugArena>();

            component.lhs      = lhs2;
            component.rhs      = rhs2;
            component.callback = callback;
        }
        private void SpawnEnemies()
        {
            startTimer = false;

            PawnGroupMakerParms pawnGroupMakerParms = new PawnGroupMakerParms
            {
                faction = faction,
                points  = points,
                generateFightersOnly = true,
                groupKind            = PawnGroupKindDefOf.Combat,
                raidStrategy         = RaidStrategyDefOf.ImmediateAttack,
                forceOneIncap        = true
            };

            List <Pawn> pawns = PawnGroupMakerUtility.GeneratePawns(pawnGroupMakerParms).ToList();

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 startingSpot, out IntVec3 second);

            int max = maxPawns == -1 ? pawns.Count : maxPawns;

            if (max > pawns.Count)
            {
                max = pawns.Count;
            }

            for (int i = 0; i < max; i++)
            {
                Pawn p = pawns[i];
                GenSpawn.Spawn(p, startingSpot, map);
            }

            LordJob lordJob = new LordJob_AssaultColony(faction, canKidnap: true, canTimeoutOrFlee: false);

            if (lordJob != null)
            {
                LordMaker.MakeNewLord(faction, lordJob, map, pawns);
            }

            pawns.Clear();
        }
Beispiel #9
0
        private static void NightvisionArenaFight
        (
            SkillDef skill, AorB[]                           sides, GlowTeam lhsTeam, int lhsCount, GlowTeam rhsTeam,
            int rhsCount, Action <ArenaUtility.ArenaResult> callback
        )
        {
            var mapParent = (MapParent)WorldObjectMaker.MakeWorldObject(def: WorldObjectDefOf.Debug_Arena);

            mapParent.Tile = TileFinder.RandomSettlementTileFor(
                faction: Faction.OfPlayer,
                mustBeAutoChoosable: true,
                extraValidator: tile
                => Find.World.tileTemperatures.SeasonAndOutdoorTemperatureAcceptableFor(
                    tile: tile,
                    animalRace: ThingDef.Named(defName: "Human")
                    )
                );

            mapParent.SetFaction(newFaction: Faction.OfPlayer);
            Find.WorldObjects.Add(o: mapParent);

            Map orGenerateMap = GetOrGenerateMapUtility.GetOrGenerateMap(
                tile: mapParent.Tile,
                size: new IntVec3(newX: 50, newY: 1, newZ: 50),
                suggestedMapParentDef: null
                );

            IntVec3 spot;
            IntVec3 spot2;

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map: orGenerateMap, first: out spot, second: out spot2);
            List <Pawn> lhs2      = NVPawnSetSpawner(map: orGenerateMap, skill: skill, team: lhsTeam, count: lhsCount, spot: spot, side: sides[0]);
            List <Pawn> rhs2      = NVPawnSetSpawner(map: orGenerateMap, skill: skill, team: rhsTeam, count: rhsCount, spot: spot2, side: sides[1]);
            var         component = mapParent.GetComponent <DebugArena>();

            component.lhs      = lhs2;
            component.rhs      = rhs2;
            component.callback = callback;
        }
        // Token: 0x0600000A RID: 10 RVA: 0x0000218C File Offset: 0x0000038C
        public static void Camp(Caravan caravan)
        {
            SetUpCampSettings settings = LoadedModManager.GetMod <SetUpCamp>().GetSettings <SetUpCampSettings>();
            int   minSize = SetUpCampSettings.MinSize;
            int   maxSize = SetUpCampSettings.MaxSize;
            float num     = CaravanPawnsCountScore(caravan);
            int   num2    = Mathf.RoundToInt(num * 900f);
            int   num3    = new System.Random().Next(minSize, maxSize);
            float num4    = Mathf.Max(num * EnemyPointsPerCaravanPawnsScoreRange.RandomInRange, 45f);
            Pawn  pawn    = caravan.PawnsListForReading[0];

            tmpCaravanPawns.Clear();
            tmpCaravanPawns.AddRange(caravan.PawnsListForReading);
            Map map = CaravanIncidentUtility.GetOrGenerateMapForIncident(caravan, new IntVec3(num3, 1, num3), DefDatabase <WorldObjectDef> .GetNamed("CaravanCamp", true));

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 playerStartingSpot, out IntVec3 intVec);
            CaravanEnterMapUtility.Enter(caravan, map, (Pawn x) => CellFinder.RandomSpawnCellForPawnNear(playerStartingSpot, map, 4), 0, true);
            tmpCaravanPawns.Clear();
            CameraJumper.TryJumpAndSelect(pawn);
            Find.TickManager.CurTimeSpeed = 0;
            Messages.Message("The caravan formed a camp.", MessageTypeDefOf.TaskCompletion);
        }
Beispiel #11
0
        protected bool Execute(Caravan caravan)
        {
            Map map = GetOrGenerateMapUtility.GetOrGenerateMap(caravan.Tile, DefDatabase <WorldObjectDef> .GetNamed("WanderingCaravanEncounter"));

            if (!WanderingCaravansUtility.AllWanderingCaravansSpawnableInMap(map).TryRandomElement(out PawnKindDef wanderingCaravanDef))
            {
                return(false);
            }
            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 caravanSpot, out IntVec3 wanderingCaravansSpot);
            IEnumerable <Pawn> wanderingCaravans = this.GenerateWanderingCaravans(wanderingCaravanDef);
            Pawn    infoPawn = wanderingCaravans.First();
            DiaNode diaNode  = new DiaNode($"A wandering {infoPawn.LabelCap} has been spotted in the distance by {caravan.LabelCap}, with more wandering caravans possible following it.\n\nYou can "
                                           + $"ignore them, or you can tame or kill them to obtain their potentially valuable inventory.")
            {
                options =
                {
                    new DiaOption("Go and claim their inventory")
                    {
                        action = delegate
                        {
                            string plural = wanderingCaravans.Count() > 1 ? "ies" : "y";
                            CaravanEnterMapUtility.Enter(caravan, map, pawn => CellFinder.RandomSpawnCellForPawnNear(caravanSpot, map));
                            Messages.Message($"You have {TimedForcedExit.GetForceExitAndRemoveMapCountdownTimeLeftString(60000)} to claim the wandering {infoPawn.LabelCap}s inventor{plural} before the "
                                             + $"caravan is reformed.", infoPawn, MessageTypeDefOf.PositiveEvent);
                            ((WorldObject)map.ParentHolder).GetComponent <TimedForcedExit>().StartForceExitAndRemoveMapCountdown();
                        },
                        resolveTree = true
                    }, new DiaOption("Ignore them and continue")
                    {
                        resolveTree = true
                    }
                }
            };

            Find.WindowStack.Add(new Dialog_NodeTree(diaNode, true, false, $"Wandering {infoPawn.LabelCap} spotted"));
            this.SpawnPawns(wanderingCaravans, map, wanderingCaravansSpot);
            return(true);
        }
Beispiel #12
0
        private void GeneratePawns(Map map, float points)
        {
            float genPoints = points * 0.7f;

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 first, out IntVec3 second);

            PawnGroupMakerParms pawnGroupMakerParms = new PawnGroupMakerParms
            {
                faction = Faction,
                points  = genPoints,
                generateFightersOnly = true,
                groupKind            = PawnGroupKindDefOf.Combat,
                raidStrategy         = RaidStrategyDefOf.ImmediateAttack,
                forceOneIncap        = true
            };

            var pawns = PawnGroupMakerUtility.GeneratePawns(pawnGroupMakerParms).ToList();

            SpawnAndGiveLord(pawns, Faction, map, first);

            pawnGroupMakerParms.faction = GarantFaction;
            pawns = PawnGroupMakerUtility.GeneratePawns(pawnGroupMakerParms).ToList();
            SpawnAndGiveLord(pawns, GarantFaction, map, second);
        }
        protected bool Execute(Caravan caravan)
        {
            Map map = GetOrGenerateMapUtility.GetOrGenerateMap(caravan.Tile, DefDatabase <WorldObjectDef> .GetNamed("WanderingCaravanEncounter"));

            if (!WanderingCaravansUtility.AllWanderingCaravansSpawnableInMap(map).TryRandomElement(out PawnKindDef wanderingCaravanDef))
            {
                return(false);
            }
            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 caravanSpot, out IntVec3 wanderingCaravansSpot);
            IEnumerable <Pawn> wanderingCaravans = this.GenerateWanderingCaravans(wanderingCaravanDef);
            Pawn    infoPawn = wanderingCaravans.First();
            DiaNode diaNode  = new DiaNode($"WanderingCaravan.WanderingCaravan_Spotted".Translate(infoPawn.LabelCap, caravan.LabelCap))
            {
                options =
                {
                    new DiaOption("WanderingCaravan.WanderingCaravan_Accept")
                    {
                        action = delegate
                        {
                            string plural = wanderingCaravans.Count() > 1 ? "ies" : "y";
                            CaravanEnterMapUtility.Enter(caravan, map, pawn => CellFinder.RandomSpawnCellForPawnNear(caravanSpot, map));
                            Messages.Message($"WanderingCaravan.WanderingCaravan_Accepted".Translate(TimedForcedExit.GetForceExitAndRemoveMapCountdownTimeLeftString(60000), infoPawn.LabelCap, plural), infoPawn, MessageTypeDefOf.PositiveEvent);
                            ((WorldObject)map.ParentHolder).GetComponent <TimedForcedExit>().StartForceExitAndRemoveMapCountdown();
                        },
                        resolveTree = true
                    }, new DiaOption("WanderingCaravan.WanderingCaravan_Reject".Translate())
                    {
                        resolveTree = true
                    }
                }
            };

            Find.WindowStack.Add(new Dialog_NodeTree(diaNode, true, false, $"WanderingCaravan.WanderingCaravan_Title".Translate(infoPawn.LabelCap)));
            this.SpawnPawns(wanderingCaravans, map, wanderingCaravansSpot);
            return(true);
        }
Beispiel #14
0
        public override void PostMapGenerate(Map map)
        {
            base.PostMapGenerate(map);

            PawnGroupMakerParms pawnGroupMakerParms = new PawnGroupMakerParms
            {
                faction = Faction,
                points  = Mathf.Clamp(Rand.Range(300, 500) * (int)Faction.def.techLevel, 450, 1600),
                generateFightersOnly = true,
                groupKind            = PawnGroupKindDefOf.Combat,
                raidStrategy         = RaidStrategyDefOf.ImmediateAttack
            };

            List <Pawn> rebels = PawnGroupMakerUtility.GeneratePawns(pawnGroupMakerParms).ToList();

            IntVec3 spot;

            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out spot, out IntVec3 second);
            foreach (var rebel in rebels)
            {
                if (CellFinder.TryFindRandomCellNear(spot, map, 6, (IntVec3 x) => x.Standable(map) && !x.Fogged(map), out IntVec3 loc))
                {
                    GenSpawn.Spawn(rebel, loc, map, Rot4.Random);
                    rebel.SetFaction(Faction.OfAncientsHostile);
                }
            }

            LordJob lordJob = new LordJob_AssaultColony(Faction.OfPlayer, canKidnap: false, canTimeoutOrFlee: false, canSteal: false);

            LordMaker.MakeNewLord(Faction.OfAncientsHostile, lordJob, map, rebels);

            supress       = true;
            UnlimitedTime = true;

            ShowInfo();
        }
Beispiel #15
0
        private void GenerateAlivePawns()
        {
            MultipleCaravansCellFinder.FindStartingCellsFor2Groups(Map, out IntVec3 first, out IntVec3 second);
            CellFinder.TryFindRandomCellNear(first, Map, 4, (IntVec3 x) => x.Standable(Map) && !x.Fogged(Map), out first);
            CellFinder.TryFindRandomCellNear(second, Map, 4, (IntVec3 x) => x.Standable(Map) && !x.Fogged(Map), out second);

            PawnGroupMakerParms pawnGroupMakerParms = new PawnGroupMakerParms
            {
                faction = Faction,
                points  = Rand.Range(500, 1300),
                generateFightersOnly = true,
                groupKind            = PawnGroupKindDefOf.Combat,
                raidStrategy         = RaidStrategyDefOf.ImmediateAttack,
                forceOneIncap        = true
            };

            var pawns = PawnGroupMakerUtility.GeneratePawns(pawnGroupMakerParms).ToList();

            SpawnAndGiveLord(pawns, Faction, Map, first);

            pawnGroupMakerParms.faction = SecondFaction;
            pawns = PawnGroupMakerUtility.GeneratePawns(pawnGroupMakerParms).ToList();
            SpawnAndGiveLord(pawns, SecondFaction, Map, second);
        }
Beispiel #16
0
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            if (parms.target is Map)
            {
                return(IncidentDefOf.TravelerGroup.Worker.TryExecute(parms));
            }
            Caravan caravan = (Caravan)parms.target;
            Faction faction;

            if (!this.TryFindFaction(out faction))
            {
                return(false);
            }
            CameraJumper.TryJumpAndSelect(caravan);
            List <Pawn> pawns                = this.GenerateCaravanPawns(faction);
            Caravan     metCaravan           = CaravanMaker.MakeCaravan(pawns, faction, -1, false);
            string      text                 = "CaravanMeeting".Translate(caravan.Name, faction.Name, PawnUtility.PawnKindsToCommaList(metCaravan.PawnsListForReading, true)).CapitalizeFirst();
            DiaNode     diaNode              = new DiaNode(text);
            Pawn        bestPlayerNegotiator = BestCaravanPawnUtility.FindBestNegotiator(caravan);

            if (metCaravan.CanTradeNow)
            {
                DiaOption diaOption = new DiaOption("CaravanMeeting_Trade".Translate());
                diaOption.action = delegate
                {
                    Find.WindowStack.Add(new Dialog_Trade(bestPlayerNegotiator, metCaravan, false));
                    PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(metCaravan.Goods.OfType <Pawn>(), "LetterRelatedPawnsTradingWithOtherCaravan".Translate(Faction.OfPlayer.def.pawnsPlural), LetterDefOf.NeutralEvent, false, true);
                };
                if (bestPlayerNegotiator == null)
                {
                    diaOption.Disable("CaravanMeeting_TradeIncapable".Translate());
                }
                diaNode.options.Add(diaOption);
            }
            DiaOption diaOption2 = new DiaOption("CaravanMeeting_Attack".Translate());

            diaOption2.action = delegate
            {
                LongEventHandler.QueueLongEvent(delegate
                {
                    Pawn t                   = caravan.PawnsListForReading[0];
                    Faction arg_49_0         = faction;
                    Faction ofPlayer         = Faction.OfPlayer;
                    FactionRelationKind kind = FactionRelationKind.Hostile;
                    string reason            = "GoodwillChangedReason_AttackedCaravan".Translate();
                    arg_49_0.TrySetRelationKind(ofPlayer, kind, true, reason, new GlobalTargetInfo?(t));
                    Map map = CaravanIncidentUtility.GetOrGenerateMapForIncident(caravan, new IntVec3(100, 1, 100), WorldObjectDefOf.AttackedNonPlayerCaravan);
                    IntVec3 playerSpot;
                    IntVec3 enemySpot;
                    MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out playerSpot, out enemySpot);
                    CaravanEnterMapUtility.Enter(caravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(playerSpot, map, 12, null), CaravanDropInventoryMode.DoNotDrop, true);
                    List <Pawn> list = metCaravan.PawnsListForReading.ToList <Pawn>();
                    CaravanEnterMapUtility.Enter(metCaravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(enemySpot, map, 12, null), CaravanDropInventoryMode.DoNotDrop, false);
                    LordMaker.MakeNewLord(faction, new LordJob_DefendAttackedTraderCaravan(list[0].Position), map, list);
                    Find.TickManager.Notify_GeneratedPotentiallyHostileMap();
                    CameraJumper.TryJumpAndSelect(t);
                    PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(list, "LetterRelatedPawnsGroupGeneric".Translate(Faction.OfPlayer.def.pawnsPlural), LetterDefOf.NeutralEvent, true, true);
                }, "GeneratingMapForNewEncounter", false, null);
            };
            diaOption2.resolveTree = true;
            diaNode.options.Add(diaOption2);
            DiaOption diaOption3 = new DiaOption("CaravanMeeting_MoveOn".Translate());

            diaOption3.action = delegate
            {
                this.RemoveAllPawnsAndPassToWorld(metCaravan);
            };
            diaOption3.resolveTree = true;
            diaNode.options.Add(diaOption3);
            string      text2              = "CaravanMeetingTitle".Translate(caravan.Label);
            WindowStack arg_1F1_0          = Find.WindowStack;
            DiaNode     nodeRoot           = diaNode;
            Faction     faction2           = faction;
            bool        delayInteractivity = true;
            string      title              = text2;

            arg_1F1_0.Add(new Dialog_NodeTreeWithFactionInfo(nodeRoot, faction2, delayInteractivity, false, title));
            Find.Archive.Add(new ArchivedDialog(diaNode.text, text2, faction));
            return(true);
        }
Beispiel #17
0
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            if (parms.target is Map)
            {
                return(IncidentDefOf.TravelerGroup.Worker.TryExecute(parms));
            }
            Caravan caravan = (Caravan)parms.target;

            if (!TryFindFaction(out var faction))
            {
                return(false);
            }
            List <Pawn> list = GenerateCaravanPawns(faction);

            if (!list.Any())
            {
                Log.Error("IncidentWorker_CaravanMeeting could not generate any pawns.");
                return(false);
            }
            Caravan metCaravan = CaravanMaker.MakeCaravan(list, faction, -1, addToWorldPawnsIfNotAlready: false);

            CameraJumper.TryJumpAndSelect(caravan);
            DiaNode diaNode = new DiaNode((string)"CaravanMeeting".Translate(caravan.Name, faction.Name, PawnUtility.PawnKindsToLineList(metCaravan.PawnsListForReading.Select((Pawn x) => x.kindDef), "  - ")).CapitalizeFirst());
            Pawn    bestPlayerNegotiator = BestCaravanPawnUtility.FindBestNegotiator(caravan, faction, metCaravan.TraderKind);

            if (metCaravan.CanTradeNow)
            {
                DiaOption diaOption = new DiaOption("CaravanMeeting_Trade".Translate());
                diaOption.action = delegate
                {
                    Find.WindowStack.Add(new Dialog_Trade(bestPlayerNegotiator, metCaravan));
                    PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(metCaravan.Goods.OfType <Pawn>(), "LetterRelatedPawnsTradingWithOtherCaravan".Translate(Faction.OfPlayer.def.pawnsPlural), LetterDefOf.NeutralEvent);
                };
                if (bestPlayerNegotiator == null)
                {
                    if (metCaravan.TraderKind.permitRequiredForTrading != null && !caravan.pawns.Any((Pawn p) => p.royalty != null && p.royalty.HasPermit(metCaravan.TraderKind.permitRequiredForTrading, faction)))
                    {
                        RoyalTitleDef royalTitleDef = faction.def.RoyalTitlesAwardableInSeniorityOrderForReading.First((RoyalTitleDef t) => t.permits != null && t.permits.Contains(metCaravan.TraderKind.permitRequiredForTrading));
                        diaOption.Disable("CaravanMeeting_NoPermit".Translate(royalTitleDef.GetLabelForBothGenders(), faction).Resolve());
                    }
                    else
                    {
                        diaOption.Disable("CaravanMeeting_TradeIncapable".Translate());
                    }
                }
                diaNode.options.Add(diaOption);
            }
            DiaOption diaOption2 = new DiaOption("CaravanMeeting_Attack".Translate());

            diaOption2.action = delegate
            {
                LongEventHandler.QueueLongEvent(delegate
                {
                    Pawn t2 = caravan.PawnsListForReading[0];
                    faction.TrySetRelationKind(Faction.OfPlayer, FactionRelationKind.Hostile, canSendLetter: true, "GoodwillChangedReason_AttackedCaravan".Translate(), t2);
                    Map map = CaravanIncidentUtility.GetOrGenerateMapForIncident(caravan, new IntVec3(100, 1, 100), WorldObjectDefOf.AttackedNonPlayerCaravan);
                    map.Parent.SetFaction(faction);
                    IntVec3 playerSpot = default(IntVec3);
                    IntVec3 enemySpot  = default(IntVec3);
                    MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out playerSpot, out enemySpot);
                    CaravanEnterMapUtility.Enter(caravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(playerSpot, map, 12), CaravanDropInventoryMode.DoNotDrop, draftColonists: true);
                    List <Pawn> list2 = metCaravan.PawnsListForReading.ToList();
                    CaravanEnterMapUtility.Enter(metCaravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(enemySpot, map, 12));
                    LordMaker.MakeNewLord(faction, new LordJob_DefendAttackedTraderCaravan(list2[0].Position), map, list2);
                    Find.TickManager.Notify_GeneratedPotentiallyHostileMap();
                    CameraJumper.TryJumpAndSelect(t2);
                    PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(list2, "LetterRelatedPawnsGroupGeneric".Translate(Faction.OfPlayer.def.pawnsPlural), LetterDefOf.NeutralEvent, informEvenIfSeenBefore: true);
                }, "GeneratingMapForNewEncounter", doAsynchronously: false, null);
            };
            diaOption2.resolveTree = true;
            diaNode.options.Add(diaOption2);
            DiaOption diaOption3 = new DiaOption("CaravanMeeting_MoveOn".Translate());

            diaOption3.action = delegate
            {
                RemoveAllPawnsAndPassToWorld(metCaravan);
            };
            diaOption3.resolveTree = true;
            diaNode.options.Add(diaOption3);
            string title = "CaravanMeetingTitle".Translate(caravan.Label);

            Find.WindowStack.Add(new Dialog_NodeTreeWithFactionInfo(diaNode, faction, delayInteractivity: true, radioMode: false, title));
            Find.Archive.Add(new ArchivedDialog(diaNode.text, title, faction));
            return(true);
        }
        private bool DoExecute(IncidentParms parms)
        {
            List <Pair <Faction, Faction> > factions = new List <Pair <Faction, Faction> >();

            foreach (var faction in Find.FactionManager.AllFactionsVisible)
            {
                if (faction == Faction.OfPlayer)
                {
                    continue;
                }

                foreach (var faction2 in Find.FactionManager.AllFactionsVisible)
                {
                    if (faction2 == Faction.OfPlayer)
                    {
                        continue;
                    }

                    if (faction.HostileTo(faction2))
                    {
                        factions.Add(new Pair <Faction, Faction>(faction, faction2));
                    }
                }
            }

            Pair <Faction, Faction>          pairFactions = factions.RandomElement();
            Pair <List <Pawn>, List <Pawn> > pawns        = new Pair <List <Pawn>, List <Pawn> >(new List <Pawn>(), new List <Pawn>());

            parms.faction = pairFactions.First;
            GeneratePawns(parms).ForEach(p => pawns.First.Add(p));

            if (pawns.First.Count == 0)
            {
                return(false);
            }

            parms.faction = pairFactions.Second;
            GeneratePawns(parms).ForEach(p => pawns.Second.Add(p));

            if (pawns.Second.Count == 0)
            {
                return(false);
            }

            Map     map  = parms.target as Map;
            bool    flag = false;
            IntVec3 existingMapEdgeCell = IntVec3.Invalid;

            if (map == null)
            {
                map  = SetupCaravanAttackMap((Caravan)parms.target, pawns.First, pawns.Second);
                flag = true;
            }
            else
            {
                MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out existingMapEdgeCell, out IntVec3 third);
                SpawnEnemies(existingMapEdgeCell, third, pawns.First, pawns.Second, map);
            }

            LordJob lordJob = new LordJob_AssaultColony(pairFactions.Second, canKidnap: true, canTimeoutOrFlee: false);

            if (lordJob != null)
            {
                LordMaker.MakeNewLord(pairFactions.First, lordJob, map, pawns.First);
            }
            LordJob lordJob2 = new LordJob_AssaultColony(pairFactions.First, canKidnap: true, canTimeoutOrFlee: false);

            if (lordJob != null)
            {
                LordMaker.MakeNewLord(pairFactions.Second, lordJob2, map, pawns.Second);
            }

            Caravan caravan    = parms.target as Caravan;
            string  letterText = string.Format(def.letterText, (caravan == null) ? "yourCaravan".Translate().ToString() : caravan.Name, pairFactions.First.Name, pairFactions.Second.Name);

            Find.LetterStack.ReceiveLetter(def.letterLabel, letterText, def.letterDef);
            if (flag)
            {
                Find.TickManager.Notify_GeneratedPotentiallyHostileMap();
            }

            return(true);
        }
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            //if(this.wo != null)
            //{
            //    this.wo.interactable = false;
            //}

            if (parms.target is Map)
            {
                return(IncidentDefOf.TravelerGroup.Worker.TryExecute(parms));
            }
            Caravan caravan         = (Caravan)parms.target;
            Faction faction         = parms.faction;
            bool    factionCanTrade = WorldUtility.FactionCanTrade(parms.faction);
            //if (parms.faction != null && factionCanTrade)
            //{
            //    faction = parms.faction;
            //}
            //else
            //{
            //    return false;
            //}
            List <Pawn> list = GenerateCaravanPawns(faction, wo.RimWarPoints);

            if (!list.Any())
            {
                Log.Error("IncidentWorker_CaravanMeeting could not generate any pawns.");
                return(false);
            }
            Caravan metCaravan      = CaravanMaker.MakeCaravan(list, faction, -1, addToWorldPawnsIfNotAlready: false);
            bool    hostileToPlayer = faction.HostileTo(Faction.OfPlayer);

            CameraJumper.TryJumpAndSelect(caravan);
            DiaNode diaNode = new DiaNode((string)"CaravanMeeting".Translate(caravan.Name, faction.Name, PawnUtility.PawnKindsToLineList(from x in metCaravan.PawnsListForReading
                                                                                                                                         select x.kindDef, "  - ")).CapitalizeFirst());
            Pawn bestPlayerNegotiator = BestCaravanPawnUtility.FindBestNegotiator(caravan, faction, metCaravan.TraderKind);

            if (metCaravan.CanTradeNow)
            {
                DiaOption diaOption = new DiaOption("CaravanMeeting_Trade".Translate());
                diaOption.action = delegate
                {
                    Find.WindowStack.Add(new Dialog_Trade(bestPlayerNegotiator, metCaravan));
                    PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(metCaravan.Goods.OfType <Pawn>(), "LetterRelatedPawnsTradingWithOtherCaravan".Translate(Faction.OfPlayer.def.pawnsPlural), LetterDefOf.NeutralEvent);
                };
                if (bestPlayerNegotiator == null)
                {
                    if (metCaravan.TraderKind.permitRequiredForTrading != null && !caravan.pawns.Any(delegate(Pawn p)
                    {
                        if (p.royalty != null)
                        {
                            return(p.royalty.HasPermit(metCaravan.TraderKind.permitRequiredForTrading, faction));
                        }
                        return(false);
                    }))
                    {
                        RoyalTitleDef royalTitleDef = faction.def.RoyalTitlesAwardableInSeniorityOrderForReading.First(delegate(RoyalTitleDef t)
                        {
                            if (t.permits != null)
                            {
                                return(t.permits.Contains(metCaravan.TraderKind.permitRequiredForTrading));
                            }
                            return(false);
                        });
                        diaOption.Disable("CaravanMeeting_NoPermit".Translate(royalTitleDef.GetLabelForBothGenders(), faction).Resolve());
                    }
                    else if (hostileToPlayer)
                    {
                        diaOption.Disable("RW_CaravanMeeting_TradeUnwilling".Translate(faction.Name));
                    }
                    else
                    {
                        diaOption.Disable("CaravanMeeting_TradeIncapable".Translate());
                    }
                }
                else if (!factionCanTrade)
                {
                    diaOption.Disable("RW_CaravanMeeting_FactionIncapableOfTrade".Translate());
                }
                diaNode.options.Add(diaOption);
            }
            DiaOption diaOption2 = new DiaOption("CaravanMeeting_Attack".Translate());

            diaOption2.action = delegate
            {
                LongEventHandler.QueueLongEvent(delegate
                {
                    Pawn t2 = caravan.PawnsListForReading[0];
                    faction.TrySetRelationKind(Faction.OfPlayer, FactionRelationKind.Hostile, true, "GoodwillChangedReason_AttackedCaravan".Translate(), t2);
                    Map map = CaravanIncidentUtility.GetOrGenerateMapForIncident(caravan, new IntVec3(100, 1, 100), WorldObjectDefOf.AttackedNonPlayerCaravan);
                    map.Parent.SetFaction(faction);
                    MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 playerSpot, out IntVec3 enemySpot);
                    CaravanEnterMapUtility.Enter(caravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(playerSpot, map, 12), CaravanDropInventoryMode.DoNotDrop, draftColonists: true);
                    List <Pawn> list2 = metCaravan.PawnsListForReading.ToList();
                    CaravanEnterMapUtility.Enter(metCaravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(enemySpot, map, 12));
                    LordMaker.MakeNewLord(faction, new LordJob_DefendAttackedTraderCaravan(list2[0].Position), map, list2);
                    Find.TickManager.Notify_GeneratedPotentiallyHostileMap();
                    CameraJumper.TryJumpAndSelect(t2);
                    PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter_Send(list2, "LetterRelatedPawnsGroupGeneric".Translate(Faction.OfPlayer.def.pawnsPlural), LetterDefOf.NeutralEvent, informEvenIfSeenBefore: true);
                    wo.Destroy();
                }, "GeneratingMapForNewEncounter", false, null);
        private void SpawnEnemies(float threatPoints, Faction faction, Verse.Map map)
        {
            PawnGroupMakerParms pawnGroupMakerParms = new PawnGroupMakerParms
            {
                faction = faction,
                points  = threatPoints * 0.4f,
                generateFightersOnly = true,
                groupKind            = PawnGroupKindDefOf.Combat,
                raidStrategy         = RaidStrategyDefOf.ImmediateAttack,
                forceOneIncap        = true
            };

            List <Pawn> pawns = PawnGroupMakerUtility.GeneratePawns(pawnGroupMakerParms).ToList();

            List <int> groups = new List <int>()
            {
                pawns.Count
            };
            int totalPawns = pawns.Count - 1;

            if (pawns.Count > 5)
            {
                groups.Clear();

                if (pawns.Count < maxPawnsInGroup)
                {
                    maxPawnsInGroup = pawns.Count;
                }

                while (groups.Count < maxGroups)
                {
                    if (totalPawns <= 0)
                    {
                        break;
                    }

                    int pawnsGroupCount = Rand.Range(1, maxPawnsInGroup);

                    if (pawnsGroupCount > totalPawns)
                    {
                        pawnsGroupCount = totalPawns;
                    }

                    groups.Add(pawnsGroupCount);
                    totalPawns -= pawnsGroupCount;
                }
            }

            int total = 0;

            for (int i = 0; i < groups.Count; i++)
            {
                MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out IntVec3 playerStartingSpot, out IntVec3 second);

                for (int i2 = 0; i2 < groups[i]; i2++)
                {
                    IntVec3 loc = CellFinder.RandomSpawnCellForPawnNear(second, map);
                    GenSpawn.Spawn(pawns[total], loc, map);
                    total++;
                }
            }

            LordJob lordJob = new LordJob_AssaultColony(faction, canKidnap: true, canTimeoutOrFlee: false);

            if (lordJob != null)
            {
                LordMaker.MakeNewLord(faction, lordJob, map, pawns);
            }
        }
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            if (parms.target is Map)
            {
                return(IncidentDefOf.TravelerGroup.Worker.TryExecute(parms));
            }
            Caravan caravan = (Caravan)parms.target;
            Faction faction;

            if (!(from x in Find.FactionManager.AllFactionsListForReading
                  where !x.IsPlayer && !x.HostileTo(Faction.OfPlayer) && !x.def.hidden && x.def.humanlikeFaction && x.def.caravanTraderKinds.Any()
                  select x).TryRandomElement <Faction>(out faction))
            {
                return(false);
            }
            CameraJumper.TryJumpAndSelect(caravan);
            List <Pawn> pawns                = this.GenerateCaravanPawns(faction);
            Caravan     metCaravan           = CaravanMaker.MakeCaravan(pawns, faction, -1, false);
            string      text                 = "CaravanMeeting".Translate(faction.Name, PawnUtility.PawnKindsToCommaList(metCaravan.PawnsListForReading));
            DiaNode     diaNode              = new DiaNode(text);
            Pawn        bestPlayerNegotiator = BestCaravanPawnUtility.FindBestNegotiator(caravan);

            if (metCaravan.CanTradeNow)
            {
                DiaOption diaOption = new DiaOption("CaravanMeeting_Trade".Translate());
                diaOption.action = delegate
                {
                    Find.WindowStack.Add(new Dialog_Trade(bestPlayerNegotiator, metCaravan));
                    string empty  = string.Empty;
                    string empty2 = string.Empty;
                    PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter(metCaravan.Goods.OfType <Pawn>(), ref empty, ref empty2, "LetterRelatedPawnsTradingWithOtherCaravan".Translate(), false, true);
                    if (!empty2.NullOrEmpty())
                    {
                        Find.LetterStack.ReceiveLetter(empty, empty2, LetterDefOf.NeutralEvent, new GlobalTargetInfo(caravan.Tile), null);
                    }
                };
                if (bestPlayerNegotiator == null)
                {
                    diaOption.Disable("CaravanMeeting_TradeIncapable".Translate());
                }
                diaNode.options.Add(diaOption);
            }
            DiaOption diaOption2 = new DiaOption("CaravanMeeting_Attack".Translate());

            diaOption2.action = delegate
            {
                LongEventHandler.QueueLongEvent(delegate
                {
                    if (!faction.HostileTo(Faction.OfPlayer))
                    {
                        faction.SetHostileTo(Faction.OfPlayer, true);
                    }
                    Pawn t  = caravan.PawnsListForReading[0];
                    Map map = CaravanIncidentUtility.GetOrGenerateMapForIncident(caravan, new IntVec3(100, 1, 100), WorldObjectDefOf.AttackedCaravan);
                    IntVec3 playerSpot;
                    IntVec3 enemySpot;
                    MultipleCaravansCellFinder.FindStartingCellsFor2Groups(map, out playerSpot, out enemySpot);
                    CaravanEnterMapUtility.Enter(caravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(playerSpot, map, 12, null), CaravanDropInventoryMode.DoNotDrop, true);
                    List <Pawn> list = metCaravan.PawnsListForReading.ToList();
                    CaravanEnterMapUtility.Enter(metCaravan, map, (Pawn p) => CellFinder.RandomClosewalkCellNear(enemySpot, map, 12, null), CaravanDropInventoryMode.DoNotDrop, false);
                    LordMaker.MakeNewLord(faction, new LordJob_DefendAttackedTraderCaravan(list[0].Position), map, list);
                    Find.TickManager.CurTimeSpeed = TimeSpeed.Paused;
                    CameraJumper.TryJumpAndSelect(t);
                    Messages.Message("MessageAttackedCaravanIsNowHostile".Translate(faction.Name), new GlobalTargetInfo(list[0].Position, list[0].Map, false), MessageTypeDefOf.ThreatBig);
                }, "GeneratingMapForNewEncounter", false, null);
            };
            diaOption2.resolveTree = true;
            diaNode.options.Add(diaOption2);
            DiaOption diaOption3 = new DiaOption("CaravanMeeting_MoveOn".Translate());

            diaOption3.action = delegate
            {
                this.RemoveAllPawnsAndPassToWorld(metCaravan);
            };
            diaOption3.resolveTree = true;
            diaNode.options.Add(diaOption3);
            string      text2              = "CaravanMeetingTitle".Translate(caravan.Label);
            WindowStack windowStack        = Find.WindowStack;
            DiaNode     nodeRoot           = diaNode;
            bool        delayInteractivity = true;
            string      title              = text2;

            windowStack.Add(new Dialog_NodeTree(nodeRoot, delayInteractivity, false, title));
            return(true);
        }