home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / sinta.swf / scripts / MochiAd.as < prev    next >
Encoding:
Text File  |  2008-08-08  |  28.3 KB  |  878 lines
  1. package
  2. {
  3.    import flash.display.*;
  4.    import flash.events.*;
  5.    import flash.net.*;
  6.    import flash.system.*;
  7.    import flash.utils.*;
  8.    
  9.    public class MochiAd
  10.    {
  11.        
  12.       
  13.       public function MochiAd()
  14.       {
  15.          super();
  16.       }
  17.       
  18.       public static function getVersion() : String
  19.       {
  20.          return "2.2";
  21.       }
  22.       
  23.       public static function showTimedAd(param1:Object) : void
  24.       {
  25.          MochiAd.showInterLevelAd(param1);
  26.       }
  27.       
  28.       public static function _allowDomains(param1:String) : String
  29.       {
  30.          var _loc2_:String = null;
  31.          _loc2_ = String(param1.split("/")[2].split(":")[0]);
  32.          Security.allowDomain("*");
  33.          Security.allowDomain(_loc2_);
  34.          Security.allowInsecureDomain("*");
  35.          Security.allowInsecureDomain(_loc2_);
  36.          return _loc2_;
  37.       }
  38.       
  39.       public static function load(param1:Object) : MovieClip
  40.       {
  41.          var DEFAULTS:Object = null;
  42.          var clip:Object = null;
  43.          var depth:Number = NaN;
  44.          var mc:MovieClip = null;
  45.          var wh:Array = null;
  46.          var lv:URLVariables = null;
  47.          var k:String = null;
  48.          var server:String = null;
  49.          var hostname:String = null;
  50.          var lc:LocalConnection = null;
  51.          var name:String = null;
  52.          var loader:Loader = null;
  53.          var f:Function = null;
  54.          var g:Function = null;
  55.          var req:URLRequest = null;
  56.          var v:Object = null;
  57.          var options:Object = param1;
  58.          DEFAULTS = {
  59.             "server":"http://x.mochiads.com/srv/1/",
  60.             "method":"load",
  61.             "depth":10333,
  62.             "id":"_UNKNOWN_"
  63.          };
  64.          options = MochiAd._parseOptions(options,DEFAULTS);
  65.          options.swfv = 9;
  66.          options.mav = MochiAd.getVersion();
  67.          clip = options.clip;
  68.          if(!MochiAd._isNetworkAvailable())
  69.          {
  70.             return null;
  71.          }
  72.          try
  73.          {
  74.             if(clip._mochiad_loaded)
  75.             {
  76.                return null;
  77.             }
  78.          }
  79.          catch(e:Error)
  80.          {
  81.             throw new Error("MochiAd requires a clip that is an instance of a dynamic class.  If your class extends Sprite or MovieClip, you must make it dynamic.");
  82.          }
  83.          depth = Number(options.depth);
  84.          delete options.depth;
  85.          mc = createEmptyMovieClip(clip,"_mochiad",depth);
  86.          wh = MochiAd._getRes(options,clip);
  87.          options.res = wh[0] + "x" + wh[1];
  88.          options.server += options.id;
  89.          delete options.id;
  90.          clip._mochiad_loaded = true;
  91.          if(clip.loaderInfo.loaderURL.indexOf("http") == 0)
  92.          {
  93.             options.as3_swf = clip.loaderInfo.loaderURL;
  94.          }
  95.          lv = new URLVariables();
  96.          for(k in options)
  97.          {
  98.             v = options[k];
  99.             if(!(v is Function))
  100.             {
  101.                lv[k] = v;
  102.             }
  103.          }
  104.          server = String(lv.server);
  105.          delete lv.server;
  106.          hostname = _allowDomains(server);
  107.          lc = new LocalConnection();
  108.          lc.client = mc;
  109.          name = ["",Math.floor(new Date().getTime()),Math.floor(Math.random() * 999999)].join("_");
  110.          lc.allowDomain("*","localhost");
  111.          lc.allowInsecureDomain("*","localhost");
  112.          lc.connect(name);
  113.          mc.lc = lc;
  114.          lv.lc = name;
  115.          lv.st = getTimer();
  116.          loader = new Loader();
  117.          f = function(param1:Object):void
  118.          {
  119.             param1.target.removeEventListener(param1.type,arguments.callee);
  120.             mc._mochiad_ctr_failed = true;
  121.          };
  122.          loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,f);
  123.          g = function(param1:Object):void
  124.          {
  125.             param1.target.removeEventListener(param1.type,arguments.callee);
  126.             MochiAd.unload(clip);
  127.          };
  128.          loader.contentLoaderInfo.addEventListener(Event.UNLOAD,g);
  129.          req = new URLRequest(server + ".swf");
  130.          req.contentType = "application/x-www-form-urlencoded";
  131.          req.method = URLRequestMethod.POST;
  132.          req.data = lv;
  133.          loader.load(req);
  134.          mc.addChild(loader);
  135.          mc._mochiad_ctr = loader;
  136.          return mc;
  137.       }
  138.       
  139.       public static function sendHighScore(param1:Object, param2:Object, param3:Object = null) : Boolean
  140.       {
  141.          var _loc4_:MovieClip = null;
  142.          if(!(_loc4_ = MochiAd._loadCommunicator({
  143.             "clip":param1.clip,
  144.             "id":param1.id
  145.          })))
  146.          {
  147.             return false;
  148.          }
  149.          _loc4_.doSend(["sendHighScore",param1],param2,param3);
  150.          return true;
  151.       }
  152.       
  153.       public static function _parseOptions(param1:Object, param2:Object) : Object
  154.       {
  155.          var _loc3_:Object = null;
  156.          var _loc4_:String = null;
  157.          var _loc5_:Array = null;
  158.          var _loc6_:Number = NaN;
  159.          var _loc7_:Array = null;
  160.          _loc3_ = {};
  161.          for(_loc4_ in param2)
  162.          {
  163.             _loc3_[_loc4_] = param2[_loc4_];
  164.          }
  165.          if(param1)
  166.          {
  167.             for(_loc4_ in param1)
  168.             {
  169.                _loc3_[_loc4_] = param1[_loc4_];
  170.             }
  171.          }
  172.          if(_loc3_.clip == undefined)
  173.          {
  174.             throw new Error("MochiAd is missing the \'clip\' parameter.  This should be a MovieClip, Sprite or an instance of a class that extends MovieClip or Sprite.");
  175.          }
  176.          param1 = _loc3_.clip.loaderInfo.parameters.mochiad_options;
  177.          if(param1)
  178.          {
  179.             _loc5_ = param1.split("&");
  180.             _loc6_ = 0;
  181.             while(_loc6_ < _loc5_.length)
  182.             {
  183.                _loc7_ = _loc5_[_loc6_].split("=");
  184.                _loc3_[unescape(_loc7_[0])] = unescape(_loc7_[1]);
  185.                _loc6_++;
  186.             }
  187.          }
  188.          if(_loc3_.id == "test")
  189.          {
  190.          }
  191.          return _loc3_;
  192.       }
  193.       
  194.       public static function _isNetworkAvailable() : Boolean
  195.       {
  196.          return Security.sandboxType != "localWithFile";
  197.       }
  198.       
  199.       public static function _cleanup(param1:Object) : void
  200.       {
  201.          var idx:Number = NaN;
  202.          var k:String = null;
  203.          var lc:LocalConnection = null;
  204.          var f:Function = null;
  205.          var mc:Object = param1;
  206.          if("lc" in mc)
  207.          {
  208.             lc = mc.lc;
  209.             f = function():void
  210.             {
  211.                try
  212.                {
  213.                   lc.client = null;
  214.                   lc.close();
  215.                }
  216.                catch(e:Error)
  217.                {
  218.                }
  219.             };
  220.             setTimeout(f,0);
  221.          }
  222.          idx = Number(DisplayObjectContainer(mc).numChildren);
  223.          while(idx > 0)
  224.          {
  225.             idx--;
  226.             DisplayObjectContainer(mc).removeChildAt(idx);
  227.          }
  228.          for(k in mc)
  229.          {
  230.             delete mc[k];
  231.          }
  232.       }
  233.       
  234.       public static function unload(param1:Object) : Boolean
  235.       {
  236.          if(Boolean(param1.clip) && Boolean(param1.clip._mochiad))
  237.          {
  238.             param1 = param1.clip;
  239.          }
  240.          if(!param1._mochiad)
  241.          {
  242.             return false;
  243.          }
  244.          if(param1._mochiad.onUnload)
  245.          {
  246.             param1._mochiad.onUnload();
  247.          }
  248.          delete param1._mochiad_loaded;
  249.          delete param1._mochiad;
  250.          return true;
  251.       }
  252.       
  253.       public static function showInterLevelAd(param1:Object) : void
  254.       {
  255.          var DEFAULTS:Object = null;
  256.          var clip:Object = null;
  257.          var ad_msec:Number = NaN;
  258.          var ad_timeout:Number = NaN;
  259.          var fadeout_time:Number = NaN;
  260.          var mc:MovieClip = null;
  261.          var wh:Array = null;
  262.          var w:Number = NaN;
  263.          var h:Number = NaN;
  264.          var chk:MovieClip = null;
  265.          var options:Object = param1;
  266.          DEFAULTS = {
  267.             "ad_timeout":2000,
  268.             "fadeout_time":250,
  269.             "regpt":"o",
  270.             "method":"showTimedAd",
  271.             "ad_started":function():void
  272.             {
  273.                if(this.clip is MovieClip)
  274.                {
  275.                   this.clip.stop();
  276.                   return;
  277.                }
  278.                throw new Error("MochiAd.showInterLevelAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers.");
  279.             },
  280.             "ad_finished":function():void
  281.             {
  282.                if(this.clip is MovieClip)
  283.                {
  284.                   this.clip.play();
  285.                   return;
  286.                }
  287.                throw new Error("MochiAd.showInterLevelAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers.");
  288.             }
  289.          };
  290.          options = MochiAd._parseOptions(options,DEFAULTS);
  291.          clip = options.clip;
  292.          ad_msec = 11000;
  293.          ad_timeout = Number(options.ad_timeout);
  294.          delete options.ad_timeout;
  295.          fadeout_time = Number(options.fadeout_time);
  296.          delete options.fadeout_time;
  297.          if(!MochiAd.load(options))
  298.          {
  299.             options.ad_finished();
  300.             return;
  301.          }
  302.          options.ad_started();
  303.          mc = clip._mochiad;
  304.          mc["onUnload"] = function():void
  305.          {
  306.             MochiAd._cleanup(mc);
  307.             options.ad_finished();
  308.          };
  309.          wh = MochiAd._getRes(options,clip);
  310.          w = Number(wh[0]);
  311.          h = Number(wh[1]);
  312.          mc.x = w * 0.5;
  313.          mc.y = h * 0.5;
  314.          chk = createEmptyMovieClip(mc,"_mochiad_wait",3);
  315.          chk.ad_msec = ad_msec;
  316.          chk.ad_timeout = ad_timeout;
  317.          chk.started = getTimer();
  318.          chk.showing = false;
  319.          chk.fadeout_time = fadeout_time;
  320.          chk.fadeFunction = function():void
  321.          {
  322.             var _loc1_:Number = NaN;
  323.             if(!this.parent)
  324.             {
  325.                delete this.onEnterFrame;
  326.                delete this.fadeFunction;
  327.                return;
  328.             }
  329.             _loc1_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  330.             if(_loc1_ > 0)
  331.             {
  332.                this.parent.alpha = _loc1_ * 0.01;
  333.             }
  334.             else
  335.             {
  336.                MochiAd.unload(clip);
  337.                delete this["onEnterFrame"];
  338.             }
  339.          };
  340.          mc.unloadAd = function():void
  341.          {
  342.             MochiAd.unload(clip);
  343.          };
  344.          mc.adjustProgress = function(param1:Number):void
  345.          {
  346.             var _loc2_:Object = null;
  347.             _loc2_ = mc._mochiad_wait;
  348.             _loc2_.server_control = true;
  349.             _loc2_.showing = true;
  350.             _loc2_.started = getTimer();
  351.             _loc2_.ad_msec = param1 - 250;
  352.          };
  353.          chk["onEnterFrame"] = function():void
  354.          {
  355.             var _loc1_:Object = null;
  356.             var _loc2_:Number = NaN;
  357.             var _loc3_:Boolean = false;
  358.             var _loc4_:Number = NaN;
  359.             if(!this.parent)
  360.             {
  361.                delete this.onEnterFrame;
  362.                delete this.fadeFunction;
  363.                return;
  364.             }
  365.             _loc1_ = this.parent._mochiad_ctr;
  366.             _loc2_ = getTimer() - this.started;
  367.             _loc3_ = false;
  368.             if(!chk.showing)
  369.             {
  370.                if((_loc4_ = Number(_loc1_.loaderInfo.bytesTotal)) > 0 || "number" == "undefined")
  371.                {
  372.                   chk.showing = true;
  373.                   chk.started = getTimer();
  374.                }
  375.                else if(_loc2_ > chk.ad_timeout)
  376.                {
  377.                   _loc3_ = true;
  378.                }
  379.             }
  380.             if(_loc2_ > chk.ad_msec || Boolean(this.parent._mochiad_ctr_failed))
  381.             {
  382.                _loc3_ = true;
  383.             }
  384.             if(_loc3_)
  385.             {
  386.                if(this.server_control)
  387.                {
  388.                   delete this.onEnterFrame;
  389.                }
  390.                else
  391.                {
  392.                   this.fadeout_start = getTimer();
  393.                   this.onEnterFrame = this.fadeFunction;
  394.                }
  395.             }
  396.          };
  397.          doOnEnterFrame(chk);
  398.       }
  399.       
  400.       public static function _getRes(param1:Object, param2:Object) : Array
  401.       {
  402.          var _loc3_:Object = null;
  403.          var _loc4_:Number = NaN;
  404.          var _loc5_:Number = NaN;
  405.          var _loc6_:Array = null;
  406.          _loc3_ = param2.getBounds(param2.root);
  407.          _loc4_ = 0;
  408.          _loc5_ = 0;
  409.          if(typeof param1.res != "undefined")
  410.          {
  411.             _loc6_ = param1.res.split("x");
  412.             _loc4_ = Number(parseFloat(_loc6_[0]));
  413.             _loc5_ = Number(parseFloat(_loc6_[1]));
  414.          }
  415.          else
  416.          {
  417.             _loc4_ = _loc3_.xMax - _loc3_.xMin;
  418.             _loc5_ = _loc3_.yMax - _loc3_.yMin;
  419.          }
  420.          if(_loc4_ == 0 || _loc5_ == 0)
  421.          {
  422.             _loc4_ = Number(param2.stage.stageWidth);
  423.             _loc5_ = Number(param2.stage.stageHeight);
  424.          }
  425.          return [_loc4_,_loc5_];
  426.       }
  427.       
  428.       public static function createEmptyMovieClip(param1:Object, param2:String, param3:Number) : MovieClip
  429.       {
  430.          var _loc4_:MovieClip = null;
  431.          _loc4_ = new MovieClip();
  432.          if(false && Boolean(param3))
  433.          {
  434.             param1.addChildAt(_loc4_,param3);
  435.          }
  436.          else
  437.          {
  438.             param1.addChild(_loc4_);
  439.          }
  440.          param1[param2] = _loc4_;
  441.          _loc4_["_name"] = param2;
  442.          return _loc4_;
  443.       }
  444.       
  445.       public static function _loadCommunicator(param1:Object) : MovieClip
  446.       {
  447.          var DEFAULTS:Object = null;
  448.          var clip:Object = null;
  449.          var clipname:String = null;
  450.          var server:String = null;
  451.          var depth:Number = NaN;
  452.          var mc:MovieClip = null;
  453.          var lv:URLVariables = null;
  454.          var k:String = null;
  455.          var lc:LocalConnection = null;
  456.          var name:String = null;
  457.          var req:URLRequest = null;
  458.          var loader:Loader = null;
  459.          var options:Object = param1;
  460.          DEFAULTS = {
  461.             "com_server":"http://x.mochiads.com/com/1/",
  462.             "method":"loadCommunicator",
  463.             "depth":10337,
  464.             "id":"_UNKNOWN_"
  465.          };
  466.          options = MochiAd._parseOptions(options,DEFAULTS);
  467.          options.swfv = 9;
  468.          options.mav = MochiAd.getVersion();
  469.          clip = options.clip;
  470.          clipname = "_mochiad_com_" + options.id;
  471.          if(!MochiAd._isNetworkAvailable())
  472.          {
  473.             return null;
  474.          }
  475.          if(clip[clipname])
  476.          {
  477.             return clip[clipname];
  478.          }
  479.          server = String(options.com_server + options.id);
  480.          MochiAd._allowDomains(server);
  481.          delete options.id;
  482.          delete options.com_server;
  483.          depth = Number(options.depth);
  484.          delete options.depth;
  485.          mc = createEmptyMovieClip(clip,clipname,depth);
  486.          lv = new URLVariables();
  487.          for(k in options)
  488.          {
  489.             lv[k] = options[k];
  490.          }
  491.          lc = new LocalConnection();
  492.          lc.client = mc;
  493.          name = ["",Math.floor(new Date().getTime()),Math.floor(Math.random() * 999999)].join("_");
  494.          lc.allowDomain("*","localhost");
  495.          lc.allowInsecureDomain("*","localhost");
  496.          lc.connect(name);
  497.          mc.name = name;
  498.          mc.lc = lc;
  499.          lv.lc = name;
  500.          mc._id = 0;
  501.          mc._queue = [];
  502.          mc.rpcResult = function(param1:Object):void
  503.          {
  504.             var _loc3_:Array = null;
  505.             var _loc4_:Array = null;
  506.             var _loc5_:Number = NaN;
  507.             var _loc6_:Object = null;
  508.             var _loc7_:Object = null;
  509.             param1 = parseInt(param1.toString());
  510.             _loc3_ = mc._callbacks[param1];
  511.             if(typeof _loc3_ == "undefined")
  512.             {
  513.                return;
  514.             }
  515.             delete mc._callbacks[param1];
  516.             _loc4_ = [];
  517.             _loc5_ = 2;
  518.             while(_loc5_ < _loc3_.length)
  519.             {
  520.                _loc4_.push(_loc3_[_loc5_]);
  521.                _loc5_++;
  522.             }
  523.             _loc5_ = 1;
  524.             while(_loc5_ < arguments.length)
  525.             {
  526.                _loc4_.push(arguments[_loc5_]);
  527.                _loc5_++;
  528.             }
  529.             _loc6_ = _loc3_[1];
  530.             if((Boolean(_loc7_ = _loc3_[0])) && typeof _loc6_ == "string")
  531.             {
  532.                _loc6_ = _loc7_[_loc6_];
  533.             }
  534.             if(typeof _loc6_ == "function")
  535.             {
  536.                _loc6_.apply(_loc7_,_loc4_);
  537.             }
  538.          };
  539.          mc._didConnect = function(param1:String):void
  540.          {
  541.             var _loc2_:Array = null;
  542.             var _loc3_:Function = null;
  543.             var _loc4_:Number = NaN;
  544.             var _loc5_:Array = null;
  545.             mc._endpoint = param1;
  546.             _loc2_ = mc._queue;
  547.             delete mc._queue;
  548.             _loc3_ = mc.doSend;
  549.             _loc4_ = 0;
  550.             while(_loc4_ < _loc2_.length)
  551.             {
  552.                _loc5_ = _loc2_[_loc4_];
  553.                _loc3_.apply(this,_loc5_);
  554.                _loc4_++;
  555.             }
  556.          };
  557.          mc.doSend = function(param1:Array, param2:Object, param3:Object):void
  558.          {
  559.             var _loc5_:Number = NaN;
  560.             var _loc6_:LocalConnection = null;
  561.             var _loc7_:Array = null;
  562.             var _loc8_:Number = NaN;
  563.             if(mc._endpoint == null)
  564.             {
  565.                _loc7_ = [];
  566.                _loc8_ = 0;
  567.                while(_loc8_ < arguments.length)
  568.                {
  569.                   _loc7_.push(arguments[_loc8_]);
  570.                   _loc8_++;
  571.                }
  572.                mc._queue.push(_loc7_);
  573.                return;
  574.             }
  575.             mc._id += 1;
  576.             _loc5_ = Number(mc._id);
  577.             mc._callbacks[_loc5_] = [param2,param3 || param2];
  578.             (_loc6_ = new LocalConnection()).send(mc._endpoint,"rpc",_loc5_,param1);
  579.          };
  580.          mc._callbacks = {};
  581.          mc._callbacks[0] = [mc,"_didConnect"];
  582.          lv.st = getTimer();
  583.          req = new URLRequest(server + ".swf");
  584.          req.contentType = "application/x-www-form-urlencoded";
  585.          req.method = URLRequestMethod.POST;
  586.          req.data = lv;
  587.          loader = new Loader();
  588.          loader.load(req);
  589.          mc.addChild(loader);
  590.          mc._mochiad_com = loader;
  591.          return mc;
  592.       }
  593.       
  594.       public static function showPreGameAd(param1:Object) : void
  595.       {
  596.          var DEFAULTS:Object = null;
  597.          var clip:Object = null;
  598.          var ad_msec:Number = NaN;
  599.          var ad_timeout:Number = NaN;
  600.          var fadeout_time:Number = NaN;
  601.          var mc:MovieClip = null;
  602.          var wh:Array = null;
  603.          var w:Number = NaN;
  604.          var h:Number = NaN;
  605.          var chk:MovieClip = null;
  606.          var bar:MovieClip = null;
  607.          var bar_color:Number = NaN;
  608.          var bar_background:Number = NaN;
  609.          var bar_outline:Number = NaN;
  610.          var backing_mc:MovieClip = null;
  611.          var backing:Object = null;
  612.          var inside_mc:MovieClip = null;
  613.          var inside:Object = null;
  614.          var outline_mc:MovieClip = null;
  615.          var outline:Object = null;
  616.          var complete:Boolean = false;
  617.          var unloaded:Boolean = false;
  618.          var f:Function = null;
  619.          var r:MovieClip = null;
  620.          var options:Object = param1;
  621.          DEFAULTS = {
  622.             "ad_timeout":3000,
  623.             "fadeout_time":250,
  624.             "regpt":"o",
  625.             "method":"showPreloaderAd",
  626.             "color":16747008,
  627.             "background":16777161,
  628.             "outline":13994812,
  629.             "ad_started":function():void
  630.             {
  631.                if(this.clip is MovieClip)
  632.                {
  633.                   this.clip.stop();
  634.                   return;
  635.                }
  636.                throw new Error("MochiAd.showPreGameAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers.");
  637.             },
  638.             "ad_finished":function():void
  639.             {
  640.                if(this.clip is MovieClip)
  641.                {
  642.                   this.clip.play();
  643.                   return;
  644.                }
  645.                throw new Error("MochiAd.showPreGameAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers.");
  646.             }
  647.          };
  648.          options = MochiAd._parseOptions(options,DEFAULTS);
  649.          clip = options.clip;
  650.          ad_msec = 11000;
  651.          ad_timeout = Number(options.ad_timeout);
  652.          delete options.ad_timeout;
  653.          fadeout_time = Number(options.fadeout_time);
  654.          delete options.fadeout_time;
  655.          if(!MochiAd.load(options))
  656.          {
  657.             options.ad_finished();
  658.             return;
  659.          }
  660.          options.ad_started();
  661.          mc = clip._mochiad;
  662.          mc["onUnload"] = function():void
  663.          {
  664.             var fn:Function = null;
  665.             MochiAd._cleanup(mc);
  666.             fn = function():void
  667.             {
  668.                options.ad_finished();
  669.             };
  670.             setTimeout(fn,100);
  671.          };
  672.          wh = MochiAd._getRes(options,clip);
  673.          w = Number(wh[0]);
  674.          h = Number(wh[1]);
  675.          mc.x = w * 0.5;
  676.          mc.y = h * 0.5;
  677.          chk = createEmptyMovieClip(mc,"_mochiad_wait",3);
  678.          chk.x = w * -0.5;
  679.          chk.y = h * -0.5;
  680.          bar = createEmptyMovieClip(chk,"_mochiad_bar",4);
  681.          bar.x = 10;
  682.          bar.y = h - 20;
  683.          bar_color = Number(options.color);
  684.          delete options.color;
  685.          bar_background = Number(options.background);
  686.          delete options.background;
  687.          bar_outline = Number(options.outline);
  688.          delete options.outline;
  689.          backing_mc = createEmptyMovieClip(bar,"_outline",1);
  690.          backing = backing_mc.graphics;
  691.          backing.beginFill(bar_background);
  692.          backing.moveTo(0,0);
  693.          backing.lineTo(w - 20,0);
  694.          backing.lineTo(w - 20,10);
  695.          backing.lineTo(0,10);
  696.          backing.lineTo(0,0);
  697.          backing.endFill();
  698.          inside_mc = createEmptyMovieClip(bar,"_inside",2);
  699.          inside = inside_mc.graphics;
  700.          inside.beginFill(bar_color);
  701.          inside.moveTo(0,0);
  702.          inside.lineTo(w - 20,0);
  703.          inside.lineTo(w - 20,10);
  704.          inside.lineTo(0,10);
  705.          inside.lineTo(0,0);
  706.          inside.endFill();
  707.          inside_mc.scaleX = 0;
  708.          outline_mc = createEmptyMovieClip(bar,"_outline",3);
  709.          outline = outline_mc.graphics;
  710.          outline.lineStyle(0,bar_outline,100);
  711.          outline.moveTo(0,0);
  712.          outline.lineTo(w - 20,0);
  713.          outline.lineTo(w - 20,10);
  714.          outline.lineTo(0,10);
  715.          outline.lineTo(0,0);
  716.          chk.ad_msec = ad_msec;
  717.          chk.ad_timeout = ad_timeout;
  718.          chk.started = getTimer();
  719.          chk.showing = false;
  720.          chk.last_pcnt = 0;
  721.          chk.fadeout_time = fadeout_time;
  722.          chk.fadeFunction = function():void
  723.          {
  724.             var _loc1_:Number = NaN;
  725.             _loc1_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  726.             if(_loc1_ > 0)
  727.             {
  728.                this.parent.alpha = _loc1_ * 0.01;
  729.             }
  730.             else
  731.             {
  732.                MochiAd.unload(clip);
  733.                delete this["onEnterFrame"];
  734.             }
  735.          };
  736.          complete = false;
  737.          unloaded = false;
  738.          f = function(param1:Event):void
  739.          {
  740.             param1.target.removeEventListener(param1.type,arguments.callee);
  741.             complete = true;
  742.             if(unloaded)
  743.             {
  744.                MochiAd.unload(clip);
  745.             }
  746.          };
  747.          clip.loaderInfo.addEventListener(Event.COMPLETE,f);
  748.          if(clip.root is MovieClip)
  749.          {
  750.             r = clip.root as MovieClip;
  751.             if(r.framesLoaded >= r.totalFrames)
  752.             {
  753.                complete = true;
  754.             }
  755.          }
  756.          mc.unloadAd = function():void
  757.          {
  758.             unloaded = true;
  759.             if(complete)
  760.             {
  761.                MochiAd.unload(clip);
  762.             }
  763.          };
  764.          mc.adjustProgress = function(param1:Number):void
  765.          {
  766.             var _loc2_:Object = null;
  767.             _loc2_ = mc._mochiad_wait;
  768.             _loc2_.server_control = true;
  769.             _loc2_.showing = true;
  770.             _loc2_.started = getTimer();
  771.             _loc2_.ad_msec = param1;
  772.          };
  773.          chk["onEnterFrame"] = function():void
  774.          {
  775.             var _loc1_:Object = null;
  776.             var _loc2_:Object = null;
  777.             var _loc3_:Number = NaN;
  778.             var _loc4_:Boolean = false;
  779.             var _loc5_:Number = NaN;
  780.             var _loc6_:Number = NaN;
  781.             var _loc7_:Number = NaN;
  782.             var _loc8_:Number = NaN;
  783.             var _loc9_:Object = null;
  784.             var _loc10_:Number = NaN;
  785.             var _loc11_:Number = NaN;
  786.             if(!this.parent.parent)
  787.             {
  788.                delete this["onEnterFrame"];
  789.                return;
  790.             }
  791.             _loc1_ = this.parent.parent.root;
  792.             _loc2_ = this.parent._mochiad_ctr;
  793.             _loc3_ = getTimer() - this.started;
  794.             _loc4_ = false;
  795.             _loc5_ = Number(_loc1_.loaderInfo.bytesTotal);
  796.             _loc6_ = Number(_loc1_.loaderInfo.bytesLoaded);
  797.             if(complete)
  798.             {
  799.                _loc5_ = _loc6_ = Math.max(1,_loc6_);
  800.             }
  801.             _loc7_ = 100 * _loc6_ / _loc5_;
  802.             _loc8_ = 100 * _loc3_ / chk.ad_msec;
  803.             _loc9_ = this._mochiad_bar._inside;
  804.             _loc10_ = Math.min(100,Math.min(_loc7_ || 0,_loc8_));
  805.             _loc10_ = Math.max(this.last_pcnt,_loc10_);
  806.             this.last_pcnt = _loc10_;
  807.             _loc9_.scaleX = _loc10_ * 0.01;
  808.             if(!chk.showing)
  809.             {
  810.                if((_loc11_ = Number(_loc2_.loaderInfo.bytesTotal)) > 0 || "number" == "undefined")
  811.                {
  812.                   chk.showing = true;
  813.                   chk.started = getTimer();
  814.                }
  815.                else if(_loc3_ > chk.ad_timeout)
  816.                {
  817.                   _loc4_ = true;
  818.                }
  819.             }
  820.             if(_loc3_ > chk.ad_msec || Boolean(this.parent._mochiad_ctr_failed))
  821.             {
  822.                _loc4_ = true;
  823.             }
  824.             if(complete && _loc4_)
  825.             {
  826.                if(this.server_control)
  827.                {
  828.                   delete this.onEnterFrame;
  829.                }
  830.                else
  831.                {
  832.                   this.fadeout_start = getTimer();
  833.                   this.onEnterFrame = chk.fadeFunction;
  834.                }
  835.             }
  836.          };
  837.          doOnEnterFrame(chk);
  838.       }
  839.       
  840.       public static function showPreloaderAd(param1:Object) : void
  841.       {
  842.          MochiAd.showPreGameAd(param1);
  843.       }
  844.       
  845.       public static function fetchHighScores(param1:Object, param2:Object, param3:Object = null) : Boolean
  846.       {
  847.          var _loc4_:MovieClip = null;
  848.          if(!(_loc4_ = MochiAd._loadCommunicator({
  849.             "clip":param1.clip,
  850.             "id":param1.id
  851.          })))
  852.          {
  853.             return false;
  854.          }
  855.          _loc4_.doSend(["fetchHighScores",param1],param2,param3);
  856.          return true;
  857.       }
  858.       
  859.       public static function doOnEnterFrame(param1:MovieClip) : void
  860.       {
  861.          var f:Function = null;
  862.          var mc:MovieClip = param1;
  863.          f = function(param1:Object):void
  864.          {
  865.             if("onEnterFrame" in mc && Boolean(mc.onEnterFrame))
  866.             {
  867.                mc.onEnterFrame();
  868.             }
  869.             else
  870.             {
  871.                param1.target.removeEventListener(param1.type,arguments.callee);
  872.             }
  873.          };
  874.          mc.addEventListener(Event.ENTER_FRAME,f);
  875.       }
  876.    }
  877. }
  878.