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