define("smashThePigWinSymbols", ["smashThePigWinSymbolsDeclaration", "viewBuilderApi", "smashThePigWinAnimatorPort", "componentmodelComponentApi", "clientkernelLoaderApi", "slotModelApi", "displayEngineApi", "clientkernelTestableApi", "gameLayoutApi", "clientkernelEventbusApi", "clientkernelModulesApi"],
    function(smashThePigWinSymbolsDeclaration, viewBuilderApi, smashThePigWinAnimatorPort, componentmodelComponentApi, clientkernelLoaderApi, slotModelApi, displayEngineApi, clientkernelTestableApi, gameLayoutApi, clientkernelEventbusApi, clientkernelModulesApi) {
        "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 = {

            get: function(k) {
                return {
                    arguments: ["*"],
                    returns: "null"
                };
            },
            keys: function() {
                return {
                    arguments: [],
                    returns: "null"
                };
            }
        };
        haxe.Log = function() {};
        haxe.Log.__name__ = ["haxe", "Log"];
        haxe.Log.trace = function(v, infos) {
            _hcmn_.js_Boot.__trace(v, infos);
        };
        haxe.Log.prototype.__class__ = haxe.Log;
        if (!haxe.ds) {
            haxe.ds = {};
        };
        haxe.ds.BalancedTree = function() {};
        haxe.ds.BalancedTree.__name__ = ["haxe", "ds", "BalancedTree"];
        haxe.ds.BalancedTree.prototype.root = null;
        haxe.ds.BalancedTree.prototype.set = function(key, value) {
            this.root = this.setLoop(key, value, this.root);
        };
        haxe.ds.BalancedTree.prototype.get = function(key) {
            var node = this.root;
            while (node != null) {
                var c = this.compare(key, node.key);
                if (c == 0) return node.value;
                if (c < 0) node = node.left;
                else node = node.right;
            }
            return null;
        };
        haxe.ds.BalancedTree.prototype.keys = function() {
            var ret = [];
            this.keysLoop(this.root, ret);
            return _hcmn_.HxOverrides.iter(ret);
        };
        haxe.ds.BalancedTree.prototype.setLoop = function(k, v, node) {
            if (node == null) return new haxe.ds.TreeNode(null, k, v, null);
            var c = this.compare(k, node.key);
            if (c == 0) return new haxe.ds.TreeNode(node.left, k, v, node.right, node == null ? 0 : node._height);
            else if (c < 0) {
                var nl = this.setLoop(k, v, node.left);
                return this.balance(nl, node.key, node.value, node.right);
            } else {
                var nr = this.setLoop(k, v, node.right);
                return this.balance(node.left, node.key, node.value, nr);
            }
        };
        haxe.ds.BalancedTree.prototype.keysLoop = function(node, acc) {
            if (node != null) {
                this.keysLoop(node.left, acc);
                acc.push(node.key);
                this.keysLoop(node.right, acc);
            }
        };
        haxe.ds.BalancedTree.prototype.balance = function(l, k, v, r) {
            var hl;
            if (l == null) hl = 0;
            else hl = l._height;
            var hr;
            if (r == null) hr = 0;
            else hr = r._height;
            if (hl > hr + 2) {
                if ((function($this) {
                        var $r;
                        var _this = l.left;
                        $r = _this == null ? 0 : _this._height;
                        return $r;
                    }(this)) >= (function($this) {
                        var $r;
                        var _this1 = l.right;
                        $r = _this1 == null ? 0 : _this1._height;
                        return $r;
                    }(this))) return new haxe.ds.TreeNode(l.left, l.key, l.value, new haxe.ds.TreeNode(l.right, k, v, r));
                else return new haxe.ds.TreeNode(new haxe.ds.TreeNode(l.left, l.key, l.value, l.right.left), l.right.key, l.right.value, new haxe.ds.TreeNode(l.right.right, k, v, r));
            } else if (hr > hl + 2) {
                if ((function($this) {
                        var $r;
                        var _this2 = r.right;
                        $r = _this2 == null ? 0 : _this2._height;
                        return $r;
                    }(this)) > (function($this) {
                        var $r;
                        var _this3 = r.left;
                        $r = _this3 == null ? 0 : _this3._height;
                        return $r;
                    }(this))) return new haxe.ds.TreeNode(new haxe.ds.TreeNode(l, k, v, r.left), r.key, r.value, r.right);
                else return new haxe.ds.TreeNode(new haxe.ds.TreeNode(l, k, v, r.left.left), r.left.key, r.left.value, new haxe.ds.TreeNode(r.left.right, r.key, r.value, r.right));
            } else return new haxe.ds.TreeNode(l, k, v, r, (hl > hr ? hl : hr) + 1);
        };
        haxe.ds.BalancedTree.prototype.compare = function(k1, k2) {
            return _hcmn_.Reflect.compare(k1, k2);
        };
        haxe.ds.BalancedTree.prototype.__class__ = haxe.ds.BalancedTree;
        haxe.ds.TreeNode = function(l, k, v, r, h) {
            if (h == null) h = -1;
            this.left = l;
            this.key = k;
            this.value = v;
            this.right = r;
            if (h == -1) this._height = ((function($this) {
                var $r;
                var _this = $this.left;
                $r = _this == null ? 0 : _this._height;
                return $r;
            }(this)) > (function($this) {
                var $r;
                var _this1 = $this.right;
                $r = _this1 == null ? 0 : _this1._height;
                return $r;
            }(this)) ? (function($this) {
                var $r;
                var _this2 = $this.left;
                $r = _this2 == null ? 0 : _this2._height;
                return $r;
            }(this)) : (function($this) {
                var $r;
                var _this3 = $this.right;
                $r = _this3 == null ? 0 : _this3._height;
                return $r;
            }(this))) + 1;
            else this._height = h;
        };
        haxe.ds.TreeNode.__name__ = ["haxe", "ds", "TreeNode"];
        haxe.ds.TreeNode.prototype.left = null;
        haxe.ds.TreeNode.prototype.right = null;
        haxe.ds.TreeNode.prototype.key = null;
        haxe.ds.TreeNode.prototype.value = null;
        haxe.ds.TreeNode.prototype._height = null;
        haxe.ds.TreeNode.prototype.__class__ = haxe.ds.TreeNode;
        haxe.ds.EnumValueMap = function() {
            haxe.ds.BalancedTree.call(this);
        };
        haxe.ds.EnumValueMap.__interfaces__ = [haxe.IMap];
        haxe.ds.EnumValueMap.__name__ = ["haxe", "ds", "EnumValueMap"];
        haxe.ds.EnumValueMap.__super__ = haxe.ds.BalancedTree;
        for (var k in haxe.ds.BalancedTree.prototype) haxe.ds.EnumValueMap.prototype[k] = haxe.ds.BalancedTree.prototype[k];
        haxe.ds.EnumValueMap.prototype.compare = function(k1, k2) {
            var d = k1[1] - k2[1];
            if (d != 0) return d;
            var p1 = k1.slice(2);
            var p2 = k2.slice(2);
            if (p1.length == 0 && p2.length == 0) return 0;
            return this.compareArgs(p1, p2);
        };
        haxe.ds.EnumValueMap.prototype.compareArgs = function(a1, a2) {
            var ld = a1.length - a2.length;
            if (ld != 0) return ld;
            var _g1 = 0;
            var _g = a1.length;
            while (_g1 < _g) {
                var i = _g1++;
                var d = this.compareArg(a1[i], a2[i]);
                if (d != 0) return d;
            }
            return 0;
        };
        haxe.ds.EnumValueMap.prototype.compareArg = function(v1, v2) {
            if (_hcmn_.Reflect.isEnumValue(v1) && _hcmn_.Reflect.isEnumValue(v2)) return this.compare(v1, v2);
            else if ((v1 instanceof Array) && v1.__enum__ == null && ((v2 instanceof Array) && v2.__enum__ == null)) return this.compareArgs(v1, v2);
            else return _hcmn_.Reflect.compare(v1, v2);
        };
        haxe.ds.EnumValueMap.prototype.__class__ = haxe.ds.EnumValueMap;
        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 smashThePigWinSymbols == 'undefined') {
            var smashThePigWinSymbols = {};
        };
        smashThePigWinSymbols.Activator = function(context) {};
        smashThePigWinSymbols.Activator = ck_implements(smashThePigWinSymbols.Activator, clientkernelModulesApi.IModuleActivator);
        smashThePigWinSymbols.Activator.__interfaces__ = [clientkernelModulesApi.IModuleActivator];
        smashThePigWinSymbols.Activator.__name__ = ["smashThePigWinSymbols", "Activator"];
        smashThePigWinSymbols.Activator.prototype.start = function(context) {
            context.getServiceTracker([displayEngineApi.IDisplayProvider, clientkernelTestableApi.ITestable, viewBuilderApi.IViewBuilderFactory]).then(function(context1) {
                smashThePigWinSymbols.ExternalService.initialize(context1);
                var factory = context1.getAnyService(viewBuilderApi.IViewBuilderFactory, null);
                smashThePigWinSymbols.ExternalService.viewBuilderFactory = factory;
                context1.registerService(new smashThePigWinSymbols.WinSymbolsFactory(factory), smashThePigWinSymbolsDeclaration.WinSymbolsDeclaration, null);
            });
        };
        smashThePigWinSymbols.Activator.prototype.stop = function(context) {};
        smashThePigWinSymbols.Activator.main = function() {};
        smashThePigWinSymbols.Activator.prototype.__class__ = smashThePigWinSymbols.Activator;

        smashThePigWinSymbols.IWinSymbols = function() {}
        smashThePigWinSymbols.IWinSymbols.prototype = {

            show: function(winsymbols, outcome) {
                return {
                    arguments: ["array", "*"],
                    returns: "void"
                };
            },
            hide: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };

        smashThePigWinSymbols.IWinSymbolsApplication = function() {}
        smashThePigWinSymbols.IWinSymbolsApplication.prototype = {

            getDisplayObject: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setVisible: function(visible) {
                return {
                    arguments: ["boolean"],
                    returns: "void"
                };
            },
            getContainerComponent: function(component) {
                return {
                    arguments: ["*"],
                    returns: "*"
                };
            }
        };
        smashThePigWinSymbols.ExternalService = function() {};
        smashThePigWinSymbols.ExternalService.__name__ = ["smashThePigWinSymbols", "ExternalService"];
        smashThePigWinSymbols.ExternalService.displayProvider = null;
        smashThePigWinSymbols.ExternalService.assetRegistry = null;
        smashThePigWinSymbols.ExternalService.testableLogger = null;
        smashThePigWinSymbols.ExternalService.viewBuilderFactory = null;
        smashThePigWinSymbols.ExternalService.initialize = function(context) {
            smashThePigWinSymbols.ExternalService.displayProvider = context.getAnyService(displayEngineApi.IDisplayProvider, null);
            smashThePigWinSymbols.ExternalService.assetRegistry = context.getAnyService(clientkernelLoaderApi.IAssetRegistry, null);
            var testable = context.getAnyService(clientkernelTestableApi.ITestable, null);
            smashThePigWinSymbols.ExternalService.testableLogger = testable.getLogger(context);
        };
        smashThePigWinSymbols.ExternalService.loadConfig = function(config_id, configCallback) {
            smashThePigWinSymbols.ExternalService.assetRegistry.getAsset(config_id).getContent().then(function(data) {
                configCallback(data);
            });
        };
        smashThePigWinSymbols.ExternalService.prototype.__class__ = smashThePigWinSymbols.ExternalService;
        smashThePigWinSymbols.WinSymbolsApplication = function(context, factory) {
            this.context = context;
            this.layoutPort = context.getUsedPort(gameLayoutApi.IGameLayoutPort);
            this.outcomePhasePort = context.getUsedPort(slotModelApi.IOutcomePhasePort);
            this.factory = factory;
            this.winLinesPort = context.getUsedPort(smashThePigWinAnimatorPort.IWinAnimatorPort);
            this.baseEvents = new smashThePigWinSymbols.BaseEvents();
            this.components = new haxe.ds.EnumValueMap();
            this.layoutPort.getUpdateComponentLayout().subscribe($bind(this, this.updateLayout));
            this.controller = new smashThePigWinSymbols.WinSymbolsController(this, this.layoutPort);
            new smashThePigWinSymbols.WinSymbolsModel($bind(this, this.modelInitialised));
            this.winLinesPort.setupWinAnimatorComponents().subscribe($bind(this, this.setupSubComponents));
        };
        smashThePigWinSymbols.WinSymbolsApplication = ck_implements(smashThePigWinSymbols.WinSymbolsApplication, smashThePigWinSymbols.IWinSymbolsApplication);
        smashThePigWinSymbols.WinSymbolsApplication.__interfaces__ = [smashThePigWinSymbols.IWinSymbolsApplication];
        smashThePigWinSymbols.WinSymbolsApplication.__name__ = ["smashThePigWinSymbols", "WinSymbolsApplication"];
        smashThePigWinSymbols.WinSymbolsApplication.prototype.components = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.factory = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.controller = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.winAnimationAssets = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.view = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.layerContainers = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.winLinesPort = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.context = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.outcomePhasePort = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.baseEvents = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.layoutPayload = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.layoutPort = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.assetsLoaded = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.vba = null;
        smashThePigWinSymbols.WinSymbolsApplication.prototype.setupSubComponents = function(e) {
            smashThePigWinSymbols.WinSymbolsModel.setupConfiguration(e.getPayload());
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.modelInitialised = function() {
            this.vba = smashThePigWinSymbols.WinSymbolsModel.vba;
            this.assetsLoaded = smashThePigWinSymbols.WinSymbolsModel.assetsLoaded;
            this.initialize();
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.updateLayout = function(e) {
            this.layoutPayload = e.getPayload();
            if (!smashThePigWinSymbols.WinSymbolsModel.initialised) this.initialize();
            else this.controller.updateLayout(this.layoutPayload, this.context.getInstance());
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.initialize = function() {
            if (this.assetsLoaded && this.layoutPayload != null) {
                this.view = this.factory.createView(this.vba);
                this.registerAllComponents();
                this.controller.init();
                this.controller.updateLayout(this.layoutPayload, this.context.getInstance());
                smashThePigWinSymbols.WinSymbolsModel.initialised = true;
            }
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.registerAllComponents = function() {
            this.layerContainers = this.view.getChildComponents();
            var $it0 = this.layerContainers.keys();
            while ($it0.hasNext()) {
                var layerId = $it0.next();
                var constructorIndex;
                var _this = _hcmn_.Type.getEnumConstructs(smashThePigWinSymbols.ComponentsEnum);
                constructorIndex = _hcmn_.HxOverrides.indexOf(_this, layerId, 0);
                if (constructorIndex < 0) continue;
                var componentEnum = _hcmn_.Type.createEnum(smashThePigWinSymbols.ComponentsEnum, layerId, null);
                if (!this.registerComponent(componentEnum, layerId)) continue;
            }
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.registerComponent = function(componentEnum, layerId) {
            switch (componentEnum[1]) {
                case 0:
                    break;
                case 3:
                    break;
                case 2:
                    this.registerContainerComponent(smashThePigWinSymbols.ComponentsEnum.WIN_SYMBOLS, layerId, smashThePigWinSymbols.WinSymbols);
                    break;
                case 1:
                    break;
            }
            return true;
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.registerContainerComponent = function(component, layerId, componentClass) {
            var container = this.view.getComponentById(component[0]);
            if (container == null) return;
            if (componentClass != null) {
                var specificComponent = _hcmn_.Type.createInstance(componentClass, [container, this.baseEvents]);
                this.components.set(component, specificComponent);
            } else this.components.set(component, container);
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.setVisible = function(visible) {
            this.getDisplayObject().setVisible(visible);
            var $it0 = (function($this) {
                var $r;
                var this1 = $this.view.getChildComponents();
                $r = this1.keys();
                return $r;
            }(this));
            while ($it0.hasNext()) {
                var key = $it0.next();
                var container = this.view.getComponentById(key);
                container.getDisplayObject().setVisible(visible);
            }
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.getDisplayObject = function() {
            return this.view.getDisplayObject();
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.getWinSymbols = function() {
            return this.components.get(smashThePigWinSymbols.ComponentsEnum.WIN_SYMBOLS);
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.getContainerComponent = function(component) {
            return this.components.get(component);
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.getBaseEvent = function(id) {
            return this.baseEvents.getEvent(id);
        };
        smashThePigWinSymbols.WinSymbolsApplication.prototype.__class__ = smashThePigWinSymbols.WinSymbolsApplication;
        smashThePigWinSymbols.Controller = function(controllerInstance) {
            smashThePigWinSymbols.Controller._CONTROLLERS.push(controllerInstance);
        };
        smashThePigWinSymbols.Controller.__name__ = ["smashThePigWinSymbols", "Controller"];
        smashThePigWinSymbols.Controller.prototype.sendMessage = function(message) {
            var _g1 = 0;
            var _g = smashThePigWinSymbols.Controller._CONTROLLERS.length;
            while (_g1 < _g) {
                var i = _g1++;
                var controller = smashThePigWinSymbols.Controller._CONTROLLERS[i];
                var controllerEvents = controller.getInterests();
                var _g3 = 0;
                var _g2 = controllerEvents.length;
                while (_g3 < _g2) {
                    var m = _g3++;
                    var interestedInMessage = controllerEvents[m];
                    if (interestedInMessage == message._messageName) {
                        controller.processMessage(message);
                        break;
                    }
                }
            }
        };
        smashThePigWinSymbols.Controller.prototype.getInterests = function() {
            return [];
        };
        smashThePigWinSymbols.Controller.prototype.processMessage = function(message) {};
        smashThePigWinSymbols.Controller.prototype.__class__ = smashThePigWinSymbols.Controller;
        smashThePigWinSymbols.WinSymbolsController = function(winAnimations, layoutPort) {
            this.winAnimations = winAnimations;
            this.layoutPort = layoutPort;
            smashThePigWinSymbols.Controller.call(this, this);
        };
        smashThePigWinSymbols.WinSymbolsController.__name__ = ["smashThePigWinSymbols", "WinSymbolsController"];
        smashThePigWinSymbols.WinSymbolsController.__super__ = smashThePigWinSymbols.Controller;
        for (var k in smashThePigWinSymbols.Controller.prototype) smashThePigWinSymbols.WinSymbolsController.prototype[k] = smashThePigWinSymbols.Controller.prototype[k];
        smashThePigWinSymbols.WinSymbolsController.prototype.winAnimations = null;
        smashThePigWinSymbols.WinSymbolsController.prototype.layoutPort = null;
        smashThePigWinSymbols.WinSymbolsController.prototype.init = function() {
            new smashThePigWinSymbols.LayoutController(this.winAnimations);
            new smashThePigWinSymbols.WinSymbolsPortController(this.winAnimations.winLinesPort, this.layoutPort, this.winAnimations);
        };
        smashThePigWinSymbols.WinSymbolsController.prototype.updateLayout = function(layoutPayload, instance) {
            this.sendMessage(new smashThePigWinSymbols.WinAnimatorMessagePayload("updateLayout", layoutPayload));
            this.sendMessage(new smashThePigWinSymbols.WinAnimatorMessagePayload("updateUpdatedComponentsPort", instance));
        };
        smashThePigWinSymbols.WinSymbolsController.prototype.__class__ = smashThePigWinSymbols.WinSymbolsController;
        smashThePigWinSymbols.WinSymbolsFactory = function(vbf) {
            this.vbf = vbf;
        };
        smashThePigWinSymbols.WinSymbolsFactory = ck_implements(smashThePigWinSymbols.WinSymbolsFactory, clientkernelModulesApi.IService);
        smashThePigWinSymbols.WinSymbolsFactory = ck_implements(smashThePigWinSymbols.WinSymbolsFactory, componentmodelComponentApi.IComponentFactory);
        smashThePigWinSymbols.WinSymbolsFactory.__interfaces__ = [clientkernelModulesApi.IService, componentmodelComponentApi.IComponentFactory];
        smashThePigWinSymbols.WinSymbolsFactory.__name__ = ["smashThePigWinSymbols", "WinSymbolsFactory"];
        smashThePigWinSymbols.WinSymbolsFactory.prototype.vbf = null;
        smashThePigWinSymbols.WinSymbolsFactory.prototype.getComponentDeclaration = function() {
            return smashThePigWinSymbolsDeclaration.WinSymbolsDeclaration;
        };
        smashThePigWinSymbols.WinSymbolsFactory.prototype.createComponent = function(context) {
            var _winlines = new smashThePigWinSymbols.WinSymbolsApplication(context, this.vbf);
        };
        smashThePigWinSymbols.WinSymbolsFactory.prototype.__class__ = smashThePigWinSymbols.WinSymbolsFactory;
        smashThePigWinSymbols.WinSymbols = function(container, baseEvents) {
            this.isMobile = false;
            this.originalSymbols = new _hcmn_.haxe_ds_StringMap();
            this.symbolsList = smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration.winSymboslMap;
            this.totalVisibleSymbols = 0;
            this.symbolOffset = 0;
            this.reelsNum = smashThePigWinSymbols.WinSymbolsModel.globalConfiguration.numberOfColums;
            this.cellsNum = smashThePigWinSymbols.WinSymbolsModel.globalConfiguration.numberOfRows;
            this.verticalGap = smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration.marginTop;
            this.horisontalGap = smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration.marginLeft;
            this.symbolHeight = smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration.height;
            this.symbolWidth = smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration.width;
            this.container = container;
            this.baseEvents = baseEvents;
            this.maskedContainer = _hcmn_.js_Boot.__cast(container.getComponentById("maskedContainer"), viewBuilderApi.IViewBuilderContainer);
            container.hide();
            this.isMobile = window.document.location.href.indexOf("skin=mobile") != -1;
        };
        smashThePigWinSymbols.WinSymbols = ck_implements(smashThePigWinSymbols.WinSymbols, smashThePigWinSymbols.IWinSymbols);
        smashThePigWinSymbols.WinSymbols.__interfaces__ = [smashThePigWinSymbols.IWinSymbols];
        smashThePigWinSymbols.WinSymbols.__name__ = ["smashThePigWinSymbols", "WinSymbols"];
        smashThePigWinSymbols.WinSymbols.prototype.container = null;
        smashThePigWinSymbols.WinSymbols.prototype.baseEvents = null;
        smashThePigWinSymbols.WinSymbols.prototype.symbolWidth = null;
        smashThePigWinSymbols.WinSymbols.prototype.symbolHeight = null;
        smashThePigWinSymbols.WinSymbols.prototype.horisontalGap = null;
        smashThePigWinSymbols.WinSymbols.prototype.verticalGap = null;
        smashThePigWinSymbols.WinSymbols.prototype.cellsNum = null;
        smashThePigWinSymbols.WinSymbols.prototype.reelsNum = null;
        smashThePigWinSymbols.WinSymbols.prototype.symbolOffset = null;
        smashThePigWinSymbols.WinSymbols.prototype.totalVisibleSymbols = null;
        smashThePigWinSymbols.WinSymbols.prototype.symbolsList = null;
        smashThePigWinSymbols.WinSymbols.prototype.originalSymbols = null;
        smashThePigWinSymbols.WinSymbols.prototype.config = null;
        smashThePigWinSymbols.WinSymbols.prototype.maskedContainer = null;
        smashThePigWinSymbols.WinSymbols.prototype.isMobile = null;
        smashThePigWinSymbols.WinSymbols.prototype.show = function(winsymbols, outcome) {
            haxe.Log.trace("[LN]: winLines.winSymbols.outcome " + _hcmn_.Std.string(outcome), {
                fileName: "WinSymbols.hx",
                lineNumber: 66,
                className: "smashthepig.components.winsymbols.component.imp.components.WinSymbols",
                methodName: "show"
            });
            var originalTotalVisibleSymbols = 0;
            var animatedCountPerSymbols = new _hcmn_.haxe_ds_IntMap();
            smashThePigWinSymbols.ExternalService.testableLogger.info("winsymbols", {
                winsymbols: winsymbols
            });
            if (outcome != null) {
                if (outcome.reelStop != null) smashThePigWinSymbols.ExternalService.testableLogger.info("reelPicture", {
                    reelstop: outcome.reelStop.reels
                });
            }
            var _g1 = 0;
            var _g = this.reelsNum;
            while (_g1 < _g) {
                var col = _g1++;
                var _g3 = 0;
                var _g2 = this.cellsNum;
                while (_g3 < _g2) {
                    var row = _g3++;
                    var symbolNum = outcome.reelStop.reels[col][row + this.symbolOffset];
                    var symbolVisible = winsymbols[col][row];
                    if (symbolVisible && (function($this) {
                            var $r;
                            var key = symbolNum;
                            $r = $this.symbolsList.h.hasOwnProperty(key);
                            return $r;
                        }(this)) && !(function($this) {
                            var $r;
                            var key1; {
                                var key2 = symbolNum;
                                key1 = $this.symbolsList.h[key2];
                            }
                            $r = $this.originalSymbols.exists(key1);
                            return $r;
                        }(this))) {
                        if (!(function($this) {
                                var $r;
                                var key3 = symbolNum;
                                $r = animatedCountPerSymbols.h.hasOwnProperty(key3);
                                return $r;
                            }(this))) {
                            var key4 = symbolNum;
                            animatedCountPerSymbols.h[key4] = 0;
                        }
                        var key5 = symbolNum;
                        var value;
                        value = (function($this) {
                            var $r;
                            var key6 = symbolNum;
                            $r = animatedCountPerSymbols.h[key6];
                            return $r;
                        }(this)) + 1;
                        animatedCountPerSymbols.h[key5] = value;
                        this.totalVisibleSymbols++;
                    }
                }
            }
            originalTotalVisibleSymbols = this.totalVisibleSymbols;
            var _g11 = 0;
            var _g4 = this.reelsNum;
            while (_g11 < _g4) {
                var col1 = _g11++;
                var _g31 = 0;
                var _g21 = this.cellsNum;
                while (_g31 < _g21) {
                    var row1 = _g31++;
                    var symbolNum1 = outcome.reelStop.reels[col1][row1 + this.symbolOffset];
                    var symbolVisible1 = winsymbols[col1][row1];
                    if (symbolVisible1) {
                        if ((function($this) {
                                var $r;
                                var key7 = symbolNum1;
                                $r = $this.symbolsList.h.hasOwnProperty(key7);
                                return $r;
                            }(this))) {
                            if ((function($this) {
                                    var $r;
                                    var key8; {
                                        var key9 = symbolNum1;
                                        key8 = $this.symbolsList.h[key9];
                                    }
                                    $r = $this.originalSymbols.exists(key8);
                                    return $r;
                                }(this))) {
                                var newSymbol = ((function($this) {
                                    var $r;
                                    var key10; {
                                        var key11 = symbolNum1;
                                        key10 = $this.symbolsList.h[key11];
                                    }
                                    $r = $this.originalSymbols.get(key10);
                                    return $r;
                                }(this))).toBitmap();
                                if (newSymbol != null) {
                                    this.maskedContainer.getDisplayObject().addChild(newSymbol);
                                    newSymbol.setX((this.symbolWidth + this.horisontalGap) * col1 + ((function($this) {
                                        var $r;
                                        var key12 = _hcmn_.Std.parseInt(newSymbol.getId());
                                        $r = smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration.winSymboslOffsetsMap.h[key12];
                                        return $r;
                                    }(this))).x);
                                    newSymbol.setY((this.symbolHeight + this.verticalGap) * row1 + ((function($this) {
                                        var $r;
                                        var key13 = _hcmn_.Std.parseInt(newSymbol.getId());
                                        $r = smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration.winSymboslOffsetsMap.h[key13];
                                        return $r;
                                    }(this))).y);
                                }
                            } else {
                                var symbolName;
                                var key14 = symbolNum1;
                                symbolName = this.symbolsList.h[key14];
                                var vbAsset = smashThePigWinSymbols.ExternalService.loadedAssets.get(symbolName + "_VB");
                                if (vbAsset != null) {
                                    var vbAnimView = smashThePigWinSymbols.ExternalService.viewBuilderFactory.createView(vbAsset);
                                    var symbolContainer = this.container.createContainerFromStoredConfig(symbolName + "_CONTAINER");
                                    this.maskedContainer.addChildComponent(symbolContainer, symbolName + "_CONTAINER" + "_" + row1 + "_" + col1);
                                    symbolContainer.setX((this.symbolWidth + this.horisontalGap) * col1 + ((function($this) {
                                        var $r;
                                        var key15 = symbolNum1;
                                        $r = smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration.winSymboslOffsetsMap.h[key15];
                                        return $r;
                                    }(this))).x);
                                    symbolContainer.setY((this.symbolHeight + this.verticalGap) * row1 + ((function($this) {
                                        var $r;
                                        var key16 = symbolNum1;
                                        $r = smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration.winSymboslOffsetsMap.h[key16];
                                        return $r;
                                    }(this))).y);
                                    symbolContainer.show();
                                    var vbAniamtionHolder = vbAnimView.createContainerFromStoredConfig("ANIMATION_HOLDER");
                                    var vbAnimationComponent;
                                    vbAnimationComponent = _hcmn_.js_Boot.__cast(vbAniamtionHolder.getComponentById("ANIMATION_CONTENT"), viewBuilderApi.IVBAnimationComponent);
                                    symbolContainer.addChildComponent(vbAniamtionHolder, symbolName + "VB");
                                    vbAnimationComponent.playParticles = !this.isMobile;
                                    vbAnimationComponent.play(true, $bind(this, this.played));
                                }
                            }
                        }
                    }
                }
            }
            if (originalTotalVisibleSymbols == 0) this.baseEvents.getEvent(smashThePigWinSymbols.BaseEventsEnum.CALLBACK_RECIVED).dispatch("WinSymbols");
            this.container.show();
        };
        smashThePigWinSymbols.WinSymbols.prototype.hide = function() {
            var $it0 = (function($this) {
                var $r;
                var this1 = $this.maskedContainer.getChildComponents();
                $r = this1.keys();
                return $r;
            }(this));
            while ($it0.hasNext()) {
                var key = $it0.next();
                this.maskedContainer.disposeChildComponent(key);
            }
            var $it1 = this.originalSymbols.keys();
            while ($it1.hasNext()) {
                var key1 = $it1.next();
                this.originalSymbols.get(key1).dispose();
                this.originalSymbols.remove(key1);
            }
            this.totalVisibleSymbols = 0;
            this.originalSymbols = new _hcmn_.haxe_ds_StringMap();
        };
        smashThePigWinSymbols.WinSymbols.prototype.played = function() {
            this.totalVisibleSymbols--;
            if (this.totalVisibleSymbols == 0) this.baseEvents.getEvent(smashThePigWinSymbols.BaseEventsEnum.CALLBACK_RECIVED).dispatch("WinSymbols");
        };
        smashThePigWinSymbols.WinSymbols.prototype.__class__ = smashThePigWinSymbols.WinSymbols;
        smashThePigWinSymbols.LayoutController = function(winAnimations) {
            this.winFramesApplication = winAnimations;
            this.winSymbols = this.winFramesApplication.getWinSymbols();
            smashThePigWinSymbols.Controller.call(this, this);
        };
        smashThePigWinSymbols.LayoutController.__name__ = ["smashThePigWinSymbols", "LayoutController"];
        smashThePigWinSymbols.LayoutController.__super__ = smashThePigWinSymbols.Controller;
        for (var k in smashThePigWinSymbols.Controller.prototype) smashThePigWinSymbols.LayoutController.prototype[k] = smashThePigWinSymbols.Controller.prototype[k];
        smashThePigWinSymbols.LayoutController.prototype.winSymbols = null;
        smashThePigWinSymbols.LayoutController.prototype.winFramesApplication = null;
        smashThePigWinSymbols.LayoutController.prototype.getInterests = function() {
            return ["handleWinSymbols", "hideAll", "setVisible", "updateLayout"];
        };
        smashThePigWinSymbols.LayoutController.prototype.processMessage = function(message) {
            var _g = message._messageName;
            switch (_g) {
                case "updateLayout":
                    this.updateLayout(message._messageData);
                    break;
                case "handleWinSymbols":
                    this.handleWinSymbols(message._messageData);
                    break;
                case "hideAll":
                    this.hideAll();
                    break;
                case "setVisible":
                    this.setVisible(message._messageData);
                    break;
            }
        };
        smashThePigWinSymbols.LayoutController.prototype.setVisible = function(messageData) {
            var visible;
            visible = _hcmn_.js_Boot.__cast(messageData, _hcmn_.Bool);
            this.winFramesApplication.setVisible(visible);
        };
        smashThePigWinSymbols.LayoutController.prototype.handleWinSymbols = function(messageData) {
            var handleWinSymbols;
            handleWinSymbols = _hcmn_.js_Boot.__cast(messageData, smashThePigWinSymbols.HandleWinSymbolsPayload);
            this.winSymbols.show(handleWinSymbols.allWinningSymbols, handleWinSymbols.outcome);
        };
        smashThePigWinSymbols.LayoutController.prototype.hideAll = function() {
            this.winSymbols.hide();
        };
        smashThePigWinSymbols.LayoutController.prototype.updateLayout = function(messageData) {
            var layoutPayload;
            layoutPayload = _hcmn_.js_Boot.__cast(messageData, gameLayoutApi.ComponentLayout);
            var $it0 = this.winFramesApplication.layerContainers.keys();
            while ($it0.hasNext()) {
                var layerId = $it0.next();
                var layerPayload = layoutPayload.containers.get(layerId);
                if (layerPayload == null) continue;
                var stage;
                var this1 = smashThePigWinSymbols.ExternalService.displayProvider.getStages();
                stage = this1.get(layerPayload.stage);
                var container = this.winFramesApplication.layerContainers.get(layerId).getDisplayObject();
                try {
                    stage.removeChild(container);
                } catch (e) {
                    if (e instanceof js._Boot.HaxeError) e = e.val;
                    if (_hcmn_.js_Boot.__instanceof(e, Error)) {} else throw (e);
                }
                stage.addChild(container);
                container.setX(layerPayload.left);
                container.setY(layerPayload.top);
                container.setScaleX(layerPayload.width / container.getUserData().viewBuilderW);
                container.setScaleY(layerPayload.height / container.getUserData().viewBuilderH);
                container.setZIndex(layerPayload.zIndex);
            }
        };
        smashThePigWinSymbols.LayoutController.prototype.__class__ = smashThePigWinSymbols.LayoutController;
        smashThePigWinSymbols.WinSymbolsPortController = function(winAnimatorPort, layoutPort, winSymbols) {
            this.cellsNum = smashThePigWinSymbols.WinSymbolsModel.globalConfiguration.numberOfRows;
            this.reelsNum = smashThePigWinSymbols.WinSymbolsModel.globalConfiguration.numberOfColums;
            this.winAnimatorPort = winAnimatorPort;
            this.layoutPort = layoutPort;
            smashThePigWinSymbols.Controller.call(this, this);
            winSymbols.getBaseEvent(smashThePigWinSymbols.BaseEventsEnum.CALLBACK_RECIVED).add($bind(this, this.handleDisplayReady));
            this.winAnimatorPort.show().subscribe($bind(this, this.handleWinSymbols));
            this.winAnimatorPort.hideAll().subscribe($bind(this, this.hideAll));
            this.winAnimatorPort.setSubComponentVisible().subscribe($bind(this, this.handleSetVisible));
        };
        smashThePigWinSymbols.WinSymbolsPortController.__name__ = ["smashThePigWinSymbols", "WinSymbolsPortController"];
        smashThePigWinSymbols.WinSymbolsPortController.__super__ = smashThePigWinSymbols.Controller;
        for (var k in smashThePigWinSymbols.Controller.prototype) smashThePigWinSymbols.WinSymbolsPortController.prototype[k] = smashThePigWinSymbols.Controller.prototype[k];
        smashThePigWinSymbols.WinSymbolsPortController.prototype.winAnimatorPort = null;
        smashThePigWinSymbols.WinSymbolsPortController.prototype.reelsNum = null;
        smashThePigWinSymbols.WinSymbolsPortController.prototype.cellsNum = null;
        smashThePigWinSymbols.WinSymbolsPortController.prototype.layoutPort = null;
        smashThePigWinSymbols.WinSymbolsPortController.prototype.handleWinSymbols = function(e) {
            haxe.Log.trace("[LN] winSymbolsPortController.handleWinSymbols: ", {
                fileName: "WinSymbolsPortController.hx",
                lineNumber: 50,
                className: "smashthepig.components.winsymbols.component.imp.controllers.WinSymbolsPortController",
                methodName: "handleWinSymbols",
                customParams: [e.getPayload()]
            });
            var showWinAnimationPayload = e.getPayload();
            this.sendMessage(new smashThePigWinSymbols.WinAnimatorMessagePayload("handleWinSymbols", new smashThePigWinSymbols.HandleWinSymbolsPayload(showWinAnimationPayload.allWinningSymbols, showWinAnimationPayload.outcome)));
        };
        smashThePigWinSymbols.WinSymbolsPortController.prototype.getInterests = function() {
            return ["updateUpdatedComponentsPort"];
        };
        smashThePigWinSymbols.WinSymbolsPortController.prototype.processMessage = function(message) {
            var _g = message._messageName;
            switch (_g) {
                case "updateUpdatedComponentsPort":
                    this.updateLayoutUpdatedComponentsPort(message._messageData);
                    break;
            }
        };
        smashThePigWinSymbols.WinSymbolsPortController.prototype.updateLayoutUpdatedComponentsPort = function(messageData) {
            var instance;
            instance = _hcmn_.js_Boot.__cast(messageData, componentmodelComponentApi.IComponentInstance);
            this.layoutPort.getComponentLayoutUpdated().publish(instance);
        };
        smashThePigWinSymbols.WinSymbolsPortController.prototype.handleSetVisible = function(e) {
            this.sendMessage(new smashThePigWinSymbols.WinAnimatorMessagePayload("setVisible", e.getPayload()));
        };
        smashThePigWinSymbols.WinSymbolsPortController.prototype.hideAll = function(e) {
            this.sendMessage(new smashThePigWinSymbols.WinAnimatorMessagePayload("hideAll"));
        };
        smashThePigWinSymbols.WinSymbolsPortController.prototype.handleDisplayReady = function(evt) {
            this.winAnimatorPort.requestDelegation().publish(new smashThePigWinAnimatorPort.RequestDelegationPayload(smashThePigWinAnimatorPort.RequestDelegationPayload.GET_WIN_SYMBOLS_CREATED, null));
        };
        smashThePigWinSymbols.WinSymbolsPortController.prototype.handleCurrentWinLine = function(data) {
            this.winAnimatorPort.requestDelegation().publish(new smashThePigWinAnimatorPort.RequestDelegationPayload(smashThePigWinAnimatorPort.RequestDelegationPayload.GET_CURRENT_WIN, data));
        };
        smashThePigWinSymbols.WinSymbolsPortController.prototype.winLineCycleEnded = function(data) {
            this.winAnimatorPort.requestDelegation().publish(new smashThePigWinAnimatorPort.RequestDelegationPayload(smashThePigWinAnimatorPort.RequestDelegationPayload.GET_WIN_LINES_CYCLE_ANIMATED, null));
        };
        smashThePigWinSymbols.WinSymbolsPortController.prototype.__class__ = smashThePigWinSymbols.WinSymbolsPortController;
        smashThePigWinSymbols.BaseEventsEnum = {
            __ename__: ["smashThePigWinSymbols", "BaseEventsEnum"],
            __constructs__: ["WIN_FRAMES_CYCLE_ENDED", "CURRENT_WIN_LINE_SHOWN", "CALLBACK_RECIVED"]
        };
        smashThePigWinSymbols.BaseEventsEnum.CALLBACK_RECIVED = ["CALLBACK_RECIVED", 2];
        smashThePigWinSymbols.BaseEventsEnum.CALLBACK_RECIVED.toString = $estr;
        smashThePigWinSymbols.BaseEventsEnum.CALLBACK_RECIVED.__enum__ = smashThePigWinSymbols.BaseEventsEnum;
        smashThePigWinSymbols.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN = ["CURRENT_WIN_LINE_SHOWN", 1];
        smashThePigWinSymbols.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN.toString = $estr;
        smashThePigWinSymbols.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN.__enum__ = smashThePigWinSymbols.BaseEventsEnum;
        smashThePigWinSymbols.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED = ["WIN_FRAMES_CYCLE_ENDED", 0];
        smashThePigWinSymbols.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED.toString = $estr;
        smashThePigWinSymbols.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED.__enum__ = smashThePigWinSymbols.BaseEventsEnum;
        smashThePigWinSymbols.ComponentsEnum = {
            __ename__: ["smashThePigWinSymbols", "ComponentsEnum"],
            __constructs__: ["WIN_FRAMES", "SKATTER_SYMBOLS", "WIN_SYMBOLS", "TOP_SYMBOLS"]
        };
        smashThePigWinSymbols.ComponentsEnum.TOP_SYMBOLS = ["TOP_SYMBOLS", 3];
        smashThePigWinSymbols.ComponentsEnum.TOP_SYMBOLS.toString = $estr;
        smashThePigWinSymbols.ComponentsEnum.TOP_SYMBOLS.__enum__ = smashThePigWinSymbols.ComponentsEnum;
        smashThePigWinSymbols.ComponentsEnum.WIN_FRAMES = ["WIN_FRAMES", 0];
        smashThePigWinSymbols.ComponentsEnum.WIN_FRAMES.toString = $estr;
        smashThePigWinSymbols.ComponentsEnum.WIN_FRAMES.__enum__ = smashThePigWinSymbols.ComponentsEnum;
        smashThePigWinSymbols.ComponentsEnum.SKATTER_SYMBOLS = ["SKATTER_SYMBOLS", 1];
        smashThePigWinSymbols.ComponentsEnum.SKATTER_SYMBOLS.toString = $estr;
        smashThePigWinSymbols.ComponentsEnum.SKATTER_SYMBOLS.__enum__ = smashThePigWinSymbols.ComponentsEnum;
        smashThePigWinSymbols.ComponentsEnum.WIN_SYMBOLS = ["WIN_SYMBOLS", 2];
        smashThePigWinSymbols.ComponentsEnum.WIN_SYMBOLS.toString = $estr;
        smashThePigWinSymbols.ComponentsEnum.WIN_SYMBOLS.__enum__ = smashThePigWinSymbols.ComponentsEnum;
        smashThePigWinSymbols.InternalMVCConstants = function() {};
        smashThePigWinSymbols.InternalMVCConstants.__name__ = ["smashThePigWinSymbols", "InternalMVCConstants"];
        smashThePigWinSymbols.InternalMVCConstants.prototype.__class__ = smashThePigWinSymbols.InternalMVCConstants;
        smashThePigWinSymbols.BaseEvents = function() {
            this.events = new haxe.ds.EnumValueMap();
            this.registerEvents();
        };
        smashThePigWinSymbols.BaseEvents.__name__ = ["smashThePigWinSymbols", "BaseEvents"];
        smashThePigWinSymbols.BaseEvents.prototype.events = null;
        smashThePigWinSymbols.BaseEvents.prototype.registerEvents = function() {
            var value = new _hcmn_.msignal_Signal1();
            this.events.set(smashThePigWinSymbols.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED, value);
            var value1 = new _hcmn_.msignal_Signal1();
            this.events.set(smashThePigWinSymbols.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN, value1);
            var value2 = new _hcmn_.msignal_Signal1();
            this.events.set(smashThePigWinSymbols.BaseEventsEnum.CALLBACK_RECIVED, value2);
        };
        smashThePigWinSymbols.BaseEvents.prototype.getEvent = function(id) {
            return this.events.get(id);
        };
        smashThePigWinSymbols.BaseEvents.prototype.__class__ = smashThePigWinSymbols.BaseEvents;
        smashThePigWinSymbols.WinSymbolsModel = function(modelInitialised) {
            smashThePigWinSymbols.WinSymbolsModel.callback = modelInitialised;
        };
        smashThePigWinSymbols.WinSymbolsModel.__name__ = ["smashThePigWinSymbols", "WinSymbolsModel"];
        smashThePigWinSymbols.WinSymbolsModel.winFramesConfiguration = null;
        smashThePigWinSymbols.WinSymbolsModel.globalConfiguration = null;
        smashThePigWinSymbols.WinSymbolsModel.scaterSymbolsConfiguration = null;
        smashThePigWinSymbols.WinSymbolsModel.topSymbosConfiguration = null;
        smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration = null;
        smashThePigWinSymbols.WinSymbolsModel.callback = null;
        smashThePigWinSymbols.WinSymbolsModel.setupConfiguration = function(setupConfig) {
            smashThePigWinSymbols.WinSymbolsModel.winFramesConfiguration = setupConfig.winFramesConfiguration;
            smashThePigWinSymbols.WinSymbolsModel.globalConfiguration = setupConfig.winAnimatorGlobalConfiguration;
            smashThePigWinSymbols.WinSymbolsModel.scaterSymbolsConfiguration = setupConfig.scaterSymbolsConfiguration;
            smashThePigWinSymbols.WinSymbolsModel.topSymbosConfiguration = setupConfig.topSymbolsConfiguration;
            smashThePigWinSymbols.WinSymbolsModel.winSymbosConfiguration = setupConfig.winSymbolConfiguration;
            smashThePigWinSymbols.WinSymbolsModel.loadVBAssets();
        };
        smashThePigWinSymbols.WinSymbolsModel.loadVBAssets = function() {
            smashThePigWinSymbols.ExternalService.assetRegistry.getAssetsContent(smashThePigWinSymbols.WinSymbolsModel.globalConfiguration.vbAssets).then(function(data) {
                smashThePigWinSymbols.ExternalService.loadedAssets = data;
                smashThePigWinSymbols.WinSymbolsModel.loadMainAssets();
            });
        };
        smashThePigWinSymbols.WinSymbolsModel.loadMainAssets = function() {
            smashThePigWinSymbols.ExternalService.assetRegistry.getAsset(smashThePigWinSymbols.WinSymbolsModel.globalConfiguration.mainAssetsId).getContent().then(function(vba) {
                smashThePigWinSymbols.WinSymbolsModel.vba = vba;
                smashThePigWinSymbols.WinSymbolsModel.assetsLoaded = true;
                smashThePigWinSymbols.WinSymbolsModel.callback();
            });
        };
        smashThePigWinSymbols.WinSymbolsModel.prototype.__class__ = smashThePigWinSymbols.WinSymbolsModel;
        smashThePigWinSymbols.HandleWinSymbolsPayload = function(allWinningSymbols, outcome) {
            this.outcome = outcome;
            this.allWinningSymbols = allWinningSymbols;
        };
        smashThePigWinSymbols.HandleWinSymbolsPayload.__name__ = ["smashThePigWinSymbols", "HandleWinSymbolsPayload"];
        smashThePigWinSymbols.HandleWinSymbolsPayload.prototype.outcome = null;
        smashThePigWinSymbols.HandleWinSymbolsPayload.prototype.allWinningSymbols = null;
        smashThePigWinSymbols.HandleWinSymbolsPayload.prototype.__class__ = smashThePigWinSymbols.HandleWinSymbolsPayload;
        smashThePigWinSymbols.WinAnimatorMessagePayload = function(messageName, messageData) {
            this._messageName = messageName;
            this._messageData = messageData;
        };
        smashThePigWinSymbols.WinAnimatorMessagePayload.__name__ = ["smashThePigWinSymbols", "WinAnimatorMessagePayload"];
        smashThePigWinSymbols.WinAnimatorMessagePayload.prototype._messageName = null;
        smashThePigWinSymbols.WinAnimatorMessagePayload.prototype._messageData = null;
        smashThePigWinSymbols.WinAnimatorMessagePayload.prototype.__class__ = smashThePigWinSymbols.WinAnimatorMessagePayload;
        smashThePigWinSymbols.ExternalService.loadedAssets = new _hcmn_.haxe_ds_StringMap();;
        smashThePigWinSymbols.Controller._CONTROLLERS = [];;
        smashThePigWinSymbols.InternalMVCConstants.HANDLE_WIN_SYMBOLS = "handleWinSymbols";;
        smashThePigWinSymbols.InternalMVCConstants.HIDE_ALL = "hideAll";;
        smashThePigWinSymbols.InternalMVCConstants.SET_VISIBLE = "setVisible";;
        smashThePigWinSymbols.InternalMVCConstants.UPDATE_LAYOUT = "updateLayout";;
        smashThePigWinSymbols.InternalMVCConstants.UPDATE_UPDATED_COMPONENTS_PORT = "updateUpdatedComponentsPort";;
        smashThePigWinSymbols.WinSymbolsModel.FRAME_CONTAINER_REGULAR = "FRAME_CONTAINER_REGULAR";;
        smashThePigWinSymbols.WinSymbolsModel.FRAME_CONTAINER_TOP = "FRAME_CONTAINER_TOP";;
        smashThePigWinSymbols.WinSymbolsModel.FRAME_CONTAINER_BOTTOM = "FRAME_CONTAINER_BOTTOM";;
        smashThePigWinSymbols.WinSymbolsModel.FRAME_CONTAINER_CENTER = "FRAME_CONTAINER_CENTER";;
        smashThePigWinSymbols.WinSymbolsModel.FRAME_CONTAINER_SCATTER = "FRAME_CONTAINER_SCATTER";;
        smashThePigWinSymbols.WinSymbolsModel.initialised = false;;
        smashThePigWinSymbols.WinSymbolsModel.assetsLoaded = false;;
        smashThePigWinSymbols.WinSymbolsModel.vba = null;;
        return {
            exports: smashThePigWinSymbols,
            activator: smashThePigWinSymbols.Activator
        };
    });
//# sourceURL=smashThePigWinSymbols.js