home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Esportes / GHtP.swf / scripts / __Packages / MochiAd.as < prev   
Text File  |  2008-09-03  |  19KB  |  640 lines
  1. class MochiAd
  2. {
  3.    function MochiAd()
  4.    {
  5.    }
  6.    static function getVersion()
  7.    {
  8.       return "2.5";
  9.    }
  10.    static function showPreGameAd(options)
  11.    {
  12.       var _loc26_ = {clip:_root,ad_timeout:3000,fadeout_time:250,regpt:"o",method:"showPreloaderAd",color:16747008,background:16777161,outline:13994812,no_progress_bar:false,ad_started:function()
  13.       {
  14.          this.clip.stop();
  15.       },ad_finished:function()
  16.       {
  17.          this.clip.play();
  18.       },ad_failed:function()
  19.       {
  20.       },ad_loaded:function(width, height)
  21.       {
  22.       },ad_skipped:function()
  23.       {
  24.       },ad_progress:function(percent)
  25.       {
  26.       }};
  27.       options = MochiAd._parseOptions(options,_loc26_);
  28.       if("c862232051e0a94e1c3609b3916ddb17".substr(0) == "dfeada81ac97cde83665f81c12da7def")
  29.       {
  30.          options.ad_started();
  31.          options.ad_finished();
  32.          return undefined;
  33.       }
  34.       var clip = options.clip;
  35.       var _loc22_ = 11000;
  36.       var _loc25_ = options.ad_timeout;
  37.       delete options.ad_timeout;
  38.       var fadeout_time = options.fadeout_time;
  39.       delete options.fadeout_time;
  40.       if(!MochiAd.load(options))
  41.       {
  42.          options.ad_failed();
  43.          options.ad_finished();
  44.          return undefined;
  45.       }
  46.       options.ad_started();
  47.       var mc = clip._mochiad;
  48.       mc.onUnload = function()
  49.       {
  50.          options.ad_finished();
  51.       };
  52.       var _loc14_ = MochiAd._getRes(options);
  53.       var _loc4_ = _loc14_[0];
  54.       var _loc13_ = _loc14_[1];
  55.       mc._x = _loc4_ * 0.5;
  56.       mc._y = _loc13_ * 0.5;
  57.       var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  58.       chk._x = _loc4_ * -0.5;
  59.       chk._y = _loc13_ * -0.5;
  60.       var _loc6_ = chk.createEmptyMovieClip("_mochiad_bar",4);
  61.       if(options.no_progress_bar)
  62.       {
  63.          _loc6_._visible = false;
  64.          delete options.no_progress_bar;
  65.       }
  66.       else
  67.       {
  68.          _loc6_._x = 10;
  69.          _loc6_._y = _loc13_ - 20;
  70.       }
  71.       var _loc21_ = options.color;
  72.       delete options.color;
  73.       var _loc19_ = options.background;
  74.       delete options.background;
  75.       var _loc23_ = options.outline;
  76.       delete options.outline;
  77.       var _loc5_ = _loc6_.createEmptyMovieClip("_outline",1);
  78.       _loc5_.beginFill(_loc19_);
  79.       _loc5_.moveTo(0,0);
  80.       _loc5_.lineTo(_loc4_ - 20,0);
  81.       _loc5_.lineTo(_loc4_ - 20,10);
  82.       _loc5_.lineTo(0,10);
  83.       _loc5_.lineTo(0,0);
  84.       _loc5_.endFill();
  85.       var _loc3_ = _loc6_.createEmptyMovieClip("_inside",2);
  86.       _loc3_.beginFill(_loc21_);
  87.       _loc3_.moveTo(0,0);
  88.       _loc3_.lineTo(_loc4_ - 20,0);
  89.       _loc3_.lineTo(_loc4_ - 20,10);
  90.       _loc3_.lineTo(0,10);
  91.       _loc3_.lineTo(0,0);
  92.       _loc3_.endFill();
  93.       _loc3_._xscale = 0;
  94.       var _loc7_ = _loc6_.createEmptyMovieClip("_outline",3);
  95.       _loc7_.lineStyle(0,_loc23_,100);
  96.       _loc7_.moveTo(0,0);
  97.       _loc7_.lineTo(_loc4_ - 20,0);
  98.       _loc7_.lineTo(_loc4_ - 20,10);
  99.       _loc7_.lineTo(0,10);
  100.       _loc7_.lineTo(0,0);
  101.       chk.ad_msec = _loc22_;
  102.       chk.ad_timeout = _loc25_;
  103.       chk.started = getTimer();
  104.       chk.showing = false;
  105.       chk.last_pcnt = 0;
  106.       chk.fadeout_time = fadeout_time;
  107.       chk.fadeFunction = function()
  108.       {
  109.          var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  110.          if(_loc2_ > 0)
  111.          {
  112.             this._parent._alpha = _loc2_;
  113.          }
  114.          else
  115.          {
  116.             var _loc3_ = this._parent._parent;
  117.             MochiAd.unload(_loc3_);
  118.             delete this.onEnterFrame;
  119.          }
  120.       };
  121.       mc.lc.regContLC = function(lc_name)
  122.       {
  123.          mc._containerLCName = lc_name;
  124.       };
  125.       var sendHostProgress = false;
  126.       mc.lc.sendHostLoadProgress = function(lc_name)
  127.       {
  128.          sendHostProgress = true;
  129.       };
  130.       mc.lc.adLoaded = options.ad_loaded;
  131.       mc.lc.adSkipped = options.ad_skipped;
  132.       mc.lc.adjustProgress = function(msec)
  133.       {
  134.          var _loc2_ = this.mc._mochiad_wait;
  135.          _loc2_.server_control = true;
  136.          _loc2_.started = getTimer();
  137.          _loc2_.ad_msec = msec;
  138.       };
  139.       mc.lc.rpc = function(callbackID, arg)
  140.       {
  141.          MochiAd.rpc(clip,callbackID,arg);
  142.       };
  143.       mc.rpcTestFn = function(s)
  144.       {
  145.          return s;
  146.       };
  147.       chk.onEnterFrame = function()
  148.       {
  149.          var _loc6_ = this._parent._parent;
  150.          var _loc11_ = this._parent._mochiad_ctr;
  151.          var _loc5_ = getTimer() - this.started;
  152.          var _loc3_ = false;
  153.          var _loc4_ = _loc6_.getBytesTotal();
  154.          var _loc8_ = _loc6_.getBytesLoaded();
  155.          var _loc2_ = 100 * _loc8_ / _loc4_;
  156.          var _loc10_ = 100 * _loc5_ / chk.ad_msec;
  157.          var _loc9_ = this._mochiad_bar._inside;
  158.          var _loc13_ = Math.min(100,Math.min(_loc2_ || 0,_loc10_));
  159.          _loc13_ = Math.max(this.last_pcnt,_loc13_);
  160.          this.last_pcnt = _loc13_;
  161.          _loc9_._xscale = _loc13_;
  162.          options.ad_progress(_loc13_);
  163.          if(sendHostProgress)
  164.          {
  165.             clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{id:"hostLoadPcnt",pcnt:_loc2_});
  166.             if(_loc2_ == 100)
  167.             {
  168.                sendHostProgress = false;
  169.             }
  170.          }
  171.          if(!chk.showing)
  172.          {
  173.             var _loc7_ = _loc11_.getBytesTotal();
  174.             if(_loc7_ > 0 || typeof _loc7_ == "undefined")
  175.             {
  176.                chk.showing = true;
  177.                chk.started = getTimer();
  178.             }
  179.             else if(_loc5_ > chk.ad_timeout && _loc2_ == 100)
  180.             {
  181.                options.ad_failed();
  182.                _loc3_ = true;
  183.             }
  184.          }
  185.          if(_loc5_ > chk.ad_msec)
  186.          {
  187.             _loc3_ = true;
  188.          }
  189.          if(_loc4_ > 0 && _loc8_ >= _loc4_ && _loc3_)
  190.          {
  191.             if(this.server_control)
  192.             {
  193.                delete this.onEnterFrame;
  194.             }
  195.             else
  196.             {
  197.                this.fadeout_start = getTimer();
  198.                this.onEnterFrame = chk.fadeFunction;
  199.             }
  200.          }
  201.       };
  202.    }
  203.    static function showClickAwayAd(options)
  204.    {
  205.       var _loc9_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showClickAwayAd",res:"300x250",no_bg:true,ad_started:function()
  206.       {
  207.       },ad_finished:function()
  208.       {
  209.       },ad_loaded:function(width, height)
  210.       {
  211.       },ad_failed:function()
  212.       {
  213.       },ad_skipped:function()
  214.       {
  215.       }};
  216.       options = MochiAd._parseOptions(options,_loc9_);
  217.       var clip = options.clip;
  218.       var _loc8_ = options.ad_timeout;
  219.       delete options.ad_timeout;
  220.       if(!MochiAd.load(options))
  221.       {
  222.          options.ad_failed();
  223.          options.ad_finished();
  224.          return undefined;
  225.       }
  226.       options.ad_started();
  227.       var mc = clip._mochiad;
  228.       mc.onUnload = function()
  229.       {
  230.          options.ad_finished();
  231.       };
  232.       var _loc4_ = MochiAd._getRes(options);
  233.       var _loc10_ = _loc4_[0];
  234.       var _loc7_ = _loc4_[1];
  235.       mc._x = _loc10_ * 0.5;
  236.       mc._y = _loc7_ * 0.5;
  237.       var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  238.       chk.ad_timeout = _loc8_;
  239.       chk.started = getTimer();
  240.       chk.showing = false;
  241.       mc.lc.adLoaded = options.ad_loaded;
  242.       mc.lc.adSkipped = options.ad_skipped;
  243.       mc.lc.rpc = function(callbackID, arg)
  244.       {
  245.          MochiAd.rpc(clip,callbackID,arg);
  246.       };
  247.       mc.rpcTestFn = function(s)
  248.       {
  249.          return s;
  250.       };
  251.       var _loc20_ = false;
  252.       mc.lc.regContLC = function(lc_name)
  253.       {
  254.          mc._containerLCName = lc_name;
  255.       };
  256.       chk.onEnterFrame = function()
  257.       {
  258.          var _loc5_ = this._parent._mochiad_ctr;
  259.          var _loc4_ = getTimer() - this.started;
  260.          var _loc2_ = false;
  261.          if(!chk.showing)
  262.          {
  263.             var _loc3_ = _loc5_.getBytesTotal();
  264.             if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  265.             {
  266.                _loc2_ = true;
  267.                chk.showing = true;
  268.                chk.started = getTimer();
  269.             }
  270.             else if(_loc4_ > chk.ad_timeout)
  271.             {
  272.                options.ad_failed();
  273.                _loc2_ = true;
  274.             }
  275.          }
  276.          if(_loc2_)
  277.          {
  278.             delete this.onEnterFrame;
  279.          }
  280.       };
  281.    }
  282.    static function showInterLevelAd(options)
  283.    {
  284.       var _loc13_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showTimedAd",ad_started:function()
  285.       {
  286.          this.clip.stop();
  287.       },ad_finished:function()
  288.       {
  289.          this.clip.play();
  290.       },ad_failed:function()
  291.       {
  292.       },ad_loaded:function(width, height)
  293.       {
  294.       },ad_skipped:function()
  295.       {
  296.       }};
  297.       options = MochiAd._parseOptions(options,_loc13_);
  298.       var clip = options.clip;
  299.       var _loc10_ = 11000;
  300.       var _loc12_ = options.ad_timeout;
  301.       delete options.ad_timeout;
  302.       var fadeout_time = options.fadeout_time;
  303.       delete options.fadeout_time;
  304.       if(!MochiAd.load(options))
  305.       {
  306.          options.ad_failed();
  307.          options.ad_finished();
  308.          return undefined;
  309.       }
  310.       options.ad_started();
  311.       var mc = clip._mochiad;
  312.       mc.onUnload = function()
  313.       {
  314.          options.ad_finished();
  315.       };
  316.       var _loc5_ = MochiAd._getRes(options);
  317.       var _loc14_ = _loc5_[0];
  318.       var _loc11_ = _loc5_[1];
  319.       mc._x = _loc14_ * 0.5;
  320.       mc._y = _loc11_ * 0.5;
  321.       var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  322.       chk.ad_msec = _loc10_;
  323.       chk.ad_timeout = _loc12_;
  324.       chk.started = getTimer();
  325.       chk.showing = false;
  326.       chk.fadeout_time = fadeout_time;
  327.       chk.fadeFunction = function()
  328.       {
  329.          var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  330.          if(_loc2_ > 0)
  331.          {
  332.             this._parent._alpha = _loc2_;
  333.          }
  334.          else
  335.          {
  336.             var _loc3_ = this._parent._parent;
  337.             MochiAd.unload(_loc3_);
  338.             delete this.onEnterFrame;
  339.          }
  340.       };
  341.       mc.lc.adLoaded = options.ad_loaded;
  342.       mc.lc.adSkipped = options.ad_skipped;
  343.       mc.lc.adjustProgress = function(msec)
  344.       {
  345.          var _loc2_ = this.mc._mochiad_wait;
  346.          _loc2_.server_control = true;
  347.          _loc2_.started = getTimer();
  348.          _loc2_.ad_msec = msec - 250;
  349.       };
  350.       mc.lc.rpc = function(callbackID, arg)
  351.       {
  352.          MochiAd.rpc(clip,callbackID,arg);
  353.       };
  354.       mc.rpcTestFn = function(s)
  355.       {
  356.          return s;
  357.       };
  358.       chk.onEnterFrame = function()
  359.       {
  360.          var _loc5_ = this._parent._mochiad_ctr;
  361.          var _loc4_ = getTimer() - this.started;
  362.          var _loc2_ = false;
  363.          if(!chk.showing)
  364.          {
  365.             var _loc3_ = _loc5_.getBytesTotal();
  366.             if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  367.             {
  368.                chk.showing = true;
  369.                chk.started = getTimer();
  370.             }
  371.             else if(_loc4_ > chk.ad_timeout)
  372.             {
  373.                options.ad_failed();
  374.                _loc2_ = true;
  375.             }
  376.          }
  377.          if(_loc4_ > chk.ad_msec)
  378.          {
  379.             _loc2_ = true;
  380.          }
  381.          if(_loc2_)
  382.          {
  383.             if(this.server_control)
  384.             {
  385.                delete this.onEnterFrame;
  386.             }
  387.             else
  388.             {
  389.                this.fadeout_start = getTimer();
  390.                this.onEnterFrame = this.fadeFunction;
  391.             }
  392.          }
  393.       };
  394.    }
  395.    static function showPreloaderAd(options)
  396.    {
  397.       MochiAd.showPreGameAd(options);
  398.    }
  399.    static function showTimedAd(options)
  400.    {
  401.       MochiAd.showInterLevelAd(options);
  402.    }
  403.    static function _allowDomains(server)
  404.    {
  405.       var _loc1_ = server.split("/")[2].split(":")[0];
  406.       if(System.security)
  407.       {
  408.          if(System.security.allowDomain)
  409.          {
  410.             System.security.allowDomain("*");
  411.             System.security.allowDomain(_loc1_);
  412.          }
  413.          if(System.security.allowInsecureDomain)
  414.          {
  415.             System.security.allowInsecureDomain("*");
  416.             System.security.allowInsecureDomain(_loc1_);
  417.          }
  418.       }
  419.       return _loc1_;
  420.    }
  421.    static function load(options)
  422.    {
  423.       var _loc13_ = {clip:_root,server:"http://x.mochiads.com/srv/1/",method:"load",depth:10333,id:"_UNKNOWN_"};
  424.       options = MochiAd._parseOptions(options,_loc13_);
  425.       options.swfv = options.clip.getSWFVersion() || 6;
  426.       options.mav = MochiAd.getVersion();
  427.       var _loc9_ = options.clip;
  428.       if(!MochiAd._isNetworkAvailable())
  429.       {
  430.          return null;
  431.       }
  432.       if(_loc9_._mochiad_loaded)
  433.       {
  434.          return null;
  435.       }
  436.       var _loc12_ = options.depth;
  437.       delete options.depth;
  438.       var _loc6_ = _loc9_.createEmptyMovieClip("_mochiad",_loc12_);
  439.       var _loc11_ = MochiAd._getRes(options);
  440.       options.res = _loc11_[0] + "x" + _loc11_[1];
  441.       options.server += options.id;
  442.       delete options.id;
  443.       _loc9_._mochiad_loaded = true;
  444.       var _loc4_ = _loc6_.createEmptyMovieClip("_mochiad_ctr",1);
  445.       for(var _loc7_ in options)
  446.       {
  447.          _loc4_[_loc7_] = options[_loc7_];
  448.       }
  449.       var _loc10_ = _loc4_.server;
  450.       delete _loc4_.server;
  451.       var _loc14_ = MochiAd._allowDomains(_loc10_);
  452.       _loc6_.onEnterFrame = function()
  453.       {
  454.          if(this._mochiad_ctr._url != this._url)
  455.          {
  456.             this.onEnterFrame = function()
  457.             {
  458.                if(!this._mochiad_ctr)
  459.                {
  460.                   delete this.onEnterFrame;
  461.                   MochiAd.unload(this._parent);
  462.                }
  463.             };
  464.          }
  465.       };
  466.       var _loc5_ = new LocalConnection();
  467.       var _loc8_ = ["",Math.floor(new Date().getTime()),random(999999)].join("_");
  468.       _loc5_.mc = _loc6_;
  469.       _loc5_.name = _loc8_;
  470.       _loc5_.hostname = _loc14_;
  471.       _loc5_.allowDomain = function(d)
  472.       {
  473.          return true;
  474.       };
  475.       _loc5_.allowInsecureDomain = _loc5_.allowDomain;
  476.       _loc5_.connect(_loc8_);
  477.       _loc6_.lc = _loc5_;
  478.       _loc4_.lc = _loc8_;
  479.       _loc4_.st = getTimer();
  480.       _loc4_.loadMovie(_loc10_ + ".swf","POST");
  481.       return _loc6_;
  482.    }
  483.    static function unload(clip)
  484.    {
  485.       if(typeof clip == "undefined")
  486.       {
  487.          clip = _root;
  488.       }
  489.       if(clip.clip && clip.clip._mochiad)
  490.       {
  491.          clip = clip.clip;
  492.       }
  493.       if(!clip._mochiad)
  494.       {
  495.          return false;
  496.       }
  497.       if(clip._mochiad._containerLCName != undefined)
  498.       {
  499.          clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{id:"unload"});
  500.       }
  501.       clip._mochiad.removeMovieClip();
  502.       delete clip._mochiad_loaded;
  503.       delete clip._mochiad;
  504.       return true;
  505.    }
  506.    static function _isNetworkAvailable()
  507.    {
  508.       if(System.security)
  509.       {
  510.          var _loc1_ = System.security;
  511.          if(_loc1_.sandboxType == "localWithFile")
  512.          {
  513.             return false;
  514.          }
  515.       }
  516.       return true;
  517.    }
  518.    static function _getRes(options)
  519.    {
  520.       var _loc3_ = options.clip.getBounds();
  521.       var _loc2_ = 0;
  522.       var _loc1_ = 0;
  523.       if(typeof options.res != "undefined")
  524.       {
  525.          var _loc4_ = options.res.split("x");
  526.          _loc2_ = parseFloat(_loc4_[0]);
  527.          _loc1_ = parseFloat(_loc4_[1]);
  528.       }
  529.       else
  530.       {
  531.          _loc2_ = _loc3_.xMax - _loc3_.xMin;
  532.          _loc1_ = _loc3_.yMax - _loc3_.yMin;
  533.       }
  534.       if(_loc2_ == 0 || _loc1_ == 0)
  535.       {
  536.          _loc2_ = Stage.width;
  537.          _loc1_ = Stage.height;
  538.       }
  539.       return [_loc2_,_loc1_];
  540.    }
  541.    static function _parseOptions(options, defaults)
  542.    {
  543.       var _loc4_ = {};
  544.       for(var _loc8_ in defaults)
  545.       {
  546.          _loc4_[_loc8_] = defaults[_loc8_];
  547.       }
  548.       if(options)
  549.       {
  550.          for(_loc8_ in options)
  551.          {
  552.             _loc4_[_loc8_] = options[_loc8_];
  553.          }
  554.       }
  555.       if(_root.mochiad_options)
  556.       {
  557.          var _loc5_ = _root.mochiad_options.split("&");
  558.          var _loc2_ = 0;
  559.          while(_loc2_ < _loc5_.length)
  560.          {
  561.             var _loc3_ = _loc5_[_loc2_].split("=");
  562.             _loc4_[unescape(_loc3_[0])] = unescape(_loc3_[1]);
  563.             _loc2_ = _loc2_ + 1;
  564.          }
  565.       }
  566.       if(_loc4_.id == "test")
  567.       {
  568.       }
  569.       return _loc4_;
  570.    }
  571.    static function rpc(clip, callbackID, arg)
  572.    {
  573.       switch(arg.id)
  574.       {
  575.          case "setValue":
  576.             MochiAd.setValue(clip,arg.objectName,arg.value);
  577.             break;
  578.          case "getValue":
  579.             var _loc4_ = MochiAd.getValue(clip,arg.objectName);
  580.             clip._mochiad.lc.send(clip._mochiad._containerLCName,"rpcResult",callbackID,_loc4_);
  581.             break;
  582.          case "runMethod":
  583.             var _loc3_ = MochiAd.runMethod(clip,arg.method,arg.args);
  584.             clip._mochiad.lc.send(clip._mochiad._containerLCName,"rpcResult",callbackID,_loc3_);
  585.       }
  586.    }
  587.    static function setValue(base, objectName, value)
  588.    {
  589.       var _loc2_ = objectName.split(".");
  590.       var _loc1_ = undefined;
  591.       _loc1_ = 0;
  592.       while(_loc1_ < _loc2_.length - 1)
  593.       {
  594.          if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  595.          {
  596.             return undefined;
  597.          }
  598.          base = base[_loc2_[_loc1_]];
  599.          _loc1_ = _loc1_ + 1;
  600.       }
  601.       base[_loc2_[_loc1_]] = value;
  602.    }
  603.    static function getValue(base, objectName)
  604.    {
  605.       var _loc2_ = objectName.split(".");
  606.       var _loc1_ = undefined;
  607.       _loc1_ = 0;
  608.       while(_loc1_ < _loc2_.length - 1)
  609.       {
  610.          if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  611.          {
  612.             return undefined;
  613.          }
  614.          base = base[_loc2_[_loc1_]];
  615.          _loc1_ = _loc1_ + 1;
  616.       }
  617.       return base[_loc2_[_loc1_]];
  618.    }
  619.    static function runMethod(base, methodName, argsArray)
  620.    {
  621.       var _loc2_ = methodName.split(".");
  622.       var _loc1_ = undefined;
  623.       _loc1_ = 0;
  624.       while(_loc1_ < _loc2_.length - 1)
  625.       {
  626.          if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  627.          {
  628.             return undefined;
  629.          }
  630.          base = base[_loc2_[_loc1_]];
  631.          _loc1_ = _loc1_ + 1;
  632.       }
  633.       if(typeof base[_loc2_[_loc1_]] == "function")
  634.       {
  635.          return base[_loc2_[_loc1_]].apply(base,argsArray);
  636.       }
  637.       return undefined;
  638.    }
  639. }
  640.