define("smashThePigWinAnimatorPort", ["componentmodelComponentApi", "slotModelApi", "gameLayoutApi", "clientkernelEventbusApi"],
    function(componentmodelComponentApi, slotModelApi, gameLayoutApi, clientkernelEventbusApi) {
        "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 (!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.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.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 smashThePigWinAnimatorPort == 'undefined') {
            var smashThePigWinAnimatorPort = {};
        };

        smashThePigWinAnimatorPort.IWinAnimatorImplementationPort = function() {}
        smashThePigWinAnimatorPort.IWinAnimatorImplementationPort.prototype = {

            getAddToStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getShowOutcome: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHandleLandingSymbols: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHideOutcome: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getWinLineCycleAnimated: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getWinSymbolsCreated: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getCurrentWin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setVisible: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            show: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setupWinAnimatorComponents: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            requestDelegation: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            hideAll: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setSubComponentVisible: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            showScaterLanding: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            stopScaterLanding: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            requestStopScaterLanding: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };

        smashThePigWinAnimatorPort.IWinAnimatorPort = function() {}
        smashThePigWinAnimatorPort.IWinAnimatorPort.prototype = {

            getAddToStage: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getShowOutcome: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHandleLandingSymbols: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getHideOutcome: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getWinLineCycleAnimated: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getWinSymbolsCreated: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            getCurrentWin: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setVisible: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            show: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setupWinAnimatorComponents: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            requestDelegation: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            hideAll: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            setSubComponentVisible: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            showScaterLanding: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            stopScaterLanding: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            },
            requestStopScaterLanding: function() {
                return {
                    arguments: [],
                    returns: "*"
                };
            }
        };
        smashThePigWinAnimatorPort.WinAnimatorDeclaration = function() {};
        smashThePigWinAnimatorPort.WinAnimatorDeclaration = ck_implements(smashThePigWinAnimatorPort.WinAnimatorDeclaration, componentmodelComponentApi.IComponentDeclaration);
        smashThePigWinAnimatorPort.WinAnimatorDeclaration.__interfaces__ = [componentmodelComponentApi.IComponentDeclaration];
        smashThePigWinAnimatorPort.WinAnimatorDeclaration.__name__ = ["smashThePigWinAnimatorPort", "WinAnimatorDeclaration"];
        smashThePigWinAnimatorPort.WinAnimatorDeclaration.prototype.getChildComponents = function() {
            return null;
        };
        smashThePigWinAnimatorPort.WinAnimatorDeclaration.prototype.getReferredComponents = function() {
            return null;
        };
        smashThePigWinAnimatorPort.WinAnimatorDeclaration.prototype.getImplementedPorts = function() {
            return [smashThePigWinAnimatorPort.IWinAnimatorImplementationPort];
        };
        smashThePigWinAnimatorPort.WinAnimatorDeclaration.prototype.getUsedPorts = function() {
            return [slotModelApi.IOutcomePhasePort, gameLayoutApi.IGameLayoutPort];
        };
        smashThePigWinAnimatorPort.WinAnimatorDeclaration.prototype.__class__ = smashThePigWinAnimatorPort.WinAnimatorDeclaration;
        smashThePigWinAnimatorPort.WinAnimatorPort = function(bus) {
            this._requestDelagation = new clientkernelEventbusApi.Topic("winanimator:requestDelegation");
            this.win = new clientkernelEventbusApi.Topic("winanimator:currentWinLine");
            this.winSymbolsCreated = new clientkernelEventbusApi.Topic("winanimator:winSymbolsCreated");
            this.winLineCycleAnimated = new clientkernelEventbusApi.Topic("winanimator:winLineCycleAnimated");
            this._requestStopScaterLanding = new clientkernelEventbusApi.Topic("winanimator:requestStopScaterLanding");
            this._stopScaterLanding = new clientkernelEventbusApi.Topic("winanimator:stopScaterLanding");
            this._showScaterLanding = new clientkernelEventbusApi.Topic("winanimator:showScaterLanding");
            this._setSubComponentVisible = new clientkernelEventbusApi.Topic("winanimator:setSubComponentVisible");
            this._hideAll = new clientkernelEventbusApi.Topic("winanimator:hideAll");
            this._setupComponents = new clientkernelEventbusApi.Topic("winanimator:setupComponent");
            this._setVisible = new clientkernelEventbusApi.Topic("winanimator:setVisible");
            this._show = new clientkernelEventbusApi.Topic("winanimator:show");
            this.hideOutcome = new clientkernelEventbusApi.Topic("winanimator:hideOutcome");
            this.showLandingSymbols = new clientkernelEventbusApi.Topic("winanimator:showLandingSymbols");
            this.showOutcome = new clientkernelEventbusApi.Topic("winanimator:showOutcome");
            this.addToStage = new clientkernelEventbusApi.Topic("winanimator:addToStage");
            this.addToStage.connect(bus);
            this.showOutcome.connect(bus);
            this.showLandingSymbols.connect(bus);
            this.hideOutcome.connect(bus);
            this.winLineCycleAnimated.connect(bus);
            this.winSymbolsCreated.connect(bus);
            this.win.connect(bus);
            this._requestDelagation.connect(bus);
            this._setVisible.connect(bus);
            this._show.connect(bus);
            this._setupComponents.connect(bus);
            this._setSubComponentVisible.connect(bus);
            this._showScaterLanding.connect(bus);
            this._stopScaterLanding.connect(bus);
            this._requestStopScaterLanding.connect(bus);
            this._hideAll.connect(bus);
        };
        smashThePigWinAnimatorPort.WinAnimatorPort = ck_implements(smashThePigWinAnimatorPort.WinAnimatorPort, smashThePigWinAnimatorPort.IWinAnimatorPort);
        smashThePigWinAnimatorPort.WinAnimatorPort = ck_implements(smashThePigWinAnimatorPort.WinAnimatorPort, smashThePigWinAnimatorPort.IWinAnimatorImplementationPort);
        smashThePigWinAnimatorPort.WinAnimatorPort.__interfaces__ = [smashThePigWinAnimatorPort.IWinAnimatorPort, smashThePigWinAnimatorPort.IWinAnimatorImplementationPort];
        smashThePigWinAnimatorPort.WinAnimatorPort.__name__ = ["smashThePigWinAnimatorPort", "WinAnimatorPort"];
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.addToStage = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.showOutcome = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.showLandingSymbols = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.hideOutcome = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype._show = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype._setVisible = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype._setupComponents = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype._hideAll = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype._setSubComponentVisible = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype._showScaterLanding = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype._stopScaterLanding = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype._requestStopScaterLanding = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.winLineCycleAnimated = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.winSymbolsCreated = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.win = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype._requestDelagation = null;
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.getAddToStage = function() {
            return this.addToStage;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.getShowOutcome = function() {
            return this.showOutcome;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.getHandleLandingSymbols = function() {
            return this.showLandingSymbols;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.getHideOutcome = function() {
            return this.hideOutcome;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.getWinLineCycleAnimated = function() {
            return this.winLineCycleAnimated;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.getWinSymbolsCreated = function() {
            return this.winSymbolsCreated;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.getCurrentWin = function() {
            return this.win;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.setVisible = function() {
            return this._setVisible;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.show = function() {
            return this._show;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.setupWinAnimatorComponents = function() {
            return this._setupComponents;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.requestDelegation = function() {
            return this._requestDelagation;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.hideAll = function() {
            return this._hideAll;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.setSubComponentVisible = function() {
            return this._setSubComponentVisible;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.showScaterLanding = function() {
            return this._showScaterLanding;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.stopScaterLanding = function() {
            return this._stopScaterLanding;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.requestStopScaterLanding = function() {
            return this._requestStopScaterLanding;
        };
        smashThePigWinAnimatorPort.WinAnimatorPort.prototype.__class__ = smashThePigWinAnimatorPort.WinAnimatorPort;
        smashThePigWinAnimatorPort.WinAnimatorPortFactory = function() {};
        smashThePigWinAnimatorPort.WinAnimatorPortFactory = ck_implements(smashThePigWinAnimatorPort.WinAnimatorPortFactory, componentmodelComponentApi.IPortFactory);
        smashThePigWinAnimatorPort.WinAnimatorPortFactory.__interfaces__ = [componentmodelComponentApi.IPortFactory];
        smashThePigWinAnimatorPort.WinAnimatorPortFactory.__name__ = ["smashThePigWinAnimatorPort", "WinAnimatorPortFactory"];
        smashThePigWinAnimatorPort.WinAnimatorPortFactory.prototype.provide = function(channel) {
            return new smashThePigWinAnimatorPort.WinAnimatorPort(channel);
        };
        smashThePigWinAnimatorPort.WinAnimatorPortFactory.prototype["use"] = function(channel) {
            return new smashThePigWinAnimatorPort.WinAnimatorPort(channel);
        };
        smashThePigWinAnimatorPort.WinAnimatorPortFactory.prototype.__class__ = smashThePigWinAnimatorPort.WinAnimatorPortFactory;
        smashThePigWinAnimatorPort.ScaterSymbolsConfiguration = function(width, height, marginLeft, marginTop, xOffset, yOffset, symbolOffset) {
            this.marginTop = marginTop;
            this.marginLeft = marginLeft;
            this.height = height;
            this.width = width;
            this.xOffset = xOffset;
            this.yOffset = yOffset;
            this.symbolOffset = symbolOffset;
        };
        smashThePigWinAnimatorPort.ScaterSymbolsConfiguration.__name__ = ["smashThePigWinAnimatorPort", "ScaterSymbolsConfiguration"];
        smashThePigWinAnimatorPort.ScaterSymbolsConfiguration.prototype.width = null;
        smashThePigWinAnimatorPort.ScaterSymbolsConfiguration.prototype.height = null;
        smashThePigWinAnimatorPort.ScaterSymbolsConfiguration.prototype.marginLeft = null;
        smashThePigWinAnimatorPort.ScaterSymbolsConfiguration.prototype.marginTop = null;
        smashThePigWinAnimatorPort.ScaterSymbolsConfiguration.prototype.xOffset = null;
        smashThePigWinAnimatorPort.ScaterSymbolsConfiguration.prototype.yOffset = null;
        smashThePigWinAnimatorPort.ScaterSymbolsConfiguration.prototype.symbolOffset = null;
        smashThePigWinAnimatorPort.ScaterSymbolsConfiguration.prototype.__class__ = smashThePigWinAnimatorPort.ScaterSymbolsConfiguration;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration = function(width, height, marginLeft, marginTop, xOffset, yOffset, symbolOffset, topSymbolsMap, topSymbolName, topSymbolId) {
            this.marginTop = marginTop;
            this.marginLeft = marginLeft;
            this.height = height;
            this.width = width;
            this.xOffset = xOffset;
            this.yOffset = yOffset;
            this.symbolOffset = symbolOffset;
            this.topSymbolsMap = topSymbolsMap;
            this.topSymbolName = topSymbolName;
            this.topSymbolId = topSymbolId;
        };
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.__name__ = ["smashThePigWinAnimatorPort", "TopSymbolsConfiguration"];
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.width = null;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.height = null;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.marginLeft = null;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.marginTop = null;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.xOffset = null;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.yOffset = null;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.symbolOffset = null;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.topSymbolsMap = null;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.topSymbolName = null;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.topSymbolId = null;
        smashThePigWinAnimatorPort.TopSymbolsConfiguration.prototype.__class__ = smashThePigWinAnimatorPort.TopSymbolsConfiguration;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration = function(reelWidth, reelHeight, numberOfColums, numberOfRows, vbAssets, mainAssetsId, scaterSymbolName, scaterSymbolId, handleShowOutcomeOffset, bonusWinType) {
            this.numberOfRows = numberOfRows;
            this.numberOfColums = numberOfColums;
            this.reelHeight = reelHeight;
            this.reelWidth = reelWidth;
            this.vbAssets = vbAssets;
            this.mainAssetsId = mainAssetsId;
            this.scaterSymbolName = scaterSymbolName;
            this.scaterSymbolId = scaterSymbolId;
            this.handleShowOutcomeOffset = handleShowOutcomeOffset;
            this.bonusWinType = bonusWinType;
        };
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.__name__ = ["smashThePigWinAnimatorPort", "WinAnimatorGlobalConfiguration"];
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.bonusWinType = null;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.reelWidth = null;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.reelHeight = null;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.numberOfColums = null;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.numberOfRows = null;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.vbAssets = null;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.mainAssetsId = null;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.scaterSymbolName = null;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.scaterSymbolId = null;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.handleShowOutcomeOffset = null;
        smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration.prototype.__class__ = smashThePigWinAnimatorPort.WinAnimatorGlobalConfiguration;
        smashThePigWinAnimatorPort.WinElementOffset = function(x, y) {
            this.x = x;
            this.y = y;
        };
        smashThePigWinAnimatorPort.WinElementOffset.__name__ = ["smashThePigWinAnimatorPort", "WinElementOffset"];
        smashThePigWinAnimatorPort.WinElementOffset.prototype.x = null;
        smashThePigWinAnimatorPort.WinElementOffset.prototype.y = null;
        smashThePigWinAnimatorPort.WinElementOffset.prototype.__class__ = smashThePigWinAnimatorPort.WinElementOffset;
        smashThePigWinAnimatorPort.WinFramesConfiguration = function(width, height, marginLeft, marginTop, xOffset, yOffset, symbolOffset) {
            this.marginTop = marginTop;
            this.marginLeft = marginLeft;
            this.height = height;
            this.width = width;
            this.xOffset = xOffset;
            this.yOffset = yOffset;
            this.symbolOffset = symbolOffset;
        };
        smashThePigWinAnimatorPort.WinFramesConfiguration.__name__ = ["smashThePigWinAnimatorPort", "WinFramesConfiguration"];
        smashThePigWinAnimatorPort.WinFramesConfiguration.prototype.width = null;
        smashThePigWinAnimatorPort.WinFramesConfiguration.prototype.height = null;
        smashThePigWinAnimatorPort.WinFramesConfiguration.prototype.marginLeft = null;
        smashThePigWinAnimatorPort.WinFramesConfiguration.prototype.marginTop = null;
        smashThePigWinAnimatorPort.WinFramesConfiguration.prototype.xOffset = null;
        smashThePigWinAnimatorPort.WinFramesConfiguration.prototype.yOffset = null;
        smashThePigWinAnimatorPort.WinFramesConfiguration.prototype.symbolOffset = null;
        smashThePigWinAnimatorPort.WinFramesConfiguration.prototype.__class__ = smashThePigWinAnimatorPort.WinFramesConfiguration;
        smashThePigWinAnimatorPort.WinSymbolsConfiguration = function(width, height, marginLeft, marginTop, xOffset, yOffset, symbolOffset, winSymboslMap, winSymboslOffsetsMap) {
            this.winSymboslMap = winSymboslMap;
            this.marginTop = marginTop;
            this.marginLeft = marginLeft;
            this.height = height;
            this.width = width;
            this.xOffset = xOffset;
            this.yOffset = yOffset;
            this.symbolOffset = symbolOffset;
            this.winSymboslOffsetsMap = winSymboslOffsetsMap;
        };
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.__name__ = ["smashThePigWinAnimatorPort", "WinSymbolsConfiguration"];
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.prototype.winSymboslMap = null;
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.prototype.width = null;
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.prototype.height = null;
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.prototype.marginLeft = null;
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.prototype.marginTop = null;
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.prototype.xOffset = null;
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.prototype.yOffset = null;
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.prototype.symbolOffset = null;
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.prototype.winSymboslOffsetsMap = null;
        smashThePigWinAnimatorPort.WinSymbolsConfiguration.prototype.__class__ = smashThePigWinAnimatorPort.WinSymbolsConfiguration;
        smashThePigWinAnimatorPort.BaseEventsEnum = {
            __ename__: ["smashThePigWinAnimatorPort", "BaseEventsEnum"],
            __constructs__: ["WIN_FRAMES_CYCLE_ENDED", "CURRENT_WIN_LINE_SHOWN", "CALLBACK_RECIVED"]
        };
        smashThePigWinAnimatorPort.BaseEventsEnum.CALLBACK_RECIVED = ["CALLBACK_RECIVED", 2];
        smashThePigWinAnimatorPort.BaseEventsEnum.CALLBACK_RECIVED.toString = $estr;
        smashThePigWinAnimatorPort.BaseEventsEnum.CALLBACK_RECIVED.__enum__ = smashThePigWinAnimatorPort.BaseEventsEnum;
        smashThePigWinAnimatorPort.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN = ["CURRENT_WIN_LINE_SHOWN", 1];
        smashThePigWinAnimatorPort.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN.toString = $estr;
        smashThePigWinAnimatorPort.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN.__enum__ = smashThePigWinAnimatorPort.BaseEventsEnum;
        smashThePigWinAnimatorPort.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED = ["WIN_FRAMES_CYCLE_ENDED", 0];
        smashThePigWinAnimatorPort.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED.toString = $estr;
        smashThePigWinAnimatorPort.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED.__enum__ = smashThePigWinAnimatorPort.BaseEventsEnum;
        smashThePigWinAnimatorPort.ComponentsEnum = {
            __ename__: ["smashThePigWinAnimatorPort", "ComponentsEnum"],
            __constructs__: ["WIN_FRAMES", "SKATTER_SYMBOLS", "WIN_SYMBOLS", "TOP_SYMBOLS"]
        };
        smashThePigWinAnimatorPort.ComponentsEnum.TOP_SYMBOLS = ["TOP_SYMBOLS", 3];
        smashThePigWinAnimatorPort.ComponentsEnum.TOP_SYMBOLS.toString = $estr;
        smashThePigWinAnimatorPort.ComponentsEnum.TOP_SYMBOLS.__enum__ = smashThePigWinAnimatorPort.ComponentsEnum;
        smashThePigWinAnimatorPort.ComponentsEnum.WIN_FRAMES = ["WIN_FRAMES", 0];
        smashThePigWinAnimatorPort.ComponentsEnum.WIN_FRAMES.toString = $estr;
        smashThePigWinAnimatorPort.ComponentsEnum.WIN_FRAMES.__enum__ = smashThePigWinAnimatorPort.ComponentsEnum;
        smashThePigWinAnimatorPort.ComponentsEnum.SKATTER_SYMBOLS = ["SKATTER_SYMBOLS", 1];
        smashThePigWinAnimatorPort.ComponentsEnum.SKATTER_SYMBOLS.toString = $estr;
        smashThePigWinAnimatorPort.ComponentsEnum.SKATTER_SYMBOLS.__enum__ = smashThePigWinAnimatorPort.ComponentsEnum;
        smashThePigWinAnimatorPort.ComponentsEnum.WIN_SYMBOLS = ["WIN_SYMBOLS", 2];
        smashThePigWinAnimatorPort.ComponentsEnum.WIN_SYMBOLS.toString = $estr;
        smashThePigWinAnimatorPort.ComponentsEnum.WIN_SYMBOLS.__enum__ = smashThePigWinAnimatorPort.ComponentsEnum;
        smashThePigWinAnimatorPort.BaseEvents = function() {
            this.events = new haxe.ds.EnumValueMap();
            this.registerEvents();
        };
        smashThePigWinAnimatorPort.BaseEvents.__name__ = ["smashThePigWinAnimatorPort", "BaseEvents"];
        smashThePigWinAnimatorPort.BaseEvents.prototype.events = null;
        smashThePigWinAnimatorPort.BaseEvents.prototype.registerEvents = function() {
            var value = new _hcmn_.msignal_Signal1();
            this.events.set(smashThePigWinAnimatorPort.BaseEventsEnum.WIN_FRAMES_CYCLE_ENDED, value);
            var value1 = new _hcmn_.msignal_Signal1();
            this.events.set(smashThePigWinAnimatorPort.BaseEventsEnum.CURRENT_WIN_LINE_SHOWN, value1);
            var value2 = new _hcmn_.msignal_Signal1();
            this.events.set(smashThePigWinAnimatorPort.BaseEventsEnum.CALLBACK_RECIVED, value2);
        };
        smashThePigWinAnimatorPort.BaseEvents.prototype.getEvent = function(id) {
            return this.events.get(id);
        };
        smashThePigWinAnimatorPort.BaseEvents.prototype.__class__ = smashThePigWinAnimatorPort.BaseEvents;
        smashThePigWinAnimatorPort.RequestDelegationPayload = function(messageName, messageData) {
            this.messageData = messageData;
            this.messageName = messageName;
        };
        smashThePigWinAnimatorPort.RequestDelegationPayload.__name__ = ["smashThePigWinAnimatorPort", "RequestDelegationPayload"];
        smashThePigWinAnimatorPort.RequestDelegationPayload.prototype.messageData = null;
        smashThePigWinAnimatorPort.RequestDelegationPayload.prototype.messageName = null;
        smashThePigWinAnimatorPort.RequestDelegationPayload.prototype.__class__ = smashThePigWinAnimatorPort.RequestDelegationPayload;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload = function(scaterSymbolsConfiguration, topSymbolsConfiguration, winFramesConfiguration, winSymbolConfiguration, winAnimatorGlobalConfiguration) {
            this.FRAME_CONTAINER_SCATTER = "FRAME_CONTAINER_SCATTER";
            this.FRAME_CONTAINER_CENTER = "FRAME_CONTAINER_CENTER";
            this.FRAME_CONTAINER_BOTTOM = "FRAME_CONTAINER_BOTTOM";
            this.FRAME_CONTAINER_TOP = "FRAME_CONTAINER_TOP";
            this.FRAME_CONTAINER_REGULAR = "FRAME_CONTAINER_REGULAR";
            this.scaterSymbolsConfiguration = scaterSymbolsConfiguration;
            this.topSymbolsConfiguration = topSymbolsConfiguration;
            this.winFramesConfiguration = winFramesConfiguration;
            this.winSymbolConfiguration = winSymbolConfiguration;
            this.winAnimatorGlobalConfiguration = winAnimatorGlobalConfiguration;
        };
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.__name__ = ["smashThePigWinAnimatorPort", "SetupWinAnimatorComponentsPayload"];
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.FRAME_CONTAINER_REGULAR = null;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.FRAME_CONTAINER_TOP = null;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.FRAME_CONTAINER_BOTTOM = null;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.FRAME_CONTAINER_CENTER = null;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.FRAME_CONTAINER_SCATTER = null;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.winAnimatorGlobalConfiguration = null;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.winSymbolConfiguration = null;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.winFramesConfiguration = null;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.topSymbolsConfiguration = null;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.scaterSymbolsConfiguration = null;
        smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload.prototype.__class__ = smashThePigWinAnimatorPort.SetupWinAnimatorComponentsPayload;
        smashThePigWinAnimatorPort.ShowOutcomeOptions = function(lineTime, spinOutcome, loop, landingSymbols) {
            this.lineTime = lineTime;
            this.spinOutcome = spinOutcome;
            this.loop = loop;
            this.landingSymbols = landingSymbols;
        };
        smashThePigWinAnimatorPort.ShowOutcomeOptions.__name__ = ["smashThePigWinAnimatorPort", "ShowOutcomeOptions"];
        smashThePigWinAnimatorPort.ShowOutcomeOptions.prototype.reelStopped = null;
        smashThePigWinAnimatorPort.ShowOutcomeOptions.prototype.lineTime = null;
        smashThePigWinAnimatorPort.ShowOutcomeOptions.prototype.loop = null;
        smashThePigWinAnimatorPort.ShowOutcomeOptions.prototype.spinOutcome = null;
        smashThePigWinAnimatorPort.ShowOutcomeOptions.prototype.landingSymbols = null;
        smashThePigWinAnimatorPort.ShowOutcomeOptions.prototype.__class__ = smashThePigWinAnimatorPort.ShowOutcomeOptions;
        smashThePigWinAnimatorPort.ShowScaterLandingPayload = function(landingSymbols, reelStopped) {
            this.reelStopped = reelStopped;
            this.landingSymbols = landingSymbols;
        };
        smashThePigWinAnimatorPort.ShowScaterLandingPayload.__name__ = ["smashThePigWinAnimatorPort", "ShowScaterLandingPayload"];
        smashThePigWinAnimatorPort.ShowScaterLandingPayload.prototype.reelStopped = null;
        smashThePigWinAnimatorPort.ShowScaterLandingPayload.prototype.landingSymbols = null;
        smashThePigWinAnimatorPort.ShowScaterLandingPayload.prototype.__class__ = smashThePigWinAnimatorPort.ShowScaterLandingPayload;
        smashThePigWinAnimatorPort.ShowWinAnimationPayload = function(allWinningSymbols, outcome, outcomeOptionsPayload) {
            this.outcomeOptionsPayload = outcomeOptionsPayload;
            this.outcome = outcome;
            this.allWinningSymbols = allWinningSymbols;
        };
        smashThePigWinAnimatorPort.ShowWinAnimationPayload.__name__ = ["smashThePigWinAnimatorPort", "ShowWinAnimationPayload"];
        smashThePigWinAnimatorPort.ShowWinAnimationPayload.prototype.allWinningSymbols = null;
        smashThePigWinAnimatorPort.ShowWinAnimationPayload.prototype.outcome = null;
        smashThePigWinAnimatorPort.ShowWinAnimationPayload.prototype.outcomeOptionsPayload = null;
        smashThePigWinAnimatorPort.ShowWinAnimationPayload.prototype.__class__ = smashThePigWinAnimatorPort.ShowWinAnimationPayload;
        smashThePigWinAnimatorPort.StagePayload = function(stageId, x, y, zIndex, scale) {
            if (scale == null) scale = 1;
            this.stageId = stageId;
            this.x = x;
            this.y = y;
            this.zIndex = zIndex;
            this.scale = scale;
        };
        smashThePigWinAnimatorPort.StagePayload.__name__ = ["smashThePigWinAnimatorPort", "StagePayload"];
        smashThePigWinAnimatorPort.StagePayload.prototype.stageId = null;
        smashThePigWinAnimatorPort.StagePayload.prototype.zIndex = null;
        smashThePigWinAnimatorPort.StagePayload.prototype.x = null;
        smashThePigWinAnimatorPort.StagePayload.prototype.y = null;
        smashThePigWinAnimatorPort.StagePayload.prototype.scale = null;
        smashThePigWinAnimatorPort.StagePayload.prototype.__class__ = smashThePigWinAnimatorPort.StagePayload;

        smashThePigWinAnimatorPort.IWinAnimatorView = function() {}
        smashThePigWinAnimatorPort.IWinAnimatorView.prototype = {

            show: function(showWinAnimationPayload) {
                return {
                    arguments: ["*"],
                    returns: "void"
                };
            },
            hide: function() {
                return {
                    arguments: [],
                    returns: "void"
                };
            }
        };
        smashThePigWinAnimatorPort.RequestDelegationPayload.GET_WIN_SYMBOLS_CREATED = "getWinSymbolsCreated";;
        smashThePigWinAnimatorPort.RequestDelegationPayload.GET_CURRENT_WIN = "getCurrentWin";;
        smashThePigWinAnimatorPort.RequestDelegationPayload.GET_WIN_LINES_CYCLE_ANIMATED = "getWinLineCycleAnimated";;
        return {
            exports: smashThePigWinAnimatorPort
        };
    });
//# sourceURL=smashThePigWinAnimatorPort.js