public class Controller {

    // These are ENUM?
    private final int offenseSuccess = -100;
    private int offensiveCritical = -95;
    private final int defenseSuccess = 100;
    private int defensiveCritical = 99;
    private int breakingPoint = 0;
    private final static double smallSuccessPercentage = .65;
    private final static double mediumSuccessPercentage = .85;

    private final Range shortSuccessOffenseRange = new Range(2, 4);
    private final Range shortSuccessDefenseRange = new Range(1, 2);
    private final Range mediumSuccessOffenseRange = new Range(shortSuccessOffenseRange.maximumPoint, 10);
    private final Range mediumSuccessDefenseRange = new Range(-2, shortSuccessDefenseRange.minimumPoint);
    private boolean hasBeenSimulated = false;
    private PlayResults mResults;

    // These are ENUM?
    public final static int OFFENSIVE_WIN = 0x111111;
    public final static int DEFENSIVE_WIN = 0x222222;
    public final static int LARGE_SUCCESS = 0x333333;
    public final static int MEDIUM_SUCCESS = 0x444444;
    public final static int SMALL_SUCCESS = 0x555555;

    Controller() {
        reset();
    }

    final void simulate() {
        if (!hasBeenSimulated) return;
        // this should be Result Class maybe?
        final int result = new Random().nextInt(defenseSuccess - offenseSuccess) + offenseSuccess;
        // should be: mResults.offensiveWin();
        if (result <= offensiveCritical) mResults.setTouchdownStatus(true).setFinalResult(OFFENSIVE_WIN);
        // should be: mResults.defensiveWin();
        if (result >= defensiveCritical) mResults.setTouchdownStatus(true).setFinalResult(DEFENSIVE_WIN);
        int minYardRange = 0;
        int maxYardRange = 0;

        // should be mresults.isDone()? isFinal?
        if (mResults.getFinalResult() == 0) {
            boolean dun = false;
            // if new Result class result.isOffensiveWin()?
            if (result < breakingPoint) {
                // move these to a method
                mResults.setFinalResult(OFFENSIVE_WIN);
                if (result < (breakingPoint - (breakingPoint() * mediumSuccessPercentage))) {
                    minYardRange = mediumSuccessOffenseRange.maximumPoint;
                    maxYardRange = 100;
                    dun = true;
                }
                if (!dun && result < breakingPoint - (breakingPoint() * smallSuccessPercentage)) {
                    minYardRange = shortSuccessOffenseRange.maximumPoint;
                    maxYardRange = mediumSuccessOffenseRange.maximumPoint;
                    dun = true;
                }
                if (!dun) {
                    minYardRange = shortSuccessOffenseRange.minimumPoint;
                    maxYardRange = shortSuccessOffenseRange.maximumPoint;
                }
            } else {
                // move this to a method
                final int breakingPointGap = Math.abs(defenseSuccess) - Math.abs(breakingPoint);
                mResults.setFinalResult(DEFENSIVE_WIN);
                if (result > breakingPoint + (breakingPointGap * mediumSuccessPercentage)) {
                    minYardRange = mediumSuccessDefenseRange.maximumPoint;
                    maxYardRange = -100;
                    dun = true;
                }
                if (!dun && result > breakingPoint + (breakingPointGap * smallSuccessPercentage)) {
                    minYardRange = mediumSuccessDefenseRange.maximumPoint;
                    maxYardRange = shortSuccessDefenseRange.maximumPoint;
                    dun = true;
                }
                if (!dun) {
                    minYardRange = shortSuccessDefenseRange.maximumPoint;
                    maxYardRange = shortSuccessDefenseRange.minimumPoint;
                }
            }
        }
        final int rangeModifier = 100;
        final int bound = (((maxYardRange - minYardRange) + rangeModifier) + minYardRange) - rangeModifier;
        mResults.setYardsGainedOnPlay(bound == 0 ? 0 :
                new Random().nextInt(Math.abs(bound)) * (bound < 0 ? -1 : 1));
        hasBeenSimulated = true;
    }

    public int breakingPoint() {
        return Math.abs(offenseSuccess) - Math.abs(breakingPoint);
    }

    final boolean isTouchdown() {
        return mResults.getTouchdownStatus();
    }

    final int resultStatus() {
        return mResults.getFinalResult();
    }

    final int getYardsGained() {
        return mResults.getYardsGained();
    }

    final void reset() {
        mResults = new PlayResults();
        hasBeenSimulated = false;
    }

    private class Range {
        private final int minimumPoint;
        private final int maximumPoint;

        private Range(final int minPoint, final int maxPoint) {
            minimumPoint = minPoint;
            maximumPoint = maxPoint;
        }
    }

    final class PlayResults {
        private boolean wasTouchdown = false;
        private int finalResult = 0;
        private int yardsGainedOnPlay = 0;

        PlayResults() {
        }

        private final PlayResults setTouchdownStatus(final boolean isTouchdown) {
            wasTouchdown = isTouchdown;
            return this;
        }

        private final PlayResults setFinalResult(final int result) {
            finalResult = result;
            return this;
        }

        private final PlayResults setYardsGainedOnPlay(final int yardsGained) {
            yardsGainedOnPlay = yardsGained;
            return this;
        }

        public final boolean getTouchdownStatus() {
            return wasTouchdown;
        }

        public final int getFinalResult() {
            return finalResult;
        }

        public final int getYardsGained() {
            return yardsGainedOnPlay;
        }
    }
}