public void Update()
        {
            data.value = valueProgression.Evaluate(data.level);

            data.cost.Clear();
            if (!IsMaxLevel())
            {
                AtomAmo amo = new AtomAmo();
                for (int i = 0; i < atomProgression.Count; i++)
                {
                    amo.amo = (int)amoProgression[i].Evaluate(data.level);

                    int index = (int)atomProgression[i].Evaluate(data.level);
                    if (index == 0)
                    {
                        amo.atom = null;
                    }
                    else
                    {
                        amo.atom = Game.Instance.gameData.FindAtom(index);
                    }

                    data.cost.Add(amo);
                }
            }
        }
    public CraftResult Craft(Craftable c, int amount)
    {
        CraftResult result = new CraftResult();

        result.atomsUsed = new List <AtomAmo>();

        var atoms = c.GetAtomsForProduction();

        for (int i = 0; i < atoms.Length; i++)  // Find Minumum
        {
            var atomAmo = atoms[i];

            AtomData data = Game.Instance.gameData.FindAtomData(atomAmo.atom.GetAtomicNumber());

            int needed = atomAmo.amo * amount;
            if (data.GetCurrAmo() < needed)
            {
                amount = data.GetCurrAmo() / atomAmo.amo;
            }
        }

        for (int i = 0; i < atoms.Length; i++)
        {
            var atomAmo = atoms[i];

            AtomData data = Game.Instance.gameData.FindAtomData(atomAmo.atom.GetAtomicNumber());

            int needed = atomAmo.amo * amount;
            data.Lose(needed);

            AtomAmo atomUsed = new AtomAmo();
            atomUsed.atom = atomAmo.atom;
            atomUsed.amo  = needed;
            result.atomsUsed.Add(atomUsed);
        }
        result.amountCreated = amount;

        int amoOfCraftables;

        if (!craftables.TryGetValue(c, out amoOfCraftables))
        {
            craftables[c] = amount;
        }
        else
        {
            craftables[c] = amoOfCraftables + amount;
        }

        if (OnCraftableProduced != null)
        {
            OnCraftableProduced(c, amount);
        }

        return(result);
    }
    public AtomCollisionResult ProduceCombine(Atom a, Atom b, int aAmo, int bAmo)
    {
        AtomCollision info = EstimateCombine(a, b, aAmo, bAmo);

        AtomCollisionResult result = new AtomCollisionResult();

        result.atomsProduced = new List <AtomAmo>();
        result.atomsUsed     = new List <AtomAmo>();

        AtomData aData   = Game.Instance.gameData.FindAtomData(a.GetAtomicNumber());
        AtomData bData   = Game.Instance.gameData.FindAtomData(b.GetAtomicNumber());
        int      usedAmo = Mathf.Min(Mathf.Min(aAmo, aData.GetCurrAmo()), Mathf.Min(bAmo, bData.GetCurrAmo()));

        Atom target = info.targetAtom;
        int  maxAmo = info.amo;

        float successChance   = info.success;
        float stabilityChance = 1.0f;

        stabilityChance = info.stability;

        int produced   = (int)(maxAmo * successChance);
        int stabilized = (int)(produced * stabilityChance);

        AtomAmo atomAmo = new AtomAmo();

        atomAmo.amo  = stabilized;
        atomAmo.atom = target;
        result.atomsProduced.Add(atomAmo);

        Game.Instance.Absorb(target, stabilized);

        AtomAmo atomAUsed = new AtomAmo();

        atomAUsed.atom = a;
        atomAUsed.amo  = usedAmo;
        result.atomsUsed.Add(atomAUsed);

        AtomAmo atomBUsed = new AtomAmo();

        atomBUsed.atom = b;
        atomBUsed.amo  = usedAmo;
        result.atomsUsed.Add(atomBUsed);

        Game.Instance.Use(a, usedAmo);
        Game.Instance.Use(b, usedAmo);

        if (OnAtomCombine != null)
        {
            OnAtomCombine(target, stabilized);
        }

        return(result);
    }
Exemple #4
0
    public void AddAtom(AtomRatio a)
    {
        atoms.Add(a);

        currAtoms.Clear();
        AtomAmo amo = new AtomAmo();

        for (int i = 0; i < atoms.Count; i++)
        {
            amo.atom = atoms[i].atom;
            double ratio = atoms[i].ratio / 100d;
            amo.amo = (int)(ratio * totalAtomAmo);
            currAtoms.Add(amo);
        }
    }
        public bool Upgrade()
        {
            bool success = CanUpgrade();

            if (success)
            {
                for (int i = 0; i < data.cost.Count; i++)   // Use
                {
                    AtomAmo atomCost = data.cost[i];
                    if (atomCost.atom == null)
                    {
                        continue;
                    }

                    AtomData atomData = Game.Instance.gameData.FindAtomData(data.cost[i].atom.GetAtomicNumber());
                    atomData.Lose(data.cost[i].amo);
                }

                data.level++;
                data.value = valueProgression.Evaluate(data.level);

                data.cost.Clear();
                if (!IsMaxLevel())
                {
                    AtomAmo amo = new AtomAmo();
                    for (int i = 0; i < atomProgression.Count; i++)
                    {
                        amo.amo = (int)amoProgression[i].Evaluate(data.level);

                        int index = (int)atomProgression[i].Evaluate(data.level);
                        if (index == 0)
                        {
                            amo.atom = null;
                        }
                        else
                        {
                            amo.atom = Game.Instance.gameData.FindAtom(index);
                        }

                        data.cost.Add(amo);
                    }
                }
            }

            return(success);
        }
    public AtomCollisionResult ProduceSplit(Atom a, int aAmo)
    {
        AtomCollision info = EstimateSplit(a, aAmo);

        AtomData aData = Game.Instance.gameData.FindAtomData(a.GetAtomicNumber());

        aAmo = Mathf.Min(aAmo, aData.GetCurrAmo());

        AtomCollisionResult result = new AtomCollisionResult();

        result.atomsProduced = new List <AtomAmo>();
        result.atomsUsed     = new List <AtomAmo>();

        Atom target = info.targetAtom;

        // Split
        int produced = (int)(info.amo * info.success); // Random Loss

        // Stabilize
        int stabilized = (int)(produced * info.stability);

        // Result
        AtomAmo atomAmo = new AtomAmo();

        atomAmo.amo  = stabilized;
        atomAmo.atom = target;
        result.atomsProduced.Add(atomAmo);
        Game.Instance.Absorb(target, stabilized);

        // Used
        AtomAmo atomAUsed = new AtomAmo();

        atomAUsed.atom = a;
        atomAUsed.amo  = aAmo;
        result.atomsUsed.Add(atomAUsed);
        Game.Instance.Use(a, aAmo);


        if (OnAtomSplit != null)
        {
            OnAtomSplit(target, stabilized);
        }

        return(result);
    }
    public void Produce()
    {
        PlayerData.AtomCollisionResult result;
        if (toHydrogenToggle.isOn)
        {
            result = new PlayerData.AtomCollisionResult();
            result.atomsProduced = new List <AtomAmo>();
            result.atomsUsed     = new List <AtomAmo>();

            AtomAmo atomAmo = new AtomAmo();
            PlayerData.AtomCollisionResult resultTemp;

            Atom atom = atomA;
            int  amo  = (int)atomAAmo.value;
            do
            {
                atomAmo.atom = atom;
                atomAmo.amo  = amo;
                result.atomsUsed.Add(atomAmo);

                resultTemp = Game.Instance.playerData.ProduceSplit(atom, amo);
                atom       = resultTemp.atomsProduced[0].atom;
                amo        = resultTemp.atomsProduced[0].amo;
            } while (atom.GetAtomicNumber() != 1);

            result.atomsProduced.Add(resultTemp.atomsProduced[0]);
        }
        else
        {
            result = Game.Instance.playerData.ProduceSplit(atomA, (int)atomAAmo.value);
        }

        // Display Popup
        resultUI.Setup(result.atomsProduced, result.atomsUsed);
        Reset();

        for (int i = 0; i < result.atomsProduced.Count; i++)
        {
            print("Atoms Produced: " + result.atomsProduced[i].atom.GetName() + " " + result.atomsProduced[i].amo);
        }
    }
Exemple #8
0
    private void Start()
    {
        renderer = GetComponent <SpriteRenderer>();

        aliveColor = renderer.color;

        this.gameObject.layer = LayerMask.NameToLayer("AtomCollector");

        AtomAmo amo        = new AtomAmo();
        float   totalRatio = 0f;

        for (int i = 0; i < atoms.Count; i++)
        {
            amo.atom = atoms[i].atom;
            double ratio = atoms[i].ratio / 100d;
            amo.amo = (int)(ratio * totalAtomAmo);
            currAtoms.Add(amo);

            totalRatio += atoms[i].ratio;
        }
        if (100.0f - totalRatio > .001f || totalRatio > 100.0f)
        {
            print(name + " has Ratio of " + totalRatio);
        }

        currAtomAmo = totalAtomAmo;
        currColor   = aliveColor;

        int tempAtomAmo = GetSum(currAtoms);

        if (tempAtomAmo > 0)
        {
            currAtomAmo = tempAtomAmo;
        }

        //if(tempAtomAmo != currAtomAmo) {
        //    print("Object " + name + " Total Amo (" + totalAtomAmo + ") doesnt equal Curr Amo (" + tempAtomAmo +
        //        ")");
        //}
    }
        public bool CanUpgrade()
        {
            if (IsMaxLevel())
            {
                return(false);
            }

            for (int i = 0; i < data.cost.Count; i++)   // Validation
            {
                AtomAmo atomCost = data.cost[i];
                if (atomCost.atom == null)
                {
                    continue;
                }

                AtomData atomData = Game.Instance.gameData.FindAtomData(atomCost.atom.GetAtomicNumber());
                if (atomData.GetCurrAmo() < atomCost.amo)
                {
                    return(false);
                }
            }
            return(true);
        }
        public void Init()
        {
            data.level = 1;
            data.value = valueProgression.Evaluate(data.level);

            AtomAmo amo = new AtomAmo();

            data.cost = new List <AtomAmo>();
            for (int i = 0; i < atomProgression.Count; i++)
            {
                amo.amo = (int)amoProgression[i].Evaluate(data.level);

                int index = (int)atomProgression[i].Evaluate(data.level);
                if (index == 0)
                {
                    amo.atom = null;
                }
                else
                {
                    amo.atom = Game.Instance.gameData.FindAtom(index);
                }
                data.cost.Add(amo);
            }
        }
Exemple #11
0
    public List <AtomAmo> Absorb()
    {
        List <AtomAmo> atomsToBeAbsorbed = new List <AtomAmo>();

        if (Time.time < nextCollectionTime)
        {
            return(atomsToBeAbsorbed);
        }

        PlayerData playerData    = Game.Instance.playerData;
        AtomAmo    amoToCollect  = new AtomAmo();
        int        atomCount     = 0;
        float      weightLimit   = playerData.GetValue(PlayerData.UpgradeType.Collect_Weight);
        float      speedRatio    = playerData.GetValue(PlayerData.UpgradeType.Collect_Speed);
        int        efficiencyAmo = (int)playerData.GetValue(PlayerData.UpgradeType.Collect_Efficiency);

        for (int i = 0; i < currAtoms.Count; i++)
        {
            AtomAmo atomAmo = currAtoms[i];
            if (atomAmo.amo <= 0)
            {
                continue;
            }

            AtomInfo info = Game.Instance.gameData.FindAtomInfo(atomAmo.atom.GetAtomicNumber());
            if (info.GetProtons() + info.GetNeutrons() > weightLimit)
            {
                continue;
            }

            int maxAmo = efficiencyAmo;/// info.GetProtons();
            if (maxAmo < 2)
            {
                maxAmo = 2;
            }

            int randAmo = UnityEngine.Random.Range(0, maxAmo);
            if (randAmo == 0)
            {
                continue;
            }

            amoToCollect.atom = atomAmo.atom;
            amoToCollect.amo  = randAmo > atomAmo.amo ? atomAmo.amo : randAmo;

            atomsToBeAbsorbed.Add(amoToCollect);
            atomCount += amoToCollect.amo;

            if (hasLife)
            {
                atomAmo.amo -= amoToCollect.amo; // Because Dumb
                currAtomAmo -= amoToCollect.amo;
                currAtoms[i] = atomAmo;
            }
        }

        // Time
        if (atomCount != 0)
        {
            nextCollectionTime = Time.time + collectionPause * speedRatio;
        }

        // Life
        if (hasLife)
        {
            CheckLife();
        }

        // Flash
        if (canFlash && !isFlashing && atomCount != 0 && !IsDead())
        {
            StartCoroutine(Flash());
        }

        return(atomsToBeAbsorbed);
    }
Exemple #12
0
    public void SetUpgradeInfo(PlayerData.UpgradeType type)
    {
        RemoveUpgrade();
        if ((int)type >= choices.Count)
        {
            return;
        }

        // Button Stuff
        ChoiceOption choiceOption = choices[(int)type];

        choiceOption.SetButtonEvent(() => {
            RemoveUpgrade();
            AudioManager.Instance.PlaySound(choiceClick);
        });
        choiceOption.SetColors(ChoiceOption.defaultPressedColor, ChoiceOption.defaultHoverColor, ChoiceOption.defaultNormalColor);
        choiceOption.SetFocus(false);
        currUpgradeType = type;

        // Display Stuff
        List <AtomAmo> atomsNeeded = Game.Instance.playerData.GetCost(type);

        upgradeName.text = Game.Instance.playerData.GetName(type);
        upgradeDesc.text = Game.Instance.playerData.GetDescription(type);
        double currValue = System.Math.Round(Game.Instance.playerData.GetValue(type), 3);
        double nextValue = System.Math.Round(Game.Instance.playerData.GetNextValue(type), 3);

        if (type == PlayerData.UpgradeType.Collect_Efficiency)
        {
            currValue *= 100;
            nextValue *= 100;
        }
        upgradeCurrValue.text = "Curr Value: " + currValue + " " +
                                Game.Instance.playerData.GetMeasurementAbbr(type); //currValue;
        upgradeNextValue.text = "Next Value: " + nextValue + " " +
                                Game.Instance.playerData.GetMeasurementAbbr(type); //nextValue;

        bool canCraft = true;

        upgradeAtomName.text = "";
        upgradeAtomNeed.text = "";
        upgradeAtomHave.text = "";
        for (int i = 0; i < atomsNeeded.Count; i++)
        {
            AtomAmo cost = atomsNeeded[i];
            if (cost.atom == null)
            {
                continue;
            }

            int amoHave = Game.Instance.gameData.FindAtomData(cost.atom.GetAtomicNumber()).GetCurrAmo();
            if (amoHave >= cost.amo)
            {
                upgradeAtomName.text += cost.atom.GetName() + "\n";
                upgradeAtomNeed.text += cost.amo + "\n";
                upgradeAtomHave.text += amoHave + "\n";
            }
            else
            {
                upgradeAtomName.text += "<color=#ff8080>" + cost.atom.GetName() + "\n</color>";
                upgradeAtomNeed.text += "<color=#ff8080>" + cost.amo + "\n</color>";
                upgradeAtomHave.text += "<color=#ff8080>" + amoHave + "\n</color>";
                canCraft              = false;
            }
        }
        upgradeBtn.interactable = canCraft;
    }