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);
    }
    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);
    }