예제 #1
0
        public override void Notify_GeneratedByQuestGen(SitePart part, Slate slate, List <Rule> outExtraDescriptionRules, Dictionary <string, string> outExtraDescriptionConstants)
        {
            base.Notify_GeneratedByQuestGen(part, slate, outExtraDescriptionRules, outExtraDescriptionConstants);
            ThingDef thingDef = slate.Get <ThingDef>("itemStashSingleThing");
            IEnumerable <ThingDef> enumerable = slate.Get <IEnumerable <ThingDef> >("itemStashThings");
            List <Thing>           list;

            if (thingDef != null)
            {
                list = new List <Thing>();
                list.Add(ThingMaker.MakeThing(thingDef));
            }
            else if (enumerable != null)
            {
                list = new List <Thing>();
                foreach (ThingDef item in enumerable)
                {
                    list.Add(ThingMaker.MakeThing(item));
                }
            }
            else
            {
                float x = slate.Get("points", 0f);
                ThingSetMakerParams parms = default(ThingSetMakerParams);
                parms.totalMarketValueRange = new FloatRange(0.7f, 1.3f) * QuestTuning.PointsToRewardMarketValueCurve.Evaluate(x);
                list = ThingSetMakerDefOf.Reward_ItemsStandard.root.Generate(parms);
            }
            part.things = new ThingOwner <Thing>(part, oneStackOnly: false);
            part.things.TryAddRangeOrTransfer(list, canMergeWithExistingStacks: false);
            slate.Set("generatedItemStashThings", list);
            outExtraDescriptionRules.Add(new Rule_String("itemStashContents", GenLabel.ThingsLabel(list)));
            outExtraDescriptionRules.Add(new Rule_String("itemStashContentsValue", GenThing.GetMarketValue(list).ToStringMoney()));
        }
        protected override void RunInt()
        {
            Quest      quest            = QuestGen.quest;
            Slate      slate            = QuestGen.slate;
            Map        map              = QuestGen_Get.GetMap();
            Faction    faction          = slate.Get <Faction>("faction");
            FloatRange marketValueRange = slate.Get <FloatRange>("marketValueRange");
            Pawn       val              = slate.Get <Pawn>("rewardGiver");

            quest.ReservePawns(Gen.YieldSingle(val));
            quest.ReserveFaction(faction);
            int num = Rand.Range(5, 20) * 60000;

            slate.Set("rewardDelayTicks", num);
            quest.Delay(num, delegate
            {
                ThingSetMakerParams parms   = default(ThingSetMakerParams);
                parms.totalMarketValueRange = marketValueRange;
                parms.qualityGenerator      = QualityGenerator.Reward;
                parms.makingFaction         = faction;
                List <Thing> list           = ThingSetMakerDefOf.Reward_ItemsStandard.root.Generate(parms);
                slate.Set("listOfRewards", GenLabel.ThingsLabel(list));
                quest.DropPods(map.Parent, list, null, null, "[rewardLetterText]", null, true);
                QuestGen_End.End(quest, QuestEndOutcome.Unknown);
            }, null, null, null, reactivatable: false, null, null, isQuestTimeout: false, null, null, "RewardDelay");
        }
        public override void Notify_GeneratedByQuestGen(SitePart part, Slate slate, List <Rule> outExtraDescriptionRules, Dictionary <string, string> outExtraDescriptionConstants)
        {
            base.Notify_GeneratedByQuestGen(part, slate, outExtraDescriptionRules, outExtraDescriptionConstants);
            ThingDef thingDef = slate.Get <ThingDef>("itemStashSingleThing", null, false);
            IEnumerable <ThingDef> enumerable = slate.Get <IEnumerable <ThingDef> >("itemStashThings", null, false);
            List <Thing>           list       = this.GenThingList();

            part.things = new ThingOwner <Thing>(part, false, LookMode.Deep);
            part.things.TryAddRangeOrTransfer(list, false, false);
            outExtraDescriptionRules.Add(new Rule_String("itemStashContents", GenLabel.ThingsLabel(list, "  - ")));
            outExtraDescriptionRules.Add(new Rule_String("itemStashContentsValue", GenThing.GetMarketValue(list).ToStringMoney(null)));
        }
        private void Outcome_Triumph(Caravan caravan)
        {
            FactionRelationKind playerRelationKind = base.Faction.PlayerRelationKind;
            int randomInRange = DiplomacyTuning.Goodwill_PeaceTalksTriumphRange.RandomInRange;

            base.Faction.TryAffectGoodwillWith(Faction.OfPlayer, randomInRange, false, false, null, null);
            List <Thing> list = ThingSetMakerDefOf.Reward_PeaceTalksGift.root.Generate();

            for (int i = 0; i < list.Count; i++)
            {
                caravan.AddPawnOrItem(list[i], true);
            }
            Find.LetterStack.ReceiveLetter("LetterLabelPeaceTalks_Triumph".Translate(), this.GetLetterText("LetterPeaceTalks_Triumph".Translate(new object[]
            {
                base.Faction.Name,
                randomInRange,
                GenLabel.ThingsLabel(list, "  - ")
            }), caravan, playerRelationKind), LetterDefOf.PositiveEvent, caravan, base.Faction, null);
        }
예제 #5
0
        public override void CompTick()
        {
            if (!active)
            {
                return;
            }

            if (!((MapParent)parent).HasMap)
            {
                if (timer <= Find.TickManager.TicksGame)
                {
                    Find.LetterStack.ReceiveLetter("LetterLabelJointRaidFail".Translate(), TranslatorFormattedStringExtensions.Translate("JointRaidFail", ally.leader, parent, parent.Faction, ally.def.leaderTitle)
                                                   , LetterDefOf.NegativeEvent, null, ally);
                    active = false;
                }
                if (parent.GetComponent <EnterCooldownComp>().Active)
                {
                    active = false;
                    if (Bonus.stackCount > 0)
                    {
                        ally.TryAffectGoodwillWith(Faction.OfPlayer, -25);
                        Find.LetterStack.ReceiveLetter("LetterLabelJointRaidAbandoned".Translate(), TranslatorFormattedStringExtensions.Translate("JointRaidAbandoned", ally.def.leaderTitle, ally.leader), LetterDefOf.NegativeEvent);
                    }
                }
                return;
            }
            else
            {
                if (FriendliesDefeated)
                {
                    Bonus.stackCount = 0;
                }
                if (!EnemiesDefeated)
                {
                    return;
                }
                if (Bonus.stackCount > 0)
                {
                    rewards.Add(Bonus);
                }

                DropPodUtility.DropThingsNear(DropCellFinder.TradeDropSpot(Find.AnyPlayerHomeMap), Find.AnyPlayerHomeMap, rewards, 110, false, true, true);

                Find.LetterStack.ReceiveLetter("LetterLabelJointRaidSuccess".Translate(), TranslatorFormattedStringExtensions.Translate("JointRaidSuccess", ally.leader) + GenLabel.ThingsLabel(rewards, string.Empty) + (Bonus.stackCount > 0 ? "\n\n" + TranslatorFormattedStringExtensions.Translate("JointRaidSuccessBonus", ally.leader) : "")
                                               , LetterDefOf.PositiveEvent, null, ally, null);
                active = false;
            }
        }
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            if (!TryFindFactions(out Faction ally, out Faction enemyFaction) || !TryFindTile(out int tile))
            {
                return(false);
            }
            Site site = SiteMaker.MakeSite(SiteCoreDefOf.Nothing, EndGameDefOf.Outpost_defense, tile, ally, true);

            List <Thing> rewards = ThingSetMakerDefOf.Reward_StandardByDropPod.root.Generate(new ThingSetMakerParams()
            {
                totalMarketValueRange = new FloatRange?(SiteTuning.BanditCampQuestRewardMarketValueRange * SiteTuning.QuestRewardMarketValueThreatPointsFactor.Evaluate(StorytellerUtility.DefaultSiteThreatPointsNow() - 500))
            });

            int randomInRange = SiteTuning.QuestSiteTimeoutDaysRange.RandomInRange * Global.DayInTicks;

            site.GetComponent <WorldComp_SiteDefense>().StartComp(enemyFaction, rewards);
            site.GetComponent <TimeoutComp>().StartTimeout(randomInRange);

            Find.WorldObjects.Add(site);
            string text = def.letterText.Formatted(ally.leader.LabelShort, ally.def.leaderTitle, ally.Name, GenLabel.ThingsLabel(rewards, string.Empty), randomInRange.ToStringTicksToPeriod(), GenThing.GetMarketValue(rewards).ToStringMoney(null)).CapitalizeFirst();

            GenThing.TryAppendSingleRewardInfo(ref text, rewards);
            Find.LetterStack.ReceiveLetter(def.letterLabel, text, def.letterDef, site, ally, null);
            return(true);
        }
예제 #7
0
        private bool HostileDefeated()
        {
            if (parent.GetComponent <TimedForcedExit>().ForceExitAndRemoveMapCountdownActive)
            {
                return(false);
            }
            MapParent map = (MapParent)parent;

            if (map.HasMap && map.Faction == ally && survivors && !GenHostility.AnyHostileActiveThreatTo(map.Map, map.Faction))
            {
                parent.Faction.TryAffectGoodwillWith(Faction.OfPlayer, 12);
                DropPodUtility.DropThingsNear(DropCellFinder.TradeDropSpot(Find.AnyPlayerHomeMap), Find.AnyPlayerHomeMap, rewards, 110, false, true, true);
                string text = TranslatorFormattedStringExtensions.Translate("SettlementDefenderWon", parent, TimedForcedExit.GetForceExitAndRemoveMapCountdownTimeLeftString(Global.DayInTicks), parent.Faction.leader) + GenLabel.ThingsLabel(rewards, string.Empty);
                GenThing.TryAppendSingleRewardInfo(ref text, rewards);
                Find.LetterStack.ReceiveLetter("LetterLabelSettlementDefenderWon".Translate(), text, LetterDefOf.PositiveEvent, parent, null, null);
                map.Map.Parent.GetComponent <TimedForcedExit>().StartForceExitAndRemoveMapCountdown(Global.DayInTicks);
                return(true);
            }
            return(false);
        }
        // Token: 0x06000075 RID: 117 RVA: 0x00004B08 File Offset: 0x00002D08
        private string GetLetterText(Faction alliedFaction, List <Thing> items, int days, Site site, SitePart sitePart)
        {
            string result = GrammarResolverSimpleStringExtensions.Formatted(this.def.letterText, alliedFaction.leader.LabelShort, alliedFaction.def.leaderTitle, alliedFaction.Name, GenLabel.ThingsLabel(items, "  - "), days.ToString(), SitePartUtility.GetDescriptionDialogue(site, sitePart), GenThing.GetMarketValue(items).ToStringMoney(null)).CapitalizeFirst();

            GenThing.TryAppendSingleRewardInfo(ref result, items);
            return(result);
        }
예제 #9
0
        protected void FoundTreasure(Caravan caravan)
        {
            List <Thing> list = GenerateReward();

            for (int i = 0; i < list.Count; i++)
            {
                caravan.AddPawnOrItem(list[i], true);
            }
            Find.LetterStack.ReceiveLetter("LetterLabelFoundTreasureLGE".Translate(), "LetterFoundTreasureLGE".Translate(GenThing.GetMarketValue(list).ToStringMoney(null), GenLabel.ThingsLabel(list, string.Empty)), LetterDefOf.PositiveEvent, caravan, null);
        }
예제 #10
0
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            Map target = (Map)parms.target;

            if (!TryFindFactions(out Faction faction) || !TryFindStravingPawns(out IEnumerable <Pawn> enumerableFood, target) || !TryFindInjuredPawns(out IEnumerable <Pawn> enumerableInjured, target))
            {
                return(false);
            }

            List <Thing> thingList = GenerateRewards(faction, enumerableFood.Count(), enumerableInjured.Count(), parms);

            DropPodUtility.DropThingsNear(DropCellFinder.TradeDropSpot(target), target, thingList, 110, false, true, true);
            Find.LetterStack.ReceiveLetter("FFE_LetterLabelAid".Translate(), "FFE_Aid".Translate(faction.leader, faction.def.leaderTitle, faction, GenLabel.ThingsLabel(thingList, string.Empty))
                                           , LetterDefOf.PositiveEvent, new TargetInfo(DropCellFinder.TradeDropSpot(target), target, false), faction, null);
            return(true);
        }
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            if (!TryFindAdjcentSettlemet(out Settlement bomber))
            {
                return(false);
            }
            float        silver = silverCurve.Evaluate(1 - (1 / Find.AnyPlayerHomeMap.wealthWatcher.WealthTotal));
            List <Thing> demand = new List <Thing>();

            GenerateDemands(demand, silver);

            silver = GenThing.GetMarketValue(demand);

            int    countdown = countDown.RandomInRange * Global.DayInTicks;
            string text      = TranslatorFormattedStringExtensions.Translate("BombardmentThreat", bomber.Faction.leader, bomber.Faction.def.leaderTitle, bomber.Name, silver.ToStringMoney(null), GenLabel.ThingsLabel(demand, string.Empty), countdown.ToStringTicksToPeriod());

            GenThing.TryAppendSingleRewardInfo(ref text, demand);

            DiaNode nodeRoot = new DiaNode(text);

            nodeRoot.options.Add(new DiaOption("BombardmentThreat_AcceptThings".Translate())
            {
                action = () =>
                {
                    foreach (Thing t in demand)
                    {
                        TradeUtility.LaunchThingsOfType(t.def, t.stackCount, Find.AnyPlayerHomeMap, null);
                    }
                },
                link = new DiaNode(TranslatorFormattedStringExtensions.Translate("BombardmentThreatAcceptThings", bomber.Faction.leader))
                {
                    options =
                    {
                        new DiaOption("OK".Translate())
                        {
                            resolveTree = true
                        }
                    }
                }
            });
            if (TradeUtility.ColonyHasEnoughSilver(TradeUtility.PlayerHomeMapWithMostLaunchableSilver(), (int)silver * 2))
            {
                nodeRoot.options.Add(new DiaOption("BombardmentThreat_AcceptSilver".Translate((silver * 2).ToStringMoney()))
                {
                    action = () =>
                    {
                        TradeUtility.LaunchSilver(Find.AnyPlayerHomeMap, (int)silver * 2);
                    },
                    link = new DiaNode(TranslatorFormattedStringExtensions.Translate("BombardmentThreatAcceptThings", bomber.Faction.leader))
                    {
                        options =
                        {
                            new DiaOption("OK".Translate())
                            {
                                resolveTree = true
                            }
                        }
                    }
                });
            }
            else
            {
                nodeRoot.options.Add(new DiaOption("BombardmentThreat_AcceptSilver".Translate(((float)silver * 2).ToStringMoney()))
                {
                    disabled       = true,
                    disabledReason = "BombardmentThreat_AcceptSilverDisabled".Translate()
                });
            }
            nodeRoot.options.Add(new DiaOption("BombardmentThreat_Refusal".Translate())
            {
                action = () =>
                {
                    Find.AnyPlayerHomeMap.GetComponent <FE_MapComponent_Bombardment>().StartComp(def.durationDays.RandomInRange * Global.DayInTicks, bomber, countdown);
                },
                link = new DiaNode("BombardmentThreatRefusal".Translate(bomber.Faction.leader))
                {
                    options =
                    {
                        new DiaOption("OK".Translate())
                        {
                            resolveTree = true
                        }
                    }
                }
            });
            string title = "LetterLabelBombardmentTitle".Translate();

            Find.WindowStack.Add(new Dialog_NodeTreeWithFactionInfo(nodeRoot, bomber.Faction, true, true, title));
            Find.Archive.Add(new ArchivedDialog(nodeRoot.text, title, bomber.Faction));
            return(true);
        }
        private void HostileDefeated()
        {
            // Killed all hostiles - Win outcome
            if (!GenHostility.AnyHostileActiveThreatTo(((MapParent)parent).Map, Faction.OfPlayer))
            {
                active = false;
                DropPodUtility.DropThingsNear(DropCellFinder.TradeDropSpot(Find.AnyPlayerHomeMap), Find.AnyPlayerHomeMap, rewards, 110, false, true, true);
                parent.Faction.TryAffectGoodwillWith(Faction.OfPlayer, +15, false, true);

                if (!Find.WorldObjects.Settlements.Where(s => s.Faction == enemy && !s.Faction.def.hidden && Find.WorldReachability.CanReach(Find.AnyPlayerHomeMap.Tile, s.Tile)).TryRandomElement(out Settlement enemySet))
                {
                    Find.LetterStack.ReceiveLetter("LetterLabelOutpostdefensesuccess".Translate(), TranslatorFormattedStringExtensions.Translate("Outpostdefensesuccess", parent.Faction.leader, parent.Faction.def.leaderTitle, GenLabel.ThingsLabel(rewards, string.Empty)), EndGameDefOf.FE_JointRaid.letterDef, null, parent.Faction, null);
                    active = false;
                    return;
                }

                List <Thing> rewardsNew = ThingSetMakerDefOf.Reward_StandardByDropPod.root.Generate(new ThingSetMakerParams()
                {
                    totalMarketValueRange = new FloatRange?(SiteTuning.BanditCampQuestRewardMarketValueRange * SiteTuning.QuestRewardMarketValueThreatPointsFactor.Evaluate(StorytellerUtility.DefaultSiteThreatPointsNow() + 500f))
                });

                Thing silver = ThingMaker.MakeThing(ThingDefOf.Silver);
                silver.stackCount = (int)FE_IncidentWorker_Jointraid.SilverBonusRewardCurve.Evaluate(parent.Faction.PlayerGoodwill);

                int random = new IntRange(Global.DayInTicks * 15, Global.DayInTicks * 25).RandomInRange;
                enemySet.GetComponent <WorldComp_JointRaid>().StartComp(random, parent.Faction, rewardsNew, silver);
                string text = TranslatorFormattedStringExtensions.Translate("OutpostdefensesuccessJointRaid", parent.Faction.leader, parent.Faction.def.leaderTitle, GenLabel.ThingsLabel(rewardsNew, string.Empty), random.ToStringTicksToPeriod(), GenThing.GetMarketValue(rewards).ToStringMoney(null), silver.stackCount.ToString(), GenLabel.ThingsLabel(rewards, string.Empty)).CapitalizeFirst();
                GenThing.TryAppendSingleRewardInfo(ref text, rewards);
                Find.LetterStack.ReceiveLetter(EndGameDefOf.FE_JointRaid.letterLabel, text, EndGameDefOf.FE_JointRaid.letterDef, enemySet, parent.Faction, null);
            }
        }
        private bool HostileDefeated()
        {
            MapParent map = (MapParent)parent;

            if (map.HasMap && !GenHostility.AnyHostileActiveThreatTo(map.Map, Faction.OfPlayer))
            {
                active = false;
                List <Pawn> prisoner  = map.Map.mapPawns.AllPawns.Where(x => !x.Dead && !x.Downed && (x.IsPrisoner || x.kindDef == PawnKindDefOf.Slave)).ToList();
                int         pawnSaved = prisoner.Count(x => !x.Dead);
                if (pawnSaved == 0)
                {
                    Find.LetterStack.ReceiveLetter("LetterLabelSettlementRescueFail".Translate(), TranslatorFormattedStringExtensions.Translate("SettlementRescueFail", parent.Faction, TimedForcedExit.GetForceExitAndRemoveMapCountdownTimeLeftString(Global.DayInTicks),
                                                                                                                                                ally.leader, ally.def.pawnsPlural), LetterDefOf.NegativeEvent, parent, null, null);
                    return(true);
                }
                else
                {
                    prisoner[0].Faction.TryAffectGoodwillWith(Faction.OfPlayer, 10 * pawnSaved);
                }

                foreach (Pawn p in prisoner)
                {
                    if (Rand.Chance(UnWillingChance))
                    {
                        pawnStaying++;
                        p.mindState.WillJoinColonyIfRescued = false;
                    }
                }
                if (pawnStaying >= 3)
                {
                    resurrectSet = true;
                }
                DropPodUtility.DropThingsNear(DropCellFinder.TradeDropSpot(Find.AnyPlayerHomeMap), Find.AnyPlayerHomeMap, new Gift_RewardGeneratorBasedTMagic().Generate(500, new List <Thing>()), 110, false, true, true);
                string text = TranslatorFormattedStringExtensions.Translate("SettlementRescueWin", parent.Faction, TimedForcedExit.GetForceExitAndRemoveMapCountdownTimeLeftString(Global.DayInTicks), ally.leader, ally.def.leaderTitle) + GenLabel.ThingsLabel(new Gift_RewardGeneratorBasedTMagic().Generate(500, new List <Thing>()), string.Empty);
                Find.LetterStack.ReceiveLetter("LetterLabelSettlementRescue".Translate(), text, LetterDefOf.PositiveEvent, parent, null, null);
                return(true);
            }
            return(false);
        }
        private string GetLetterText(string settlementName, MedievalTournament tournament, int durationDays)
        {
            var hostFaction = tournament.Faction;
            var textBuilder = new StringBuilder();

            textBuilder.AppendLine(def.letterText.Formatted(hostFaction.def.leaderTitle, hostFaction.Name, settlementName, GenLabel.ThingsLabel(tournament.rewards), hostFaction.leader.Named("PAWN")).AdjustedFor(hostFaction.leader));
            textBuilder.AppendLine();
            textBuilder.AppendLine(tournament.category.description);
            textBuilder.AppendLine();
            textBuilder.AppendLine("VanillaFactionsExpanded.TournamentDurationDays".Translate(durationDays));
            return(textBuilder.ToString().TrimEndNewlines());
        }
예제 #15
0
        protected void TreasureWithHumanAmbush(Caravan caravan)
        {
            List <Thing> rewardList = GenerateReward();

            for (int i = 0; i < rewardList.Count; i++)
            {
                caravan.AddPawnOrItem(rewardList[i], true);
            }
            LongEventHandler.QueueLongEvent(delegate
            {
                IncidentParms incidentParms = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.ThreatBig, caravan);
                //make sure a minimum point threshold is hit
                if (incidentParms.points < MinimumPointThreshold)
                {
                    incidentParms.points = MinimumPointThreshold + 100f;
                }
                incidentParms.faction = Find.FactionManager.RandomEnemyFaction();
                PawnGroupMakerParms defaultPawnGroupMakerParms  = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(PawnGroupKindDefOf.Combat, incidentParms, true);
                defaultPawnGroupMakerParms.generateFightersOnly = true;
                List <Pawn> pawnList = PawnGroupMakerUtility.GeneratePawns(defaultPawnGroupMakerParms, true).ToList <Pawn>();
                Map map = CaravanIncidentUtility.SetupCaravanAttackMap(caravan, pawnList, false);
                if (pawnList.Any <Pawn>())
                {
                    LordMaker.MakeNewLord(incidentParms.faction, new LordJob_AssaultColony(incidentParms.faction, true, true, false, false, true), map, pawnList);
                }
                Find.TickManager.CurTimeSpeed = TimeSpeed.Paused;
                GlobalTargetInfo lookTarget   = (!pawnList.Any <Pawn>()) ? GlobalTargetInfo.Invalid : new GlobalTargetInfo(pawnList[0].Position, map, false);
                Find.LetterStack.ReceiveLetter("LetterLabelTreasureAmbushLGE".Translate(), "LetterTreasureAmbushLGE".Translate(GenThing.GetMarketValue(rewardList).ToStringMoney(null), GenLabel.ThingsLabel(rewardList, string.Empty)), LetterDefOf.ThreatBig, lookTarget, null);
            }, "GeneratingMapForNewEncounter", false, null);
        }
예제 #16
0
        public void Notify_CaravanArrived(Caravan caravan)
        {
            var participants    = new List <Pawn>();
            var nonParticipants = new List <Pawn>();

            MedievalTournamentUtility.GroupParticipants(caravan.PlayerPawnsForStoryteller.Where(p => p.RaceProps.Humanlike).ToList(), category, participants, nonParticipants);

            // Create dialogue tree
            var leader      = Faction.leader;
            var tourneyNode = new DiaNode("VanillaFactionsExpanded.MedievalTournamentInitial".Translate(leader.LabelShort, Faction.Name, category.label, competitorCount, GenLabel.ThingsLabel(rewards), leader.Named("PAWN")));

            // Option 1: Participate
            var participateNode   = new DiaNode("VanillaFactionsExpanded.ParticipateInitial".Translate());
            var participateOption = new DiaOption("VanillaFactionsExpanded.Participate".Translate())
            {
                link = participateNode
            };

            tourneyNode.options.Add(participateOption);
            for (int i = 0; i < participants.Count; i++)
            {
                var pawn       = participants[i];
                var pawnOption = new DiaOption(MedievalTournamentUtility.ParticipantOptionText(pawn, category))
                {
                    action      = () => DoTournament(caravan, pawn),
                    resolveTree = true
                };
                participateNode.options.Add(pawnOption);
            }
            for (int i = 0; i < nonParticipants.Count; i++)
            {
                var pawn       = nonParticipants[i];
                var pawnOption = new DiaOption(MedievalTournamentUtility.ParticipantOptionText(pawn, category))
                {
                    disabled = true
                };
                participateNode.options.Add(pawnOption);
            }
            var participateGoBack = new DiaOption("GoBack".Translate())
            {
                link = tourneyNode
            };

            participateNode.options.Add(participateGoBack);

            // Option 2: Attack (angers faction)
            var attackOption = new DiaOption($"{"CommandAttackSettlement".Translate()} ({"AngersFaction".Translate()})")
            {
                action = () =>
                {
                    LongEventHandler.QueueLongEvent(() =>
                    {
                        Faction.TrySetRelationKind(Faction.OfPlayer, FactionRelationKind.Hostile, false);
                        var competitorPool       = PossibleCompetitors.ToList();
                        var extraPawnParams      = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.ThreatBig, caravan);
                        extraPawnParams.faction  = Faction;
                        var pawnGroupMakerParams = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(PawnGroupKindDefOf.Combat, extraPawnParams, true);
                        pawnGroupMakerParams.generateFightersOnly = true;
                        var hostilePawns = MedievalTournamentUtility.GenerateCompetitors(competitorCount, category, Faction, PossibleCompetitors).Concat(PawnGroupMakerUtility.GeneratePawns(pawnGroupMakerParams)).ToList();
                        var map          = CaravanIncidentUtility.SetupCaravanAttackMap(caravan, hostilePawns, true);
                        if (hostilePawns.Any())
                        {
                            LordMaker.MakeNewLord(Faction, new LordJob_AssaultColony(Faction), map, hostilePawns);
                        }
                        Find.TickManager.Notify_GeneratedPotentiallyHostileMap();
                        for (int i = 0; i < rewards.Count; i++)
                        {
                            GenPlace.TryPlaceThing(rewards[i], map.Center, map, ThingPlaceMode.Near);
                        }
                    },
                                                    "GeneratingMapForNewEncounter", false, null);
                    Find.WorldObjects.Remove(this);
                },
                resolveTree = true
            };

            tourneyNode.options.Add(attackOption);

            // Option 3: Leave
            var leaveOption = new DiaOption("VanillaFactionsExpanded.Leave".Translate())
            {
                resolveTree = true
            };

            tourneyNode.options.Add(leaveOption);

            // Add dialogue menu
            Find.WindowStack.Add(new Dialog_NodeTree(tourneyNode, title: LabelCap));
        }
예제 #17
0
        protected void TreasureWithManhunters(Caravan caravan)
        {
            List <Thing> rewardList = GenerateReward();

            for (int i = 0; i < rewardList.Count; i++)
            {
                caravan.AddPawnOrItem(rewardList[i], true);
            }
            LongEventHandler.QueueLongEvent(delegate
            {
                IncidentParms incidentParms = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.ThreatBig, caravan);
                //make sure a minimum point threshold is hit
                if (incidentParms.points < MinimumPointThreshold)
                {
                    incidentParms.points = MinimumPointThreshold + 100f;
                }
                PawnKindDef animalKind;
                if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(this.AdjustedPoints(incidentParms.points), incidentParms.target.Tile, out animalKind) && !ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(this.AdjustedPoints(incidentParms.points), -1, out animalKind))
                {
                    Log.Warning("Could not find any valid animal kind for " + this.def + " incident. Going with Wargs", false);
                    animalKind = ThingDefOfVanilla.Warg;
                }
                List <Pawn> pawnList = ManhunterPackIncidentUtility.GenerateAnimals(animalKind, incidentParms.target.Tile, this.AdjustedPoints(incidentParms.points));
                Map map = CaravanIncidentUtility.SetupCaravanAttackMap(caravan, pawnList, false);
                for (int i = 0; i < pawnList.Count; i++)
                {
                    pawnList[i].mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent, null, false, false, null, false);
                }
                Find.TickManager.CurTimeSpeed = TimeSpeed.Paused;
                GlobalTargetInfo lookTarget   = (!pawnList.Any <Pawn>()) ? GlobalTargetInfo.Invalid : new GlobalTargetInfo(pawnList[0].Position, map, false);
                Find.LetterStack.ReceiveLetter("LetterLabelTreasureAmbushLGE".Translate(), "LetterTreasureAmbushLGE".Translate(GenThing.GetMarketValue(rewardList).ToStringMoney(null), GenLabel.ThingsLabel(rewardList, string.Empty)), LetterDefOf.ThreatBig, lookTarget, null);
            }, "GeneratingMapForNewEncounter", false, null);
        }
예제 #18
0
        private void Outcome_Triumph(Caravan caravan)
        {
            FactionRelationKind playerRelationKind = base.Faction.PlayerRelationKind;
            int randomInRange = DiplomacyTuning.Goodwill_PeaceTalksTriumphRange.RandomInRange;

            base.Faction.TryAffectGoodwillWith(Faction.OfPlayer, randomInRange, canSendMessage: false, canSendHostilityLetter: false);
            ThingSetMakerParams parms = default(ThingSetMakerParams);

            parms.makingFaction         = base.Faction;
            parms.techLevel             = base.Faction.def.techLevel;
            parms.maxTotalMass          = 20f;
            parms.totalMarketValueRange = new FloatRange(500f, 1200f);
            parms.tile = base.Tile;
            List <Thing> list = ThingSetMakerDefOf.Reward_ItemsStandard.root.Generate(parms);

            for (int i = 0; i < list.Count; i++)
            {
                caravan.AddPawnOrItem(list[i], addCarriedPawnToWorldPawnsIfAny: true);
            }
            Find.LetterStack.ReceiveLetter("LetterLabelPeaceTalks_Triumph".Translate(), GetLetterText("LetterPeaceTalks_Triumph".Translate(base.Faction.NameColored, randomInRange, GenLabel.ThingsLabel(list)), caravan, playerRelationKind, TryGainRoyalFavor(caravan)), LetterDefOf.PositiveEvent, caravan, base.Faction);
        }
예제 #19
0
        private void Outcome_Triumph(Caravan caravan)
        {
            FactionRelationKind playerRelationKind = base.Faction.PlayerRelationKind;
            int randomInRange = DiplomacyTuning.Goodwill_PeaceTalksTriumphRange.RandomInRange;

            base.Faction.TryAffectGoodwillWith(Faction.OfPlayer, randomInRange, canSendMessage: false, canSendHostilityLetter: false);
            List <Thing> list = ThingSetMakerDefOf.Reward_PeaceTalksGift.root.Generate();

            for (int i = 0; i < list.Count; i++)
            {
                caravan.AddPawnOrItem(list[i], addCarriedPawnToWorldPawnsIfAny: true);
            }
            Find.LetterStack.ReceiveLetter("LetterLabelPeaceTalks_Triumph".Translate(), GetLetterText("LetterPeaceTalks_Triumph".Translate(base.Faction.Name, randomInRange, GenLabel.ThingsLabel(list)), caravan, playerRelationKind), LetterDefOf.PositiveEvent, caravan, base.Faction);
        }
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            if (!TryFindFactions(out Faction ally, out Faction enemyFaction) || !TryFindTile(ally, out Settlement sis))
            {
                return(false);
            }

            int          random  = new IntRange(Global.DayInTicks * 15, Global.DayInTicks * 25).RandomInRange;
            List <Thing> rewards = ThingSetMakerDefOf.Reward_StandardByDropPod.root.Generate(new ThingSetMakerParams()
            {
                totalMarketValueRange = new FloatRange?(SiteTuning.BanditCampQuestRewardMarketValueRange * SiteTuning.QuestRewardMarketValueThreatPointsFactor.Evaluate(StorytellerUtility.DefaultSiteThreatPointsNow() + 500f))
            });

            sis.GetComponent <WorldComp_SettlementDefender>().StartComp(enemyFaction, ally, random, rewards);

            string text = def.letterText.Formatted(ally.leader.LabelShort, ally.def.leaderTitle, ally.Name, GenLabel.ThingsLabel(rewards, string.Empty), random.ToStringTicksToPeriod(), GenThing.GetMarketValue(rewards).ToStringMoney(null)).CapitalizeFirst();

            GenThing.TryAppendSingleRewardInfo(ref text, rewards);
            Find.LetterStack.ReceiveLetter(def.letterLabel, text, def.letterDef, sis, ally, null);
            return(true);
        }
        protected override void RunInt()
        {
            if (!ModLister.RoyaltyInstalled)
            {
                Log.ErrorOnce("Hospitality refugee is a Royalty-specific game system. If you want to use this code please check ModLister.RoyaltyInstalled before calling it. See rules on the Ludeon forum for more info.", 8811221);
                return;
            }
            Quest quest       = QuestGen.quest;
            Slate slate       = QuestGen.slate;
            Map   map         = QuestGen_Get.GetMap();
            int   num         = (slate.Exists("population") ? slate.Get("population", 0) : map.mapPawns.FreeColonistsSpawnedCount);
            int   lodgerCount = Mathf.Max(Mathf.RoundToInt(LodgerCountBasedOnColonyPopulationFactorRange.RandomInRange * (float)num), 1);

            lodgerCount = Mathf.Min(lodgerCount, MaxLodgerCount);
            int questDurationDays       = QuestDurationDaysRange.RandomInRange;
            int questDurationTicks      = questDurationDays * 60000;
            List <FactionRelation> list = new List <FactionRelation>();

            foreach (Faction item4 in Find.FactionManager.AllFactionsListForReading)
            {
                if (!item4.def.permanentEnemy)
                {
                    list.Add(new FactionRelation
                    {
                        other    = item4,
                        goodwill = 0,
                        kind     = FactionRelationKind.Neutral
                    });
                }
            }
            Faction faction = FactionGenerator.NewGeneratedFactionWithRelations(FactionDefOf.OutlanderRefugee, list);

            faction.hidden    = true;
            faction.temporary = true;
            faction.hostileFromMemberCapture = false;
            Find.FactionManager.Add(faction);
            string      lodgerRecruitedSignal = QuestGenUtility.HardcodedSignalWithQuestID("lodgers.Recruited");
            string      text = QuestGenUtility.HardcodedSignalWithQuestID("lodgers.Arrested");
            string      lodgerDestroyedSignal = QuestGenUtility.HardcodedSignalWithQuestID("lodgers.Destroyed");
            string      lodgerKidnapped       = QuestGenUtility.HardcodedSignalWithQuestID("lodgers.Kidnapped");
            string      lodgerLeftMap         = QuestGenUtility.HardcodedSignalWithQuestID("lodgers.LeftMap");
            string      lodgerBanished        = QuestGenUtility.HardcodedSignalWithQuestID("lodgers.Banished");
            List <Pawn> pawns = new List <Pawn>();

            for (int i = 0; i < lodgerCount; i++)
            {
                Pawn pawn = quest.GeneratePawn(PawnKindDefOf.Refugee, faction, allowAddictions: true, null, 0f, mustBeCapableOfViolence: true, null, 0f, 0f, ensureNonNumericName: false, forceGenerateNewPawn: true);
                pawns.Add(pawn);
                quest.PawnJoinOffer(pawn, "LetterJoinOfferLabel".Translate(pawn.Named("PAWN")), "LetterJoinOfferTitle".Translate(pawn.Named("PAWN")), "LetterJoinOfferText".Translate(pawn.Named("PAWN"), map.Parent.Named("MAP")), delegate
                {
                    quest.Letter(LetterDefOf.PositiveEvent, null, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, label: "LetterLabelMessageRecruitSuccess".Translate() + ": " + pawn.LabelShortCap, text: "MessageRecruitJoinOfferAccepted".Translate(pawn.Named("RECRUITEE")));
                    quest.SignalPass(null, null, lodgerRecruitedSignal);
                });
            }
            slate.Set("lodgers", pawns);
            faction.leader = pawns.First();
            Pawn var = pawns.First();

            quest.SetFactionHidden(faction);
            QuestPart_ExtraFaction extraFactionPart = quest.ExtraFaction(faction, pawns, ExtraFactionType.MiniFaction, areHelpers: false, lodgerRecruitedSignal);

            quest.PawnsArrive(pawns, null, map.Parent, null, joinPlayer: true, null, "[lodgersArriveLetterLabel]", "[lodgersArriveLetterText]");
            QuestPart_Choice questPart_Choice = quest.RewardChoice();

            QuestPart_Choice.Choice item = new QuestPart_Choice.Choice
            {
                rewards =
                {
                    (Reward) new Reward_VisitorsHelp(),
                    (Reward) new Reward_PossibleFutureReward()
                }
            };
            questPart_Choice.choices.Add(item);
            bool   mutiny = false;
            string assaultColonySignal = QuestGen.GenerateNewSignal("AssaultColony");
            Action item2 = delegate
            {
                int num4 = Mathf.FloorToInt(MutinyTimeRange.RandomInRange * (float)questDurationTicks);
                quest.Delay(num4, delegate
                {
                    quest.Letter(LetterDefOf.ThreatBig, null, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[mutinyLetterText]", null, "[mutinyLetterLabel]");
                    quest.SignalPass(null, null, assaultColonySignal);
                    QuestGen_End.End(quest, QuestEndOutcome.Unknown);
                }, null, null, null, reactivatable: false, null, null, isQuestTimeout: false, null, null, "Mutiny (" + num4.ToStringTicksToDays() + ")");
                mutiny = true;
            };
            Action item3 = delegate
            {
                Pawn factionOpponent = quest.GetPawn(new QuestGen_Pawns.GetPawnParms
                {
                    mustBeWorldPawn          = true,
                    mustBeFactionLeader      = true,
                    canGeneratePawn          = true,
                    mustBeNonHostileToPlayer = true
                });
                slate.Set("factionOpponent", factionOpponent);
                int num2 = Mathf.FloorToInt(BetrayalOfferTimeRange.RandomInRange * (float)questDurationTicks);
                quest.Delay(num2, delegate
                {
                    float val2                        = (float)lodgerCount * 300f;
                    FloatRange value                  = new FloatRange(0.7f, 1.3f) * val2 * Find.Storyteller.difficultyValues.EffectiveQuestRewardValueFactor;
                    ThingSetMakerParams parms         = default(ThingSetMakerParams);
                    parms.totalMarketValueRange       = value;
                    parms.qualityGenerator            = QualityGenerator.Reward;
                    parms.makingFaction               = faction;
                    List <Thing> betrayalRewardThings = ThingSetMakerDefOf.Reward_ItemsStandard.root.Generate(parms);
                    quest.BetrayalOffer(pawns, extraFactionPart.extraFaction, factionOpponent, delegate
                    {
                        float num3 = 0f;
                        for (int j = 0; j < betrayalRewardThings.Count; j++)
                        {
                            num3 += betrayalRewardThings[j].MarketValue * (float)betrayalRewardThings[j].stackCount;
                        }
                        slate.Set("betrayalRewards", GenLabel.ThingsLabel(betrayalRewardThings));
                        slate.Set("betrayalRewardMarketValue", num3);
                        quest.DropPods(map.Parent, betrayalRewardThings, null, null, null, null, true, useTradeDropSpot: false, joinPlayer: false, makePrisoners: false, null, null, QuestPart.SignalListenMode.Always, null, destroyItemsOnCleanup: false);
                        quest.FactionGoodwillChange(factionOpponent.Faction, 10, null, canSendMessage: true, canSendHostilityLetter: true, "GoodwillChangeReason_AttackedFaction".Translate(faction), getLookTargetFromSignal: true, QuestPart.SignalListenMode.Always);
                        quest.Letter(LetterDefOf.PositiveEvent, null, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.Always, betrayalRewardThings, filterDeadPawnsFromLookTargets: false, "[betrayalOfferRewardLetterText]", null, "[betrayalOfferRewardLetterLabel]");
                    }, delegate
                    {
                        quest.DestroyThingsOrPassToWorld(betrayalRewardThings, null, questLookTargets: true, QuestPart.SignalListenMode.Always);
                        quest.Letter(LetterDefOf.NegativeEvent, null, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.Always, null, filterDeadPawnsFromLookTargets: false, "[betrayalOfferFailedLetterText]", null, "[betrayalOfferFailedLetterLabel]");
                    }, delegate
                    {
                        (quest.Letter(LetterDefOf.BetrayVisitors, null, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[betrayalOffserLetterText]", null, "[betrayalOfferLetterLabel]").letter as ChoiceLetter_BetrayVisitors).pawns.AddRange(pawns);
                    }, new List <string>
                    {
                        lodgerDestroyedSignal,
                        lodgerKidnapped,
                        lodgerLeftMap,
                        lodgerBanished
                    }, null, QuestPart.SignalListenMode.Always);
                }, null, null, null, reactivatable: false, null, null, isQuestTimeout: false, null, null, "BetrayalOffer (" + num2.ToStringTicksToDays() + ")");
            };

            if (new List <Tuple <float, Action> >
            {
                Tuple.Create(0.25f, item2),
                Tuple.Create(0.25f, item3),
                Tuple.Create <float, Action>(0.5f, delegate
                {
                })
            }.TryRandomElementByWeight((Tuple <float, Action> t) => t.Item1, out var result))
            {
                result.Item2();
            }
            QuestPart_RefugeeInteractions questPart_RefugeeInteractions = new QuestPart_RefugeeInteractions();

            questPart_RefugeeInteractions.inSignalEnable                          = QuestGen.slate.Get <string>("inSignal");
            questPart_RefugeeInteractions.inSignalDestroyed                       = lodgerDestroyedSignal;
            questPart_RefugeeInteractions.inSignalArrested                        = text;
            questPart_RefugeeInteractions.inSignalSurgeryViolation                = QuestGenUtility.HardcodedSignalWithQuestID("lodgers.SurgeryViolation");
            questPart_RefugeeInteractions.inSignalKidnapped                       = lodgerKidnapped;
            questPart_RefugeeInteractions.inSignalRecruited                       = lodgerRecruitedSignal;
            questPart_RefugeeInteractions.inSignalAssaultColony                   = assaultColonySignal;
            questPart_RefugeeInteractions.inSignalLeftMap                         = lodgerLeftMap;
            questPart_RefugeeInteractions.inSignalBanished                        = lodgerBanished;
            questPart_RefugeeInteractions.outSignalDestroyed_AssaultColony        = QuestGen.GenerateNewSignal("LodgerDestroyed_AssaultColony");
            questPart_RefugeeInteractions.outSignalDestroyed_LeaveColony          = QuestGen.GenerateNewSignal("LodgerDestroyed_LeaveColony");
            questPart_RefugeeInteractions.outSignalDestroyed_BadThought           = QuestGen.GenerateNewSignal("LodgerDestroyed_BadThought");
            questPart_RefugeeInteractions.outSignalArrested_AssaultColony         = QuestGen.GenerateNewSignal("LodgerArrested_AssaultColony");
            questPart_RefugeeInteractions.outSignalArrested_LeaveColony           = QuestGen.GenerateNewSignal("LodgerArrested_LeaveColony");
            questPart_RefugeeInteractions.outSignalArrested_BadThought            = QuestGen.GenerateNewSignal("LodgerArrested_BadThought");
            questPart_RefugeeInteractions.outSignalSurgeryViolation_AssaultColony = QuestGen.GenerateNewSignal("LodgerSurgeryViolation_AssaultColony");
            questPart_RefugeeInteractions.outSignalSurgeryViolation_LeaveColony   = QuestGen.GenerateNewSignal("LodgerSurgeryViolation_LeaveColony");
            questPart_RefugeeInteractions.outSignalSurgeryViolation_BadThought    = QuestGen.GenerateNewSignal("LodgerSurgeryViolation_BadThought");
            questPart_RefugeeInteractions.outSignalLast_Destroyed                 = QuestGen.GenerateNewSignal("LastLodger_Destroyed");
            questPart_RefugeeInteractions.outSignalLast_Arrested                  = QuestGen.GenerateNewSignal("LastLodger_Arrested");
            questPart_RefugeeInteractions.outSignalLast_Kidnapped                 = QuestGen.GenerateNewSignal("LastLodger_Kidnapped");
            questPart_RefugeeInteractions.outSignalLast_Recruited                 = QuestGen.GenerateNewSignal("LastLodger_Recruited");
            questPart_RefugeeInteractions.outSignalLast_LeftMapAllHealthy         = QuestGen.GenerateNewSignal("LastLodger_LeftMapAllHealthy");
            questPart_RefugeeInteractions.outSignalLast_LeftMapAllNotHealthy      = QuestGen.GenerateNewSignal("LastLodger_LeftMapAllNotHealthy");
            questPart_RefugeeInteractions.outSignalLast_Banished                  = QuestGen.GenerateNewSignal("LastLodger_Banished");
            questPart_RefugeeInteractions.pawns.AddRange(pawns);
            questPart_RefugeeInteractions.faction          = faction;
            questPart_RefugeeInteractions.mapParent        = map.Parent;
            questPart_RefugeeInteractions.signalListenMode = QuestPart.SignalListenMode.Always;
            quest.AddPart(questPart_RefugeeInteractions);
            string lodgerArrestedOrRecruited = QuestGen.GenerateNewSignal("Lodger_ArrestedOrRecruited");

            quest.AnySignal(new List <string>
            {
                lodgerRecruitedSignal,
                text
            }, null, new List <string>
            {
                lodgerArrestedOrRecruited
            });
            if (!mutiny)
            {
                quest.Delay(questDurationTicks, delegate
                {
                    quest.SignalPassWithFaction(faction, null, delegate
                    {
                        quest.Letter(LetterDefOf.PositiveEvent, null, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgersLeavingLetterText]", null, "[lodgersLeavingLetterLabel]");
                    });
                    quest.Leave(pawns, null, sendStandardLetter: false, leaveOnCleanup: false, lodgerArrestedOrRecruited);
                }, null, null, null, reactivatable: false, null, null, isQuestTimeout: false, "GuestsDepartsIn".Translate(), "GuestsDepartsOn".Translate(), "QuestDelay");
            }
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalDestroyed_BadThought, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgerDiedMemoryThoughtLetterText]", null, "[lodgerDiedMemoryThoughtLetterLabel]");
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalDestroyed_AssaultColony, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgerDiedAttackPlayerLetterText]", null, "[lodgerDiedAttackPlayerLetterLabel]");
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalDestroyed_LeaveColony, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgerDiedLeaveMapLetterText]", null, "[lodgerDiedLeaveMapLetterLabel]");
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalLast_Destroyed, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgersAllDiedLetterText]", null, "[lodgersAllDiedLetterLabel]");
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalArrested_BadThought, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgerArrestedMemoryThoughtLetterText]", null, "[lodgerArrestedMemoryThoughtLetterLabel]");
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalArrested_AssaultColony, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgerArrestedAttackPlayerLetterText]", null, "[lodgerArrestedAttackPlayerLetterLabel]");
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalArrested_LeaveColony, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgerArrestedLeaveMapLetterText]", null, "[lodgerArrestedLeaveMapLetterLabel]");
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalLast_Arrested, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgersAllArrestedLetterText]", null, "[lodgersAllArrestedLetterLabel]");
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalSurgeryViolation_BadThought, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgerViolatedMemoryThoughtLetterText]", null, "[lodgerViolatedMemoryThoughtLetterLabel]");
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalSurgeryViolation_AssaultColony, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgerViolatedAttackPlayerLetterText]", null, "[lodgerViolatedAttackPlayerLetterLabel]");
            quest.Letter(LetterDefOf.NegativeEvent, questPart_RefugeeInteractions.outSignalSurgeryViolation_LeaveColony, null, null, null, useColonistsFromCaravanArg: false, QuestPart.SignalListenMode.OngoingOnly, null, filterDeadPawnsFromLookTargets: false, "[lodgerViolatedLeaveMapLetterText]", null, "[lodgerViolatedLeaveMapLetterLabel]");
            quest.AddMemoryThought(pawns, ThoughtDefOf.OtherTravelerDied, questPart_RefugeeInteractions.outSignalDestroyed_BadThought);
            quest.AddMemoryThought(pawns, ThoughtDefOf.OtherTravelerArrested, questPart_RefugeeInteractions.outSignalArrested_BadThought);
            quest.AddMemoryThought(pawns, ThoughtDefOf.OtherTravelerSurgicallyViolated, questPart_RefugeeInteractions.outSignalSurgeryViolation_BadThought);
            quest.End(QuestEndOutcome.Fail, 0, null, questPart_RefugeeInteractions.outSignalDestroyed_AssaultColony, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            quest.End(QuestEndOutcome.Fail, 0, null, questPart_RefugeeInteractions.outSignalDestroyed_LeaveColony, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            quest.End(QuestEndOutcome.Fail, 0, null, questPart_RefugeeInteractions.outSignalLast_Destroyed);
            quest.End(QuestEndOutcome.Fail, 0, null, questPart_RefugeeInteractions.outSignalArrested_AssaultColony, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            quest.End(QuestEndOutcome.Fail, 0, null, questPart_RefugeeInteractions.outSignalArrested_LeaveColony, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            quest.End(QuestEndOutcome.Fail, 0, null, questPart_RefugeeInteractions.outSignalLast_Arrested);
            quest.End(QuestEndOutcome.Fail, 0, null, questPart_RefugeeInteractions.outSignalSurgeryViolation_AssaultColony, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            quest.End(QuestEndOutcome.Fail, 0, null, questPart_RefugeeInteractions.outSignalSurgeryViolation_LeaveColony, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            quest.End(QuestEndOutcome.Fail, 0, null, questPart_RefugeeInteractions.outSignalLast_Kidnapped, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            quest.End(QuestEndOutcome.Fail, 0, null, questPart_RefugeeInteractions.outSignalLast_Banished, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            quest.End(QuestEndOutcome.Success, 0, null, questPart_RefugeeInteractions.outSignalLast_Recruited, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            quest.End(QuestEndOutcome.Success, 0, null, questPart_RefugeeInteractions.outSignalLast_LeftMapAllNotHealthy, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            quest.SignalPass(delegate
            {
                if (Rand.Chance(0.5f))
                {
                    float val = (float)(lodgerCount * questDurationDays) * 55f;
                    FloatRange marketValueRange = new FloatRange(0.7f, 1.3f) * val * Find.Storyteller.difficultyValues.EffectiveQuestRewardValueFactor;
                    quest.AddQuestRefugeeDelayedReward(quest.AccepterPawn, faction, pawns, marketValueRange);
                }
                quest.End(QuestEndOutcome.Success, 0, null, null, QuestPart.SignalListenMode.OngoingOnly, sendStandardLetter: true);
            }, questPart_RefugeeInteractions.outSignalLast_LeftMapAllHealthy);
            slate.Set("lodgerCount", lodgerCount);
            slate.Set("lodgersCountMinusOne", lodgerCount - 1);
            slate.Set("asker", var);
            slate.Set("map", map);
            slate.Set("questDurationTicks", questDurationTicks);
            slate.Set("faction", faction);
        }
        private void Payment(List <Thing> payment, bool vassalPay, bool TributePay, string factionList)
        {
            if (GenLocalDate.Year(Find.AnyPlayerHomeMap) >= year)
            {
                year = GenLocalDate.Year(Find.AnyPlayerHomeMap) + 1;
            }
            if (GenLocalDate.DayOfYear(Find.AnyPlayerHomeMap) >= dayOfMonth)
            {
                dayOfMonth = ClosestNumberOf15(GenLocalDate.DayOfYear(Find.AnyPlayerHomeMap) + 1);
            }
            if (!payment.NullOrEmpty())
            {
                string text = "";
                if (vassalPay && TributePay)
                {
                    text += "FactionVassalSilverRecivedBoth".Translate(GenThing.GetMarketValue(payment).ToStringMoney(), GenLabel.ThingsLabel(payment, string.Empty));
                }
                else if (vassalPay)
                {
                    text += "FactionVassalSilverRecivedVassals".Translate(GenThing.GetMarketValue(payment).ToStringMoney(), GenLabel.ThingsLabel(payment, string.Empty));
                }
                else if (TributePay)
                {
                    text += "FactionVassalSilverRecivedTrivutaries".Translate(GenThing.GetMarketValue(payment).ToStringMoney(), GenLabel.ThingsLabel(payment, string.Empty));
                }

                factionList.Remove(factionList.Count() - 1);
                DropPodUtility.DropThingsNear(DropCellFinder.TradeDropSpot(Find.AnyPlayerHomeMap), Find.AnyPlayerHomeMap, payment, 110, false, true, true);
                Find.LetterStack.ReceiveLetter("LetterFactionVassalSilverRecived".Translate(), text + factionList, LetterDefOf.PositiveEvent, null);
            }
        }
예제 #23
0
 public static string ProstheticslabsTextPerLevel(Faction faction, List <Thing> requirements) => ("FE_ProstheticslabsLevel" + Utilities.FactionsWar().GetByFaction(faction).investments.Prosthetics).Translate(faction, GenLabel.ThingsLabel(requirements, string.Empty));
예제 #24
0
 private static void AddSlateVar(ref GrammarRequest req, string absoluteName, object obj)
 {
     if (obj == null)
     {
         return;
     }
     if (obj is BodyPartRecord)
     {
         req.Rules.AddRange(GrammarUtility.RulesForBodyPartRecord(absoluteName, (BodyPartRecord)obj));
     }
     else if (obj is Def)
     {
         req.Rules.AddRange(GrammarUtility.RulesForDef(absoluteName, (Def)obj));
     }
     else if (obj is Faction)
     {
         Faction faction = (Faction)obj;
         req.Rules.AddRange(GrammarUtility.RulesForFaction(absoluteName, faction));
         if (faction.leader != null)
         {
             req.Rules.AddRange(GrammarUtility.RulesForPawn(absoluteName + "_leader", faction.leader, req.Constants));
         }
     }
     else if (obj is Pawn)
     {
         Pawn pawn = (Pawn)obj;
         req.Rules.AddRange(GrammarUtility.RulesForPawn(absoluteName, pawn, req.Constants));
         if (pawn.Faction != null)
         {
             req.Rules.AddRange(GrammarUtility.RulesForFaction(absoluteName + "_faction", pawn.Faction));
         }
     }
     else if (obj is WorldObject)
     {
         req.Rules.AddRange(GrammarUtility.RulesForWorldObject(absoluteName, (WorldObject)obj));
     }
     else if (obj is Map)
     {
         req.Rules.AddRange(GrammarUtility.RulesForWorldObject(absoluteName, ((Map)obj).Parent));
     }
     else if (obj is IntVec2)
     {
         req.Rules.Add(new Rule_String(absoluteName, ((IntVec2)obj).ToStringCross()));
     }
     else if (obj is IEnumerable && !(obj is string))
     {
         if (obj is IEnumerable <Thing> )
         {
             req.Rules.Add(new Rule_String(absoluteName, GenLabel.ThingsLabel(((IEnumerable <Thing>)obj).Where((Thing x) => x != null))));
         }
         else if (obj is IEnumerable <Pawn> )
         {
             req.Rules.Add(new Rule_String(absoluteName, GenLabel.ThingsLabel(((IEnumerable <Pawn>)obj).Where((Pawn x) => x != null).Cast <Thing>())));
         }
         else if (obj is IEnumerable <object> && ((IEnumerable <object>)obj).Any() && ((IEnumerable <object>)obj).All((object x) => x is Thing))
         {
             req.Rules.Add(new Rule_String(absoluteName, GenLabel.ThingsLabel(((IEnumerable <object>)obj).Where((object x) => x != null).Cast <Thing>())));
         }
         else
         {
             List <string> list = new List <string>();
             foreach (object item in (IEnumerable)obj)
             {
                 if (item != null)
                 {
                     list.Add(item.ToString());
                 }
             }
             req.Rules.Add(new Rule_String(absoluteName, list.ToCommaList(useAnd: true)));
         }
         req.Rules.Add(new Rule_String(absoluteName + "_count", ((IEnumerable)obj).EnumerableCount().ToString()));
         int num = 0;
         foreach (object item2 in (IEnumerable)obj)
         {
             AddSlateVar(ref req, absoluteName + num, item2);
             num++;
         }
     }
     else
     {
         req.Rules.Add(new Rule_String(absoluteName, obj.ToString()));
         if (ConvertHelper.CanConvert <int>(obj))
         {
             req.Rules.Add(new Rule_String(absoluteName + "_duration", ConvertHelper.Convert <int>(obj).ToStringTicksToPeriod(allowSeconds: true, shortForm: false, canUseDecimals: true, allowYears: false).Colorize(ColoredText.DateTimeColor)));
         }
         if (ConvertHelper.CanConvert <float>(obj))
         {
             req.Rules.Add(new Rule_String(absoluteName + "_money", ConvertHelper.Convert <float>(obj).ToStringMoney()));
         }
         if (ConvertHelper.CanConvert <float>(obj))
         {
             req.Rules.Add(new Rule_String(absoluteName + "_percent", ConvertHelper.Convert <float>(obj).ToStringPercent()));
         }
         if (ConvertHelper.CanConvert <FloatRange>(obj))
         {
             AddSlateVar(ref req, absoluteName + "_average", ConvertHelper.Convert <FloatRange>(obj).Average);
         }
         if (ConvertHelper.CanConvert <FloatRange>(obj))
         {
             AddSlateVar(ref req, absoluteName + "_min", ConvertHelper.Convert <FloatRange>(obj).min);
         }
         if (ConvertHelper.CanConvert <FloatRange>(obj))
         {
             AddSlateVar(ref req, absoluteName + "_max", ConvertHelper.Convert <FloatRange>(obj).max);
         }
     }
     if (obj is Def)
     {
         if (!req.Constants.ContainsKey(absoluteName))
         {
             req.Constants.Add(absoluteName, ((Def)obj).defName);
         }
     }
     else if (obj is Faction)
     {
         if (!req.Constants.ContainsKey(absoluteName))
         {
             req.Constants.Add(absoluteName, ((Faction)obj).def.defName);
         }
     }
     else if ((obj.GetType().IsPrimitive || obj is string || obj.GetType().IsEnum) && !req.Constants.ContainsKey(absoluteName))
     {
         req.Constants.Add(absoluteName, obj.ToString());
     }
     if (obj is IEnumerable && !(obj is string))
     {
         string key = absoluteName + "_count";
         if (!req.Constants.ContainsKey(key))
         {
             req.Constants.Add(key, ((IEnumerable)obj).EnumerableCount().ToString());
         }
     }
 }
예제 #25
0
 public static string WeaponryTextPerLevel(Faction faction, List <Thing> requirements) => ("FE_WeaponryLevel" + Utilities.FactionsWar().GetByFaction(faction).investments.Weaponry).Translate(faction, GenLabel.ThingsLabel(requirements, string.Empty));
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            int tile;

            if (!TileFinder.TryFindNewSiteTile(out tile, minDist, maxDist, false, true, -1))
            {
                return(false);
            }
            Faction faction;

            if (!TryFindFaction(out faction))
            {
                return(false);
            }
            Site site = (Site)WorldObjectMaker.MakeWorldObject(SiteDefOf.PrisonSiteLGE);

            site.Tile = tile;
            site.core = new SiteCore(SiteDefOf.PrisonCampLGE, SiteDefOf.PrisonCampLGE.Worker.GenerateDefaultParams(site, StorytellerUtility.DefaultSiteThreatPointsNow()));
            site.SetFaction(faction);
            ThingSetMakerParams thingMakerparms = default(ThingSetMakerParams);

            thingMakerparms.totalMarketValueRange = new FloatRange?(SiteTuning.BanditCampQuestRewardMarketValueRange);
            List <Thing> list = ThingSetMakerDefOf.Reward_StandardByDropPod.root.Generate(thingMakerparms);

            site.GetComponent <PrisonerRescueQuestComp>().StartQuest(faction, 18, list);

            site.GetComponent <TimeoutComp>().StartTimeout(TimeoutDaysRange.RandomInRange * 60000);
            Find.WorldObjects.Add(site);
            Find.LetterStack.ReceiveLetter("LetterLabelPrisonCampLGE".Translate(), "LetterPrisonCampLGE".Translate(faction.Name, GenThing.GetMarketValue(list).ToStringMoney(null), GenLabel.ThingsLabel(list, string.Empty)), LetterDefOf.PositiveEvent, site, null);

            return(true);
        }
예제 #27
0
 public static string RawMaterialsTextPerLevel(Faction faction, List <Thing> requirements) => ("FE_RawMaterialLevel" + Utilities.FactionsWar().GetByFaction(faction).investments.Mining).Translate(faction, GenLabel.ThingsLabel(requirements, string.Empty));
 private string GenerateMessageText(Faction enemyFaction, int attackerCount, List <ThingCount> demands, Caravan caravan)
 {
     if (enemyFaction.HostileTo(caravan.Faction))
     {
         return("CaravanDemand".Translate(caravan.Name, enemyFaction.Name, attackerCount, GenLabel.ThingsLabel(demands), enemyFaction.def.pawnsPlural).CapitalizeFirst());
     }
     else
     {
         return("RW_CaravanDemand_Friendly".Translate(caravan.Name, attackerCount, enemyFaction.def.pawnsPlural, enemyFaction.Name).CapitalizeFirst());
     }
 }
예제 #29
0
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            if (!TryFindSettlement(out Faction ally, out Settlement Set))
            {
                return(false);
            }

            // Balance
            List <Thing> rewards = ThingSetMakerDefOf.Reward_StandardByDropPod.root.Generate(new ThingSetMakerParams()
            {
                totalMarketValueRange = new FloatRange?(SiteTuning.BanditCampQuestRewardMarketValueRange * SiteTuning.QuestRewardMarketValueThreatPointsFactor.Evaluate(StorytellerUtility.DefaultSiteThreatPointsNow() + 500f))
            });

            Thing silver = ThingMaker.MakeThing(ThingDefOf.Silver);

            silver.stackCount = (int)SilverBonusRewardCurve.Evaluate(ally.PlayerGoodwill);
            int random = new IntRange(Global.DayInTicks * 15, Global.DayInTicks * 25).RandomInRange;

            Set.GetComponent <WorldComp_JointRaid>().StartComp(random, ally, rewards, silver);
            string text = def.letterText.Formatted(ally.leader.LabelShort, ally.def.leaderTitle, ally.Name, GenLabel.ThingsLabel(rewards, string.Empty), random.ToStringTicksToPeriod(), GenThing.GetMarketValue(rewards).ToStringMoney(null), silver.stackCount.ToString()).CapitalizeFirst();

            GenThing.TryAppendSingleRewardInfo(ref text, rewards);
            Find.LetterStack.ReceiveLetter(def.letterLabel, text, def.letterDef, Set, ally, null);
            return(true);
        }