Files
DiamondHollowII/research/decompiled/scripts/mochicrypt/as3/MochiAd.as
T

1033 lines
34 KiB
ActionScript

package mochicrypt.as3
{
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.Loader;
import flash.display.MovieClip;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.net.LocalConnection;
import flash.net.URLRequest;
import flash.net.URLRequestMethod;
import flash.net.URLVariables;
import flash.system.Security;
import flash.utils.getTimer;
import flash.utils.setTimeout;
public class MochiAd
{
public function MochiAd()
{
super();
}
public static function getVersion() : String
{
return MochiServices.getVersion();
}
public static function showClickAwayAd(param1:Object) : void
{
var h:Number;
var wh:Array;
var w:Number;
var sendHostProgress:Boolean;
var clip:Object = null;
var mc:MovieClip = null;
var chk:MovieClip = null;
var options:Object = param1;
var DEFAULTS:Object = {
"ad_timeout":2000,
"regpt":"o",
"method":"showClickAwayAd",
"res":"300x250",
"no_bg":true,
"ad_started":function():void
{
},
"ad_finished":function():void
{
},
"ad_loaded":function(param1:Number, param2:Number):void
{
},
"ad_failed":function():void
{
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");
},
"ad_skipped":function():void
{
}
};
options = MochiAd._parseOptions(options,DEFAULTS);
clip = options.clip;
var ad_timeout:Number = Number(options.ad_timeout);
delete options.ad_timeout;
if(!MochiAd.load(options))
{
options.ad_failed();
options.ad_finished();
return;
}
options.ad_started();
mc = clip._mochiad;
mc["onUnload"] = function():void
{
MochiAd._cleanup(mc);
options.ad_finished();
};
wh = MochiAd._getRes(options,clip);
w = Number(wh[0]);
h = Number(wh[1]);
mc.x = w * 0.5;
mc.y = h * 0.5;
chk = createEmptyMovieClip(mc,"_mochiad_wait",3);
chk.ad_timeout = ad_timeout;
chk.started = getTimer();
chk.showing = false;
mc.unloadAd = function():void
{
MochiAd.unload(clip);
};
mc.adLoaded = options.ad_loaded;
mc.adSkipped = options.ad_skipped;
mc.rpc = function(param1:Number, param2:Object):void
{
MochiAd.rpc(clip,param1,param2);
};
sendHostProgress = false;
mc.regContLC = function(param1:String):void
{
mc._containerLCName = param1;
};
chk["onEnterFrame"] = function():void
{
var _loc4_:Number = NaN;
if(!this.parent)
{
delete this.onEnterFrame;
return;
}
var _loc1_:Object = this.parent._mochiad_ctr;
var _loc2_:Number = getTimer() - this.started;
var _loc3_:Boolean = false;
if(!chk.showing)
{
_loc4_ = Number(this.parent._mochiad_ctr.contentLoaderInfo.bytesTotal);
if(_loc4_ > 0)
{
chk.showing = true;
_loc3_ = true;
chk.started = getTimer();
}
else if(_loc2_ > chk.ad_timeout)
{
options.ad_failed();
_loc3_ = true;
}
}
if(this.root == null)
{
_loc3_ = true;
}
if(_loc3_)
{
delete this.onEnterFrame;
}
};
doOnEnterFrame(chk);
}
public static function _isNetworkAvailable() : Boolean
{
return Security.sandboxType != "localWithFile";
}
public static function _allowDomains(param1:String) : String
{
var _loc2_:String = param1.split("/")[2].split(":")[0];
if(Security.sandboxType == "application")
{
return _loc2_;
}
Security.allowDomain("*");
Security.allowDomain(_loc2_);
Security.allowInsecureDomain("*");
Security.allowInsecureDomain(_loc2_);
return _loc2_;
}
public static function unload(param1:Object) : Boolean
{
if(Boolean(param1.clip) && Boolean(param1.clip._mochiad))
{
param1 = param1.clip;
}
if(param1.origFrameRate != undefined)
{
param1.stage.frameRate = param1.origFrameRate;
}
if(!param1._mochiad)
{
return false;
}
if(param1._mochiad._containerLCName != undefined)
{
param1._mochiad.lc.send(param1._mochiad._containerLCName,"notify",{"id":"unload"});
}
if(param1._mochiad.onUnload)
{
param1._mochiad.onUnload();
}
delete param1._mochiad_loaded;
delete param1._mochiad;
return true;
}
public static function showInterLevelAd(param1:Object) : void
{
var h:Number;
var wh:Array;
var w:Number;
var fadeout_time:Number;
var clip:Object = null;
var mc:MovieClip = null;
var chk:MovieClip = null;
var options:Object = param1;
var DEFAULTS:Object = {
"ad_timeout":2000,
"fadeout_time":250,
"regpt":"o",
"method":"showTimedAd",
"ad_started":function():void
{
if(this.clip is MovieClip)
{
this.clip.stop();
return;
}
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.");
},
"ad_finished":function():void
{
if(this.clip is MovieClip)
{
this.clip.play();
return;
}
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.");
},
"ad_loaded":function(param1:Number, param2:Number):void
{
},
"ad_failed":function():void
{
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");
},
"ad_skipped":function():void
{
}
};
options = MochiAd._parseOptions(options,DEFAULTS);
clip = options.clip;
var ad_msec:Number = 11000;
var ad_timeout:Number = Number(options.ad_timeout);
delete options.ad_timeout;
fadeout_time = Number(options.fadeout_time);
delete options.fadeout_time;
if(!MochiAd.load(options))
{
options.ad_failed();
options.ad_finished();
return;
}
options.ad_started();
mc = clip._mochiad;
mc["onUnload"] = function():void
{
MochiAd._cleanup(mc);
options.ad_finished();
};
wh = MochiAd._getRes(options,clip);
w = Number(wh[0]);
h = Number(wh[1]);
mc.x = w * 0.5;
mc.y = h * 0.5;
chk = createEmptyMovieClip(mc,"_mochiad_wait",3);
chk.ad_msec = ad_msec;
chk.ad_timeout = ad_timeout;
chk.started = getTimer();
chk.showing = false;
chk.fadeout_time = fadeout_time;
chk.fadeFunction = function():void
{
if(!this.parent)
{
delete this.onEnterFrame;
delete this.fadeFunction;
return;
}
var _loc1_:Number = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
if(_loc1_ > 0)
{
this.parent.alpha = _loc1_ * 0.01;
}
else
{
MochiAd.unload(clip);
delete this["onEnterFrame"];
}
};
mc.unloadAd = function():void
{
MochiAd.unload(clip);
};
mc.adLoaded = options.ad_loaded;
mc.adSkipped = options.ad_skipped;
mc.adjustProgress = function(param1:Number):void
{
var _loc2_:Object = mc._mochiad_wait;
_loc2_.server_control = true;
_loc2_.showing = true;
_loc2_.started = getTimer();
_loc2_.ad_msec = param1 - 250;
};
mc.rpc = function(param1:Number, param2:Object):void
{
MochiAd.rpc(clip,param1,param2);
};
chk["onEnterFrame"] = function():void
{
var _loc4_:Number = NaN;
if(!this.parent)
{
delete this.onEnterFrame;
delete this.fadeFunction;
return;
}
var _loc1_:Object = this.parent._mochiad_ctr;
var _loc2_:Number = getTimer() - this.started;
var _loc3_:Boolean = false;
if(!chk.showing)
{
_loc4_ = Number(this.parent._mochiad_ctr.contentLoaderInfo.bytesTotal);
if(_loc4_ > 0)
{
chk.showing = true;
chk.started = getTimer();
MochiAd.adShowing(clip);
}
else if(_loc2_ > chk.ad_timeout)
{
options.ad_failed();
_loc3_ = true;
}
}
if(_loc2_ > chk.ad_msec)
{
_loc3_ = true;
}
if(_loc3_)
{
if(this.server_control)
{
delete this.onEnterFrame;
}
else
{
this.fadeout_start = getTimer();
this.onEnterFrame = this.fadeFunction;
}
}
};
doOnEnterFrame(chk);
}
public static function _parseOptions(param1:Object, param2:Object) : Object
{
var _loc4_:String = null;
var _loc5_:Array = null;
var _loc6_:Number = NaN;
var _loc7_:Array = null;
var _loc3_:Object = {};
for(_loc4_ in param2)
{
_loc3_[_loc4_] = param2[_loc4_];
}
if(param1)
{
for(_loc4_ in param1)
{
_loc3_[_loc4_] = param1[_loc4_];
}
}
if(_loc3_.clip == undefined)
{
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.");
}
param1 = _loc3_.clip.loaderInfo.parameters.mochiad_options;
if(param1)
{
_loc5_ = param1.split("&");
_loc6_ = 0;
while(_loc6_ < _loc5_.length)
{
_loc7_ = _loc5_[_loc6_].split("=");
_loc3_[unescape(_loc7_[0])] = unescape(_loc7_[1]);
_loc6_++;
}
}
if(_loc3_.id == "test")
{
trace("[MochiAd] WARNING: Using the MochiAds test identifier, make sure to use the code from your dashboard, not this example!");
}
return _loc3_;
}
public static function _cleanup(param1:Object) : void
{
var idx:Number;
var k:String = null;
var lc:LocalConnection = null;
var f:Function = null;
var mc:Object = param1;
if("lc" in mc)
{
lc = mc.lc;
f = function():void
{
try
{
lc.client = null;
lc.close();
}
catch(e:Error)
{
}
};
setTimeout(f,0);
}
idx = DisplayObjectContainer(mc).numChildren;
while(idx > 0)
{
idx--;
DisplayObjectContainer(mc).removeChildAt(idx);
}
for(k in mc)
{
delete mc[k];
}
}
public static function load(param1:Object) : MovieClip
{
var depth:Number;
var lv:URLVariables;
var wh:Array;
var mc:MovieClip;
var clip:Object = null;
var k:String = null;
var server:String = null;
var hostname:String = null;
var lc:LocalConnection = null;
var name:String = null;
var loader:Loader = null;
var g:Function = null;
var req:URLRequest = null;
var v:Object = null;
var options:Object = param1;
var DEFAULTS:Object = {
"server":"http://x.mochiads.com/srv/1/",
"method":"load",
"depth":10333,
"id":"_UNKNOWN_"
};
options = MochiAd._parseOptions(options,DEFAULTS);
options.swfv = 9;
options.mav = MochiAd.getVersion();
clip = options.clip;
if(!(clip is DisplayObject))
{
trace("Warning: Object passed as container clip not a descendant of the DisplayObject type");
return null;
}
if(MovieClip(clip).stage == null)
{
trace("Warning: Container clip for ad is not attached to the stage");
return null;
}
if(!MochiAd._isNetworkAvailable())
{
return null;
}
try
{
if(clip._mochiad_loaded)
{
return null;
}
}
catch(e:Error)
{
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.");
}
depth = Number(options.depth);
delete options.depth;
mc = createEmptyMovieClip(clip,"_mochiad",depth);
wh = MochiAd._getRes(options,clip);
options.res = wh[0] + "x" + wh[1];
options.server += options.id;
delete options.id;
clip._mochiad_loaded = true;
if(clip.loaderInfo.loaderURL.indexOf("http") == 0)
{
options.as3_swf = clip.loaderInfo.loaderURL;
}
else
{
trace("[MochiAd] NOTE: Security Sandbox Violation errors below are normal");
}
lv = new URLVariables();
for(k in options)
{
v = options[k];
if(!(v is Function))
{
lv[k] = v;
}
}
server = lv.server;
delete lv.server;
hostname = _allowDomains(server);
lc = new LocalConnection();
lc.client = mc;
name = ["",Math.floor(new Date().getTime()),Math.floor(Math.random() * 999999)].join("_");
lc.allowDomain("*","localhost");
lc.allowInsecureDomain("*","localhost");
lc.connect(name);
mc.lc = lc;
mc.lcName = name;
lv.lc = name;
lv.st = getTimer();
loader = new Loader();
g = function(param1:Object):void
{
param1.target.removeEventListener(param1.type,arguments.callee);
MochiAd.unload(clip);
};
loader.contentLoaderInfo.addEventListener(Event.UNLOAD,g);
req = new URLRequest(server + ".swf?cacheBust=" + new Date().getTime());
req.contentType = "application/x-www-form-urlencoded";
req.method = URLRequestMethod.POST;
req.data = lv;
loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,function(param1:IOErrorEvent):void
{
trace("[MochiAds] Blocked URL");
});
if(!options.skip)
{
loader.load(req);
}
mc.addChild(loader);
mc._mochiad_ctr = loader;
return mc;
}
public static function runMethod(param1:Object, param2:String, param3:Array) : Object
{
var _loc4_:Array = param2.split(".");
var _loc5_:Number = 0;
while(_loc5_ < _loc4_.length - 1)
{
if(param1[_loc4_[_loc5_]] == undefined || param1[_loc4_[_loc5_]] == null)
{
return undefined;
}
param1 = param1[_loc4_[_loc5_]];
_loc5_++;
}
if(typeof param1[_loc4_[_loc5_]] == "function")
{
return param1[_loc4_[_loc5_]].apply(param1,param3);
}
return undefined;
}
public static function createEmptyMovieClip(param1:Object, param2:String, param3:Number) : MovieClip
{
var _loc4_:MovieClip = new MovieClip();
if(false && Boolean(param3))
{
param1.addChildAt(_loc4_,param3);
}
else
{
param1.addChild(_loc4_);
}
param1[param2] = _loc4_;
_loc4_["_name"] = param2;
return _loc4_;
}
public static function _getRes(param1:Object, param2:Object) : Array
{
var _loc6_:Array = null;
var _loc3_:Object = param2.getBounds(param2.root);
var _loc4_:Number = 0;
var _loc5_:Number = 0;
if(typeof param1.res != "undefined")
{
_loc6_ = param1.res.split("x");
_loc4_ = parseFloat(_loc6_[0]);
_loc5_ = parseFloat(_loc6_[1]);
}
else
{
_loc4_ = _loc3_.xMax - _loc3_.xMin;
_loc5_ = _loc3_.yMax - _loc3_.yMin;
}
if(_loc4_ == 0 || _loc5_ == 0)
{
_loc4_ = Number(param2.stage.stageWidth);
_loc5_ = Number(param2.stage.stageHeight);
}
return [_loc4_,_loc5_];
}
public static function adShowing(param1:Object) : void
{
param1.origFrameRate = param1.stage.frameRate;
param1.stage.frameRate = 30;
}
public static function getValue(param1:Object, param2:String) : Object
{
var _loc3_:Array = param2.split(".");
var _loc4_:Number = 0;
while(_loc4_ < _loc3_.length - 1)
{
if(param1[_loc3_[_loc4_]] == undefined || param1[_loc3_[_loc4_]] == null)
{
return undefined;
}
param1 = param1[_loc3_[_loc4_]];
_loc4_++;
}
return param1[_loc3_[_loc4_]];
}
public static function rpc(param1:Object, param2:Number, param3:Object) : void
{
var _loc4_:Object = null;
var _loc5_:Object = null;
switch(param3.id)
{
case "setValue":
MochiAd.setValue(param1,param3.objectName,param3.value);
break;
case "getValue":
_loc4_ = MochiAd.getValue(param1,param3.objectName);
param1._mochiad.lc.send(param1._mochiad._containerLCName,"rpcResult",param2,_loc4_);
break;
case "runMethod":
_loc5_ = MochiAd.runMethod(param1,param3.method,param3.args);
param1._mochiad.lc.send(param1._mochiad._containerLCName,"rpcResult",param2,_loc5_);
break;
default:
trace("[mochiads rpc] unknown rpc id: " + param3.id);
}
}
public static function setValue(param1:Object, param2:String, param3:Object) : void
{
var _loc4_:Array = param2.split(".");
var _loc5_:Number = 0;
while(_loc5_ < _loc4_.length - 1)
{
if(param1[_loc4_[_loc5_]] == undefined || param1[_loc4_[_loc5_]] == null)
{
return;
}
param1 = param1[_loc4_[_loc5_]];
_loc5_++;
}
param1[_loc4_[_loc5_]] = param3;
}
public static function showPreGameAd(param1:Object) : void
{
var bar:MovieClip;
var fadeout_time:Number;
var backing:Object;
var bar_outline:Number;
var progress:Number;
var outline_mc:MovieClip;
var bar_color:Number;
var inside_mc:MovieClip;
var backing_mc:MovieClip;
var outline:Object;
var ad_timeout:Number;
var bar_w:Number;
var wh:Array;
var bar_background:Number;
var ad_msec:Number;
var h:Number;
var f:Function;
var w:Number;
var inside:Object;
var clip:Object = null;
var mc:MovieClip = null;
var chk:MovieClip = null;
var complete:Boolean = false;
var unloaded:Boolean = false;
var sendHostProgress:Boolean = false;
var fn:Function = null;
var r:MovieClip = null;
var options:Object = param1;
var DEFAULTS:Object = {
"ad_timeout":3000,
"fadeout_time":250,
"regpt":"o",
"method":"showPreloaderAd",
"color":16747008,
"background":16777161,
"outline":13994812,
"no_progress_bar":false,
"ad_started":function():void
{
if(this.clip is MovieClip)
{
this.clip.stop();
return;
}
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.");
},
"ad_finished":function():void
{
if(this.clip is MovieClip)
{
this.clip.play();
return;
}
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.");
},
"ad_loaded":function(param1:Number, param2:Number):void
{
},
"ad_failed":function():void
{
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");
},
"ad_skipped":function():void
{
},
"ad_progress":function(param1:Number):void
{
},
"progress_override":function(param1:Object):Number
{
return NaN;
},
"bar_offset":0
};
options = MochiAd._parseOptions(options,DEFAULTS);
if("c862232051e0a94e1c3609b3916ddb17".substr(0) == "dfeada81ac97cde83665f81c12da7def")
{
options.ad_started();
fn = function():void
{
options.ad_finished();
};
setTimeout(fn,100);
return;
}
clip = options.clip;
ad_msec = 11000;
ad_timeout = Number(options.ad_timeout);
if(options.skip)
{
ad_timeout = 0;
}
delete options.ad_timeout;
fadeout_time = Number(options.fadeout_time);
delete options.fadeout_time;
if(!MochiAd.load(options))
{
options.ad_failed();
options.ad_finished();
return;
}
options.ad_started();
mc = clip._mochiad;
mc["onUnload"] = function():void
{
var fn:Function;
MochiAd._cleanup(mc);
fn = function():void
{
options.ad_finished();
};
setTimeout(fn,100);
};
wh = MochiAd._getRes(options,clip);
w = Number(wh[0]);
h = Number(wh[1]);
mc.x = w * 0.5;
mc.y = h * 0.5;
chk = createEmptyMovieClip(mc,"_mochiad_wait",3);
chk.x = w * -0.5;
chk.y = h * -0.5;
bar = createEmptyMovieClip(chk,"_mochiad_bar",4);
if(options.no_progress_bar)
{
bar.visible = false;
delete options.no_progress_bar;
}
else
{
bar.x = 10 + options.bar_offset;
bar.y = h - 20;
}
bar_w = w - bar.x - 10;
bar_color = Number(options.color);
delete options.color;
bar_background = Number(options.background);
delete options.background;
bar_outline = Number(options.outline);
delete options.outline;
backing_mc = createEmptyMovieClip(bar,"_outline",1);
backing = backing_mc.graphics;
backing.beginFill(bar_background);
backing.moveTo(0,0);
backing.lineTo(bar_w,0);
backing.lineTo(bar_w,10);
backing.lineTo(0,10);
backing.lineTo(0,0);
backing.endFill();
inside_mc = createEmptyMovieClip(bar,"_inside",2);
inside = inside_mc.graphics;
inside.beginFill(bar_color);
inside.moveTo(0,0);
inside.lineTo(bar_w,0);
inside.lineTo(bar_w,10);
inside.lineTo(0,10);
inside.lineTo(0,0);
inside.endFill();
inside_mc.scaleX = 0;
outline_mc = createEmptyMovieClip(bar,"_outline",3);
outline = outline_mc.graphics;
outline.lineStyle(0,bar_outline,100);
outline.moveTo(0,0);
outline.lineTo(bar_w,0);
outline.lineTo(bar_w,10);
outline.lineTo(0,10);
outline.lineTo(0,0);
chk.ad_msec = ad_msec;
chk.ad_timeout = ad_timeout;
chk.started = getTimer();
chk.showing = false;
chk.last_pcnt = 0;
chk.fadeout_time = fadeout_time;
chk.fadeFunction = function():void
{
var _loc1_:Number = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
if(_loc1_ > 0)
{
this.parent.alpha = _loc1_ * 0.01;
}
else
{
MochiAd.unload(clip);
delete this["onEnterFrame"];
}
};
complete = false;
unloaded = false;
progress = Math.min(1,options.progress_override(clip));
f = function(param1:Event):void
{
param1.target.removeEventListener(param1.type,arguments.callee);
complete = true;
if(unloaded)
{
MochiAd.unload(clip);
}
};
if(!isNaN(progress))
{
complete = progress == 1;
}
else if(clip.loaderInfo.bytesLoaded == clip.loaderInfo.bytesTotal)
{
complete = true;
}
else if(clip.root is MovieClip)
{
r = clip.root as MovieClip;
if(r.framesLoaded >= r.totalFrames)
{
complete = true;
}
else
{
clip.loaderInfo.addEventListener(Event.COMPLETE,f);
}
}
else
{
clip.loaderInfo.addEventListener(Event.COMPLETE,f);
}
mc.unloadAd = function():void
{
unloaded = true;
if(complete)
{
MochiAd.unload(clip);
}
};
mc.adLoaded = options.ad_loaded;
mc.adSkipped = options.ad_skipped;
mc.adjustProgress = function(param1:Number):void
{
var _loc2_:Object = mc._mochiad_wait;
_loc2_.server_control = true;
_loc2_.showing = true;
_loc2_.started = getTimer();
_loc2_.ad_msec = param1;
};
mc.rpc = function(param1:Number, param2:Object):void
{
MochiAd.rpc(clip,param1,param2);
};
mc.rpcTestFn = function(param1:String):Object
{
trace("[MOCHIAD rpcTestFn] " + param1);
return param1;
};
mc.regContLC = function(param1:String):void
{
mc._containerLCName = param1;
};
sendHostProgress = false;
mc.sendHostLoadProgress = function(param1:String):void
{
sendHostProgress = true;
};
chk["onEnterFrame"] = function():void
{
var _loc12_:Number = NaN;
if(!this.parent || !this.parent.parent)
{
delete this["onEnterFrame"];
return;
}
var _loc1_:Object = this.parent.parent.root;
var _loc2_:Object = this.parent._mochiad_ctr;
var _loc3_:Number = getTimer() - this.started;
var _loc4_:Boolean = false;
var _loc5_:Number = Number(_loc1_.loaderInfo.bytesTotal);
var _loc6_:Number = Number(_loc1_.loaderInfo.bytesLoaded);
var _loc7_:Number = Math.min(1,options.progress_override(_loc1_));
if(_loc7_ == 1)
{
complete = true;
}
if(complete)
{
_loc5_ = _loc6_ = Math.max(1,_loc6_);
}
var _loc8_:Number = 100 * _loc6_ / _loc5_;
if(!isNaN(_loc7_))
{
_loc8_ = 100 * _loc7_;
}
var _loc9_:Number = 100 * _loc3_ / chk.ad_msec;
var _loc10_:Object = this._mochiad_bar._inside;
var _loc11_:Number = Math.min(100,Math.min(_loc8_ || 0,_loc9_));
_loc11_ = Math.max(this.last_pcnt,_loc11_);
this.last_pcnt = _loc11_;
_loc10_.scaleX = _loc11_ * 0.01;
options.ad_progress(_loc11_);
if(sendHostProgress)
{
clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{
"id":"hostLoadPcnt",
"pcnt":_loc8_
});
if(_loc8_ >= 100)
{
sendHostProgress = false;
}
}
if(!chk.showing)
{
_loc12_ = Number(this.parent._mochiad_ctr.contentLoaderInfo.bytesTotal);
if(_loc12_ > 0)
{
chk.showing = true;
chk.started = getTimer();
MochiAd.adShowing(clip);
}
else if(_loc3_ > chk.ad_timeout && _loc8_ == 100)
{
options.ad_failed();
_loc4_ = true;
}
}
if(_loc3_ > chk.ad_msec)
{
_loc4_ = true;
}
if(complete && _loc4_)
{
if(unloaded)
{
MochiAd.unload(_loc1_);
}
else if(this.server_control)
{
delete this.onEnterFrame;
}
else
{
this.fadeout_start = getTimer();
this.onEnterFrame = chk.fadeFunction;
}
}
};
doOnEnterFrame(chk);
}
public static function showPreloaderAd(param1:Object) : void
{
trace("[MochiAd] DEPRECATED: showPreloaderAd was renamed to showPreGameAd in 2.0");
MochiAd.showPreGameAd(param1);
}
public static function showTimedAd(param1:Object) : void
{
trace("[MochiAd] DEPRECATED: showTimedAd was renamed to showInterLevelAd in 2.0");
MochiAd.showInterLevelAd(param1);
}
public static function doOnEnterFrame(param1:MovieClip) : void
{
var mc:MovieClip = param1;
var f:Function = function(param1:Object):void
{
if("onEnterFrame" in mc && Boolean(mc.onEnterFrame))
{
mc.onEnterFrame();
}
else
{
param1.target.removeEventListener(param1.type,arguments.callee);
}
};
mc.addEventListener(Event.ENTER_FRAME,f);
}
}
}