////This file was auto-generated via compilation from TypeScript.
////Any changes that you make will be overwritten when the file is recompiled.
////If you need to change this code, please make changes in the parent TypeScript file.


//@ts-nocheck
function MoreOrLess_prog(stage, exportRoot) {
    var gameFrame, gameStage, background;
    // Game Data
    GameFrame.TEST = false;
    var PREK = 4;
    var K2 = 0;
    var WHOLE_NUMBERS = 1;
    var DECIMALS = 2;
    var FRACTIONS = 3;
    var gameFlag = 0;
    var currentValue = 0;
    var mistakesCount = 0;
    var currentOrb;
    var losingOrb;
    var minValue = null;
    var maxValue = null;
    var usedNumbers = [];
    var slideCount = 0;
    // game variant specific
    var numbersAsSymbols = 0; //0 = no, 1=yes, 2=mixed
    var allowNegative = false;
    var decimalsPrecision = 1;
    var plusOneHalf = false;
    var maxNumerator = 0;
    var denominators = [];
    var orbEnterMs = 3000;
    var orbStallMs = 500;
    var orbExitMs = 4000;
    var dragArrow = null;
    var dragTarget = null;
    var dragStartX = -1;
    var numberLineOrbs = [];
    var orbs = [];
    var buttonCount = 10;
    var numberLineButtons = [];
    var bonusSchedule = [[1, 0, 0], [2, 1, .5], [1.5, .5, 0], [1.5, .5, 0], [1, 0, 0]];
    var scoreIncrement = [60, 60, 60, 60, 90];
    var mistakeTimer = new Timer(1000, tick);
    var NUMBER_LINE_X_START = 112;
    var NUMBER_LINE_X_SPACING = 64;
    var blnButtonsEnabled = false;
    var gameIndex;
    this.run = function () {
        gameFrame = exportRoot.gameFrame;
        gameStage = exportRoot.gameStage;
        background = exportRoot.background;
        gameFrame.init(stage);
        MoreOrLess();
    };
    function MoreOrLess() {
        gameFrame.moduleId = UIUtil.getParamAsInt("moduleId", 137);
        if (GameFrame.TEST) {
            gameFrame.setGameData({ round: 2, game: 12, loginId: 1 });
            gameFrame.scoreMax = 360;
            gameFlag = PREK;
            gameFrame.mute();
        }
        //This is needed to translate ModuleId/ModuleVariant into gameFlag.
        if (gameFrame.moduleId == 137) {
            gameFlag = K2;
        }
        else if (gameFrame.moduleId == 241) {
            gameFlag = PREK;
        }
        else if (gameFrame.moduleId == 94) {
            gameFlag = WHOLE_NUMBERS;
        }
        else if (gameFrame.moduleId == 106) {
            gameFlag = DECIMALS;
        }
        else if (gameFrame.moduleId == 111) {
            gameFlag = FRACTIONS;
        }
        UIUtil.hide(gameStage);
        initInterface();
        initAnimation();
        gameFrame.initGame(startGame, stopGame);
    }
    function startGame() {
        loadSounds();
        killAllOrbs();
        UIUtil.show(gameStage, 500);
        ArrayUtil.fill(numberLineOrbs, null, buttonCount);
        gameFrame.incrementBonus(-1 * gameFrame.bonus);
        UIUtil.delay(newSequence, 500);
    }
    function stopGame() {
        //TestUtil.log("stopGame() called...");
        //LoadUtil.stopLoop();	
        stopTimer();
        UIUtil.hide(gameStage, 500);
        UIUtil.cancelAllDelays();
        killAllOrbs();
        ArrayUtil.fill(numberLineOrbs, null, buttonCount);
    }
    function newSequence() {
        //TestUtil.log("newSequence");
        LoadUtil.playSound("start");
        setupLevel();
        updateInterface();
        slideCount = 0;
        gameStage.slideText.text = slideCount;
        usedNumbers = [];
        newNumber();
    }
    function newNumber() {
        //TestUtil.log("newNumber");
        var value;
        do {
            switch (gameFlag) {
                case DECIMALS:
                    value = Chance.randomInt(minValue * decimalsPrecision + 1, maxValue * decimalsPrecision - 1) * (1.0 / decimalsPrecision);
                    break;
                case FRACTIONS:
                    var wholeComponent, numerator, denominator;
                    var maxDenominator = denominators[denominators.length - 1];
                    denominator = Chance.selectRandom(denominators);
                    if (maxNumerator == 0 && denominator != maxDenominator) {
                        wholeComponent = Chance.randomInt(minValue, Calculator.ceil(maxValue - 1));
                        numerator = Chance.randomInt(1, denominator - 1);
                    }
                    else {
                        wholeComponent = 0;
                        numerator = Chance.randomInt(1, maxNumerator == 0 ? denominator - 1 : maxNumerator);
                    }
                    if (denominator == 64) {
                        wholeComponent = 0;
                    }
                    value = [wholeComponent * denominator + numerator, denominator];
                    break;
                default:
                    value = Chance.randomInt(minValue + 1, maxValue - 1);
            }
        } while (ArrayUtil.contains(usedNumbers, Calculator.asDecimal(value)) || Calculator.asDecimal(value) <= minValue || Calculator.asDecimal(value) >= maxValue);
        newOrb(value);
        //TestUtil.log("new Orb created->" + value.toString());
    }
    function checkNumber(index) {
        //TestUtil.log("checkNumber");		
        var currentMax = Calculator.asDecimal(minValue);
        var incorrect = false;
        var full = true;
        for (var i = 0; i < buttonCount; i++) {
            if (i == index || numberLineOrbs[i] != null) {
                var val = Calculator.asDecimal((i == index) ? currentOrb.value : numberLineOrbs[i].value);
                if (val < currentMax) {
                    incorrect = true;
                    break;
                }
                else {
                    currentMax = val;
                }
            }
            else {
                full = false;
            }
        }
        if (incorrect) {
            onIncorrectAnswer();
        }
        else {
            numberLineOrbs[index] = currentOrb;
            usedNumbers.push(Calculator.asDecimal(currentOrb.value));
            if (full) {
                onCorrectAnswer();
            }
            else {
                makeOrbSlideable(currentOrb);
                newNumber();
            }
        }
    }
    function onCorrectAnswer() {
        //currentOrb = null;
        //TestUtil.log("onCorrectAnswer");
        LoadUtil.playSound("correct");
        clearNumberLine();
        gameFrame.incrementScore(scoreIncrement[gameFlag]);
        if (Number(gameFrame.bonus) < 12) {
            if (slideCount == 0)
                gameFrame.incrementBonus(bonusSchedule[gameFlag][0]);
            else if (slideCount == 1)
                gameFrame.incrementBonus(bonusSchedule[gameFlag][1]);
            else if (slideCount == 2)
                gameFrame.incrementBonus(bonusSchedule[gameFlag][2]);
        }
        if (Number(gameFrame.bonus) > 12) {
            gameFrame.bonus = 12;
            gameFrame.scoreboard.updateBonus(12);
        }
        if (gameFrame.finished()) {
            endGame();
        }
        else {
            UIUtil.delay(newSequence, 2000);
        }
    }
    function clearNumberLine() {
        //TestUtil.log("clearNumberLine");
        stopTimer();
        currentOrb = null;
        for (var i = 0; i < buttonCount; i++) {
            //for (var i in numberLineOrbs){
            var orb = numberLineOrbs[i];
            //TestUtil.log("clearOrb:"+orb.name)
            if (orb != null) {
                orbDrop(orb);
            }
            ;
            //}
            //numberLineOrbs[i] = null;
        }
        ArrayUtil.fill(numberLineOrbs, null, buttonCount);
    }
    function onIncorrectAnswer() {
        //TestUtil.log("onIncorrectAnswer");
        losingOrb = currentOrb;
        animateIncorrect(currentOrb);
        onMistake();
    }
    function onMistake() {
        //TestUtil.log("onMistake " + losingOrb.name);
        var nevermind = 0;
        if ((losingOrb != undefined) && (losingOrb != null)) {
            for (var i in numberLineOrbs) {
                if (losingOrb == numberLineOrbs[i]) {
                    nevermind = 1;
                }
            }
        }
        if (nevermind == 0) {
            //TestUtil.log("onMistake-->YES");
            currentOrb = null;
            mistakesCount++;
            if (gameFrame.score >= 30 || GameFrame.TEST) {
                //TestUtil.log("mistakeTimer.isrunning()->" + mistakeTimer.isRunning().toString());
                //if ( mistakeTimer.isRunning() ) {
                //	LoadUtil.playSound("lose");
                //	stopTimer();
                //	endGame();
                //	} else {
                //if ( gameFlag > K2 ) {
                //LoadUtil.playSound("thunder");
                //startTimer();
                //}
                //else {
                if (gameFlag != K2 && gameFlag != PREK) {
                    gameFrame.incrementScore(-30);
                }
                LoadUtil.playSound("incorrect");
                //}
                UIUtil.delay(newNumber, 1000);
                //}
            }
            else {
                LoadUtil.playSound("incorrect");
                UIUtil.delay(newNumber, 1000);
            }
        }
    }
    function slideNumbers(index, direction) {
        //TestUtil.log("slideNumbers...direction->" + direction.toString());
        return slideNumber(index, direction);
    }
    function slideNumber(index, direction) {
        //TestUtil.log("slideNumber");
        //TestUtil.log("index->" + index.toString() + "direction->" + direction.toString() + ",..." + numberLineOrbs.length.toString());
        if (index + direction < 0 || index + direction >= numberLineOrbs.length) {
            return false;
        }
        else {
            if (numberLineOrbs[index + direction] == null || slideNumber(index + direction, direction)) {
                numberLineOrbs[index + direction] = numberLineOrbs[index];
                numberLineOrbs[index] = null;
                return true;
            }
            else {
                return false;
            }
        }
    }
    function endGame() {
        //TestUtil.log("endGame");
        gameFrame.endGame();
    }
    function startTimer() {
        //TestUtil.log("startTimer");
        mistakeTimer.setTimeout(stopTimer, 20);
        mistakeTimer.start();
        gameStage.mistakeTimer.timerText.text = "" + mistakeTimer.remainingTicks();
        UIUtil.show(gameStage.mistakeTimer, 1000);
        UIUtil.show(gameStage.warningVeil, 2000);
    }
    function stopTimer() {
        //TestUtil.log("stopTimer");
        if (mistakeTimer) {
            mistakeTimer.stop();
        }
        if (gameStage.mistakeTimer) {
            UIUtil.hide(gameStage.mistakeTimer, 1000);
        }
        UIUtil.hide(gameStage.warningVeil, 2000);
    }
    function tick() {
        var remainingTicks = mistakeTimer.remainingTicks();
        if (gameFlag > WHOLE_NUMBERS && gameFlag != PREK) {
            if (remainingTicks == 8)
                LoadUtil.playSound("wind-long");
        }
        if (gameFlag > K2 && (remainingTicks == 7 || remainingTicks == 4))
            LoadUtil.playSound("thunder-small");
        gameStage.mistakeTimer.timerText.text = "" + remainingTicks;
    }
    /* Loading */
    function loadSounds() {
        //TestUtil.log("loadSounds");
        if (gameFlag == PREK) {
            gameFrame.setBackgroundLoop("pk-mol.mp3");
        }
        else {
            gameFrame.setBackgroundLoop("numbers-on-the-line.mp3");
        }
        gameFrame.loadSound("start.mp3", "start");
        gameFrame.loadSound("whoosh.mp3", "click");
        gameFrame.loadSound("slide.mp3", "slide");
        gameFrame.loadSound("energy-whoosh.mp3", "correct");
        gameFrame.loadSound("win.mp3", "win");
        gameFrame.loadSound("sorry-whistle.mp3", "incorrect");
        gameFrame.loadSound("thunder.mp3", "thunder");
        gameFrame.loadSound("thunder-small.mp3", "thunder-small");
        gameFrame.loadSound("wind-gust1.mp3", "wind1");
        gameFrame.loadSound("wind-gust2.mp3", "wind2");
        gameFrame.loadSound("wind-gust-long.mp3", "wind-long");
        gameFrame.loadSound("lose.mp3", "lose");
        if (gameFlag > WHOLE_NUMBERS && gameFlag != PREK)
            ambientNoise();
    }
    function ambientNoise() {
        //TestUtil.log("ambientNoise");
        LoadUtil.playSoundAtVolume("wind" + Chance.semiRandomInt(1, 2, "wind"), mistakeTimer.isRunning() ? .15 * gameFrame.round : .05 * gameFrame.round);
        UIUtil.setTimeout(ambientNoise, Chance.randomInt(1500, 6000));
    }
    /* Interface */
    function initInterface() {
        //TestUtil.log("initInterface");
        switch (gameFlag) {
            case FRACTIONS:
            case DECIMALS:
                buttonCount = 7;
                break;
            case K2:
                buttonCount = 5;
                break;
            case PREK:
                buttonCount = 3;
                UIUtil.setFrame(gameStage, 2);
                break;
            default:
                buttonCount = 10;
        }
        if (gameFlag != PREK) {
            UIUtil.setFrame(background, gameFlag + 1);
        }
        else {
            UIUtil.setFrame(background, 1);
        }
        for (var i = 0; i < buttonCount; i++) {
            var btn = UIUtil.createNew("NumberLineButton");
            btn.x = (640 / buttonCount) * (i + (10 - buttonCount) / 20);
            if (gameFlag != PREK) {
                UIUtil.scaleTo(btn, 10 / buttonCount);
            }
            else {
                UIUtil.scaleTo(btn, 7.8 / buttonCount);
            }
            gameStage.numberLine.addChild(btn);
            btn.name = "xx" + i.toString();
            UIUtil.createSimpleButton(btn, onNumberLineClick, i);
            UIUtil.disable(btn);
            numberLineButtons[i] = btn;
        }
        ArrayUtil.fill(numberLineOrbs, null, buttonCount);
        dragArrow = UIUtil.createNew("DragArrow");
        gameStage.foreground.addChild(dragArrow);
        UIUtil.hide(dragArrow);
        UIUtil.onMouseMove(stage, null, onMouseMoved, null);
        UIUtil.onMouseDownAndUp(stage, null, onOrbDrop);
        updateInterface();
    }
    function updateInterface() {
        //TestUtil.log("updateInterface");
        gameStage.numberLine.minOrb.incorrectX.alpha = 0.0;
        gameStage.numberLine.maxOrb.incorrectX.alpha = 0.0;
        gameStage.numberLine.minOrb.valueText.displayValue(minValue);
        plusOneHalf ? gameStage.numberLine.maxOrb.valueText.displayValue([3, 2]) : gameStage.numberLine.maxOrb.valueText.displayValue(maxValue);
        //gameStage.numberLine.maxOrb.valueText.displayValue(maxValue);
    }
    function updateOrbPositions() {
        //TestUtil.log("updateOrbPositions");
        for (var i = 0; i < numberLineOrbs.length; i++) {
            var orb = numberLineOrbs[i];
            if (orb != null) {
                var btn = numberLineButtons[i];
                var x = gameStage.numberLine.x + btn.x;
                var y = gameStage.numberLine.y + btn.y;
                UIUtil.tweenTo(orb, x, y, btn.scaleX, 1.0, 300);
            }
        }
        enableButtons();
    }
    function disableNumberButtons() {
        for (var i in numberLineButtons) {
            UIUtil.disable(numberLineButtons[i]);
        }
    }
    function disableButtons() {
        //gameStage.stat.text = "disabled";
        blnButtonsEnabled = false;
        disableNumberButtons();
    }
    function enableButtons() {
        //TestUtil.log("enableButtons");
        blnButtonsEnabled = true;
        //	gameStage.stat.text = "enabled";
        for (var i in numberLineButtons) {
            UIUtil.enable(numberLineButtons[i]);
        }
    }
    function onNumberLineClick(e) {
        //TestUtil.log("onNumberLineClick");
        if (currentOrb) {
            disableButtons();
            LoadUtil.playSound("click");
            if (dragTarget == null) {
                var ms = 300;
                var btn = UIUtil.getEventTarget(e);
                var x = gameStage.numberLine.x + btn.x;
                var y = gameStage.numberLine.y + btn.y;
                UIUtil.cancelAllDelays();
                UIUtil.removeObjectTweens(currentOrb);
                //TestUtil.log("onNumberLineClick...currentOrb > " + currentOrb.value.toString());
                UIUtil.tweenTo(currentOrb, x, y, btn.scaleX, 1.0, ms, "easeOut");
                UIUtil.delay(checkNumber, ms, [btn.value]);
            }
        }
    }
    function makeOrbSlideable(orb) {
        //TestUtil.log("makeOrbSlideable");
        UIUtil.onMouseDownAndUp(orb, onOrbDrag, onOrbDrop);
    }
    function onOrbDrag(e) {
        //TestUtil.log("onOrbDrag");
        if (blnButtonsEnabled) {
            disableButtons();
            dragTarget = UIUtil.getEventTarget(e);
            dragStartX = e.stageX;
        }
    }
    function doNull(e) {
        //TestUtil.log("null function");	
    }
    function onMouseMoved(e) {
        //TestUtil.log("onMouseMovedxx");
        if (dragTarget) {
            //TestUtil.log("foundTarget");
            var dir = getArrowDirection(e);
            //TestUtil.log("dir->" + dir.toString());
            if (dir != 0) {
                UIUtil.show(dragArrow);
                dragArrow.x = dragTarget.x;
                dragArrow.y = dragTarget.y - 80;
                dragArrow.scaleX = dir;
            }
            else {
                UIUtil.hide(dragArrow);
            }
        }
    }
    function onOrbDrop(e) {
        //TestUtil.log("onOrbDrop");
        disableButtons();
        if (dragTarget) {
            var dir = getArrowDirection(e);
            //TestUtil.log("inOnDrop logic...dir-->" + dir.toString());
            if (dir != 0 && slideNumbers(numberLineOrbs.indexOf(dragTarget), dir)) {
                //TestUtil.log("should move");
                slideCount++;
                gameStage.slideText.text = slideCount;
                LoadUtil.playSound("slide");
                updateOrbPositions();
            }
            UIUtil.hide(dragArrow);
            dragTarget = null;
        }
        UIUtil.delay(enableButtons, 440);
    }
    function getArrowDirection(e) {
        //TestUtil.log("getArrowDirection");
        if (dragTarget != null) {
            var mouseX = e.stageX;
            if (mouseX - dragStartX > NUMBER_LINE_X_SPACING / 2) {
                return 1; // right
            }
            else if (dragStartX - mouseX > NUMBER_LINE_X_SPACING / 2) {
                return -1; // left
            }
            else {
                return 0;
            }
        }
        else {
            return 0;
        }
    }
    function getOrbX(index) {
        //TestUtil.log("getOrbX");
        return NUMBER_LINE_X_START + NUMBER_LINE_X_SPACING * index;
    }
    function newOrb(value) {
        //TestUtil.log("newOrb");
        UIUtil.delay(addCloud, Chance.randomInt(100, 1200));
        currentOrb = UIUtil.createNew("Orb");
        orbs.push(currentOrb);
        /* This just reduces the chances of two similar colors being
            next to one another on the number line */
        if (gameFlag == FRACTIONS) {
            UIUtil.setFrame(currentOrb, Chance.randomInt(2, 14));
        }
        else {
            switch (value * decimalsPrecision % 4) {
                case 0:
                    UIUtil.setFrame(currentOrb, Chance.randomInt(2, 4));
                    break;
                case 1:
                    UIUtil.setFrame(currentOrb, Chance.randomInt(5, 8));
                    break;
                case 2:
                    UIUtil.setFrame(currentOrb, Chance.randomInt(9, 11));
                    break;
                default:
                    UIUtil.setFrame(currentOrb, Chance.randomInt(12, 14));
            }
        }
        var targetX = Chance.randomInt(200, 500);
        var targetY = Chance.randomInt(100, 200 + 10 * buttonCount);
        var shiftX = -orbStallMs / Chance.randomInt(30, 60);
        var shiftY = Chance.randomInt(-10, 10);
        currentOrb.x = -100;
        currentOrb.y = targetY - shiftY * 5;
        currentOrb.alpha = 0.0;
        currentOrb.incorrectX.alpha = 0.0;
        currentOrb.value = value;
        if (numbersAsSymbols == 0) {
            if (decimalsPrecision == 1000)
                currentOrb.valueText.precision = 3;
            currentOrb.valueText.displayValue(value);
        }
        else if (numbersAsSymbols == 1) {
            UIUtil.setFrame(currentOrb.dots, value + 1);
            currentOrb.dots.rotation = 45 * Chance.randomInt(0, 7);
        }
        else {
            if (Chance.trueOrFalse()) {
                currentOrb.valueText.displayValue(value);
            }
            else {
                UIUtil.setFrame(currentOrb.dots, value + 1);
                currentOrb.dots.rotation = 45 * Chance.randomInt(0, 7);
            }
        }
        UIUtil.tweenTo(currentOrb, targetX, targetY, 2.5, 1.0, orbEnterMs);
        gameStage.foreground.addChild(currentOrb);
        UIUtil.delay(UIUtil.tweenTo, orbEnterMs, [currentOrb, targetX + shiftX, targetY + shiftY, 2.5, 1.0, orbStallMs]);
        UIUtil.delay(orbFlyAway, orbEnterMs + orbStallMs, [currentOrb]);
        UIUtil.delay(enableButtons, orbEnterMs / 3);
    }
    function orbFlyAway(orb) {
        //TestUtil.log("orbFlyAway");
        losingOrb = currentOrb;
        if (orb) {
            UIUtil.removeObjectTweens(orb);
            UIUtil.tweenTo(orb, 900, orb.y, 1.0, 0.0, orbExitMs * 2);
            UIUtil.delay(killOrb, orbExitMs * 2, [orb]);
        }
        UIUtil.delay(disableNumberButtons, (orbExitMs * 1.6));
        UIUtil.delay(onMistake, orbExitMs * 2);
    }
    function orbDrop(orb) {
        //TestUtil.log("orbDrop");
        if (orb != null) {
            UIUtil.removeObjectTweens(orb);
            UIUtil.tweenTo(orb, orb.x, -100, 1.0, 0.0, 1000);
            UIUtil.delay(killOrb, 2000, [orb]);
        }
    }
    function killOrb(orb) {
        //TestUtil.log("killOrb");
        try {
            gameStage.foreground.removeChild(orb);
        }
        catch (e) { }
        ArrayUtil.remove(orbs, orb);
    }
    function killAllOrbs() {
        //TestUtil.log("killAllOrbs");
        for (var i in orbs) {
            try {
                gameStage.foreground.removeChild(orbs[i]);
            }
            catch (e) { }
        }
        orbs = [];
    }
    /* Animation */
    function initAnimation() {
        //TestUtil.log("initAnimation");
        UIUtil.hide(gameStage.warningVeil);
        UIUtil.hide(gameStage.mistakeTimer);
        UIUtil.clearInterval(addCloud);
        UIUtil.delay(addCloud, 900);
    }
    function animateIncorrect(orb) {
        //TestUtil.log("animateIncorrect");
        UIUtil.pulse(orb.incorrectX, 1000);
        UIUtil.delay(dropOrb, 1000, [orb]);
    }
    function dropOrb(orb) {
        //TestUtil.log("dropOrb");
        if (orb) {
            UIUtil.removeObjectTweens(orb);
            UIUtil.tween(orb, "y", 900, 1000, "easeIn", killOrb, [orb]);
        }
    }
    function addCloud() {
        var cloud = UIUtil.createNew("Cloud");
        UIUtil.setFrame(cloud, Chance.randomInt(1, 4));
        var closeness = Chance.randomNumber();
        cloud.alpha = closeness * .3 + .1;
        cloud.y = 50 + closeness * 450;
        UIUtil.scaleTo(cloud, 1.0 + 2 * closeness);
        cloud.x = -400;
        var blur = Chance.randomInt(50, 100 - closeness * 50);
        cloud.filters = [new createjs.BlurFilter(blur, blur)]; //TODO: OK I think
        var ms = 7500 - closeness * 5000;
        background.cloudCanvas.addChild(cloud);
        UIUtil.tween(cloud, "x", 1200, ms * 3, "linear", removeCloud, [cloud]);
    }
    function removeCloud(cloud) {
        background.cloudCanvas.removeChild(cloud);
    }
    /* Setup Level */
    function setupLevel() {
        //TestUtil.log("setupLevel");
        if (gameFrame.game <= 5) {
            gameIndex = 0;
        }
        else if (gameFrame.game <= 10) {
            gameIndex = 1;
        }
        else {
            gameIndex = 2;
        }
        if (gameFlag == K2) {
            setupK2();
        }
        else if (gameFlag == PREK) {
            setupPreK();
        }
        else {
            var level = gameFrame.getLevel();
            if (gameFrame.round == 1) {
                //orbEnterMs = 3100 - level * 100;
                orbStallMs = 415 - level * 15;
                orbEnterMs = 4100 - level * 100;
            }
            else if (gameFrame.round == 2) {
                //orbEnterMs = 2800 - level * 100;
                orbStallMs = 375 - level * 15;
                orbEnterMs = 2800 - level * 100;
            }
            else if (gameFrame.round == 3) {
                //orbEnterMs = 2400 - level * 100;
                orbStallMs = 335 - level * 15;
                orbEnterMs = 3400 - level * 100;
            }
            else if (gameFrame.round == 4) {
                //orbEnterMs = 1900 - level * 100;
                orbStallMs = 295 - level * 15;
                orbEnterMs = 2900 - level * 100;
            }
            orbStallMs *= 6;
            switch (gameFlag) {
                case DECIMALS:
                    setupDecimals(level);
                    break;
                case FRACTIONS:
                    setupFractions(level);
                    break;
                case K2:
                    break;
                case PREK:
                    break;
                default: setupWholeNumbers(level);
            }
        }
    }
    function setupPreK() {
        //TestUtil.log("setupPREK");
        var stallCyclesBase = 60;
        var intRiseSecondsBase = 2;
        var intSlideSecondsBase = 4;
        var gameTier = Math.floor(gameFrame.game / 5);
        if (gameFrame.round == 1) {
            orbEnterMs = 2000;
            orbStallMs = 2400;
            orbExitMs = 4000 - 100 * gameTier;
        }
        else if (gameFrame.round == 2) {
            orbEnterMs = 2000;
            orbStallMs = 2200;
            orbExitMs = 4000 - 100 * (gameTier + 3);
        }
        else if (gameFrame.round == 3) {
            orbEnterMs = 1900;
            orbStallMs = 2000;
            orbExitMs = 4000 - 100 * (gameTier + 7);
        }
        else if (gameFrame.round == 4) {
            orbEnterMs = 1800;
            orbStallMs = 1600;
            orbExitMs = 4000 - 100 * (gameTier + 12);
        }
        orbStallMs *= 4.2;
        minValue = 0;
        numbersAsSymbols = 1;
        if (gameIndex == 0) {
            maxValue = 7;
        }
        else if (gameIndex == 1) {
            maxValue = 9;
        }
        else {
            maxValue = 11;
        }
        if (gameFrame.round == 2) {
            numbersAsSymbols = 2;
        }
        else if (gameFrame.round == 3) {
            numbersAsSymbols = 0;
        }
        else if (gameFrame.round == 4) {
            //TestUtil.log("round 4");
            numbersAsSymbols = 0;
            if (gameIndex == 0) {
                maxValue = 13;
            }
            else if (gameIndex == 1) {
                maxValue = 17;
            }
            else {
                maxValue = 21;
            }
        }
    }
    function setupK2() {
        //TestUtil.log("setupK2");
        var stallCyclesBase = 60;
        var intRiseSecondsBase = 2;
        var intSlideSecondsBase = 4;
        var gameTier = Math.floor(gameFrame.game / 5);
        if (gameFrame.round == 1) {
            orbEnterMs = 2000;
            orbStallMs = 2400;
            orbExitMs = 4000 - 100 * gameTier;
        }
        else if (gameFrame.round == 2) {
            orbEnterMs = 2000;
            orbStallMs = 2200;
            orbExitMs = 4000 - 100 * (gameTier + 3);
        }
        else if (gameFrame.round == 3) {
            orbEnterMs = 1900;
            orbStallMs = 2000;
            orbExitMs = 4000 - 100 * (gameTier + 7);
        }
        else if (gameFrame.round == 4) {
            orbEnterMs = 1800;
            orbStallMs = 1600;
            orbExitMs = 4000 - 100 * (gameTier + 12);
        }
        orbStallMs *= 3;
        if (gameFrame.round == 1) {
            numbersAsSymbols = 1;
            if (gameFrame.game <= 5) {
                minValue = 0;
                maxValue = 6;
            }
            else if (gameFrame.game <= 10) {
                minValue = 0;
                maxValue = 8;
            }
            else {
                minValue = 0;
                maxValue = 10;
            }
        }
        else if (gameFrame.round == 2 || gameFrame.round == 3) {
            numbersAsSymbols = gameFrame.round == 2 ? 2 : 0;
            if (gameFrame.game <= 5) {
                minValue = 0;
                maxValue = 6;
            }
            else if (gameFrame.game <= 10) {
                minValue = 0;
                maxValue = 8;
            }
            else {
                minValue = 0;
                maxValue = 10;
            }
        }
        else {
            numbersAsSymbols = 0;
            if (gameFrame.game <= 5) {
                minValue = 0;
                maxValue = 12;
            }
            else if (gameFrame.game <= 10) {
                minValue = 0;
                maxValue = 16;
            }
            else {
                minValue = 0;
                maxValue = 20;
            }
        }
    }
    function setupWholeNumbers(level) {
        //TestUtil.log("setupWholeNumbers");
        if (gameFrame.round == 1) {
            switch (level) {
                case 1:
                    minValue = 1;
                    maxValue = 13;
                    break;
                case 2:
                    minValue = 1;
                    maxValue = 15;
                    break;
                case 3:
                    minValue = 2;
                    maxValue = 18;
                    break;
                case 4:
                    minValue = 2;
                    maxValue = 20;
                    break;
                case 5:
                    minValue = 3;
                    maxValue = 23;
                    break;
                case 6:
                    minValue = 3;
                    maxValue = 25;
                    break;
            }
        }
        else if (gameFrame.round == 2) {
            switch (level) {
                case 1:
                    minValue = 31;
                    maxValue = 45;
                    break;
                case 2:
                    minValue = 32;
                    maxValue = 49;
                    break;
                case 3:
                    minValue = 33;
                    maxValue = 53;
                    break;
                case 4:
                    minValue = 34;
                    maxValue = 57;
                    break;
                case 5:
                    minValue = 35;
                    maxValue = 61;
                    break;
                case 6:
                    minValue = 36;
                    maxValue = 65;
                    break;
            }
        }
        else if (gameFrame.round == 3) {
            switch (level) {
                case 1:
                    minValue = 101;
                    maxValue = 117;
                    break;
                case 2:
                    minValue = 111;
                    maxValue = 131;
                    break;
                case 3:
                    minValue = 121;
                    maxValue = 145;
                    break;
                case 4:
                    minValue = 131;
                    maxValue = 159;
                    break;
                case 5:
                    minValue = 141;
                    maxValue = 173;
                    break;
                case 6:
                    minValue = 151;
                    maxValue = 187;
                    break;
            }
        }
        else if (gameFrame.round == 4) {
            switch (level) {
                case 1:
                    minValue = 301;
                    maxValue = 319;
                    break;
                case 2:
                    minValue = 351;
                    maxValue = 374;
                    break;
                case 3:
                    minValue = 401;
                    maxValue = 429;
                    break;
                case 4:
                    minValue = 451;
                    maxValue = 484;
                    break;
                case 5:
                    minValue = 501;
                    maxValue = 539;
                    break;
                case 6:
                    minValue = 551;
                    maxValue = 594;
                    break;
            }
        }
    }
    function setupDecimals(level) {
        //TestUtil.log("setupDecimals");
        minValue = 0;
        decimalsPrecision = (gameFrame.round <= 2) ? 10 : (gameFrame.round == 3) ? 100 : 1000;
        if (gameFrame.round == 2) {
            switch (level) {
                case 1:
                    maxValue = 5.0;
                    break;
                case 2:
                    maxValue = 10.0;
                    break;
                case 3:
                    maxValue = 15.0;
                    break;
                case 4:
                    maxValue = 20.0;
                    break;
                case 5:
                    maxValue = 25.0;
                    break;
                case 6:
                    maxValue = 30.0;
                    break;
            }
        }
        else if (gameFrame.round == 3) {
            switch (level) {
                case 1:
                    maxValue = 1.0;
                    break;
                case 2:
                    maxValue = 1.2;
                    break;
                case 3:
                    maxValue = 1.4;
                    break;
                case 4:
                    maxValue = 1.6;
                    break;
                case 5:
                    maxValue = 1.8;
                    break;
                case 6:
                    maxValue = 2.0;
                    break;
            }
        }
        else {
            switch (level) {
                case 1:
                    maxValue = 1.0;
                    break;
                case 2:
                    maxValue = 1.2;
                    break;
                case 3:
                    maxValue = 1.4;
                    break;
                case 4:
                    maxValue = 1.6;
                    break;
                case 5:
                    maxValue = 1.8;
                    break;
                case 6:
                    maxValue = 2.0;
                    break;
            }
        }
    }
    function setupFractions(level) {
        //TestUtil.log("setupFractions");
        var possibleDenominators = [
            [2, 4, 8],
            [2, 4, 8, 16],
            [2, 3, 4, 8, 16],
            [2, 3, 4, 6, 8, 9, 12, 16],
            [2, 4, 8, 16, 32],
            [2, 4, 8, 16, 32, 64],
            [2, 3, 4, 6, 8, 9, 12, 16, 32],
            [2, 3, 4, 6, 8, 9, 12, 16, 32, 64],
            [2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 16, 32, 64]
        ];
        minValue = 0;
        maxValue = 1;
        maxNumerator = 0;
        denominators = possibleDenominators[1];
        plusOneHalf = false;
        if (gameFrame.round == 1) {
            switch (level) {
                case 1:
                    denominators = possibleDenominators[0];
                    maxNumerator = 0;
                    break;
                case 2:
                    maxNumerator = 3;
                    break;
                case 3:
                    maxNumerator = 6;
                    break;
                case 4:
                    maxNumerator = 9;
                    break;
                case 5:
                    maxNumerator = 12;
                    break;
                case 6:
                    maxNumerator = 0;
                    break;
            }
        }
        else if (gameFrame.round == 2) {
            switch (level) {
                case 1:
                    plusOneHalf = true;
                    maxNumerator = 4;
                    break;
                case 2:
                    plusOneHalf = true;
                    maxNumerator = 8;
                    break;
                case 3:
                    plusOneHalf = true;
                    maxNumerator = 12;
                    break;
                case 4:
                    maxValue = 2;
                    maxNumerator = 0;
                    break;
                case 5:
                    maxValue = 2;
                    maxNumerator = 0;
                    break;
                case 6:
                    maxValue = 2;
                    maxNumerator = 0;
                    break;
            }
        }
        else if (gameFrame.round == 3) {
            switch (level) {
                case 1:
                    plusOneHalf = true;
                    denominators = possibleDenominators[2];
                    break;
                case 2:
                    plusOneHalf = true;
                    denominators = possibleDenominators[2];
                    break;
                case 3:
                    plusOneHalf = true;
                    denominators = possibleDenominators[2];
                    break;
                case 4:
                    maxValue = 2;
                    denominators = possibleDenominators[3];
                    break;
                case 5:
                    maxValue = 2;
                    denominators = possibleDenominators[3];
                    break;
                case 6:
                    maxValue = 2;
                    denominators = possibleDenominators[3];
                    break;
            }
        }
        else if (gameFrame.round == 4) {
            orbEnterMs = 6000;
            orbStallMs = 1000;
            orbExitMs = 8000;
            switch (level) {
                case 1:
                    maxValue = 1;
                    denominators = possibleDenominators[4];
                    break;
                case 2:
                    maxValue = 1;
                    denominators = possibleDenominators[5];
                    plusOneHalf = true;
                    break;
                case 3:
                    maxValue = 2;
                    denominators = possibleDenominators[6];
                    break;
                case 4:
                    maxValue = 3;
                    denominators = possibleDenominators[7];
                    break;
                case 5:
                    maxValue = 4;
                    denominators = possibleDenominators[8];
                    break;
                case 6:
                    maxValue = 5;
                    denominators = possibleDenominators[8];
                    break;
            }
        }
        if (plusOneHalf)
            maxValue += 0.5;
    }
}