private void GenerateCharacter(bool is_starter, string guaranteedAptitudeID = null)
{
int num = 0;
do
{
stats = new MinionStartingStats(is_starter, guaranteedAptitudeID);
num++;
}while (IsCharacterRedundant() && num < 20);
if ((UnityEngine.Object)animController != (UnityEngine.Object)null)
{
ScreenResize instance = ScreenResize.Instance;
instance.OnResize = (System.Action)Delegate.Remove(instance.OnResize, new System.Action(OnResize));
UnityEngine.Object.Destroy(animController.gameObject);
animController = null;
}
SetAnimator();
SetInfoText();
StartCoroutine(SetAttributes());
selectButton.ClearOnClick();
if (!controller.IsStarterMinion)
{
selectButton.enabled = true;
selectButton.onClick += delegate
{
SelectDeliverable();
};
}
}
private static void DoXpGive(MinionStartingStats __instance, GameObject go)
{
__instance.Apply(go);
var resume = go.GetComponent <MinionResume>();
var config = AdvancedStartOptions.GetConfig();
resume.AddExperience(XPForSkillPoints(config.startSkillPoints));
}
public static void Postfix(MinionStartingStats __instance, bool is_starter_minion)
{
var config = AdvancedStartOptions.GetConfig();
if (is_starter_minion)
{
// Set all stats to 10.
foreach (var attribute in DUPLICANTSTATS.ALL_ATTRIBUTES)
{
__instance.StartingLevels[attribute] += config.startAttributeBoost;
}
}
}
private void SpawnMinion()
{
GameObject gameObject = Util.KInstantiate(Assets.GetPrefab(MinionConfig.ID), null, null);
gameObject.name = Assets.GetPrefab(MinionConfig.ID).name;
Immigration.Instance.ApplyDefaultPersonalPriorities(gameObject);
Vector3 position = Grid.CellToPosCBC(currentCell, Grid.SceneLayer.Move);
gameObject.transform.SetLocalPosition(position);
gameObject.SetActive(true);
MinionStartingStats minionStartingStats = new MinionStartingStats(false, null);
minionStartingStats.Apply(gameObject);
}
private static void Postfix(MinionStartingStats __instance)
{
var name = __instance.NameStringKey;
var state = EndpointState.Load();
if (state.times_rescued.ContainsKey(name))
{
int count = state.times_rescued[name];
var trait = new Klei.AI.Trait("Rescued", "Rescued", "A previous iteration of this duplicant visited the great printing pod in the sky (x" + count + ").", 0, true, null, true, true);
foreach (var attribute in TUNING.DUPLICANTSTATS.DISTRIBUTED_ATTRIBUTES)
{
trait.Add(new Klei.AI.AttributeModifier(attribute, state.times_rescued[name], "Rescued x" + count));
}
__instance.Traits.Add(trait);
}
}
private void SpawnMinion()
{
if (!((UnityEngine.Object)Immigration.Instance == (UnityEngine.Object)null))
{
if (!Grid.IsValidBuildingCell(GetMouseCell()))
{
PopFXManager.Instance.SpawnFX(PopFXManager.Instance.sprite_Negative, UI.DEBUG_TOOLS.INVALID_LOCATION, null, GetMousePos(), 1.5f, false, true);
}
else
{
GameObject gameObject = Util.KInstantiate(Assets.GetPrefab(MinionConfig.ID), null, null);
gameObject.name = Assets.GetPrefab(MinionConfig.ID).name;
Immigration.Instance.ApplyDefaultPersonalPriorities(gameObject);
Vector3 position = Grid.CellToPosCBC(GetMouseCell(), Grid.SceneLayer.Move);
gameObject.transform.SetLocalPosition(position);
gameObject.SetActive(true);
MinionStartingStats minionStartingStats = new MinionStartingStats(false, null);
minionStartingStats.Apply(gameObject);
}
}
}
public static bool Prefix(MinionStartingStats __instance, string guaranteedAptitudeID)
{
if (Always3Interests.Settings.randomNumberOfInterests)
{
return(true);
}
int num = Always3Interests.Settings.numberOfInterests;
List <SkillGroup> list = new List <SkillGroup>(Db.Get().SkillGroups.resources);
list.Shuffle <SkillGroup>();
if (guaranteedAptitudeID != null)
{
__instance.skillAptitudes.Add(Db.Get().SkillGroups.Get(guaranteedAptitudeID), DUPLICANTSTATS.APTITUDE_BONUS);
list.Remove(Db.Get().SkillGroups.Get(guaranteedAptitudeID));
num--;
}
for (int i = 0; i < num; i++)
{
__instance.skillAptitudes.Add(list[i], DUPLICANTSTATS.APTITUDE_BONUS);
}
return(false);
}
public static bool Prefix(MinionStartingStats __instance, bool is_starter_minion, List <ChoreGroup> disabled_chore_groups, string guaranteedAptitudeID = null)
{
DUPLICANTSTATS.MAX_TRAITS = 10;
int statDelta = 0;
List <string> selectedTraits = new List <string>();
System.Random randSeed = new System.Random();
Trait trait = Db.Get().traits.Get(__instance.personality.stresstrait);
__instance.stressTrait = trait;
if (Always3Interests.Settings.disableStressTrait)
{
__instance.stressTrait = Db.Get().traits.Get("None");
}
// set joy trait if it is not disable
Trait joytrait = Db.Get().traits.Get(__instance.personality.joyTrait);
__instance.joyTrait = joytrait;
if (Always3Interests.Settings.disableJoyTrait)
{
__instance.joyTrait = Db.Get().traits.Get("None");
}
Trait trait2 = Db.Get().traits.Get(__instance.personality.congenitaltrait);
if (trait2.Name == "None")
{
__instance.stickerType = __instance.personality.stickerType;
}
Trait trait3 = Db.Get().traits.Get(__instance.personality.congenitaltrait);
if (trait3.Name == "None")
{
__instance.congenitaltrait = null;
}
else
{
__instance.congenitaltrait = trait3;
}
Func <List <DUPLICANTSTATS.TraitVal>, bool, bool> func = delegate(List <DUPLICANTSTATS.TraitVal> traitPossibilities, bool positiveTrait)
{
if (__instance.Traits.Count > DUPLICANTSTATS.MAX_TRAITS)
{
return(false);
}
Mathf.Abs(Util.GaussianRandom(0f, 1f));
int num6 = traitPossibilities.Count;
int num7;
if (!positiveTrait)
{
if (DUPLICANTSTATS.rarityDeckActive.Count < 1)
{
DUPLICANTSTATS.rarityDeckActive.AddRange(DUPLICANTSTATS.RARITY_DECK);
}
if (DUPLICANTSTATS.rarityDeckActive.Count == DUPLICANTSTATS.RARITY_DECK.Count)
{
DUPLICANTSTATS.rarityDeckActive.ShuffleSeeded(new KRandom());
}
num7 = DUPLICANTSTATS.rarityDeckActive[DUPLICANTSTATS.rarityDeckActive.Count - 1];
DUPLICANTSTATS.rarityDeckActive.RemoveAt(DUPLICANTSTATS.rarityDeckActive.Count - 1);
}
else
{
List <int> list = new List <int>();
if (is_starter_minion)
{
list.Add(__instance.rarityBalance - 1);
list.Add(__instance.rarityBalance);
list.Add(__instance.rarityBalance);
list.Add(__instance.rarityBalance + 1);
}
else
{
list.Add(__instance.rarityBalance - 2);
list.Add(__instance.rarityBalance - 1);
list.Add(__instance.rarityBalance);
list.Add(__instance.rarityBalance + 1);
list.Add(__instance.rarityBalance + 2);
}
list.ShuffleSeeded(new KRandom());
num7 = list[0];
num7 = Mathf.Max(DUPLICANTSTATS.RARITY_COMMON, num7);
num7 = Mathf.Min(DUPLICANTSTATS.RARITY_LEGENDARY, num7);
}
List <DUPLICANTSTATS.TraitVal> list2 = new List <DUPLICANTSTATS.TraitVal>(traitPossibilities);
for (int i = list2.Count - 1; i > -1; i--)
{
if (list2[i].rarity != num7)
{
list2.RemoveAt(i);
num6--;
}
}
list2.ShuffleSeeded(new KRandom());
foreach (DUPLICANTSTATS.TraitVal traitVal in list2)
{
if (!DlcManager.IsContentActive(traitVal.dlcId))
{
num6--;
}
else if (selectedTraits.Contains(traitVal.id))
{
num6--;
}
else
{
Trait trait4 = Db.Get().traits.TryGet(traitVal.id);
if (trait4 == null)
{
global::Debug.LogWarning("Trying to add nonexistent trait: " + traitVal.id);
num6--;
}
else if (is_starter_minion && !trait4.ValidStarterTrait)
{
num6--;
}
else if ((bool)Traverse.Create(__instance).Method("AreTraitAndAptitudesExclusive", new object[] { traitVal, __instance.skillAptitudes }).GetValue())
{
num6--;
}
else if (is_starter_minion && guaranteedAptitudeID != null &&
(bool)Traverse.Create(__instance).Method("AreTraitAndArchetypeExclusive", new object[] { traitVal, guaranteedAptitudeID }).GetValue())
{
num6--;
}
else
{
if (!(bool)Traverse.Create(__instance).Method("AreTraitsMutuallyExclusive", new object[] { traitVal, selectedTraits }).GetValue())
{
selectedTraits.Add(traitVal.id);
statDelta += traitVal.statBonus;
__instance.rarityBalance += (positiveTrait ? (-traitVal.rarity) : traitVal.rarity);
__instance.Traits.Add(trait4);
if (trait4.disabledChoreGroups != null)
{
for (int j = 0; j < trait4.disabledChoreGroups.Length; j++)
{
disabled_chore_groups.Add(trait4.disabledChoreGroups[j]);
}
}
return(true);
}
num6--;
}
}
}
return(false);
};
int numberOfGoodTraits = Always3Interests.Settings.numberOfGoodTraits;
int numberOfBadTraits = Always3Interests.Settings.numberOfBadTraits;
if (numberOfGoodTraits > 5)
{
numberOfGoodTraits = 5;
}
if (numberOfBadTraits > 5)
{
numberOfBadTraits = 5;
}
for (int i = 0; i < numberOfBadTraits; i++)
{
bool isTraitAdded = false;
while (!isTraitAdded)
{
isTraitAdded = func(DUPLICANTSTATS.BADTRAITS, false);
}
}
for (int i = 0; i < numberOfGoodTraits; i++)
{
bool isTraitAdded = false;
while (!isTraitAdded)
{
isTraitAdded = func(DUPLICANTSTATS.GOODTRAITS, true);
}
}
return(false);
}
public static bool Prefix(MinionStartingStats __instance, List <ChoreGroup> disabled_chore_groups)
{
DUPLICANTSTATS.MAX_TRAITS = 10;
List <string> selectedTraits = new List <string>();
System.Random randSeed = new System.Random();
// set stress trait if it is not disable
Trait trait = Db.Get().traits.Get(__instance.personality.stresstrait);
__instance.stressTrait = trait;
if (TuningConfigPatch.settings.disableStressTrait)
{
__instance.stressTrait = Db.Get().traits.Get("None");
}
// set joy trait if it is not disable
Trait joytrait = Db.Get().traits.Get(__instance.personality.joyTrait);
__instance.joyTrait = joytrait;
if (TuningConfigPatch.settings.disableJoyTrait)
{
__instance.joyTrait = Db.Get().traits.Get("None");
}
Trait trait2 = Db.Get().traits.Get(__instance.personality.congenitaltrait);
if (trait2.Name == "None")
{
__instance.congenitaltrait = null;
}
else
{
__instance.congenitaltrait = trait2;
}
Func <List <DUPLICANTSTATS.TraitVal>, bool> func = delegate(List <DUPLICANTSTATS.TraitVal> traitPossibilities)
{
if (__instance.Traits.Count > DUPLICANTSTATS.MAX_TRAITS)
{
return(false);
}
float num2 = Util.GaussianRandom(0f, 1f);
List <DUPLICANTSTATS.TraitVal> list = new List <DUPLICANTSTATS.TraitVal>(traitPossibilities);
list.ShuffleSeeded(randSeed);
list.Sort((DUPLICANTSTATS.TraitVal t1, DUPLICANTSTATS.TraitVal t2) => - t1.probability.CompareTo(t2.probability));
foreach (DUPLICANTSTATS.TraitVal traitVal in list)
{
if (!selectedTraits.Contains(traitVal.id))
{
if (traitVal.requiredNonPositiveAptitudes != null)
{
bool flag2 = false;
foreach (KeyValuePair <SkillGroup, float> keyValuePair in __instance.skillAptitudes)
{
if (flag2)
{
break;
}
foreach (HashedString x in traitVal.requiredNonPositiveAptitudes)
{
if (x == keyValuePair.Key.IdHash && keyValuePair.Value > 0f)
{
flag2 = true;
break;
}
}
}
if (flag2)
{
continue;
}
}
if (traitVal.mutuallyExclusiveTraits != null)
{
bool flag3 = false;
foreach (string item in selectedTraits)
{
flag3 = traitVal.mutuallyExclusiveTraits.Contains(item);
if (flag3)
{
break;
}
}
if (flag3)
{
continue;
}
}
if (num2 > traitVal.probability)
{
Trait trait3 = Db.Get().traits.TryGet(traitVal.id);
if (trait3 == null)
{
global::Debug.LogWarning("Trying to add nonexistent trait: " + traitVal.id);
}
else if (trait3.ValidStarterTrait)
{
selectedTraits.Add(traitVal.id);
__instance.Traits.Add(trait3);
if (trait3.disabledChoreGroups != null)
{
for (int k = 0; k < trait3.disabledChoreGroups.Length; k++)
{
disabled_chore_groups.Add(trait3.disabledChoreGroups[k]);
}
}
return(true);
}
}
}
}
return(false);
};
int numberOfGoodTraits = TuningConfigPatch.settings.numberOfGoodTraits;
int numberOfBadTraits = TuningConfigPatch.settings.numberOfBadTraits;
if (numberOfGoodTraits > 5)
{
numberOfGoodTraits = 5;
}
if (numberOfBadTraits > 5)
{
numberOfBadTraits = 5;
}
for (int i = 0; i < numberOfBadTraits; i++)
{
bool isTraitAdded = false;
while (!isTraitAdded)
{
isTraitAdded = func(DUPLICANTSTATS.BADTRAITS);
}
}
for (int i = 0; i < numberOfGoodTraits; i++)
{
bool isTraitAdded = false;
while (!isTraitAdded)
{
isTraitAdded = func(DUPLICANTSTATS.GOODTRAITS);
}
}
return(false);
}
