コード例 #1
0
    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);
    }
コード例 #2
0
    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);
    }
コード例 #3
0
    public AtomCollision EstimateSplit(Atom a, int aAmo)
    {
        AtomCollision info = new AtomCollision();

        if (a.GetAtomicNumber() == 1)  // Hydrogen, Can Not Split...
        {
            return(info);
        }

        AtomInfo aInfo = Game.Instance.gameData.FindAtomInfo(a.GetAtomicNumber());

        //aAmo = Mathf.Min(aAmo, int.MaxValue / aInfo.GetNeutrons());

        int  halfProtons   = aInfo.GetProtons() / 2;
        long totalNeutrons = aInfo.GetNeutrons() * 1L * aAmo;

        // Target
        info.targetAtom = Game.Instance.gameData.FindAtom(halfProtons); // Should Correlate to Atomic number
        AtomInfo targetInfo = Game.Instance.gameData.FindAtomInfo(halfProtons);

        // Max Amount to Be Made
        if (info.targetAtom.GetAtomicNumber() == 1)  // Hydrogen
        {
            long protons = aInfo.GetProtons() * aAmo;
            info.amo = (int)(protons / targetInfo.GetProtons()); // Proton Based
        }
        else
        {
            long amo = totalNeutrons / targetInfo.GetNeutrons();
            info.amo = amo > int.MaxValue ? int.MaxValue : (int)amo; // Neutron Based
        }

        // Success
        float estimatedSpeed = aInfo.GetProtons() / 10f;

        info.success = Mathf.Clamp01(1 - estimatedSpeed / accelerationUpgrade.GetValue());

        // Stability
        if (targetInfo.GetHalfLife() == 0f)
        {
            info.stability = 1.0f;
        }
        else
        {
            //float halfLife = targetInfo.GetHalfLife() + timeUpgrade.GetValue();
            //float multiple = 1 / Mathf.Sqrt(1 - (stabilityUpgrade.GetValue() * stabilityUpgrade.GetValue()) / (100 * 100));
            //info.stability = AtomInfo.GetStability(halfLife * multiple * multiple);

            float halflife = targetInfo.GetHalfLife() + timeUpgrade.GetValue();
            if (halflife < 0)
            {
                info.stability = 0f;
            }
            else
            {
                float yearPercentage = 5256000; // 10 years ish
                float t = .001f;

                float stableValue = stabilityUpgrade.GetValue();

                float lerp      = Mathf.Lerp(halflife, yearPercentage, t);
                float power     = Mathf.Sqrt(stableValue / 30);
                float stability = Mathf.Pow(lerp, power);
                info.stability = Mathf.Clamp01(stability / yearPercentage);
            }
        }

        return(info);
    }
コード例 #4
0
    public AtomCollision EstimateCombine(Atom a, Atom b, int aAmo, int bAmo)
    {
        AtomCollision info = new AtomCollision();

        AtomInfo aInfo = Game.Instance.gameData.FindAtomInfo(a.GetAtomicNumber());
        AtomInfo bInfo = Game.Instance.gameData.FindAtomInfo(b.GetAtomicNumber());
        AtomData aData = Game.Instance.gameData.FindAtomData(a.GetAtomicNumber());
        AtomData bData = Game.Instance.gameData.FindAtomData(b.GetAtomicNumber());

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

        //aAmo = Mathf.Min(aAmo, int.MaxValue / aInfo.GetNeutrons());
        //bAmo = Mathf.Min(bAmo, int.MaxValue / bInfo.GetNeutrons());

        int  maxProtons     = aInfo.GetProtons() + bInfo.GetProtons();
        long totalANeutrons = aAmo * aInfo.GetNeutrons();
        long totalBNeutrons = bAmo * bInfo.GetNeutrons();

        if (Game.Instance.gameData.GetAtomAmount() >= maxProtons)
        {
            info.targetAtom = Game.Instance.gameData.FindAtom(maxProtons); // Should Correlate to Atomic number
        }
        else
        {
            info.targetAtom = null;
            return(info);
        }
        AtomInfo targetInfo = Game.Instance.gameData.FindAtomInfo(maxProtons);

        long minProtons  = Mathf.Min(aAmo, bAmo); // Min of Atoms
        long minNeutrons = (totalANeutrons + totalBNeutrons) / targetInfo.GetNeutrons();
        long amo         = minProtons > minNeutrons ? minNeutrons : minProtons;

        info.amo = amo > int.MaxValue ? int.MaxValue : (int)amo;

        // 119 / 10 -> 11.9% Speed
        // 1 - (11.9 / 12)  -> .008333 About 1 / 12
        //
        // At 10% speed of light, Titanium -> Berkelium produces an estimated 1 / 1 billion atoms of Element 119
        float estimatedSpeed = maxProtons / 10f;

        info.success = Mathf.Clamp01(1 - estimatedSpeed / accelerationUpgrade.GetValue());

        // Apparently the half life of atoms can be changed by Time Dialation, Gravity, and External Radiation
        // There is no known way to accurately predict the half-life of atoms. There are two many variables
        // How about this, we place radioactive atoms near a black hole. Depending on the strength and randomness, the atom's half-life may be extended and stored indefinetly.

        // Our goal is to get that between 525600 1 year and 525600000 1000 years
        //  However if we have a value of 0.00085
        // That requires a multiple of 618,352,941 Just for the min

        //100*sqrt(1-((x*x)/(100*100))); Percentage of Speed -> Time Ratio
        //1 / sqrt(1-((x*x)/(100*100))); Percentage of Speed -> Time Multiple
        if (targetInfo.GetHalfLife() == 0f)
        {
            info.stability = 1.0f;
        }
        else
        {
            //float halfLife = targetInfo.GetHalfLife() + timeUpgrade.GetValue();
            //float multiple = 1 / Mathf.Sqrt(1 - (stabilityUpgrade.GetValue() * stabilityUpgrade.GetValue()) / (100 * 100));
            //info.stability = AtomInfo.GetStability(halfLife * multiple * multiple);

            //\frac{\left(\left(t\cdot\left(a-v\right)+v\right)^{\sqrt{\frac{x}{30}}}\right)}{525600}
            float halflife = targetInfo.GetHalfLife() + timeUpgrade.GetValue();
            if (halflife < 0)
            {
                info.stability = 0f;
            }
            else
            {
                float yearPercentage = 5256000; // 10 years ish
                float t = .001f;

                float stableValue = stabilityUpgrade.GetValue();

                float lerp      = Mathf.Lerp(halflife, yearPercentage, t);
                float power     = Mathf.Sqrt(stableValue / 30);
                float stability = Mathf.Pow(lerp, power);
                info.stability = Mathf.Clamp01(stability / yearPercentage);
            }
        }

        return(info);
    }