define("wildFurySlotModelGleGamePlugin", ["clientkernelLoaderApi", "slotModelApi", "slotmodelGamePluginCommonGle", "money", "clientkernelEventbusApi", "clientkernelModulesApi", "tools", "wildFuryPluginApi", "slotmodelGamePluginApi", "clientkernelLoggerApi"],
    function(clientkernelLoaderApi, slotModelApi, slotmodelGamePluginCommonGle, money, clientkernelEventbusApi, clientkernelModulesApi, tools, wildFuryPluginApi, slotmodelGamePluginApi, clientkernelLoggerApi) {
        "use strict";

        function $iterator(o) {
            if (o instanceof Array) return function() {
                return {
                    cur: 0,
                    arr: o,
                    hasNext: function() {
                        return this.cur < this.arr.length;
                    },
                    next: function() {
                        return this.arr[this.cur++];
                    }
                };
            };
            return typeof(o.iterator) == 'function' ? $bind(o, o.iterator) : o.iterator;
        };;
        var $fid = 0;

        function $bind(o, m) {
            if (m == null) return null;
            if (m.__id__ == null) m.__id__ = $fid++;
            var f;
            if (o.hx__closures__ == null) o.hx__closures__ = {};
            else f = o.hx__closures__[m.__id__];
            if (f == null) {
                f = function() {
                    return f.method.apply(f.scope, arguments);
                };
                f.scope = o;
                f.method = m;
                o.hx__closures__[m.__id__] = f;
            }
            return f;
        };
        var $_;
        var $estr = function() {
            return _hcmn_.js_Boot.__string_rec(this, '');
        };
        if (typeof haxe == 'undefined') {
            var haxe = {};
        };

        haxe.IMap = function() {}
        haxe.IMap.prototype = {

        };
        if (typeof js == 'undefined') {
            var js = {};
        };
        if (!js._Boot) {
            js._Boot = {};
        };
        js._Boot.HaxeError = function(val) {
            Error.call(this);
            this.val = val;
            this.message = String(val);
            if (Error.captureStackTrace) Error.captureStackTrace(this, js._Boot.HaxeError);
        };
        js._Boot.HaxeError.__name__ = ["js", "_Boot", "HaxeError"];
        js._Boot.HaxeError.__super__ = Error;
        for (var k in Error.prototype) js._Boot.HaxeError.prototype[k] = Error.prototype[k];
        js._Boot.HaxeError.prototype.val = null;
        js._Boot.HaxeError.prototype.__class__ = js._Boot.HaxeError;
        if (typeof wildFurySlotModelGleGamePlugin == 'undefined') {
            var wildFurySlotModelGleGamePlugin = {};
        };
        wildFurySlotModelGleGamePlugin.GamePlugin = function() {
            wildFurySlotModelGleGamePlugin.GamePlugin.commonParser = new slotmodelGamePluginCommonGle.PfPluginCommonResponseParser(wildFurySlotModelGleGamePlugin.GamePlugin.GAME_ID, $bind(this, this.onError), wildFurySlotModelGleGamePlugin.GamePlugin.PF_RESPONSE_PARSER_ERROR_ID);
            this.parser = new wildFurySlotModelGleGamePlugin.Parser();
        };
        wildFurySlotModelGleGamePlugin.GamePlugin = ck_implements(wildFurySlotModelGleGamePlugin.GamePlugin, clientkernelModulesApi.IService);
        wildFurySlotModelGleGamePlugin.GamePlugin = ck_implements(wildFurySlotModelGleGamePlugin.GamePlugin, slotmodelGamePluginApi.IGamePlugin);
        wildFurySlotModelGleGamePlugin.GamePlugin.__interfaces__ = [clientkernelModulesApi.IService, slotmodelGamePluginApi.IGamePlugin];
        wildFurySlotModelGleGamePlugin.GamePlugin.__name__ = ["wildFurySlotModelGleGamePlugin", "GamePlugin"];
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.parser = null;
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.getAdditionalLineWins = function(platformResponse, stage, slotDefinition) {
            return [];
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.getBonusWins = function(platformResponse, stage, slotDefinition) {
            if (stage != "FreeSpin") return null;
            var bonusWins = this.parser.parseBonusWins(platformResponse);
            return bonusWins;
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.getCustomBigWin = function(totalStakeCredit, totalWinCredit) {
            throw new js._Boot.HaxeError("Not implemented");
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.getImplementedFeatures = function() {
            return [slotmodelGamePluginApi.EPluginFeature.CUSTOM_FIELD, slotmodelGamePluginApi.EPluginFeature.STRIPE_LAYER_PER_BET, slotmodelGamePluginApi.EPluginFeature.BONUS_OUTCOMES, slotmodelGamePluginApi.EPluginFeature.SCATTER_OUTCOMES, slotmodelGamePluginApi.EPluginFeature.CUSTOM_DATA];
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.getNextSpinStripeLayersForSynchronizedReels = function(platformResponse, slotDefinition) {
            throw new js._Boot.HaxeError("Not implemented");
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.getNextSpinStripeLayersPerBet = function(paytableresponse, slotDefinition) {
            this.parser.parseGameDenominator(paytableresponse);
            this.parser.parseJackpotInitialData(paytableresponse);
            this.parser.parseLadderInfo(paytableresponse);
            this.parser.parseWheelStrips(paytableresponse);
            this.parser.parsePayLines(paytableresponse);
            return null;
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.getProgressMeter = function(platformResponse, slotDefinition) {
            throw new js._Boot.HaxeError("Not implemented");
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.getResumePerStake = function(platformResponse, slotDefinition) {
            throw new js._Boot.HaxeError("Not implemented");
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.getScatterWins = function(platformResponse, stage, slotDefinition) {
            this.parser.parseMaxLevelExceeded(platformResponse, stage);
            return this.parser.getScatterWins(platformResponse, stage, slotDefinition);
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.parseCustomField = function(platformResponse) {
            this.parser.parseJackpotLevel(platformResponse);
            return this.parser.parseCustomFields(platformResponse);
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.parseCustomData = function(platformResponse) {
            this.parser.parsePromoFreeSpins(platformResponse);
            return this.parseCustomField(platformResponse);
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.stop = function(context) {};
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.onError = function(error) {
            slotmodelGamePluginCommonGle.Log.getLogger(this).error("[GamePlugin][" + error.id + "] " + error.message);
            throw new js._Boot.HaxeError(error);
        };
        wildFurySlotModelGleGamePlugin.GamePlugin.commonParser = null;
        wildFurySlotModelGleGamePlugin.GamePlugin.prototype.__class__ = wildFurySlotModelGleGamePlugin.GamePlugin;
        wildFurySlotModelGleGamePlugin.ModuleActivator = function() {};
        wildFurySlotModelGleGamePlugin.ModuleActivator = ck_implements(wildFurySlotModelGleGamePlugin.ModuleActivator, clientkernelModulesApi.IModuleActivator);
        wildFurySlotModelGleGamePlugin.ModuleActivator.__interfaces__ = [clientkernelModulesApi.IModuleActivator];
        wildFurySlotModelGleGamePlugin.ModuleActivator.__name__ = ["wildFurySlotModelGleGamePlugin", "ModuleActivator"];
        wildFurySlotModelGleGamePlugin.ModuleActivator.prototype.gamePlugin = null;
        wildFurySlotModelGleGamePlugin.ModuleActivator.prototype.registration = null;
        wildFurySlotModelGleGamePlugin.ModuleActivator.prototype.start = function(context) {
            var _g = this;
            context.getServiceTracker([clientkernelLoaderApi.IAssetRegistry, clientkernelLoggerApi.ILoggerFactory, clientkernelEventbusApi.IEventBus]).then(function(context1) {
                _g.gamePlugin = new wildFurySlotModelGleGamePlugin.GamePlugin();
                _g.registration = context1.registerService(_g.gamePlugin, slotmodelGamePluginApi.IGamePlugin, null);
            });
        };
        wildFurySlotModelGleGamePlugin.ModuleActivator.prototype.stop = function(context) {
            if (this.gamePlugin != null) this.gamePlugin.stop(context);
            if (this.registration != null) this.registration.unregister();
        };
        wildFurySlotModelGleGamePlugin.ModuleActivator.main = function() {};
        wildFurySlotModelGleGamePlugin.ModuleActivator.prototype.__class__ = wildFurySlotModelGleGamePlugin.ModuleActivator;
        wildFurySlotModelGleGamePlugin.Parser = function() {
            this.freeSpinsCounter = null;
        };
        wildFurySlotModelGleGamePlugin.Parser.__name__ = ["wildFurySlotModelGleGamePlugin", "Parser"];
        wildFurySlotModelGleGamePlugin.Parser.prototype.payLines = null;
        wildFurySlotModelGleGamePlugin.Parser.prototype.denominator = null;
        wildFurySlotModelGleGamePlugin.Parser.prototype.freeSpinsCounter = null;
        wildFurySlotModelGleGamePlugin.Parser.prototype.getScatterWins = function(platformResponse, stage, slotDefinition) {
            var prizeOutcome = slotmodelGamePluginCommonGle.StdHelper.getArrayField(platformResponse, "PrizeOutcome");
            var highlightOutcome = slotmodelGamePluginCommonGle.StdHelper.getArrayField(platformResponse, "HighlightOutcome");
            if (prizeOutcome == null || highlightOutcome == null) return null;
            var result = [];
            if (stage == "BaseGame") result = this.getScatterWinsByName(stage, "Scatter", prizeOutcome, highlightOutcome, "12");
            else {
                var levelUp = this.getScatterWinsByName(stage, "LevelUp", prizeOutcome, highlightOutcome, "14");
                if (levelUp != null && levelUp.length > 0) result = result.concat(levelUp);
            }
            if (result != null && result.length > 0) return result;
            else return null;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.getScatterWinsByName = function(stage, name, prizeOutcome, highlightOutcome, scatterId) {
            var scatterWins = [];
            var prize = this.getOutcomeByName(stage + "." + name, prizeOutcome);
            var highlight = this.getOutcomeByName(stage + "." + name, highlightOutcome);
            if (prize != null && highlight != null) scatterWins = this.createScatterWin(prize, highlight, name, scatterId);
            return scatterWins;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.getOutcomeByName = function(name, response) {
            var _g = 0;
            while (_g < response.length) {
                var outcome = response[_g];
                ++_g;
                var outcomeName = slotmodelGamePluginCommonGle.StdHelper.getField(outcome, "@name");
                if (outcomeName == name) return outcome;
            }
            return null;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.createScatterWin = function(prizeOutcome, highlightOutcome, scatter, scatterId) {
            var scatterWins = [];
            var prizeNode = slotmodelGamePluginCommonGle.StdHelper.getArrayField(prizeOutcome, "Prize");
            if (prizeNode != null) {
                var prize = slotmodelGamePluginCommonGle.StdHelper.getArrayField(prizeOutcome, "Prize")[0];
                var winningSymbol = slotmodelGamePluginCommonGle.StdHelper.getField(prize, "@payName").split(" ")[1];
                var scatterName;
                if (winningSymbol == scatterId) scatterName = scatter;
                else scatterName = "LevelDoubleUp";
                var win = new slotmodelGamePluginCommonGle.ScatterWin(scatterName);
                var symbolsCount = slotmodelGamePluginCommonGle.StdHelper.parseIntField(prize, "@symbolCount", null);
                var position = slotmodelGamePluginCommonGle.StdHelper.getField(prize, "@position");
                win.setRenderProperties(winningSymbol, position, symbolsCount);
                var stakePerLineCredit = slotmodelGamePluginCommonGle.StdHelper.parseIntField(prize, "@betMultiplier", null);
                var price = new money.Money(slotmodelGamePluginCommonGle.StdHelper.getField(prize, "@pay"));
                var multiplier = slotmodelGamePluginCommonGle.StdHelper.parseIntField(prize, "@multiplier", null);
                var payoutCredit = slotmodelGamePluginCommonGle.StdHelper.parseIntField(prize, "@totalPay", null);
                win.setPayProperties(stakePerLineCredit, price, multiplier, payoutCredit);
                var winPath = this.createWinPath(highlightOutcome);
                win.setWinPath(new slotModelApi.ReelPictureInfo(winPath));
                scatterWins.push(win);
            }
            if (scatterWins.length > 0) return scatterWins;
            else return null;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.createWinPath = function(highlightOutcome) {
            var winPath;
            var _g = [];
            var _g1 = 0;
            while (_g1 < 5) {
                var i = _g1++;
                _g.push((function($this) {
                    var $r;
                    var _g2 = []; {
                        var _g3 = 0;
                        while (_g3 < 4) {
                            var j = _g3++;
                            _g2.push(0);
                        }
                    }
                    $r = _g2;
                    return $r;
                }(this)));
            }
            winPath = _g;
            var highlight = slotmodelGamePluginCommonGle.StdHelper.getField(highlightOutcome, "Highlight");
            var cells = slotmodelGamePluginCommonGle.StdHelper.getArrayField(highlight, "Cell");
            var _g11 = 0;
            while (_g11 < cells.length) {
                var cell = cells[_g11];
                ++_g11;
                var cellInfo = slotmodelGamePluginCommonGle.StdHelper.getField(cell, "@name");
                var colIndex = _hcmn_.Std.parseInt(cellInfo.charAt(3));
                var rowIndex = _hcmn_.Std.parseInt(cellInfo.charAt(5));
                winPath[colIndex][rowIndex] = 1;
            }
            return winPath;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.getBonusGameScatterWins = function(prizeOutcome, highlightOutcome) {
            return null;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parseBonusWins = function(platformResponse) {
            var result = [];
            var wilds = null;
            var freespins = null;
            var wildOutcome = slotmodelGamePluginCommonGle.StdHelper.getArrayField(platformResponse, "HighlightOutcome");
            if (wildOutcome != null) {
                var _g = 0;
                while (_g < wildOutcome.length) {
                    var outcome = wildOutcome[_g];
                    ++_g;
                    var name = slotmodelGamePluginCommonGle.StdHelper.getField(outcome, "@name");
                    if (name == "FreeSpin.Wilds") wilds = this.createBonusWin(outcome, "WILD", "1");
                    if (name == "FreeSpin.Scatter") freespins = this.createBonusWin(outcome, "FREESPIN", "13");
                }
            }
            if (wilds != null) result = result.concat(wilds);
            if (freespins != null) result = result.concat(freespins);
            if (result.length > 0) return result;
            else return null;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.createBonusWin = function(wildOutcome, type, symbolId) {
            var result = null;
            var highlight = slotmodelGamePluginCommonGle.StdHelper.getField(wildOutcome, "Highlight");
            if (highlight != null) {
                result = [];
                var cells = slotmodelGamePluginCommonGle.StdHelper.getArrayField(highlight, "Cell");
                var _g = 0;
                while (_g < cells.length) {
                    var cell = cells[_g];
                    ++_g;
                    var pos = this.getSymbolPos(cell);
                    var bonusWin = new slotmodelGamePluginCommonGle.BonusWin(type, symbolId, type, 0);
                    bonusWin.setPayProperties(0, new money.Money("0"), 1, 0);
                    bonusWin.setRenderProperties(pos, 0, 1);
                    result.push(bonusWin);
                }
            }
            return result;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.getSymbolPos = function(cell) {
            var name = slotmodelGamePluginCommonGle.StdHelper.getField(cell, "@name");
            return name.charAt(3) + "," + name.charAt(5);
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parseCustomFields = function(platformResponse) {
            var populationOutcome = slotmodelGamePluginCommonGle.StdHelper.getArrayField(platformResponse, "PopulationOutcome");
            var stopIndex = null;
            var _g = 0;
            while (_g < populationOutcome.length) {
                var outcome = populationOutcome[_g];
                ++_g;
                if (this.isWheelStrip(outcome)) {
                    var entry = slotmodelGamePluginCommonGle.StdHelper.getField(outcome, "Entry");
                    if (entry) {
                        var stripIndex = slotmodelGamePluginCommonGle.StdHelper.getField(entry, "@stripIndex");
                        stopIndex = _hcmn_.Std.parseInt(stripIndex);
                    }
                }
            }
            var jackpotWonCredits = this.getPrizeInfo(platformResponse, "Jackpot.Credits");
            var freeSpinWonTotal = this.getPrizeInfo(platformResponse, "FreeSpin.Total");
            var bonusWonTotal = this.getPrizeInfo(platformResponse, "JackpotWithFreeSpin.Total");
            return {
                stripStopIndex: stopIndex,
                payLines: this.payLines,
                jackpotCreditsWin: jackpotWonCredits,
                freeSpinTotalWin: freeSpinWonTotal,
                bonusTotalWin: bonusWonTotal,
                freeSpinsCount: this.freeSpinsCounter
            };
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parsePayLines = function(paytableResponse) {
            this.payLines = new _hcmn_.haxe_ds_StringMap();
            var patterns = slotmodelGamePluginCommonGle.StdHelper.getArrayField(paytableResponse, "PatternInfo");
            var _g = 0;
            while (_g < patterns.length) {
                var pattern = patterns[_g];
                ++_g;
                var isPayline = slotmodelGamePluginCommonGle.StdHelper.getField(pattern, "@name");
                if (isPayline == "Paylines") {
                    var lines = slotmodelGamePluginCommonGle.StdHelper.getArrayField(pattern, "Pattern");
                    var _g1 = 0;
                    while (_g1 < lines.length) {
                        var line = lines[_g1];
                        ++_g1;
                        var lineId = slotmodelGamePluginCommonGle.StdHelper.getField(line, "@name").split("Line ")[1];
                        var cells = slotmodelGamePluginCommonGle.StdHelper.getArrayField(line, "Cell");
                        var linePositions = [];
                        var position = null;
                        var _g2 = 0;
                        while (_g2 < cells.length) {
                            var cell = cells[_g2];
                            ++_g2;
                            var name = slotmodelGamePluginCommonGle.StdHelper.getField(cell, "@name");
                            position = this.parsePosition(name);
                            linePositions.push(position);
                        }
                        this.payLines.set("bg_" + lineId, linePositions);
                    }
                }
            }
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parsePosition = function(name) {
            var pos = {
                x: _hcmn_.Std.parseInt(name.split("C")[1].split("R")[0]),
                y: _hcmn_.Std.parseInt(name.split("R")[1])
            };
            return pos;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.getPrizeInfo = function(platformResponse, fieldName) {
            var prizeOutcome = slotmodelGamePluginCommonGle.StdHelper.getArrayField(platformResponse, "PrizeOutcome");
            var result = null;
            if (prizeOutcome != null) {
                var _g = 0;
                while (_g < prizeOutcome.length) {
                    var outcome = prizeOutcome[_g];
                    ++_g;
                    var name = slotmodelGamePluginCommonGle.StdHelper.getField(outcome, "@name");
                    if (name == fieldName) {
                        var prizeNode = slotmodelGamePluginCommonGle.StdHelper.getField(outcome, "Prize");
                        if (prizeNode != null) {
                            var totalPay = slotmodelGamePluginCommonGle.StdHelper.getField(prizeNode, "@totalPay");
                            result = tools.FloatUtil.fixedFloat(parseFloat(totalPay) * this.denominator) + "";
                        }
                    }
                }
            }
            return result;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parseGameDenominator = function(paytableResponse) {
            var denominationList = slotmodelGamePluginCommonGle.StdHelper.getField(paytableResponse, "DenominationList");
            var denom = slotmodelGamePluginCommonGle.StdHelper.getField(denominationList, "Denomination");
            var denomvalue = slotmodelGamePluginCommonGle.StdHelper.getField(denom, "#text");
            this.denominator = tools.FloatUtil.fixedFloat(parseFloat(denomvalue));
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parseJackpotInitialData = function(paytableResponse) {
            var jackpotCredits = [];
            var triggerinfo = slotmodelGamePluginCommonGle.StdHelper.getField(paytableResponse, "TriggerInfo");
            if (triggerinfo != null) {
                jackpotCredits = this.parseJackpotCredits(triggerinfo);
                wildFuryPluginApi.JackpotDataStorage.setJackpotCredits(jackpotCredits);
            }
            return null;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parseLadderInfo = function(paytableResponse) {
            var ladderInfo = _hcmn_.Reflect.getProperty(paytableResponse, "LadderInfo");
            var ladderData = this.getLadderDataFromLadderInfo(ladderInfo);
            var wildsLadder = this.parseJackpotWildsLadder(ladderData);
            wildFuryPluginApi.JackpotDataStorage.setJackpotWildsLadder(wildsLadder);
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parsePromoFreeSpins = function(platformResponse) {
            this.freeSpinsCounter = null;
            var promoFreeSpins = slotmodelGamePluginCommonGle.StdHelper.getField(platformResponse, "PromotionalFreeSpin");
            if (promoFreeSpins != null) this.freeSpinsCounter = slotmodelGamePluginCommonGle.StdHelper.getField(promoFreeSpins, "@count");
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parseJackpotLevel = function(platformResponse) {
            var ladder = slotmodelGamePluginCommonGle.StdHelper.getArrayField(platformResponse, "LadderOutcome");
            if (ladder != null) {
                var $it0 = _hcmn_.HxOverrides.iter(ladder);
                while ($it0.hasNext()) {
                    var data = $it0.next();
                    if (this.isJackpotLevelNode(data)) wildFuryPluginApi.JackpotDataStorage.setJackpotLevel(this.getLevelValue(data));
                    if (this.isWildNumberNode(data)) wildFuryPluginApi.JackpotDataStorage.setWildNumber(this.getWildNumberValue(data));
                }
            }
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parseMaxLevelExceeded = function(platformResponse, stage) {
            if (stage != "FreeSpin") {
                wildFuryPluginApi.JackpotDataStorage.setMaxLevelExceededValue(false);
                return;
            }
            var triggerOutcome = slotmodelGamePluginCommonGle.StdHelper.getArrayField(platformResponse, "TriggerOutcome");
            if (triggerOutcome != null) {
                var value = false;
                var $it0 = _hcmn_.HxOverrides.iter(triggerOutcome);
                while ($it0.hasNext()) {
                    var outcome = $it0.next();
                    if (slotmodelGamePluginCommonGle.StdHelper.getField(outcome, "@name") == "MaxLevel") {
                        value = slotmodelGamePluginCommonGle.StdHelper.getArrayField(outcome, "Trigger") != null;
                        break;
                    }
                }
                wildFuryPluginApi.JackpotDataStorage.setMaxLevelExceededValue(value);
            }
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.getLevelValue = function(data) {
            var ladder = slotmodelGamePluginCommonGle.StdHelper.getField(data, "Ladder");
            var value = _hcmn_.Std.parseInt(slotmodelGamePluginCommonGle.StdHelper.getField(ladder, "#text")) + 1 + "";
            return value;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.getWildNumberValue = function(data) {
            var ladder = slotmodelGamePluginCommonGle.StdHelper.getField(data, "Ladder");
            var value = slotmodelGamePluginCommonGle.StdHelper.getField(ladder, "#text");
            return value;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.isJackpotLevelNode = function(data) {
            var nodeName = slotmodelGamePluginCommonGle.StdHelper.getField(data, "@name");
            return nodeName == "JackpotLevel";
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.isWildNumberNode = function(data) {
            var nodeName = slotmodelGamePluginCommonGle.StdHelper.getField(data, "@name");
            return nodeName == "WildNumber";
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parseJackpotWildsLadder = function(ladderData) {
            var result = [];
            var _g = 0;
            while (_g < ladderData.length) {
                var data = ladderData[_g];
                ++_g;
                var val = _hcmn_.Reflect.getProperty(data, "@minTriggerCount");
                var minTriggerCount = _hcmn_.Std.parseInt(val);
                result.push(minTriggerCount);
            }
            return result;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.getLadderDataFromLadderInfo = function(ladderInfo) {
            var ladderData;
            var outputEvents = ladderInfo.OutputEvents;
            if ((outputEvents instanceof Array) && outputEvents.__enum__ == null) ladderData = outputEvents;
            else ladderData = outputEvents.Event;
            return ladderData;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parseJackpotCredits = function(triggerinfo) {
            var jackpotData = slotmodelGamePluginCommonGle.StdHelper.getArrayField(triggerinfo, "Trigger");
            var result = null;
            if (jackpotData != null) {
                result = [];
                var _g = 0;
                while (_g < jackpotData.length) {
                    var data = jackpotData[_g];
                    ++_g;
                    var val = slotmodelGamePluginCommonGle.StdHelper.getField(data, "@name").split(",")[1];
                    var creditVal = tools.FloatUtil.fixedFloat(this.denominator * parseFloat(val));
                    result.push(creditVal);
                }
            }
            return result;
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.parseWheelStrips = function(paytableResponse) {
            var stripInfo = slotmodelGamePluginCommonGle.StdHelper.getArrayField(paytableResponse, "StripInfo");
            var _g = 0;
            while (_g < stripInfo.length) {
                var info = stripInfo[_g];
                ++_g;
                if (this.isWheelStrip(info)) {
                    var strip = slotmodelGamePluginCommonGle.StdHelper.getField(info, "Strip");
                    var stops = slotmodelGamePluginCommonGle.StdHelper.getArrayField(strip, "Stop");
                    var _g1 = 0;
                    while (_g1 < stops.length) {
                        var stop = stops[_g1];
                        ++_g1;
                        wildFuryPluginApi.WheelStripsData.addWheelStrip(this.getStopValue(stop));
                    }
                }
            }
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.getStopValue = function(stop) {
            var symbolID = slotmodelGamePluginCommonGle.StdHelper.getField(stop, "@symbolID");
            var result = symbolID.split(",")[1];
            var regularExp = new _hcmn_.EReg("(\\d([\\d]+))", "");
            regularExp.match(result);
            return regularExp.matched(1);
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.isWheelStrip = function(strip) {
            var name = slotmodelGamePluginCommonGle.StdHelper.getField(strip, "@name");
            return new _hcmn_.EReg("^Wheel", "").match(name);
        };
        wildFurySlotModelGleGamePlugin.Parser.prototype.__class__ = wildFurySlotModelGleGamePlugin.Parser;
        wildFurySlotModelGleGamePlugin.GamePlugin.GAME_ID = "wildFury";;
        wildFurySlotModelGleGamePlugin.GamePlugin.PF_RESPONSE_PARSER_ERROR_ID = 9999;;
        wildFurySlotModelGleGamePlugin.Parser.CELLS_NUM = 4;;
        wildFurySlotModelGleGamePlugin.Parser.REELS_NUM = 5;;
        return {
            exports: wildFurySlotModelGleGamePlugin,
            activator: wildFurySlotModelGleGamePlugin.ModuleActivator
        };
    });
//# sourceURL=wildFurySlotModelGleGamePlugin.js