private float CheapestSapperCost(Faction faction, PawnGroupKindDef groupKind) { IEnumerable <PawnGroupMaker> enumerable = PawnGenOptionsWithSappers(faction, groupKind); if (!enumerable.Any()) { Log.Error("Tried to get MinimumPoints for " + GetType().ToString() + " for faction " + faction.ToString() + " but the faction has no groups with sappers. groupKind=" + groupKind); return(99999f); } float num = 9999999f; foreach (PawnGroupMaker item in enumerable) { foreach (PawnGenOption item2 in from op in item.options where op.kind.canBeSapper select op) { if (item2.Cost < num) { num = item2.Cost; } } } return(num); }
public override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind) { if (parms.raidStrategy == null) { parms.raidStrategy = RaidStrategyDefOf.ImmediateAttackFriendly; } }
protected override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind) { if (parms.raidStrategy != null) { return; } Map map = (Map)parms.target; if (!(from d in DefDatabase <RaidStrategyDef> .AllDefs where d.Worker.CanUseWith(parms, groupKind) && (parms.raidArrivalMode != null || (d.arriveModes != null && d.arriveModes.Any((PawnsArrivalModeDef x) => x.Worker.CanUseWith(parms)))) select d).TryRandomElementByWeight((RaidStrategyDef d) => d.Worker.SelectionWeight(map, parms.points), out parms.raidStrategy)) { Log.Error(string.Concat(new object[] { "No raid stategy for ", parms.faction, " with points ", parms.points, ", groupKind=", groupKind, "\nparms=", parms }), false); if (!Prefs.DevMode) { parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack; } } }
private float CheapestSapperCost(Faction faction, PawnGroupKindDef groupKind) { IEnumerable <PawnGroupMaker> enumerable = this.PawnGenOptionsWithSappers(faction, groupKind); if (!enumerable.Any <PawnGroupMaker>()) { Log.Error(string.Concat(new object[] { "Tried to get MinimumPoints for ", base.GetType().ToString(), " for faction ", faction.ToString(), " but the faction has no groups with sappers. groupKind=", groupKind }), false); return(99999f); } float num = 9999999f; foreach (PawnGroupMaker current in enumerable) { foreach (PawnGenOption current2 in from op in current.options where op.kind.canBeSapper select op) { if (current2.Cost < num) { num = current2.Cost; } } } return(num); }
// Token: 0x06000EC0 RID: 3776 RVA: 0x0006EA07 File Offset: 0x0006CE07 public override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind) { if (parms.raidStrategy != null) { return; } parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack; }
public override bool CanUseWith(IncidentParms parms, PawnGroupKindDef groupKind) { if (!base.CanUseWith(parms, groupKind)) { return(false); } return(parms.faction.def.canStageAttacks); }
public virtual bool CanUseWith(IncidentParms parms, PawnGroupKindDef groupKind) { if (parms.points < MinimumPoints(parms.faction, groupKind)) { return(false); } return(true); }
public override bool CanUseWith(IncidentParms parms, PawnGroupKindDef groupKind) { if (!PawnGenOptionsWithSappers(parms.faction, groupKind).Any()) { return(false); } if (!base.CanUseWith(parms, groupKind)) { return(false); } return(true); }
public override bool CanUseWith(IncidentParms parms, PawnGroupKindDef groupKind) { if (!base.CanUseWith(parms, groupKind)) { return(false); } if (!parms.faction.def.canUseAvoidGrid) { return(false); } return(true); }
public override bool CanUseWith(IncidentParms parms, PawnGroupKindDef groupKind) { if (parms.points < MinimumPoints(parms.faction, groupKind)) { return(false); } if (parms.faction == Faction.OfMechanoids) { return(ModsConfig.RoyaltyActive); } return(false); }
public float MinPointsToGeneratePawnGroup(PawnGroupKindDef groupKind) { if (pawnGroupMakers == null) { return(0f); } IEnumerable <PawnGroupMaker> source = pawnGroupMakers.Where((PawnGroupMaker x) => x.kindDef == groupKind); if (!source.Any()) { return(0f); } return(source.Min((PawnGroupMaker pgm) => pgm.MinPointsToGenerateAnything)); }
public override void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind) { if (parms.raidStrategy == null) { Map map = (Map)parms.target; DefDatabase <RaidStrategyDef> .AllDefs.Where((RaidStrategyDef d) => d.Worker.CanUseWith(parms, groupKind) && (parms.raidArrivalMode != null || (d.arriveModes != null && d.arriveModes.Any((PawnsArrivalModeDef x) => x.Worker.CanUseWith(parms))))).TryRandomElementByWeight((RaidStrategyDef d) => d.Worker.SelectionWeight(map, parms.points), out RaidStrategyDef result); parms.raidStrategy = result; if (parms.raidStrategy == null) { Log.Error("No raid stategy found, defaulting to ImmediateAttack. Faction=" + parms.faction.def.defName + ", points=" + parms.points + ", groupKind=" + groupKind + ", parms=" + parms); parms.raidStrategy = RaidStrategyDefOf.ImmediateAttack; } } }
public float MinPointsToGeneratePawnGroup(PawnGroupKindDef groupKind) { if (pawnGroupMakers == null) { return(0); } var groups = pawnGroupMakers.Where(x => x.kindDef == groupKind); if (!groups.Any()) { return(0); } return(groups.Min(pgm => pgm.MinPointsToGenerateAnything)); }
public float MinPointsToGeneratePawnGroup(PawnGroupKindDef groupKind) { if (this.pawnGroupMakers == null) { return(0f); } IEnumerable <PawnGroupMaker> source = from x in this.pawnGroupMakers where x.kindDef == groupKind select x; if (!source.Any <PawnGroupMaker>()) { return(0f); } return(source.Min((PawnGroupMaker pgm) => pgm.MinPointsToGenerateAnything)); }
public static IEnumerable <Pawn> GeneratePawns(PawnGroupKindDef groupKind, PawnGroupMakerParms parms, bool warnOnZeroResults = true) { if (groupKind == null) { Log.Error("Tried to generate pawns with null pawn group kind def. parms=" + parms); } else if (parms.faction.def.pawnGroupMakers.NullOrEmpty <PawnGroupMaker>()) { Log.Error(string.Concat(new object[] { "Faction ", parms.faction, " of def ", parms.faction.def, " has no any PawnGroupMakers." })); } else { IEnumerable <PawnGroupMaker> usableGroupMakers = from gm in parms.faction.def.pawnGroupMakers where gm.kindDef == groupKind && gm.CanGenerateFrom(parms) select gm; PawnGroupMaker chosenGroupMaker; if (!usableGroupMakers.TryRandomElementByWeight((PawnGroupMaker gm) => gm.commonality, out chosenGroupMaker)) { Log.Error(string.Concat(new object[] { "Faction ", parms.faction, " of def ", parms.faction.def, " has no usable PawnGroupMakers for parms ", parms, ". groupKind=", groupKind })); } else { foreach (Pawn p in chosenGroupMaker.GeneratePawns(parms, warnOnZeroResults)) { yield return(p); } } } }
public static PawnGroupMakerParms GetDefaultPawnGroupMakerParms(PawnGroupKindDef groupKind, IncidentParms parms, bool ensureCanGenerateAtLeastOnePawn = false) { PawnGroupMakerParms pawnGroupMakerParms = new PawnGroupMakerParms(); pawnGroupMakerParms.groupKind = groupKind; pawnGroupMakerParms.tile = parms.target.Tile; pawnGroupMakerParms.points = parms.points; pawnGroupMakerParms.faction = parms.faction; pawnGroupMakerParms.traderKind = parms.traderKind; pawnGroupMakerParms.generateFightersOnly = parms.generateFightersOnly; pawnGroupMakerParms.raidStrategy = parms.raidStrategy; pawnGroupMakerParms.forceOneIncap = parms.raidForceOneIncap; if (ensureCanGenerateAtLeastOnePawn && parms.faction != null) { pawnGroupMakerParms.points = Mathf.Max(pawnGroupMakerParms.points, parms.faction.def.MinPointsToGeneratePawnGroup(groupKind)); } return(pawnGroupMakerParms); }
public static IEnumerable <Pawn> GeneratePawns(PawnGroupKindDef groupKind, PawnGroupMakerParms parms, bool warnOnZeroResults = true) { _003CGeneratePawns_003Ec__Iterator0 _003CGeneratePawns_003Ec__Iterator = (_003CGeneratePawns_003Ec__Iterator0) /*Error near IL_0034: stateMachine*/; if (groupKind == null) { Log.Error("Tried to generate pawns with null pawn group kind def. parms=" + parms); } else if (parms.faction.def.pawnGroupMakers.NullOrEmpty()) { Log.Error("Faction " + parms.faction + " of def " + parms.faction.def + " has no any PawnGroupMakers."); } else { IEnumerable <PawnGroupMaker> usableGroupMakers = from gm in parms.faction.def.pawnGroupMakers where gm.kindDef == groupKind && gm.CanGenerateFrom(parms) select gm; PawnGroupMaker chosenGroupMaker; if (!usableGroupMakers.TryRandomElementByWeight <PawnGroupMaker>((Func <PawnGroupMaker, float>)((PawnGroupMaker gm) => gm.commonality), out chosenGroupMaker)) { Log.Error("Faction " + parms.faction + " of def " + parms.faction.def + " has no usable PawnGroupMakers for parms " + parms + ". groupKind=" + groupKind); } else { using (IEnumerator <Pawn> enumerator = chosenGroupMaker.GeneratePawns(parms, warnOnZeroResults).GetEnumerator()) { if (enumerator.MoveNext()) { Pawn p = enumerator.Current; yield return(p); /*Error: Unable to find new state assignment for yield return*/; } } } } yield break; IL_0293: /*Error near IL_0294: Unexpected return in MoveNext()*/; }
public float MinPointsToGeneratePawnGroup(PawnGroupKindDef groupKind) { float result; if (this.pawnGroupMakers == null) { result = 0f; } else { IEnumerable <PawnGroupMaker> source = from x in this.pawnGroupMakers where x.kindDef == groupKind select x; if (!source.Any <PawnGroupMaker>()) { result = 0f; } else { result = source.Min((PawnGroupMaker pgm) => pgm.MinPointsToGenerateAnything); } } return(result); }
private IEnumerable <PawnGroupMaker> PawnGenOptionsWithSappers(Faction faction, PawnGroupKindDef groupKind) { if (faction.def.pawnGroupMakers == null) { return(Enumerable.Empty <PawnGroupMaker>()); } return(faction.def.pawnGroupMakers.Where(delegate(PawnGroupMaker gm) { bool arg_47_0; if (gm.kindDef == groupKind && gm.options != null) { arg_47_0 = gm.options.Any((PawnGenOption op) => op.kind.canBeSapper); } else { arg_47_0 = false; } return arg_47_0; })); }
public abstract void ResolveRaidStrategy(IncidentParms parms, PawnGroupKindDef groupKind);
public static float AdjustedRaidPoints(float points, PawnsArrivalModeDef raidArrivalMode, RaidStrategyDef raidStrategy, Faction faction, PawnGroupKindDef groupKind) { if (raidArrivalMode.pointsFactorCurve != null) { points *= raidArrivalMode.pointsFactorCurve.Evaluate(points); } if (raidStrategy.pointsFactorCurve != null) { points *= raidStrategy.pointsFactorCurve.Evaluate(points); } points = Mathf.Max(points, raidStrategy.Worker.MinimumPoints(faction, groupKind) * 1.05f); return(points); }
private IEnumerable <PawnGroupMaker> PawnGenOptionsWithSappers(Faction faction, PawnGroupKindDef groupKind) { if (faction.def.pawnGroupMakers == null) { return(Enumerable.Empty <PawnGroupMaker>()); } return(faction.def.pawnGroupMakers.Where((PawnGroupMaker gm) => gm.kindDef == groupKind && gm.options != null && gm.options.Any((PawnGenOption op) => op.kind.canBeSapper))); }
public override float MinMaxAllowedPawnGenOptionCost(Faction faction, PawnGroupKindDef groupKind) { return(CheapestSapperCost(faction, groupKind)); }
public override float MinimumPoints(Faction faction, PawnGroupKindDef groupKind) { return(Mathf.Max(base.MinimumPoints(faction, groupKind), CheapestSapperCost(faction, groupKind))); }
protected override bool TryExecuteWorker(IncidentParms parms) { ResolveRaidPoints(parms); if (!TryResolveRaidFaction(parms)) { return(false); } PawnGroupKindDef combat = PawnGroupKindDefOf.Combat; ResolveRaidStrategy(parms, combat); ResolveRaidArriveMode(parms); parms.raidStrategy.Worker.TryGenerateThreats(parms); if (!parms.raidArrivalMode.Worker.TryResolveRaidSpawnCenter(parms)) { return(false); } float points = parms.points; parms.points = AdjustedRaidPoints(parms.points, parms.raidArrivalMode, parms.raidStrategy, parms.faction, combat); List <Pawn> list = parms.raidStrategy.Worker.SpawnThreats(parms); if (list == null) { list = PawnGroupMakerUtility.GeneratePawns(IncidentParmsUtility.GetDefaultPawnGroupMakerParms(combat, parms)).ToList(); if (list.Count == 0) { Log.Error("Got no pawns spawning raid from parms " + parms); return(false); } parms.raidArrivalMode.Worker.Arrive(list, parms); } GenerateRaidLoot(parms, points, list); TaggedString letterLabel = GetLetterLabel(parms); TaggedString letterText = GetLetterText(parms, list); PawnRelationUtility.Notify_PawnsSeenByPlayer_Letter(list, ref letterLabel, ref letterText, GetRelatedPawnsInfoLetterText(parms), informEvenIfSeenBefore: true); List <TargetInfo> list2 = new List <TargetInfo>(); if (parms.pawnGroups != null) { List <List <Pawn> > list3 = IncidentParmsUtility.SplitIntoGroups(list, parms.pawnGroups); List <Pawn> list4 = list3.MaxBy((List <Pawn> x) => x.Count); if (list4.Any()) { list2.Add(list4[0]); } for (int i = 0; i < list3.Count; i++) { if (list3[i] != list4 && list3[i].Any()) { list2.Add(list3[i][0]); } } } else if (list.Any()) { foreach (Pawn item in list) { list2.Add(item); } } SendStandardLetter(letterLabel, letterText, GetLetterDef(), parms, list2); parms.raidStrategy.Worker.MakeLords(parms, list); LessonAutoActivator.TeachOpportunity(ConceptDefOf.EquippingWeapons, OpportunityType.Critical); if (!PlayerKnowledgeDatabase.IsComplete(ConceptDefOf.ShieldBelts)) { for (int j = 0; j < list.Count; j++) { if (list[j].apparel.WornApparel.Any((Apparel ap) => ap is ShieldBelt)) { LessonAutoActivator.TeachOpportunity(ConceptDefOf.ShieldBelts, OpportunityType.Critical); break; } } } return(true); }
public static float MaxPawnCost(Faction faction, float totalPoints, RaidStrategyDef raidStrategy, PawnGroupKindDef groupKind) { float num = faction.def.maxPawnCostPerTotalPointsCurve.Evaluate(totalPoints); if (raidStrategy != null) { num = Mathf.Min(num, totalPoints / raidStrategy.minPawns); } num = Mathf.Max(num, faction.def.MinPointsToGeneratePawnGroup(groupKind) * 1.2f); if (raidStrategy != null) { num = Mathf.Max(num, raidStrategy.Worker.MinMaxAllowedPawnGenOptionCost(faction, groupKind) * 1.2f); } return(num); }
public virtual float MinMaxAllowedPawnGenOptionCost(Faction faction, PawnGroupKindDef groupKind) { return(0f); }
public virtual float MinimumPoints(Faction faction, PawnGroupKindDef groupKind) { return(faction.def.MinPointsToGeneratePawnGroup(groupKind)); }
public virtual bool CanUseWith(IncidentParms parms, PawnGroupKindDef groupKind) { return(parms.points >= this.MinimumPoints(parms.faction, groupKind)); }
public override bool CanUseWith(IncidentParms parms, PawnGroupKindDef groupKind) { return(this.PawnGenOptionsWithSappers(parms.faction, groupKind).Any <PawnGroupMaker>() && base.CanUseWith(parms, groupKind)); }