DNA.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using Newtonsoft.Json;
using UnityEngine;
 
public class DNA : EClass
{
    public enum Type
    {
        Inferior = 0,
        Default = 3,
        Superior = 5,
        Brain = 8
    }
 
    [JsonProperty]
    public string id;
 
    [JsonProperty]
    public int[] ints = new int[6];
 
    [JsonProperty]
    public List<int> vals = new List<int>();
 
    public BitArray32 bits;
 
    public Type type
    {
        get
        {
            return ints[0].ToEnum<Type>();
        }
        set
        {
            ints[0] = (int)value;
        }
    }
 
    public int cost
    {
        get
        {
            return ints[1];
        }
        set
        {
            ints[1] = value;
        }
    }
 
    public int lv
    {
        get
        {
            return ints[2];
        }
        set
        {
            ints[2] = value;
        }
    }
 
    public int seed
    {
        get
        {
            return ints[3];
        }
        set
        {
            ints[3] = value;
        }
    }
 
    public int slot
    {
        get
        {
            return ints[5];
        }
        set
        {
            ints[5] = value;
        }
    }
 
    public bool isManiGene
    {
        get
        {
            return bits[0];
        }
        set
        {
            bits[0] = value;
        }
    }
 
    [OnSerializing]
    private void _OnSerializing(StreamingContext context)
    {
        ints[4] = bits.ToInt();
    }
 
    [OnDeserialized]
    private void _OnDeserialized(StreamingContext context)
    {
        if (ints.Length < 6)
        {
            Array.Resize(ref ints, 6);
            slot = 1;
        }
    }
 
    public static Thing GenerateGene(Chara c, Type? type = null)
    {
        Thing thing = ThingGen.Create((type == Type.Brain) ? "gene_brain" : "gene");
        DNA dNA = new DNA();
        thing.MakeRefFrom(c);
        dNA.id = c.id;
        dNA.lv = c.LV;
        dNA.seed = EClass.rnd(20000);
        thing.c_DNA = dNA;
        dNA.GenerateWithGene(type ?? dNA.GetRandomType(), thing, c);
        return thing;
    }
 
    public static Thing GenerateGene(CardRow r, Type? type = null, int lv = -1, int seed = -1)
    {
        Thing thing = ThingGen.Create((type == Type.Brain) ? "gene_brain" : "gene");
        DNA dNA = new DNA();
        thing.MakeRefFrom(r.id);
        dNA.id = r.id;
        dNA.lv = ((lv == -1) ? r.LV : lv);
        dNA.seed = ((seed == -1) ? EClass.rnd(20000) : seed);
        thing.c_DNA = dNA;
        dNA.GenerateWithGene(type ?? dNA.GetRandomType(), thing);
        return thing;
    }
 
    public static Thing CopyDNA(Thing from, Thing to)
    {
        to.c_DNA = from.c_DNA;
        to.c_idRefCard = from.c_idRefCard;
        to.ChangeMaterial(from.material);
        return to;
    }
 
    public static Thing GenerateRandomGene(int lv = -1, int seed = -1)
    {
        if (lv == -1)
        {
            lv = EClass._zone.ContentLv;
        }
        Rand.SetSeed(seed);
        CardRow r = SpawnList.Get("chara").Select(100);
        Rand.SetSeed();
        return GenerateGene(r, Type.Superior, lv, seed);
    }
 
    public static Thing GenerateManiGene(Card owner)
    {
        owner.things.DestroyAll();
        Debug.Log("Mani:" + owner.c_seed);
        Rand.SetSeed(owner.c_seed);
        CardRow r = SpawnList.Get("chara").Select(100);
        Rand.SetSeed(owner.c_seed);
        Thing thing = GenerateGene(r, Type.Superior, owner.LV, owner.c_seed);
        thing.c_DNA.cost = thing.c_DNA.cost / 2;
        thing.c_DNA.isManiGene = true;
        thing.MakeRefFrom("mani");
        Rand.SetSeed();
        owner.c_seed++;
        return thing;
    }
 
    public void Apply(Chara c)
    {
        if (c.c_genes == null)
        {
            c.c_genes = new CharaGenes();
        }
        CharaGenes c_genes = c.c_genes;
        if (type == Type.Inferior)
        {
            c.c_genes.inferior++;
            return;
        }
        c.feat -= cost * c.GeneCostMTP / 100;
        Apply(c, reverse: false);
        c_genes.items.Add(this);
    }
 
    public void Apply(Chara c, bool reverse)
    {
        if (type == Type.Brain)
        {
            c._tactics = null;
            return;
        }
        for (int i = 0; i < vals.Count; i += 2)
        {
            int num = vals[i];
            int num2 = vals[i + 1];
            SourceElement.Row row = EClass.sources.elements.map[num];
            switch (row.category)
            {
            case "slot":
                if (reverse)
                {
                    c.body.RemoveBodyPart(row.id);
                }
                else
                {
                    c.body.AddBodyPart(row.id);
                }
                c.body.RefreshBodyParts();
                if (c.IsPC && (bool)WidgetEquip.Instance)
                {
                    WidgetEquip.Instance.Rebuild();
                }
                break;
            case "feat":
            {
                int num3 = c.elements.ValueWithoutLink(num) + ((!reverse) ? 1 : (-1));
                if (num3 < 0)
                {
                    num3 = 0;
                }
                c.SetFeat(num, num3, !reverse);
                if (reverse && num == 1423 && c.GetInt(134) > 0)
                {
                    int num4 = c.elements.ValueWithoutLink(num) - c.GetInt(134);
                    if (num4 < 0)
                    {
                        num4 = 0;
                    }
                    c.SetFeat(num, num4);
                    c.SetInt(134);
                }
                break;
            }
            case "ability":
                if (reverse)
                {
                    c.ability.Remove(num * ((num2 >= 0) ? 1 : (-1)));
                }
                else
                {
                    c.ability.Add(num, Mathf.Abs(num2), num2 < 0);
                }
                break;
            default:
                if (!reverse && c.elements.ValueWithoutLink(row.id) == 0)
                {
                    c.elements.Learn(row.id, num2);
                }
                else
                {
                    c.elements.ModBase(num, reverse ? (-num2) : num2);
                }
                break;
            }
        }
        c.RefreshFaithElement();
        c.Refresh();
        if (reverse)
        {
            c.RemoveAllStances();
        }
    }
 
    public bool CanRemove(Chara c)
    {
        for (int i = 0; i < vals.Count; i += 2)
        {
            if (EClass.sources.elements.map[vals[i]].tag.Contains("permaGene"))
            {
                return false;
            }
            int num = vals[i];
            if (num == 1228 || num == 1414)
            {
                if (c != null)
                {
                    return !c.IsPC;
                }
                return true;
            }
        }
        return true;
    }
 
    public void GenerateWithGene(Type _type, Card gene, Chara model = null)
    {
        Generate(_type, model);
        gene.ChangeMaterial(GetMaterialId(type));
        gene.elements.SetTo(10, 0);
    }
 
    public void Generate(Type _type, Chara model = null)
    {
        type = _type;
        cost = 0;
        slot = 0;
        vals.Clear();
        Rand.SetSeed(seed);
        if (model == null)
        {
            model = CharaGen.Create(id);
            if (lv > model.LV)
            {
                model.SetLv(lv);
            }
        }
        if (type == Type.Inferior || model == null)
        {
            type = Type.Inferior;
            return;
        }
        if (type == Type.Brain)
        {
            cost = 4;
            return;
        }
        int body = 0;
        int action = 0;
        int feat = 0;
        int maxSlot = 1;
        List<Element> listAttb = model.elements.ListBestAttributes();
        List<Element> listSkill = model.elements.ListBestSkills();
        List<Element> listFeat = model.elements.ListGeneFeats();
        Rand.SetSeed(seed);
        if (listFeat.Count == 0)
        {
            listFeat = model.ListAvailabeFeats(pet: true);
        }
        Rand.SetSeed(seed);
        switch (type)
        {
        case Type.Default:
            AddRandom(EClass.rnd(EClass.rnd(4)) + 1);
            if (EClass.rnd(3) == 0 || vals.Count == 0)
            {
                AddSpecial();
            }
            break;
        case Type.Superior:
            AddRandom(EClass.rnd(EClass.rnd(4)) + 3);
            if (EClass.rnd(3) == 0)
            {
                AddSpecial();
            }
            AddSpecial();
            break;
        }
        if (vals.Count == 0)
        {
            for (int i = 0; i < 10; i++)
            {
                if (EClass.rnd(4) == 0)
                {
                    AddSpecial();
                }
                else
                {
                    AddRandom(1);
                }
                if (vals.Count > 0)
                {
                    break;
                }
            }
        }
        Rand.SetSeed();
        CalcCost();
        CalcSlot();
        void AddAction()
        {
            if (model.ability.list.items.Count != 0)
            {
                ActList.Item a = model.ability.list.items.RandomItem();
                if (!(a.act.source.category != "ability") && a.act.source.geneSlot >= 0)
                {
                    AddVal(a.act.source.id, a.chance * ((!a.pt) ? 1 : (-1)), allowStack: false, (int v) => 8 + a.act.source.cost[0] / 10 * 2, allowNegative: true);
                    action++;
                }
            }
        }
        void AddAttribute()
        {
            Element element = listAttb[EClass.rnd(3)];
            AddVal(element.id, EClass.rndHalf(element.ValueWithoutLink / 2), allowStack: true, (int v) => v / 5 + 1, allowNegative: false);
        }
        void AddBody()
        {
            if (body == 0)
            {
                BodySlot bodySlot = null;
                for (int j = 0; j < 100; j++)
                {
                    BodySlot bodySlot2 = model.body.slots.RandomItem();
                    if (bodySlot2 != null && bodySlot2.elementId != 40 && bodySlot2.elementId != 44 && bodySlot2.elementId != 46)
                    {
                        bodySlot = bodySlot2;
                        break;
                    }
                }
                if (bodySlot != null)
                {
                    AddVal(bodySlot.elementId, 1, allowStack: false, (int v) => 20, allowNegative: false);
                    body++;
                }
            }
        }
        void AddFeat()
        {
            if (listFeat.Count != 0)
            {
                feat++;
                Element e = listFeat.RandomItem();
                if (maxSlot <= 1 || e.source.geneSlot <= 1)
                {
                    if (e.source.geneSlot > maxSlot)
                    {
                        maxSlot = e.source.geneSlot;
                    }
                    AddVal(e.id, 1, allowStack: false, (int v) => e.source.cost[0] * 5, allowNegative: false);
                }
            }
        }
        void AddRandom(int n)
        {
            for (int j = 0; j < n; j++)
            {
                if (EClass.debug.enable && EClass.rnd(2) == 0)
                {
                    AddSpecial();
                }
                else if (EClass.rnd(2) == 0)
                {
                    AddSkill();
                }
                else
                {
                    AddAttribute();
                }
            }
        }
        void AddSkill()
        {
            Element element = listSkill[Mathf.Clamp(EClass.rnd(6), 0, listSkill.Count - 1)];
            AddVal(element.id, EClass.rndHalf(element.ValueWithoutLink / 2), allowStack: true, (int v) => v / 5 + 1, allowNegative: false);
        }
        void AddSpecial()
        {
            if (EClass.rnd(3) == 0)
            {
                AddAction();
            }
            else if (EClass.rnd(5) == 0)
            {
                AddBody();
            }
            else if (listFeat.Count > 0)
            {
                AddFeat();
            }
            else if (EClass.rnd(2) == 0)
            {
                AddSkill();
            }
            else
            {
                AddAttribute();
            }
        }
        void AddVal(int id, int v, bool allowStack, Func<int, int> funcCost, bool allowNegative)
        {
            if (v >= 0 || allowNegative)
            {
                bool flag = false;
                int num = EClass.curve(v, 20, 10, 90);
                if (v < -100)
                {
                    num = EClass.curve(Mathf.Abs(v + 100), 20, 10, 90);
                }
                v = EClass.curve(v, 20, 10, 80);
                for (int j = 0; j < vals.Count; j += 2)
                {
                    if (vals[j] == id)
                    {
                        if (allowStack)
                        {
                            v /= 2;
                            num /= 2;
                            vals[j + 1] += v;
                            Debug.Log(vals[j + 1] + ": " + v + "/" + num);
                            flag = true;
                            break;
                        }
                        return;
                    }
                }
                if (v != 0)
                {
                    if (!flag)
                    {
                        vals.Add(id);
                        vals.Add(v);
                    }
                    cost += Mathf.Max(0, funcCost(num));
                }
            }
        }
    }
 
    public void CalcCost()
    {
        if (cost < 0)
        {
            cost = 0;
        }
    }
 
    public void CalcSlot()
    {
        slot = 0;
        for (int i = 0; i < vals.Count; i += 2)
        {
            Element element = Element.Create(vals[i], vals[i + 1]);
            if (element.source.geneSlot < 0)
            {
                slot = 99;
            }
            if (element.source.geneSlot > slot)
            {
                slot = element.source.geneSlot;
            }
        }
        if (slot < 0)
        {
            slot = 0;
        }
    }
 
    public static Type GetType(string idMat)
    {
        return idMat switch
        {
            "jelly" => Type.Default, 
            "gold" => Type.Superior, 
            "amethyst" => Type.Brain, 
            _ => Type.Inferior, 
        };
    }
 
    public string GetMaterialId(Type type)
    {
        return type switch
        {
            Type.Default => "jelly", 
            Type.Superior => "gold", 
            Type.Brain => "amethyst", 
            _ => "process", 
        };
    }
 
    public int GetDurationHour()
    {
        return Mathf.Min(cost, 5000) * Mathf.Min(cost, 5000) / 2;
    }
 
    public Type GetRandomType()
    {
        if (EClass.rnd(5) == 0)
        {
            return Type.Superior;
        }
        if (EClass.rnd(10) == 0)
        {
            return Type.Inferior;
        }
        return Type.Default;
    }
 
    public string GetText()
    {
        string text = EClass.sources.cards.map.TryGetValue(id)?.GetName() ?? "???";
        if (text == "*r")
        {
            text = "???";
        }
        return "gene".lang(text.ToTitleCase(), (cost == 0) ? "" : (cost.ToString() ?? ""));
    }
 
    public void WriteNote(UINote n, Thing owner = null, Chara tg = null)
    {
        if (slot >= 1 && (owner == null || !(owner.category.id == "relic")))
        {
            n.AddText("NoteText_enc", "isGeneReqSlots".lang(slot.ToString() ?? ""), FontColor.Warning);
        }
        if (!CanRemove(tg))
        {
            n.AddText("NoteText_enc", "isPermaGene".lang(), FontColor.Warning);
        }
        n.Space(4);
        if (type == Type.Brain)
        {
            SourceChara.Row row = EClass.sources.charas.map.TryGetValue(id);
            if (row != null)
            {
                string key = row.tactics.IsEmpty(EClass.sources.tactics.map.TryGetValue(row.id)?.id ?? EClass.sources.tactics.map.TryGetValue(row.job)?.id ?? "predator");
                n.AddText("NoteText_enc", "gene_info".lang(EClass.sources.tactics.map[key].GetName().ToTitleCase(), ""), FontColor.ButtonGeneral);
            }
            for (int i = 0; i < vals.Count; i += 2)
            {
                int num = vals[i];
                int num2 = vals[i + 1];
                FontColor color = ((num2 >= 0) ? FontColor.Good : FontColor.Bad);
                string @ref = (num + 1).ToString() ?? "";
                string text = "";
                num2 = Mathf.Abs(num2 / 20) + 1;
                text = text + "[" + "*".Repeat(Mathf.Clamp(num2, 1, 5)) + ((num2 > 5) ? "+" : "") + "]";
                n.AddText("NoteText_enc", "gene_info_brain".lang(@ref, text), color);
            }
            return;
        }
        for (int j = 0; j < vals.Count; j += 2)
        {
            Element element = Element.Create(vals[j], vals[j + 1]);
            string text2 = "";
            int num3 = element.Value / 10;
            FontColor color2 = FontColor.Good;
            bool flag = false;
            switch (element.source.category)
            {
            case "slot":
                color2 = FontColor.Myth;
                num3 = -1;
                break;
            case "feat":
                color2 = FontColor.FoodMisc;
                num3 = -1;
                break;
            case "ability":
                color2 = FontColor.Topic2;
                num3 = -1;
                break;
            default:
                flag = true;
                break;
            }
            if (num3 >= 0)
            {
                text2 = text2 + "[" + "*".Repeat(Mathf.Clamp(num3, 1, 5)) + ((num3 > 5) ? "+" : "") + "]";
            }
            if (flag)
            {
                text2 = text2 + " (" + element.Value + ")";
            }
            if ((bool)LayerCraft.Instance && (element.source.category == "slot" || element.HasTag("noRelic") || element.HasTag("permaGene")))
            {
                color2 = FontColor.Bad;
            }
            n.AddText("NoteText_enc", "gene_info".lang(element.Name.ToTitleCase(wholeText: true), text2), color2);
        }
    }
 
    public void WriteNoteExtra(UINote n, Thing owner, Chara tg)
    {
        n.AddHeader("HeaderAdditionalTrait", "gene_hint");
        _ = tg.c_genes;
        int num = slot;
        if (num > 1 && tg.HasElement(1237))
        {
            num--;
        }
        int num2 = tg.MaxGeneSlot - tg.CurrentGeneSlot;
        int num3 = num2 - num;
        int maxGeneSlot = tg.MaxGeneSlot;
        n.AddText("gene_hint_slot".lang(num2.ToString() ?? "", num3.ToString() ?? "", maxGeneSlot.ToString() ?? ""), (num3 >= 0) ? FontColor.Good : FontColor.Bad);
        int num4 = cost * tg.GeneCostMTP / 100;
        int num5 = tg.feat - num4;
        n.AddText("gene_hint_cost".lang(tg.feat.ToString() ?? "", num4 + ((num4 == cost) ? "" : ("(" + cost + ")")), num5.ToString() ?? ""), (num5 >= 0) ? FontColor.Good : FontColor.Bad);
    }
 
    public Element GetInvalidFeat(Chara c)
    {
        for (int i = 0; i < vals.Count; i += 2)
        {
            Element element = Element.Create(vals[i], vals[i + 1]);
            if (c.IsPC && !CanRemove(c))
            {
                return element;
            }
            if (!(element.source.category == "feat"))
            {
                continue;
            }
            if (c.Evalue(element.id) < element.source.max)
            {
                Element orCreateElement = c.elements.GetOrCreateElement(element.id);
                if (orCreateElement != null && orCreateElement.vLink == 0)
                {
                    continue;
                }
            }
            return element;
        }
        return null;
    }
 
    public Element GetInvalidAction(Chara c)
    {
        for (int i = 0; i < vals.Count; i += 2)
        {
            Element element = Element.Create(vals[i], vals[i + 1]);
            if (!(element.source.category == "ability"))
            {
                continue;
            }
            foreach (ActList.Item item in c.ability.list.items)
            {
                if (item.act.source.id == element.id)
                {
                    return element;
                }
            }
        }
        return null;
    }
 
    public int GetBodySlot()
    {
        for (int i = 0; i < vals.Count; i += 2)
        {
            Element element = Element.Create(vals[i], vals[i + 1]);
            if (element.source.category == "slot")
            {
                return element.id;
            }
        }
        return -1;
    }
 
    public void ReplaceBodySlot(int slot)
    {
        for (int i = 0; i < vals.Count; i += 2)
        {
            if (Element.Create(vals[i], vals[i + 1]).source.category == "slot")
            {
                vals[i] = slot;
            }
        }
    }
 
    public void MakeSlimeFood(Chara c)
    {
        int num = c.Evalue(6608) + 10;
        for (int i = 0; i < vals.Count; i += 2)
        {
            Element element = Element.Create(vals[i], vals[i + 1]);
            if ((element.source.category == "attribute" || element.source.category == "skill") && vals[i + 1] > num)
            {
                vals[i + 1] = num;
            }
        }
        cost = 0;
    }
 
    public DNA Relicize()
    {
        for (int i = 0; i < vals.Count; i += 2)
        {
            Element element = Element.Create(vals[i], vals[i + 1]);
            if (element.source.category == "slot" || element.HasTag("noRelic") || element.HasTag("permaGene"))
            {
                vals.RemoveRange(i, 2);
                i -= 2;
            }
        }
        cost = cost * Mathf.Clamp(slot, 1, 10) / 10;
        return this;
    }
}