private void ApplyRandomTrait(Worker worker)
	{
		Traits component = worker.GetComponent<Traits>();
		List<string> list = new List<string>();
		foreach (DUPLICANTSTATS.TraitVal gENESHUFFLERTRAIT in DUPLICANTSTATS.GENESHUFFLERTRAITS)
		{
			DUPLICANTSTATS.TraitVal current = gENESHUFFLERTRAIT;
			if (!component.HasTrait(current.id))
			{
				list.Add(current.id);
			}
		}
		Trait trait = null;
		if (list.Count > 0)
		{
			string id = list[Random.Range(0, list.Count)];
			trait = Db.Get().traits.TryGet(id);
			worker.GetComponent<Traits>().Add(trait);
			InfoDialogScreen infoDialogScreen = (InfoDialogScreen)GameScreenManager.Instance.StartScreen(ScreenPrefabs.Instance.InfoDialogScreen.gameObject, GameScreenManager.Instance.ssOverlayCanvas.gameObject, GameScreenManager.UIRenderTarget.ScreenSpaceOverlay);
			string text = string.Format(UI.GENESHUFFLERMESSAGE.BODY_SUCCESS, worker.GetProperName(), trait.Name, trait.GetTooltip());
			infoDialogScreen.SetHeader(UI.GENESHUFFLERMESSAGE.HEADER).AddPlainText(text);
			SetConsumed(true);
		}
		else
		{
			InfoDialogScreen infoDialogScreen2 = (InfoDialogScreen)GameScreenManager.Instance.StartScreen(ScreenPrefabs.Instance.InfoDialogScreen.gameObject, GameScreenManager.Instance.ssOverlayCanvas.gameObject, GameScreenManager.UIRenderTarget.ScreenSpaceOverlay);
			string text2 = string.Format(UI.GENESHUFFLERMESSAGE.BODY_FAILURE, worker.GetProperName());
			infoDialogScreen2.SetHeader(UI.GENESHUFFLERMESSAGE.HEADER).AddPlainText(text2);
		}
	}
    private int GenerateTraits(bool is_starter_minion, List <ChoreGroup> disabled_chore_groups)
    {
        int           statDelta      = 0;
        List <string> selectedTraits = new List <string>();

        System.Random randSeed = new System.Random();
        Trait         trait    = stressTrait = Db.Get().traits.Get(personality.stresstrait);
        Trait         trait2   = Db.Get().traits.Get(personality.congenitaltrait);

        if (trait2.Name == "None")
        {
            congenitaltrait = null;
        }
        else
        {
            congenitaltrait = trait2;
        }
        Func <List <DUPLICANTSTATS.TraitVal>, bool> func = delegate(List <DUPLICANTSTATS.TraitVal> traitPossibilities)
        {
            if (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 item in list)
            {
                DUPLICANTSTATS.TraitVal current = item;
                if (!selectedTraits.Contains(current.id))
                {
                    if (current.requiredNonPositiveAptitudes != null)
                    {
                        bool flag2 = false;
                        foreach (KeyValuePair <SkillGroup, float> skillAptitude in skillAptitudes)
                        {
                            if (flag2)
                            {
                                break;
                            }
                            foreach (HashedString requiredNonPositiveAptitude in current.requiredNonPositiveAptitudes)
                            {
                                if (requiredNonPositiveAptitude == skillAptitude.Key.IdHash && skillAptitude.Value > 0f)
                                {
                                    flag2 = true;
                                    break;
                                }
                            }
                        }
                        if (flag2)
                        {
                            continue;
                        }
                    }
                    if (current.mutuallyExclusiveTraits != null)
                    {
                        bool flag3 = false;
                        foreach (string item2 in selectedTraits)
                        {
                            flag3 = current.mutuallyExclusiveTraits.Contains(item2);
                            if (flag3)
                            {
                                break;
                            }
                        }
                        if (flag3)
                        {
                            continue;
                        }
                    }
                    if (num2 > current.probability)
                    {
                        Trait trait3 = Db.Get().traits.TryGet(current.id);
                        if (trait3 == null)
                        {
                            Debug.LogWarning("Trying to add nonexistent trait: " + current.id);
                        }
                        else if (!is_starter_minion || trait3.ValidStarterTrait)
                        {
                            selectedTraits.Add(current.id);
                            statDelta += current.statBonus;
                            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  num  = is_starter_minion ? 1 : 3;
        bool flag = false;

        while (!flag)
        {
            for (int i = 0; i < num; i++)
            {
                flag = (func(DUPLICANTSTATS.BADTRAITS) || flag);
            }
        }
        flag = false;
        while (!flag)
        {
            for (int j = 0; j < num; j++)
            {
                flag = (func(DUPLICANTSTATS.GOODTRAITS) || flag);
            }
        }
        return(statDelta);
    }