Savage Defense Simulator

package tangedyn;

import java.util.TreeSet;

import ec.util.MersenneTwisterFast;

public class SavageDefenseSim {
    private static final double pYellowCrit = .29628;
    private static final double pWhiteCrit = .38896;
    private static final double pAvoid = .38016 + .05;
    private static final double hastePercent = .02194;

    private static final double yellowInterval = 1.5;
    private static final double maulInterval = 3.0;
    private static final double whiteInterval = 2.5 / (1 + hastePercent) / 1.1;
    private static final double bossInterval = 2.4;

    private static final int bossDamage = 34585;
    private static final int vengeanceCap = 12930;
    private static final int attackPower = 16772;

    private static final double pSavageDefense = 0.50;
    private static final double mastery = 18.877;

    private static final int SAMPLES = 10000000;

    private abstract class Event implements Comparable<Event> {
        double mNext = 0;
        double mInterval = 0;

        Event(double interval) {
            mInterval = interval;
            mNext = mInterval / 2;
        }

        abstract void onEvent();

        @Override
        public int compareTo(Event ev) {
            if (mNext == ev.mNext) return hashCode() - ev.hashCode();
            else return mNext < ev.mNext ? -1 : 1;
        }
    }

    MersenneTwisterFast mRandom = new MersenneTwisterFast();
    int mSamples = 0;
    int mSdUpSamples = 0;
    boolean mSdUp = false;

    double mTotalVengeance = 0.0;
    int mTotalTime = -100;
    double mVengeance = 0.0;
    double mTotalVengeanceSq = 0.0;
    double mDamageTaken = 0.0;
    int mTimeAtCap = 0;
    int mTimeAtZero = 0;
    double mShieldSize = 0;
    double mMaxVengeanceStack = 0;
    double mLowestVengeance = vengeanceCap;
    boolean mWasAttacked = false;

    boolean DEBUG = false;

    public void sd() {
        mSdUp = true;
        mShieldSize = (attackPower + mVengeance * 1.1 * 1.25) * 0.35 * (1 + mastery * 0.04);
    }

    public void run() {
        Event vengeanceCheck = new Event(2.0) {
            @Override
            void onEvent() {
//              if (mDamageTaken > 0.0) {
                if (mWasAttacked) {
                    mVengeance = 0.95 * mVengeance + mDamageTaken * 0.05;
                    if (mVengeance >= vengeanceCap) {
                        mVengeance = vengeanceCap;
                        mTimeAtCap ++;
                    }
                    if (mVengeance > mMaxVengeanceStack) mMaxVengeanceStack = mVengeance;
                    mDamageTaken = 0.0;
                }
                else {
                    if (mVengeance > mMaxVengeanceStack / 10) {
                        mVengeance = mVengeance - mMaxVengeanceStack / 10;
                    }
                    else {
                        mVengeance = mMaxVengeanceStack = 0;
                        mTimeAtZero ++;
                    }
                }
                mTotalTime ++;
                if (mTotalTime == 0) mTotalVengeance = mTimeAtCap = mTimeAtZero = 0;
                if (mTotalTime > 0 && mVengeance < mLowestVengeance) mLowestVengeance = mVengeance;
                mTotalVengeance += mVengeance;
                mTotalVengeanceSq += mVengeance * mVengeance;
                mWasAttacked = false;
                if (DEBUG) System.out.println(mNext + " Vengeance at: " + mVengeance);
            }
        };

        Event yellowEvent = new Event(yellowInterval) {
            @Override
            void onEvent() {
                if (mRandom.nextBoolean(pYellowCrit) && mRandom.nextBoolean(pSavageDefense)) mSdUp = true;
            }
        };

        Event maulEvent = new Event(maulInterval) {
            @Override
            void onEvent() {
                if (mRandom.nextBoolean(pYellowCrit) && mRandom.nextBoolean(pSavageDefense)) mSdUp = true;
            }
        };

        Event whiteEvent = new Event(whiteInterval) {
            @Override
            void onEvent() {
                if (mRandom.nextBoolean(pWhiteCrit) && mRandom.nextBoolean(pSavageDefense)) mSdUp = true;
            }
        };

        Event bossEvent = new Event(bossInterval) {
            @Override
            void onEvent() {
                if (mRandom.nextBoolean(1.0 - pAvoid)) {
                    if (mSdUp) {
                        mSdUpSamples++;
                        double damage = bossDamage - mShieldSize;
                        if (damage > 0) mDamageTaken += damage;
                        if (DEBUG) System.out.println(mNext + "Absorbed!");
                    } else {
                        mDamageTaken += bossDamage;
                        if (DEBUG) System.out.println(mNext + "Ouch!");
                    }
                    mSdUp = false;
                    mSamples++;
                }
                else if (DEBUG) System.out.println(mNext + " Avoided!");
                mWasAttacked = true;
            }
        };

        TreeSet<Event> events = new TreeSet<Event>();
        events.add(vengeanceCheck);
        events.add(yellowEvent);
        events.add(whiteEvent);
        events.add(maulEvent);
        events.add(bossEvent);

        while (mSamples < SAMPLES) {
            Event ev = events.pollFirst();
            ev.onEvent();
            ev.mNext += ev.mInterval;
//          System.out.println(ev.mNext + " " + mSdUp + " " + mSdUpSamples + "/" + mSamples);
            events.add(ev);
        }

        double vengeanceMean = mTotalVengeance / mTotalTime;
        double stddev = Math.sqrt(mTotalVengeanceSq / mTotalTime - (vengeanceMean * vengeanceMean));

        System.out.println("p(SD up) = " + (double)mSdUpSamples / mSamples);
        System.out.println("vengeance cap = " + vengeanceCap);
        System.out.println("average vengeance = " + vengeanceMean + "  (" + (double)vengeanceMean / vengeanceCap + ")");
        System.out.println("stddev = " + stddev + "  (" + (double)stddev / vengeanceCap + ")");
        System.out.println("lowest vengeance = " + (double)mLowestVengeance / vengeanceCap);
        System.out.println("p(max vengeance) = " + (double)mTimeAtCap / mTotalTime);
        System.out.println("p(0 vengeance) = " + (double)mTimeAtZero / mTotalTime);
    }


    public static void main(String args[]) {
        new SavageDefenseSim().run();
    }
}