Brought up to date with the private repository (feea4c7)

This commit is contained in:
S committed 2026-10-14 20:57:33 +03:00
1 parent 1aa738d692
commit 1b1df1ae48
7925 files changed
+2617237 -20

No files matched your search

@@ -0,0 +1,168 @@
package com.adobe.crypto
{
import com.adobe.utils.IntUtil;
public class MD5
{
public function MD5()
{
super();
}
public static function hash(param1:String) : String
{
var _loc6_:int = 0;
var _loc7_:int = 0;
var _loc8_:int = 0;
var _loc9_:int = 0;
var _loc2_:int = 1732584193;
var _loc3_:int = -271733879;
var _loc4_:int = -1732584194;
var _loc5_:int = 271733878;
var _loc10_:Array = createBlocks(param1);
var _loc11_:int = int(_loc10_.length);
var _loc12_:int = 0;
while(_loc12_ < _loc11_)
{
_loc6_ = _loc2_;
_loc7_ = _loc3_;
_loc8_ = _loc4_;
_loc9_ = _loc5_;
_loc2_ = ff(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 0],7,-680876936);
_loc5_ = ff(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 1],12,-389564586);
_loc4_ = ff(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 2],17,606105819);
_loc3_ = ff(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 3],22,-1044525330);
_loc2_ = ff(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 4],7,-176418897);
_loc5_ = ff(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 5],12,1200080426);
_loc4_ = ff(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 6],17,-1473231341);
_loc3_ = ff(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 7],22,-45705983);
_loc2_ = ff(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 8],7,1770035416);
_loc5_ = ff(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 9],12,-1958414417);
_loc4_ = ff(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 10],17,-42063);
_loc3_ = ff(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 11],22,-1990404162);
_loc2_ = ff(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 12],7,1804603682);
_loc5_ = ff(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 13],12,-40341101);
_loc4_ = ff(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 14],17,-1502002290);
_loc3_ = ff(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 15],22,1236535329);
_loc2_ = gg(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 1],5,-165796510);
_loc5_ = gg(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 6],9,-1069501632);
_loc4_ = gg(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 11],14,643717713);
_loc3_ = gg(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 0],20,-373897302);
_loc2_ = gg(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 5],5,-701558691);
_loc5_ = gg(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 10],9,38016083);
_loc4_ = gg(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 15],14,-660478335);
_loc3_ = gg(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 4],20,-405537848);
_loc2_ = gg(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 9],5,568446438);
_loc5_ = gg(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 14],9,-1019803690);
_loc4_ = gg(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 3],14,-187363961);
_loc3_ = gg(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 8],20,1163531501);
_loc2_ = gg(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 13],5,-1444681467);
_loc5_ = gg(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 2],9,-51403784);
_loc4_ = gg(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 7],14,1735328473);
_loc3_ = gg(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 12],20,-1926607734);
_loc2_ = hh(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 5],4,-378558);
_loc5_ = hh(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 8],11,-2022574463);
_loc4_ = hh(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 11],16,1839030562);
_loc3_ = hh(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 14],23,-35309556);
_loc2_ = hh(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 1],4,-1530992060);
_loc5_ = hh(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 4],11,1272893353);
_loc4_ = hh(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 7],16,-155497632);
_loc3_ = hh(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 10],23,-1094730640);
_loc2_ = hh(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 13],4,681279174);
_loc5_ = hh(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 0],11,-358537222);
_loc4_ = hh(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 3],16,-722521979);
_loc3_ = hh(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 6],23,76029189);
_loc2_ = hh(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 9],4,-640364487);
_loc5_ = hh(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 12],11,-421815835);
_loc4_ = hh(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 15],16,530742520);
_loc3_ = hh(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 2],23,-995338651);
_loc2_ = ii(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 0],6,-198630844);
_loc5_ = ii(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 7],10,1126891415);
_loc4_ = ii(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 14],15,-1416354905);
_loc3_ = ii(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 5],21,-57434055);
_loc2_ = ii(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 12],6,1700485571);
_loc5_ = ii(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 3],10,-1894986606);
_loc4_ = ii(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 10],15,-1051523);
_loc3_ = ii(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 1],21,-2054922799);
_loc2_ = ii(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 8],6,1873313359);
_loc5_ = ii(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 15],10,-30611744);
_loc4_ = ii(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 6],15,-1560198380);
_loc3_ = ii(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 13],21,1309151649);
_loc2_ = ii(_loc2_,_loc3_,_loc4_,_loc5_,_loc10_[_loc12_ + 4],6,-145523070);
_loc5_ = ii(_loc5_,_loc2_,_loc3_,_loc4_,_loc10_[_loc12_ + 11],10,-1120210379);
_loc4_ = ii(_loc4_,_loc5_,_loc2_,_loc3_,_loc10_[_loc12_ + 2],15,718787259);
_loc3_ = ii(_loc3_,_loc4_,_loc5_,_loc2_,_loc10_[_loc12_ + 9],21,-343485551);
_loc2_ += _loc6_;
_loc3_ += _loc7_;
_loc4_ += _loc8_;
_loc5_ += _loc9_;
_loc12_ += 16;
}
return IntUtil.toHex(_loc2_) + IntUtil.toHex(_loc3_) + IntUtil.toHex(_loc4_) + IntUtil.toHex(_loc5_);
}
private static function f(param1:int, param2:int, param3:int) : int
{
return param1 & param2 | ~param1 & param3;
}
private static function g(param1:int, param2:int, param3:int) : int
{
return param1 & param3 | param2 & ~param3;
}
private static function h(param1:int, param2:int, param3:int) : int
{
return param1 ^ param2 ^ param3;
}
private static function i(param1:int, param2:int, param3:int) : int
{
return param2 ^ (param1 | ~param3);
}
private static function transform(param1:Function, param2:int, param3:int, param4:int, param5:int, param6:int, param7:int, param8:int) : int
{
var _loc9_:int = param2 + int(param1(param3,param4,param5)) + param6 + param8;
return IntUtil.rol(_loc9_,param7) + param3;
}
private static function ff(param1:int, param2:int, param3:int, param4:int, param5:int, param6:int, param7:int) : int
{
return transform(f,param1,param2,param3,param4,param5,param6,param7);
}
private static function gg(param1:int, param2:int, param3:int, param4:int, param5:int, param6:int, param7:int) : int
{
return transform(g,param1,param2,param3,param4,param5,param6,param7);
}
private static function hh(param1:int, param2:int, param3:int, param4:int, param5:int, param6:int, param7:int) : int
{
return transform(h,param1,param2,param3,param4,param5,param6,param7);
}
private static function ii(param1:int, param2:int, param3:int, param4:int, param5:int, param6:int, param7:int) : int
{
return transform(i,param1,param2,param3,param4,param5,param6,param7);
}
private static function createBlocks(param1:String) : Array
{
var _loc2_:Array = new Array();
var _loc3_:int = param1.length * 8;
var _loc4_:int = 255;
var _loc5_:int = 0;
while(_loc5_ < _loc3_)
{
_loc2_[_loc5_ >> 5] |= (param1.charCodeAt(_loc5_ / 8) & _loc4_) << _loc5_ % 32;
_loc5_ += 8;
}
_loc2_[_loc3_ >> 5] |= 128 << _loc3_ % 32;
_loc2_[(_loc3_ + 64 >>> 9 << 4) + 14] = _loc3_;
return _loc2_;
}
}
}
@@ -0,0 +1,24 @@
package com.adobe.serialization.json
{
public class JSON
{
public function JSON()
{
super();
}
public static function encode(param1:Object) : String
{
var _loc2_:JSONEncoder = new JSONEncoder(param1);
return _loc2_.getString();
}
public static function decode(param1:String) : *
{
var _loc2_:JSONDecoder = new JSONDecoder(param1);
return _loc2_.getValue();
}
}
}
@@ -0,0 +1,125 @@
package com.adobe.serialization.json
{
public class JSONDecoder
{
private var value:*;
private var tokenizer:JSONTokenizer;
private var token:JSONToken;
public function JSONDecoder(param1:String)
{
super();
this.tokenizer = new JSONTokenizer(param1);
this.nextToken();
this.value = this.parseValue();
}
public function getValue() : *
{
return this.value;
}
private function nextToken() : JSONToken
{
return this.token = this.tokenizer.getNextToken();
}
private function parseArray() : Array
{
var _loc1_:Array = new Array();
this.nextToken();
if(this.token.type == JSONTokenType.RIGHT_BRACKET)
{
return _loc1_;
}
while(true)
{
_loc1_.push(this.parseValue());
this.nextToken();
if(this.token.type == JSONTokenType.RIGHT_BRACKET)
{
break;
}
if(this.token.type == JSONTokenType.COMMA)
{
this.nextToken();
}
else
{
this.tokenizer.parseError("Expecting ] or , but found " + this.token.value);
}
}
return _loc1_;
}
private function parseObject() : Object
{
var _loc2_:String = null;
var _loc1_:Object = new Object();
this.nextToken();
if(this.token.type == JSONTokenType.RIGHT_BRACE)
{
return _loc1_;
}
while(true)
{
if(this.token.type == JSONTokenType.STRING)
{
_loc2_ = String(this.token.value);
this.nextToken();
if(this.token.type == JSONTokenType.COLON)
{
this.nextToken();
_loc1_[_loc2_] = this.parseValue();
this.nextToken();
if(this.token.type == JSONTokenType.RIGHT_BRACE)
{
break;
}
if(this.token.type == JSONTokenType.COMMA)
{
this.nextToken();
}
else
{
this.tokenizer.parseError("Expecting } or , but found " + this.token.value);
}
}
else
{
this.tokenizer.parseError("Expecting : but found " + this.token.value);
}
}
else
{
this.tokenizer.parseError("Expecting string but found " + this.token.value);
}
}
return _loc1_;
}
private function parseValue() : Object
{
switch(this.token.type)
{
case JSONTokenType.LEFT_BRACE:
return this.parseObject();
case JSONTokenType.LEFT_BRACKET:
return this.parseArray();
case JSONTokenType.STRING:
case JSONTokenType.NUMBER:
case JSONTokenType.TRUE:
case JSONTokenType.FALSE:
case JSONTokenType.NULL:
return this.token.value;
default:
this.tokenizer.parseError("Unexpected " + this.token.value);
return null;
}
}
}
}
@@ -0,0 +1,151 @@
package com.adobe.serialization.json
{
import flash.utils.describeType;
public class JSONEncoder
{
private var jsonString:String;
public function JSONEncoder(param1:*)
{
super();
this.jsonString = this.convertToString(param1);
}
public function getString() : String
{
return this.jsonString;
}
private function convertToString(param1:*) : String
{
if(param1 is String)
{
return this.escapeString(param1 as String);
}
if(param1 is Number)
{
return isFinite(param1 as Number) ? param1.toString() : "null";
}
if(param1 is Boolean)
{
return param1 ? "true" : "false";
}
if(param1 is Array)
{
return this.arrayToString(param1 as Array);
}
if(param1 is Object && param1 != null)
{
return this.objectToString(param1);
}
return "null";
}
private function escapeString(param1:String) : String
{
var _loc3_:String = null;
var _loc6_:String = null;
var _loc7_:String = null;
var _loc2_:String = "";
var _loc4_:Number = param1.length;
var _loc5_:int = 0;
while(_loc5_ < _loc4_)
{
_loc3_ = param1.charAt(_loc5_);
switch(_loc3_)
{
case "\"":
_loc2_ += "\\\"";
break;
case "\\":
_loc2_ += "\\\\";
break;
case "\b":
_loc2_ += "\\b";
break;
case "\f":
_loc2_ += "\\f";
break;
case "\n":
_loc2_ += "\\n";
break;
case "\r":
_loc2_ += "\\r";
break;
case "\t":
_loc2_ += "\\t";
break;
default:
if(_loc3_ < " ")
{
_loc6_ = _loc3_.charCodeAt(0).toString(16);
_loc7_ = _loc6_.length == 2 ? "00" : "000";
_loc2_ += "\\u" + _loc7_ + _loc6_;
}
else
{
_loc2_ += _loc3_;
}
}
_loc5_++;
}
return "\"" + _loc2_ + "\"";
}
private function arrayToString(param1:Array) : String
{
var _loc2_:String = "";
var _loc3_:int = 0;
while(_loc3_ < param1.length)
{
if(_loc2_.length > 0)
{
_loc2_ += ",";
}
_loc2_ += this.convertToString(param1[_loc3_]);
_loc3_++;
}
return "[" + _loc2_ + "]";
}
private function objectToString(param1:Object) : String
{
var value:Object = null;
var key:String = null;
var v:XML = null;
var o:Object = param1;
var s:String = "";
var classInfo:XML = describeType(o);
if(classInfo.@name.toString() == "Object")
{
for(key in o)
{
value = o[key];
if(!(value is Function))
{
if(s.length > 0)
{
s += ",";
}
s += this.escapeString(key) + ":" + this.convertToString(value);
}
}
}
else
{
for each(v in classInfo..*.(name() == "variable" || name() == "accessor"))
{
if(s.length > 0)
{
s += ",";
}
s += this.escapeString(v.@name.toString()) + ":" + this.convertToString(o[v.@name]);
}
}
return "{" + s + "}";
}
}
}
@@ -0,0 +1,28 @@
package com.adobe.serialization.json
{
public class JSONParseError extends Error
{
private var _location:int;
private var _text:String;
public function JSONParseError(param1:String = "", param2:int = 0, param3:String = "")
{
super(param1);
this._location = param2;
this._text = param3;
}
public function get location() : int
{
return this._location;
}
public function get text() : String
{
return this._text;
}
}
}
@@ -0,0 +1,38 @@
package com.adobe.serialization.json
{
public class JSONToken
{
private var _type:int;
private var _value:Object;
public function JSONToken(param1:int = -1, param2:Object = null)
{
super();
this._type = param1;
this._value = param2;
}
public function get type() : int
{
return this._type;
}
public function set type(param1:int) : void
{
this._type = param1;
}
public function get value() : Object
{
return this._value;
}
public function set value(param1:Object) : void
{
this._value = param1;
}
}
}
@@ -0,0 +1,36 @@
package com.adobe.serialization.json
{
public class JSONTokenType
{
public static const UNKNOWN:int = -1;
public static const COMMA:int = 0;
public static const LEFT_BRACE:int = 1;
public static const RIGHT_BRACE:int = 2;
public static const LEFT_BRACKET:int = 3;
public static const RIGHT_BRACKET:int = 4;
public static const COLON:int = 6;
public static const TRUE:int = 7;
public static const FALSE:int = 8;
public static const NULL:int = 9;
public static const STRING:int = 10;
public static const NUMBER:int = 11;
public function JSONTokenType()
{
super();
}
}
}
@@ -0,0 +1,352 @@
package com.adobe.serialization.json
{
public class JSONTokenizer
{
private var obj:Object;
private var jsonString:String;
private var loc:int;
private var ch:String;
public function JSONTokenizer(param1:String)
{
super();
this.jsonString = param1;
this.loc = 0;
this.nextChar();
}
public function getNextToken() : JSONToken
{
var _loc2_:String = null;
var _loc3_:String = null;
var _loc4_:String = null;
var _loc1_:JSONToken = new JSONToken();
this.skipIgnored();
switch(this.ch)
{
case "{":
_loc1_.type = JSONTokenType.LEFT_BRACE;
_loc1_.value = "{";
this.nextChar();
break;
case "}":
_loc1_.type = JSONTokenType.RIGHT_BRACE;
_loc1_.value = "}";
this.nextChar();
break;
case "[":
_loc1_.type = JSONTokenType.LEFT_BRACKET;
_loc1_.value = "[";
this.nextChar();
break;
case "]":
_loc1_.type = JSONTokenType.RIGHT_BRACKET;
_loc1_.value = "]";
this.nextChar();
break;
case ",":
_loc1_.type = JSONTokenType.COMMA;
_loc1_.value = ",";
this.nextChar();
break;
case ":":
_loc1_.type = JSONTokenType.COLON;
_loc1_.value = ":";
this.nextChar();
break;
case "t":
_loc2_ = "t" + this.nextChar() + this.nextChar() + this.nextChar();
if(_loc2_ == "true")
{
_loc1_.type = JSONTokenType.TRUE;
_loc1_.value = true;
this.nextChar();
}
else
{
this.parseError("Expecting \'true\' but found " + _loc2_);
}
break;
case "f":
_loc3_ = "f" + this.nextChar() + this.nextChar() + this.nextChar() + this.nextChar();
if(_loc3_ == "false")
{
_loc1_.type = JSONTokenType.FALSE;
_loc1_.value = false;
this.nextChar();
}
else
{
this.parseError("Expecting \'false\' but found " + _loc3_);
}
break;
case "n":
_loc4_ = "n" + this.nextChar() + this.nextChar() + this.nextChar();
if(_loc4_ == "null")
{
_loc1_.type = JSONTokenType.NULL;
_loc1_.value = null;
this.nextChar();
}
else
{
this.parseError("Expecting \'null\' but found " + _loc4_);
}
break;
case "\"":
_loc1_ = this.readString();
break;
default:
if(this.isDigit(this.ch) || this.ch == "-")
{
_loc1_ = this.readNumber();
}
else
{
if(this.ch == "")
{
return null;
}
this.parseError("Unexpected " + this.ch + " encountered");
}
}
return _loc1_;
}
private function readString() : JSONToken
{
var _loc3_:String = null;
var _loc4_:int = 0;
var _loc1_:JSONToken = new JSONToken();
_loc1_.type = JSONTokenType.STRING;
var _loc2_:String = "";
this.nextChar();
while(this.ch != "\"" && this.ch != "")
{
if(this.ch == "\\")
{
this.nextChar();
switch(this.ch)
{
case "\"":
_loc2_ += "\"";
break;
case "/":
_loc2_ += "/";
break;
case "\\":
_loc2_ += "\\";
break;
case "b":
_loc2_ += "\b";
break;
case "f":
_loc2_ += "\f";
break;
case "n":
_loc2_ += "\n";
break;
case "r":
_loc2_ += "\r";
break;
case "t":
_loc2_ += "\t";
break;
case "u":
_loc3_ = "";
_loc4_ = 0;
while(_loc4_ < 4)
{
if(!this.isHexDigit(this.nextChar()))
{
this.parseError(" Excepted a hex digit, but found: " + this.ch);
}
_loc3_ += this.ch;
_loc4_++;
}
_loc2_ += String.fromCharCode(parseInt(_loc3_,16));
break;
default:
_loc2_ += "\\" + this.ch;
}
}
else
{
_loc2_ += this.ch;
}
this.nextChar();
}
if(this.ch == "")
{
this.parseError("Unterminated string literal");
}
this.nextChar();
_loc1_.value = _loc2_;
return _loc1_;
}
private function readNumber() : JSONToken
{
var _loc1_:JSONToken = new JSONToken();
_loc1_.type = JSONTokenType.NUMBER;
var _loc2_:String = "";
if(this.ch == "-")
{
_loc2_ += "-";
this.nextChar();
}
if(!this.isDigit(this.ch))
{
this.parseError("Expecting a digit");
}
if(this.ch == "0")
{
_loc2_ += this.ch;
this.nextChar();
if(this.isDigit(this.ch))
{
this.parseError("A digit cannot immediately follow 0");
}
}
else
{
while(this.isDigit(this.ch))
{
_loc2_ += this.ch;
this.nextChar();
}
}
if(this.ch == ".")
{
_loc2_ += ".";
this.nextChar();
if(!this.isDigit(this.ch))
{
this.parseError("Expecting a digit");
}
while(this.isDigit(this.ch))
{
_loc2_ += this.ch;
this.nextChar();
}
}
if(this.ch == "e" || this.ch == "E")
{
_loc2_ += "e";
this.nextChar();
if(this.ch == "+" || this.ch == "-")
{
_loc2_ += this.ch;
this.nextChar();
}
if(!this.isDigit(this.ch))
{
this.parseError("Scientific notation number needs exponent value");
}
while(this.isDigit(this.ch))
{
_loc2_ += this.ch;
this.nextChar();
}
}
var _loc3_:Number = Number(_loc2_);
if(isFinite(_loc3_) && !isNaN(_loc3_))
{
_loc1_.value = _loc3_;
return _loc1_;
}
this.parseError("Number " + _loc3_ + " is not valid!");
return null;
}
private function nextChar() : String
{
return this.ch = this.jsonString.charAt(this.loc++);
}
private function skipIgnored() : void
{
this.skipWhite();
this.skipComments();
this.skipWhite();
}
private function skipComments() : void
{
if(this.ch == "/")
{
this.nextChar();
switch(this.ch)
{
case "/":
do
{
this.nextChar();
}
while(this.ch != "\n" && this.ch != "");
this.nextChar();
break;
case "*":
this.nextChar();
while(true)
{
if(this.ch == "*")
{
this.nextChar();
if(this.ch == "/")
{
break;
}
}
else
{
this.nextChar();
}
if(this.ch == "")
{
this.parseError("Multi-line comment not closed");
}
}
this.nextChar();
break;
default:
this.parseError("Unexpected " + this.ch + " encountered (expecting \'/\' or \'*\' )");
}
}
}
private function skipWhite() : void
{
while(this.isWhiteSpace(this.ch))
{
this.nextChar();
}
}
private function isWhiteSpace(param1:String) : Boolean
{
return param1 == " " || param1 == "\t" || param1 == "\n";
}
private function isDigit(param1:String) : Boolean
{
return param1 >= "0" && param1 <= "9";
}
private function isHexDigit(param1:String) : Boolean
{
var _loc2_:String = param1.toUpperCase();
return this.isDigit(param1) || _loc2_ >= "A" && _loc2_ <= "F";
}
public function parseError(param1:String) : void
{
throw new JSONParseError(param1,this.loc,this.jsonString);
}
}
}
@@ -0,0 +1,51 @@
package com.adobe.utils
{
public class IntUtil
{
private static var hexChars:String = "0123456789abcdef";
public function IntUtil()
{
super();
}
public static function rol(param1:int, param2:int) : int
{
return param1 << param2 | param1 >>> 32 - param2;
}
public static function ror(param1:int, param2:int) : uint
{
var _loc3_:int = 32 - param2;
return param1 << _loc3_ | param1 >>> 32 - _loc3_;
}
public static function toHex(param1:int, param2:Boolean = false) : String
{
var _loc4_:int = 0;
var _loc5_:int = 0;
var _loc3_:String = "";
if(param2)
{
_loc4_ = 0;
while(_loc4_ < 4)
{
_loc3_ += hexChars.charAt(param1 >> (3 - _loc4_) * 8 + 4 & 0x0F) + hexChars.charAt(param1 >> (3 - _loc4_) * 8 & 0x0F);
_loc4_++;
}
}
else
{
_loc5_ = 0;
while(_loc5_ < 4)
{
_loc3_ += hexChars.charAt(param1 >> _loc5_ * 8 + 4 & 0x0F) + hexChars.charAt(param1 >> _loc5_ * 8 & 0x0F);
_loc5_++;
}
}
return _loc3_;
}
}
}
@@ -0,0 +1,106 @@
package com.adobe.utils
{
public class StringUtil
{
public function StringUtil()
{
super();
}
public static function stringsAreEqual(param1:String, param2:String, param3:Boolean) : Boolean
{
if(param3)
{
return param1 == param2;
}
return param1.toUpperCase() == param2.toUpperCase();
}
public static function trim(param1:String) : String
{
return StringUtil.ltrim(StringUtil.rtrim(param1));
}
public static function ltrim(param1:String) : String
{
var _loc2_:Number = param1.length;
var _loc3_:Number = 0;
while(_loc3_ < _loc2_)
{
if(param1.charCodeAt(_loc3_) > 32)
{
return param1.substring(_loc3_);
}
_loc3_++;
}
return "";
}
public static function rtrim(param1:String) : String
{
var _loc2_:Number = param1.length;
var _loc3_:Number = _loc2_;
while(_loc3_ > 0)
{
if(param1.charCodeAt(_loc3_ - 1) > 32)
{
return param1.substring(0,_loc3_);
}
_loc3_--;
}
return "";
}
public static function beginsWith(param1:String, param2:String) : Boolean
{
return param2 == param1.substring(0,param2.length);
}
public static function endsWith(param1:String, param2:String) : Boolean
{
return param2 == param1.substring(param1.length - param2.length);
}
public static function remove(param1:String, param2:String) : String
{
return StringUtil.replace(param1,param2,"");
}
public static function replace(param1:String, param2:String, param3:String) : String
{
var _loc9_:Number = NaN;
var _loc4_:String = new String();
var _loc5_:Boolean = false;
var _loc6_:Number = param1.length;
var _loc7_:Number = param2.length;
var _loc8_:Number = 0;
for(; _loc8_ < _loc6_; _loc8_++)
{
if(param1.charAt(_loc8_) == param2.charAt(0))
{
_loc5_ = true;
_loc9_ = 0;
while(_loc9_ < _loc7_)
{
if(param1.charAt(_loc8_ + _loc9_) != param2.charAt(_loc9_))
{
_loc5_ = false;
break;
}
_loc9_++;
}
if(_loc5_)
{
_loc4_ += param3;
_loc8_ += _loc7_ - 1;
continue;
}
}
_loc4_ += param1.charAt(_loc8_);
}
return _loc4_;
}
}
}
@@ -0,0 +1,152 @@
package com.baseoneonline.astar
{
import flash.utils.Dictionary;
public class AStar
{
private var graph:Graph;
private var g:Vector.<Number>;
private var h:Vector.<Number>;
private var f:Vector.<Number>;
private var parent:Vector.<int>;
private var open:Vector.<int>;
private var closed:Vector.<int>;
private var closedDict:Dictionary;
private var goalReached:Boolean = false;
public function AStar(param1:Graph = null)
{
super();
if(param1)
{
this.setGraph(param1);
}
}
public function setGraph(param1:Graph) : void
{
this.graph = param1;
this.updateGraph();
}
private function updateGraph() : void
{
var _loc1_:int = this.graph.size();
this.g = new Vector.<Number>(_loc1_,true);
this.h = new Vector.<Number>(_loc1_,true);
this.f = new Vector.<Number>(_loc1_,true);
this.parent = new Vector.<int>(_loc1_,true);
}
public function solve(param1:int, param2:int) : Vector.<int>
{
var _loc6_:int = 0;
var _loc7_:Number = NaN;
var _loc8_:int = 0;
var _loc9_:int = 0;
var _loc10_:int = 0;
var _loc11_:int = 0;
var _loc12_:Number = NaN;
var _loc13_:Boolean = false;
var _loc14_:Number = NaN;
var _loc3_:Vector.<int> = new Vector.<int>();
this.goalReached = false;
this.open = new Vector.<int>();
this.closed = new Vector.<int>();
this.closedDict = new Dictionary(true);
this.open.push(param1);
this.g[param1] = 0;
this.h[param1] = this.graph.distance(param1,param2);
this.f[param1] = this.h[param1];
this.parent[param1] = -1;
this.graph.setStartGridPos(param1);
while(this.open.length > 0)
{
_loc7_ = Number.POSITIVE_INFINITY;
_loc8_ = -1;
_loc9_ = 0;
while(_loc9_ < this.open.length)
{
_loc11_ = this.open[_loc9_];
if(this.f[_loc11_] < _loc7_)
{
_loc7_ = this.f[_loc11_];
_loc8_ = _loc11_;
}
_loc9_++;
}
if(_loc8_ == param2)
{
this.goalReached = true;
return this.createPath(param2,param1);
}
this.open.splice(this.open.indexOf(_loc8_),1);
this.closed.push(_loc8_);
this.closedDict[_loc8_] = 1;
for each(_loc10_ in this.graph.getNeighbors(_loc8_,_loc3_))
{
if(this.closedDict[_loc10_] != 1)
{
_loc12_ = this.g[_loc8_] + this.graph.distance(_loc8_,_loc10_);
_loc13_ = false;
if(this.open.indexOf(_loc10_) == -1)
{
this.open.push(_loc10_);
_loc13_ = true;
}
else if(_loc12_ < this.g[_loc10_])
{
_loc13_ = true;
}
if(_loc13_)
{
this.parent[_loc10_] = _loc8_;
this.g[_loc10_] = _loc12_;
this.h[_loc10_] = this.graph.distance(_loc10_,param2);
this.f[_loc10_] = this.g[_loc10_] + this.h[_loc10_];
}
}
}
}
var _loc4_:Number = Number.POSITIVE_INFINITY;
var _loc5_:int = -1;
for each(_loc6_ in this.closed)
{
_loc14_ = this.h[_loc6_];
if(_loc14_ < _loc4_)
{
_loc4_ = _loc14_;
_loc5_ = _loc6_;
}
}
return this.createPath(_loc5_,param1);
}
public function hasReachedGoal() : Boolean
{
return this.goalReached;
}
private function createPath(param1:int, param2:int) : Vector.<int>
{
var _loc3_:Vector.<int> = new Vector.<int>();
while(this.parent[param1] != -1)
{
_loc3_.push(param1);
param1 = this.parent[param1];
}
_loc3_.push(param2);
return _loc3_.reverse();
}
}
}
@@ -0,0 +1,15 @@
package com.baseoneonline.astar
{
public interface Graph
{
function getNeighbors(param1:int, param2:Vector.<int>) : Vector.<int>;
function distance(param1:int, param2:int) : Number;
function size() : int;
function setStartGridPos(param1:int) : void;
}
}
@@ -0,0 +1,180 @@
package com.carlcalderon.arthropod
{
import flash.display.BitmapData;
import flash.display.Stage;
import flash.events.StatusEvent;
import flash.geom.Matrix;
import flash.geom.Rectangle;
import flash.net.LocalConnection;
import flash.system.System;
public class Debug
{
public static const NAME:String = "Debug";
public static const VERSION:String = "0.74";
public static var password:String = "CDC309AF";
public static var RED:uint = 13369344;
public static var GREEN:uint = 52224;
public static var BLUE:uint = 6710988;
public static var PINK:uint = 13369548;
public static var YELLOW:uint = 13421568;
public static var LIGHT_BLUE:uint = 52428;
public static var ignoreStatus:Boolean = true;
public static var secure:Boolean = false;
public static var secureDomain:String = "*";
public static var allowLog:Boolean = true;
private static const DOMAIN:String = "com.carlcalderon.Arthropod";
private static const CHECK:String = ".161E714B6C1A76DE7B9865F88B32FCCE8FABA7B5.1";
private static const TYPE:String = "app";
private static const CONNECTION:String = "arthropod";
private static const LOG_OPERATION:String = "debug";
private static const ERROR_OPERATION:String = "debugError";
private static const WARNING_OPERATION:String = "debugWarning";
private static const ARRAY_OPERATION:String = "debugArray";
private static const BITMAP_OPERATION:String = "debugBitmapData";
private static const OBJECT_OPERATION:String = "debugObject";
private static const MEMORY_OPERATION:String = "debugMemory";
private static const CLEAR_OPERATION:String = "debugClear";
private static var lc:LocalConnection = new LocalConnection();
private static var hasEventListeners:Boolean = false;
public function Debug()
{
super();
}
public static function log(param1:*, param2:uint = 16711422) : Boolean
{
return send(LOG_OPERATION,String(param1),param2);
}
public static function error(param1:*) : Boolean
{
return send(ERROR_OPERATION,String(param1),13369344);
}
public static function warning(param1:*) : Boolean
{
return send(WARNING_OPERATION,String(param1),13421568);
}
public static function clear() : Boolean
{
return send(CLEAR_OPERATION,0,0);
}
public static function array(param1:Array) : Boolean
{
return send(ARRAY_OPERATION,param1,null);
}
public static function bitmap(param1:*, param2:String = null) : Boolean
{
var _loc3_:BitmapData = new BitmapData(100,100,true,16777215);
var _loc4_:Matrix = new Matrix();
var _loc5_:Number = 100 / (param1.width >= param1.height ? param1.width : param1.height);
_loc4_.scale(_loc5_,_loc5_);
_loc3_.draw(param1,_loc4_,null,null,null,true);
var _loc6_:Rectangle = new Rectangle(0,0,Math.floor(param1.width * _loc5_),Math.floor(param1.height * _loc5_));
return send(BITMAP_OPERATION,_loc3_.getPixels(_loc6_),{
"bounds":_loc6_,
"lbl":param2
});
}
public static function snapshot(param1:Stage, param2:String = null) : Boolean
{
if(param1)
{
return bitmap(param1,param2);
}
return false;
}
public static function object(param1:*) : Boolean
{
return send(OBJECT_OPERATION,param1,null);
}
public static function memory() : Boolean
{
return send(MEMORY_OPERATION,System.totalMemory,null);
}
private static function send(param1:String, param2:*, param3:*) : Boolean
{
var operation:String = param1;
var value:* = param2;
var prop:* = param3;
if(!secure)
{
lc.allowInsecureDomain("*");
}
else
{
lc.allowDomain(secureDomain);
}
if(!hasEventListeners)
{
if(ignoreStatus)
{
lc.addEventListener(StatusEvent.STATUS,ignore);
}
else
{
lc.addEventListener(StatusEvent.STATUS,status);
}
hasEventListeners = true;
}
if(!allowLog)
{
return false;
}
try
{
lc.send(TYPE + "#" + DOMAIN + CHECK + ":" + CONNECTION,operation,password,value,prop);
return true;
}
catch(e:*)
{
return false;
}
}
private static function status(param1:StatusEvent) : void
{
}
private static function ignore(param1:StatusEvent) : void
{
}
}
}
@@ -0,0 +1,221 @@
package com.hurlant.crypto
{
import com.hurlant.crypto.hash.HMAC;
import com.hurlant.crypto.hash.IHash;
import com.hurlant.crypto.hash.MD2;
import com.hurlant.crypto.hash.MD5;
import com.hurlant.crypto.hash.SHA1;
import com.hurlant.crypto.hash.SHA224;
import com.hurlant.crypto.hash.SHA256;
import com.hurlant.crypto.prng.ARC4;
import com.hurlant.crypto.rsa.RSAKey;
import com.hurlant.crypto.symmetric.AESKey;
import com.hurlant.crypto.symmetric.BlowFishKey;
import com.hurlant.crypto.symmetric.CBCMode;
import com.hurlant.crypto.symmetric.CFB8Mode;
import com.hurlant.crypto.symmetric.CFBMode;
import com.hurlant.crypto.symmetric.CTRMode;
import com.hurlant.crypto.symmetric.DESKey;
import com.hurlant.crypto.symmetric.ECBMode;
import com.hurlant.crypto.symmetric.ICipher;
import com.hurlant.crypto.symmetric.IMode;
import com.hurlant.crypto.symmetric.IPad;
import com.hurlant.crypto.symmetric.ISymmetricKey;
import com.hurlant.crypto.symmetric.IVMode;
import com.hurlant.crypto.symmetric.NullPad;
import com.hurlant.crypto.symmetric.OFBMode;
import com.hurlant.crypto.symmetric.PKCS5;
import com.hurlant.crypto.symmetric.SimpleIVMode;
import com.hurlant.crypto.symmetric.TripleDESKey;
import com.hurlant.crypto.symmetric.XTeaKey;
import com.hurlant.util.Base64;
import flash.utils.ByteArray;
public class Crypto
{
private var b64:Base64;
public function Crypto()
{
super();
}
public static function getCipher(param1:String, param2:ByteArray, param3:IPad = null) : ICipher
{
var _loc5_:ICipher = null;
var _loc4_:Array = param1.split("-");
switch(_loc4_[0])
{
case "simple":
_loc4_.shift();
param1 = _loc4_.join("-");
_loc5_ = getCipher(param1,param2,param3);
if(_loc5_ is IVMode)
{
return new SimpleIVMode(_loc5_ as IVMode);
}
return _loc5_;
break;
case "aes":
case "aes128":
case "aes192":
case "aes256":
_loc4_.shift();
if(param2.length * 8 == _loc4_[0])
{
_loc4_.shift();
}
return getMode(_loc4_[0],new AESKey(param2),param3);
case "bf":
case "blowfish":
_loc4_.shift();
return getMode(_loc4_[0],new BlowFishKey(param2),param3);
case "des":
_loc4_.shift();
if(_loc4_[0] != "ede" && _loc4_[0] != "ede3")
{
return getMode(_loc4_[0],new DESKey(param2),param3);
}
if(_loc4_.length == 1)
{
_loc4_.push("ecb");
}
break;
case "3des":
case "des3":
break;
case "xtea":
_loc4_.shift();
return getMode(_loc4_[0],new XTeaKey(param2),param3);
case "rc4":
_loc4_.shift();
return new ARC4(param2);
default:
return null;
}
_loc4_.shift();
return getMode(_loc4_[0],new TripleDESKey(param2),param3);
}
public static function getKeySize(param1:String) : uint
{
var _loc2_:Array = param1.split("-");
switch(_loc2_[0])
{
case "simple":
_loc2_.shift();
return getKeySize(_loc2_.join("-"));
case "aes128":
return 16;
case "aes192":
return 24;
case "aes256":
return 32;
case "aes":
_loc2_.shift();
return parseInt(_loc2_[0]) / 8;
case "bf":
case "blowfish":
return 16;
case "des":
_loc2_.shift();
switch(_loc2_[0])
{
case "ede":
return 16;
case "ede3":
return 24;
default:
return 8;
}
break;
case "3des":
case "des3":
return 24;
case "xtea":
return 8;
case "rc4":
if(parseInt(_loc2_[1]) > 0)
{
return parseInt(_loc2_[1]) / 8;
}
return 16;
break;
default:
return 0;
}
}
private static function getMode(param1:String, param2:ISymmetricKey, param3:IPad = null) : IMode
{
switch(param1)
{
case "ecb":
return new ECBMode(param2,param3);
case "cfb":
return new CFBMode(param2,param3);
case "cfb8":
return new CFB8Mode(param2,param3);
case "ofb":
return new OFBMode(param2,param3);
case "ctr":
return new CTRMode(param2,param3);
case "cbc":
}
return new CBCMode(param2,param3);
}
public static function getHash(param1:String) : IHash
{
switch(param1)
{
case "md2":
return new MD2();
case "md5":
return new MD5();
case "sha":
case "sha1":
return new SHA1();
case "sha224":
return new SHA224();
case "sha256":
return new SHA256();
default:
return null;
}
}
public static function getHMAC(param1:String) : HMAC
{
var _loc2_:Array = param1.split("-");
if(_loc2_[0] == "hmac")
{
_loc2_.shift();
}
var _loc3_:uint = 0;
if(_loc2_.length > 1)
{
_loc3_ = parseInt(_loc2_[1]);
}
return new HMAC(getHash(_loc2_[0]),_loc3_);
}
public static function getPad(param1:String) : IPad
{
switch(param1)
{
case "null":
return new NullPad();
case "pkcs5":
}
return new PKCS5();
}
public static function getRSA(param1:String, param2:String) : RSAKey
{
return RSAKey.parsePublicKey(param2,param1);
}
}
}
@@ -0,0 +1,78 @@
package com.hurlant.crypto.hash
{
import flash.utils.ByteArray;
public class HMAC
{
private var hash:IHash;
private var bits:uint;
public function HMAC(param1:IHash, param2:uint = 0)
{
super();
this.hash = param1;
this.bits = param2;
}
public function getHashSize() : uint
{
if(this.bits != 0)
{
return this.bits / 8;
}
return this.hash.getHashSize();
}
public function compute(param1:ByteArray, param2:ByteArray) : ByteArray
{
var _loc3_:ByteArray = null;
if(param1.length > this.hash.getInputSize())
{
_loc3_ = this.hash.hash(param1);
}
else
{
_loc3_ = new ByteArray();
_loc3_.writeBytes(param1);
}
while(_loc3_.length < this.hash.getInputSize())
{
_loc3_[_loc3_.length] = 0;
}
var _loc4_:ByteArray = new ByteArray();
var _loc5_:ByteArray = new ByteArray();
var _loc6_:uint = 0;
while(_loc6_ < _loc3_.length)
{
_loc4_[_loc6_] = _loc3_[_loc6_] ^ 0x36;
_loc5_[_loc6_] = _loc3_[_loc6_] ^ 0x5C;
_loc6_++;
}
_loc4_.position = _loc3_.length;
_loc4_.writeBytes(param2);
var _loc7_:ByteArray = this.hash.hash(_loc4_);
_loc5_.position = _loc3_.length;
_loc5_.writeBytes(_loc7_);
var _loc8_:ByteArray = this.hash.hash(_loc5_);
if(this.bits > 0 && this.bits < 8 * _loc8_.length)
{
_loc8_.length = this.bits / 8;
}
return _loc8_;
}
public function dispose() : void
{
this.hash = null;
this.bits = 0;
}
public function toString() : String
{
return "hmac-" + (this.bits > 0 ? this.bits + "-" : "") + this.hash.toString();
}
}
}
@@ -0,0 +1,17 @@
package com.hurlant.crypto.hash
{
import flash.utils.ByteArray;
public interface IHash
{
function getInputSize() : uint;
function getHashSize() : uint;
function hash(param1:ByteArray) : ByteArray;
function toString() : String;
}
}
@@ -0,0 +1,92 @@
package com.hurlant.crypto.hash
{
import flash.utils.ByteArray;
public class MD2 implements IHash
{
public static const HASH_SIZE:int = 16;
private static const S:Array = [41,46,67,201,162,216,124,1,61,54,84,161,236,240,6,19,98,167,5,243,192,199,115,140,152,147,43,217,188,76,130,202,30,155,87,60,253,212,224,22,103,66,111,24,138,23,229,18,190,78,196,214,218,158,222,73,160,251,245,142,187,47,238,122,169,104,121,145,21,178,7,63,148,194,16,137,11,34,95,33,128,127,93,154,90,144,50,39,53,62,204,231,191,247,151,3,255,25,48,179,72,165,181,209,215,94,146,42,172,86,170,198,79,184,56,210,150,164,125,182,118,252,107,226,156,116,4,241,69,157,112,89,100,113,135,32,134,91,207,101,230,45,168,2,27,96,37,173,174,176,185,246,28,70,97,105,52,64,126,15,85,71,163,35,221,81,175,58,195,92,249,206,186,197,234,38,44,83,13,110,133,40,132,9,211,223,205,244,65,129,77,82,106,220,55,200,108,193,171,250,36,225,123,8,12,189,177,74,120,136,149,139,227,99,232,109,233,203,213,254,59,0,29,57,242,239,183,14,102,88,208,228,166,119,114,248,235,117,75,10,49,68,80,180,143,237,31,26,219,153,141,51,159,17,131,20];
public function MD2()
{
super();
}
public function getInputSize() : uint
{
return 16;
}
public function getHashSize() : uint
{
return HASH_SIZE;
}
public function hash(param1:ByteArray) : ByteArray
{
var _loc8_:uint = 0;
var _loc9_:uint = 0;
var _loc10_:uint = 0;
var _loc2_:uint = param1.length;
var _loc3_:uint = uint(uint(16 - param1.length % 16) || 16);
do
{
param1[param1.length] = _loc3_;
}
while(param1.length % 16 != 0);
var _loc4_:uint = param1.length;
var _loc5_:ByteArray = new ByteArray();
var _loc6_:uint = 0;
_loc3_ = 0;
while(_loc3_ < _loc4_)
{
_loc8_ = 0;
while(_loc8_ < 16)
{
_loc6_ = uint(_loc5_[_loc8_] = _loc5_[_loc8_] ^ S[param1[_loc3_ + _loc8_] ^ _loc6_]);
_loc8_++;
}
_loc3_ += 16;
}
param1.position = param1.length;
param1.writeBytes(_loc5_);
_loc4_ += 16;
var _loc7_:ByteArray = new ByteArray();
_loc3_ = 0;
while(_loc3_ < _loc4_)
{
_loc8_ = 0;
while(_loc8_ < 16)
{
_loc7_[32 + _loc8_] = (_loc7_[16 + _loc8_] = param1[_loc3_ + _loc8_]) ^ _loc7_[_loc8_];
_loc8_++;
}
_loc9_ = 0;
_loc8_ = 0;
while(_loc8_ < 18)
{
_loc10_ = 0;
while(_loc10_ < 48)
{
_loc7_[_loc10_] = _loc9_ = uint(_loc7_[_loc10_] ^ S[_loc9_]);
_loc10_++;
}
_loc9_ = uint(_loc9_ + _loc8_ & 0xFF);
_loc8_++;
}
_loc3_ += 16;
}
_loc7_.length = 16;
param1.length = _loc2_;
return _loc7_;
}
public function toString() : String
{
return "md2";
}
}
}
@@ -0,0 +1,201 @@
package com.hurlant.crypto.hash
{
import flash.utils.ByteArray;
import flash.utils.Endian;
public class MD5 implements IHash
{
public static const HASH_SIZE:int = 16;
public function MD5()
{
super();
}
public function getInputSize() : uint
{
return 64;
}
public function getHashSize() : uint
{
return HASH_SIZE;
}
public function hash(param1:ByteArray) : ByteArray
{
var _loc2_:uint = param1.length * 8;
var _loc3_:String = param1.endian;
while(param1.length % 4 != 0)
{
param1[param1.length] = 0;
}
param1.position = 0;
var _loc4_:Array = [];
param1.endian = Endian.LITTLE_ENDIAN;
var _loc5_:uint = 0;
while(_loc5_ < param1.length)
{
_loc4_.push(param1.readUnsignedInt());
_loc5_ += 4;
}
var _loc6_:Array = this.core_md5(_loc4_,_loc2_);
var _loc7_:ByteArray = new ByteArray();
_loc7_.endian = Endian.LITTLE_ENDIAN;
_loc5_ = 0;
while(_loc5_ < 4)
{
_loc7_.writeUnsignedInt(_loc6_[_loc5_]);
_loc5_++;
}
param1.length = _loc2_ / 8;
param1.endian = _loc3_;
return _loc7_;
}
private function core_md5(param1:Array, param2:uint) : Array
{
var _loc8_:uint = 0;
var _loc9_:uint = 0;
var _loc10_:uint = 0;
var _loc11_:uint = 0;
param1[param2 >> 5] |= 128 << param2 % 32;
param1[(param2 + 64 >>> 9 << 4) + 14] = param2;
var _loc3_:uint = 1732584193;
var _loc4_:uint = 4023233417;
var _loc5_:uint = 2562383102;
var _loc6_:uint = 271733878;
var _loc7_:uint = 0;
while(_loc7_ < param1.length)
{
param1[_loc7_] = param1[_loc7_] || 0;
param1[_loc7_ + 1] = param1[_loc7_ + 1] || 0;
param1[_loc7_ + 2] = param1[_loc7_ + 2] || 0;
param1[_loc7_ + 3] = param1[_loc7_ + 3] || 0;
param1[_loc7_ + 4] = param1[_loc7_ + 4] || 0;
param1[_loc7_ + 5] = param1[_loc7_ + 5] || 0;
param1[_loc7_ + 6] = param1[_loc7_ + 6] || 0;
param1[_loc7_ + 7] = param1[_loc7_ + 7] || 0;
param1[_loc7_ + 8] = param1[_loc7_ + 8] || 0;
param1[_loc7_ + 9] = param1[_loc7_ + 9] || 0;
param1[_loc7_ + 10] = param1[_loc7_ + 10] || 0;
param1[_loc7_ + 11] = param1[_loc7_ + 11] || 0;
param1[_loc7_ + 12] = param1[_loc7_ + 12] || 0;
param1[_loc7_ + 13] = param1[_loc7_ + 13] || 0;
param1[_loc7_ + 14] = param1[_loc7_ + 14] || 0;
param1[_loc7_ + 15] = param1[_loc7_ + 15] || 0;
_loc8_ = _loc3_;
_loc9_ = _loc4_;
_loc10_ = _loc5_;
_loc11_ = _loc6_;
_loc3_ = this.ff(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 0],7,3614090360);
_loc6_ = this.ff(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 1],12,3905402710);
_loc5_ = this.ff(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 2],17,606105819);
_loc4_ = this.ff(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 3],22,3250441966);
_loc3_ = this.ff(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 4],7,4118548399);
_loc6_ = this.ff(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 5],12,1200080426);
_loc5_ = this.ff(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 6],17,2821735955);
_loc4_ = this.ff(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 7],22,4249261313);
_loc3_ = this.ff(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 8],7,1770035416);
_loc6_ = this.ff(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 9],12,2336552879);
_loc5_ = this.ff(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 10],17,4294925233);
_loc4_ = this.ff(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 11],22,2304563134);
_loc3_ = this.ff(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 12],7,1804603682);
_loc6_ = this.ff(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 13],12,4254626195);
_loc5_ = this.ff(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 14],17,2792965006);
_loc4_ = this.ff(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 15],22,1236535329);
_loc3_ = this.gg(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 1],5,4129170786);
_loc6_ = this.gg(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 6],9,3225465664);
_loc5_ = this.gg(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 11],14,643717713);
_loc4_ = this.gg(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 0],20,3921069994);
_loc3_ = this.gg(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 5],5,3593408605);
_loc6_ = this.gg(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 10],9,38016083);
_loc5_ = this.gg(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 15],14,3634488961);
_loc4_ = this.gg(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 4],20,3889429448);
_loc3_ = this.gg(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 9],5,568446438);
_loc6_ = this.gg(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 14],9,3275163606);
_loc5_ = this.gg(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 3],14,4107603335);
_loc4_ = this.gg(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 8],20,1163531501);
_loc3_ = this.gg(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 13],5,2850285829);
_loc6_ = this.gg(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 2],9,4243563512);
_loc5_ = this.gg(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 7],14,1735328473);
_loc4_ = this.gg(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 12],20,2368359562);
_loc3_ = this.hh(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 5],4,4294588738);
_loc6_ = this.hh(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 8],11,2272392833);
_loc5_ = this.hh(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 11],16,1839030562);
_loc4_ = this.hh(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 14],23,4259657740);
_loc3_ = this.hh(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 1],4,2763975236);
_loc6_ = this.hh(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 4],11,1272893353);
_loc5_ = this.hh(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 7],16,4139469664);
_loc4_ = this.hh(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 10],23,3200236656);
_loc3_ = this.hh(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 13],4,681279174);
_loc6_ = this.hh(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 0],11,3936430074);
_loc5_ = this.hh(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 3],16,3572445317);
_loc4_ = this.hh(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 6],23,76029189);
_loc3_ = this.hh(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 9],4,3654602809);
_loc6_ = this.hh(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 12],11,3873151461);
_loc5_ = this.hh(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 15],16,530742520);
_loc4_ = this.hh(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 2],23,3299628645);
_loc3_ = this.ii(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 0],6,4096336452);
_loc6_ = this.ii(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 7],10,1126891415);
_loc5_ = this.ii(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 14],15,2878612391);
_loc4_ = this.ii(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 5],21,4237533241);
_loc3_ = this.ii(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 12],6,1700485571);
_loc6_ = this.ii(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 3],10,2399980690);
_loc5_ = this.ii(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 10],15,4293915773);
_loc4_ = this.ii(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 1],21,2240044497);
_loc3_ = this.ii(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 8],6,1873313359);
_loc6_ = this.ii(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 15],10,4264355552);
_loc5_ = this.ii(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 6],15,2734768916);
_loc4_ = this.ii(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 13],21,1309151649);
_loc3_ = this.ii(_loc3_,_loc4_,_loc5_,_loc6_,param1[_loc7_ + 4],6,4149444226);
_loc6_ = this.ii(_loc6_,_loc3_,_loc4_,_loc5_,param1[_loc7_ + 11],10,3174756917);
_loc5_ = this.ii(_loc5_,_loc6_,_loc3_,_loc4_,param1[_loc7_ + 2],15,718787259);
_loc4_ = this.ii(_loc4_,_loc5_,_loc6_,_loc3_,param1[_loc7_ + 9],21,3951481745);
_loc3_ += _loc8_;
_loc4_ += _loc9_;
_loc5_ += _loc10_;
_loc6_ += _loc11_;
_loc7_ += 16;
}
return [_loc3_,_loc4_,_loc5_,_loc6_];
}
private function rol(param1:uint, param2:uint) : uint
{
return param1 << param2 | param1 >>> 32 - param2;
}
private function cmn(param1:uint, param2:uint, param3:uint, param4:uint, param5:uint, param6:uint) : uint
{
return this.rol(param2 + param1 + param4 + param6,param5) + param3;
}
private function ff(param1:uint, param2:uint, param3:uint, param4:uint, param5:uint, param6:uint, param7:uint) : uint
{
return this.cmn(param2 & param3 | ~param2 & param4,param1,param2,param5,param6,param7);
}
private function gg(param1:uint, param2:uint, param3:uint, param4:uint, param5:uint, param6:uint, param7:uint) : uint
{
return this.cmn(param2 & param4 | param3 & ~param4,param1,param2,param5,param6,param7);
}
private function hh(param1:uint, param2:uint, param3:uint, param4:uint, param5:uint, param6:uint, param7:uint) : uint
{
return this.cmn(param2 ^ param3 ^ param4,param1,param2,param5,param6,param7);
}
private function ii(param1:uint, param2:uint, param3:uint, param4:uint, param5:uint, param6:uint, param7:uint) : uint
{
return this.cmn(param3 ^ (param2 | ~param4),param1,param2,param5,param6,param7);
}
public function toString() : String
{
return "md5";
}
}
}
@@ -0,0 +1,105 @@
package com.hurlant.crypto.hash
{
public class SHA1 extends SHABase implements IHash
{
public static const HASH_SIZE:int = 20;
public function SHA1()
{
super();
}
override public function getHashSize() : uint
{
return HASH_SIZE;
}
override protected function core(param1:Array, param2:uint) : Array
{
var _loc10_:uint = 0;
var _loc11_:uint = 0;
var _loc12_:uint = 0;
var _loc13_:uint = 0;
var _loc14_:uint = 0;
var _loc15_:uint = 0;
var _loc16_:uint = 0;
param1[param2 >> 5] |= 128 << 24 - param2 % 32;
param1[(param2 + 64 >> 9 << 4) + 15] = param2;
var _loc3_:Array = [];
var _loc4_:uint = 1732584193;
var _loc5_:uint = 4023233417;
var _loc6_:uint = 2562383102;
var _loc7_:uint = 271733878;
var _loc8_:uint = 3285377520;
var _loc9_:uint = 0;
while(_loc9_ < param1.length)
{
_loc10_ = _loc4_;
_loc11_ = _loc5_;
_loc12_ = _loc6_;
_loc13_ = _loc7_;
_loc14_ = _loc8_;
_loc15_ = 0;
while(_loc15_ < 80)
{
if(_loc15_ < 16)
{
_loc3_[_loc15_] = param1[_loc9_ + _loc15_] || 0;
}
else
{
_loc3_[_loc15_] = this.rol(_loc3_[_loc15_ - 3] ^ _loc3_[_loc15_ - 8] ^ _loc3_[_loc15_ - 14] ^ _loc3_[_loc15_ - 16],1);
}
_loc16_ = this.rol(_loc4_,5) + this.ft(_loc15_,_loc5_,_loc6_,_loc7_) + _loc8_ + _loc3_[_loc15_] + this.kt(_loc15_);
_loc8_ = _loc7_;
_loc7_ = _loc6_;
_loc6_ = this.rol(_loc5_,30);
_loc5_ = _loc4_;
_loc4_ = _loc16_;
_loc15_++;
}
_loc4_ += _loc10_;
_loc5_ += _loc11_;
_loc6_ += _loc12_;
_loc7_ += _loc13_;
_loc8_ += _loc14_;
_loc9_ += 16;
}
return [_loc4_,_loc5_,_loc6_,_loc7_,_loc8_];
}
private function rol(param1:uint, param2:uint) : uint
{
return param1 << param2 | param1 >>> 32 - param2;
}
private function ft(param1:uint, param2:uint, param3:uint, param4:uint) : uint
{
if(param1 < 20)
{
return param2 & param3 | ~param2 & param4;
}
if(param1 < 40)
{
return param2 ^ param3 ^ param4;
}
if(param1 < 60)
{
return param2 & param3 | param2 & param4 | param3 & param4;
}
return param2 ^ param3 ^ param4;
}
private function kt(param1:uint) : uint
{
return param1 < 20 ? 1518500249 : (param1 < 40 ? 1859775393 : (param1 < 60 ? uint(2400959708) : uint(3395469782)));
}
override public function toString() : String
{
return "sha1";
}
}
}
@@ -0,0 +1,23 @@
package com.hurlant.crypto.hash
{
public class SHA224 extends SHA256
{
public function SHA224()
{
super();
_h = [3238371032,914150663,812702999,4144912697,4290775857,1750603025,1694076839,3204075428];
}
override public function getHashSize() : uint
{
return 28;
}
override public function toString() : String
{
return "sha224";
}
}
}
@@ -0,0 +1,106 @@
package com.hurlant.crypto.hash
{
public class SHA256 extends SHABase implements IHash
{
protected static const k:Array = [1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298];
protected var _h:Array = [1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225];
public function SHA256()
{
super();
}
override public function getHashSize() : uint
{
return 32;
}
override protected function core(param1:Array, param2:uint) : Array
{
var _loc13_:uint = 0;
var _loc14_:uint = 0;
var _loc15_:uint = 0;
var _loc16_:uint = 0;
var _loc17_:uint = 0;
var _loc18_:uint = 0;
var _loc19_:uint = 0;
var _loc20_:uint = 0;
var _loc21_:uint = 0;
var _loc22_:uint = 0;
var _loc23_:uint = 0;
var _loc24_:uint = 0;
var _loc25_:uint = 0;
param1[param2 >> 5] |= 128 << 24 - param2 % 32;
param1[(param2 + 64 >> 9 << 4) + 15] = param2;
var _loc3_:Array = [];
var _loc4_:uint = uint(this._h[0]);
var _loc5_:uint = uint(this._h[1]);
var _loc6_:uint = uint(this._h[2]);
var _loc7_:uint = uint(this._h[3]);
var _loc8_:uint = uint(this._h[4]);
var _loc9_:uint = uint(this._h[5]);
var _loc10_:uint = uint(this._h[6]);
var _loc11_:uint = uint(this._h[7]);
var _loc12_:uint = 0;
while(_loc12_ < param1.length)
{
_loc13_ = _loc4_;
_loc14_ = _loc5_;
_loc15_ = _loc6_;
_loc16_ = _loc7_;
_loc17_ = _loc8_;
_loc18_ = _loc9_;
_loc19_ = _loc10_;
_loc20_ = _loc11_;
_loc21_ = 0;
while(_loc21_ < 64)
{
if(_loc21_ < 16)
{
_loc3_[_loc21_] = param1[_loc12_ + _loc21_] || 0;
}
else
{
_loc24_ = uint(this.rrol(_loc3_[_loc21_ - 15],7) ^ this.rrol(_loc3_[_loc21_ - 15],18) ^ _loc3_[_loc21_ - 15] >>> 3);
_loc25_ = uint(this.rrol(_loc3_[_loc21_ - 2],17) ^ this.rrol(_loc3_[_loc21_ - 2],19) ^ _loc3_[_loc21_ - 2] >>> 10);
_loc3_[_loc21_] = _loc3_[_loc21_ - 16] + _loc24_ + _loc3_[_loc21_ - 7] + _loc25_;
}
_loc22_ = (this.rrol(_loc4_,2) ^ this.rrol(_loc4_,13) ^ this.rrol(_loc4_,22)) + (_loc4_ & _loc5_ ^ _loc4_ & _loc6_ ^ _loc5_ & _loc6_);
_loc23_ = _loc11_ + (this.rrol(_loc8_,6) ^ this.rrol(_loc8_,11) ^ this.rrol(_loc8_,25)) + (_loc8_ & _loc9_ ^ _loc10_ & ~_loc8_) + k[_loc21_] + _loc3_[_loc21_];
_loc11_ = _loc10_;
_loc10_ = _loc9_;
_loc9_ = _loc8_;
_loc8_ = _loc7_ + _loc23_;
_loc7_ = _loc6_;
_loc6_ = _loc5_;
_loc5_ = _loc4_;
_loc4_ = _loc23_ + _loc22_;
_loc21_++;
}
_loc4_ += _loc13_;
_loc5_ += _loc14_;
_loc6_ += _loc15_;
_loc7_ += _loc16_;
_loc8_ += _loc17_;
_loc9_ += _loc18_;
_loc10_ += _loc19_;
_loc11_ += _loc20_;
_loc12_ += 16;
}
return [_loc4_,_loc5_,_loc6_,_loc7_,_loc8_,_loc9_,_loc10_,_loc11_];
}
protected function rrol(param1:uint, param2:uint) : uint
{
return param1 << 32 - param2 | param1 >>> param2;
}
override public function toString() : String
{
return "sha256";
}
}
}
@@ -0,0 +1,67 @@
package com.hurlant.crypto.hash
{
import flash.utils.ByteArray;
import flash.utils.Endian;
public class SHABase implements IHash
{
public function SHABase()
{
super();
}
public function getInputSize() : uint
{
return 64;
}
public function getHashSize() : uint
{
return 0;
}
public function hash(param1:ByteArray) : ByteArray
{
var _loc2_:uint = param1.length;
var _loc3_:String = param1.endian;
param1.endian = Endian.BIG_ENDIAN;
var _loc4_:uint = _loc2_ * 8;
while(param1.length % 4 != 0)
{
param1[param1.length] = 0;
}
param1.position = 0;
var _loc5_:Array = [];
var _loc6_:uint = 0;
while(_loc6_ < param1.length)
{
_loc5_.push(param1.readUnsignedInt());
_loc6_ += 4;
}
var _loc7_:Array = this.core(_loc5_,_loc4_);
var _loc8_:ByteArray = new ByteArray();
var _loc9_:uint = this.getHashSize() / 4;
_loc6_ = 0;
while(_loc6_ < _loc9_)
{
_loc8_.writeUnsignedInt(_loc7_[_loc6_]);
_loc6_++;
}
param1.length = _loc2_;
param1.endian = _loc3_;
return _loc8_;
}
protected function core(param1:Array, param2:uint) : Array
{
return null;
}
public function toString() : String
{
return "sha";
}
}
}
@@ -0,0 +1,115 @@
package com.hurlant.crypto.prng
{
import com.hurlant.crypto.symmetric.IStreamCipher;
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
public class ARC4 implements IPRNG, IStreamCipher
{
private var i:int = 0;
private var j:int = 0;
private var S:ByteArray;
private const psize:uint = 256;
public function ARC4(param1:ByteArray = null)
{
super();
this.S = new ByteArray();
if(param1)
{
this.init(param1);
}
}
public function getPoolSize() : uint
{
return this.psize;
}
public function init(param1:ByteArray) : void
{
var _loc2_:int = 0;
var _loc3_:int = 0;
var _loc4_:int = 0;
_loc2_ = 0;
while(_loc2_ < 256)
{
this.S[_loc2_] = _loc2_;
_loc2_++;
}
_loc3_ = 0;
_loc2_ = 0;
while(_loc2_ < 256)
{
_loc3_ = _loc3_ + this.S[_loc2_] + param1[_loc2_ % param1.length] & 0xFF;
_loc4_ = int(this.S[_loc2_]);
this.S[_loc2_] = this.S[_loc3_];
this.S[_loc3_] = _loc4_;
_loc2_++;
}
this.i = 0;
this.j = 0;
}
public function next() : uint
{
var _loc1_:int = 0;
this.i = this.i + 1 & 0xFF;
this.j = this.j + this.S[this.i] & 0xFF;
_loc1_ = int(this.S[this.i]);
this.S[this.i] = this.S[this.j];
this.S[this.j] = _loc1_;
return this.S[_loc1_ + this.S[this.i] & 0xFF];
}
public function getBlockSize() : uint
{
return 1;
}
public function encrypt(param1:ByteArray) : void
{
var _loc2_:uint = 0;
while(_loc2_ < param1.length)
{
var _temp_2:* = param1;
var _loc3_:uint = _loc2_++;
_temp_2[_loc3_] ^= this.next();
}
}
public function decrypt(param1:ByteArray) : void
{
this.encrypt(param1);
}
public function dispose() : void
{
var _loc1_:uint = 0;
if(this.S != null)
{
_loc1_ = 0;
while(_loc1_ < this.S.length)
{
this.S[_loc1_] = Math.random() * 256;
_loc1_++;
}
this.S.length = 0;
this.S = null;
}
this.i = 0;
this.j = 0;
Memory.gc();
}
public function toString() : String
{
return "rc4";
}
}
}
@@ -0,0 +1,19 @@
package com.hurlant.crypto.prng
{
import flash.utils.ByteArray;
public interface IPRNG
{
function getPoolSize() : uint;
function init(param1:ByteArray) : void;
function next() : uint;
function dispose() : void;
function toString() : String;
}
}
@@ -0,0 +1,137 @@
package com.hurlant.crypto.prng
{
import com.hurlant.util.Memory;
import flash.system.Capabilities;
import flash.system.System;
import flash.text.Font;
import flash.utils.ByteArray;
import flash.utils.getTimer;
public class Random
{
private var state:IPRNG;
private var ready:Boolean = false;
private var pool:ByteArray;
private var psize:int;
private var pptr:int;
private var seeded:Boolean = false;
public function Random(param1:Class = null)
{
var _loc2_:uint = 0;
super();
if(param1 == null)
{
param1 = ARC4;
}
this.state = new param1() as IPRNG;
this.psize = this.state.getPoolSize();
this.pool = new ByteArray();
this.pptr = 0;
while(this.pptr < this.psize)
{
_loc2_ = 65536 * Math.random();
this.pool[this.pptr++] = _loc2_ >>> 8;
var _loc4_:Number;
this.pool[_loc4_ = this.pptr++] = _loc2_ & 0xFF;
}
this.pptr = 0;
this.seed();
}
public function seed(param1:int = 0) : void
{
if(param1 == 0)
{
param1 = new Date().getTime();
}
var _temp_3:* = this.pool;
var _loc2_:Number = this.pptr++;
_temp_3[_loc2_] ^= param1 & 0xFF;
var _temp_6:* = this.pool;
var _loc3_:Number = this.pptr++;
_temp_6[_loc3_] ^= param1 >> 8 & 0xFF;
var _loc4_:Number;
this.pool[_loc4_ = this.pptr++] = this.pool[_loc4_] ^ param1 >> 16 & 0xFF;
var _loc5_:Number;
this.pool[_loc5_ = this.pptr++] = this.pool[_loc5_] ^ param1 >> 24 & 0xFF;
this.pptr %= this.psize;
this.seeded = true;
}
public function autoSeed() : void
{
var _loc3_:Font = null;
var _loc1_:ByteArray = new ByteArray();
_loc1_.writeUnsignedInt(System.totalMemory);
_loc1_.writeUTF(Capabilities.serverString);
_loc1_.writeUnsignedInt(getTimer());
_loc1_.writeUnsignedInt(new Date().getTime());
var _loc2_:Array = Font.enumerateFonts(true);
for each(_loc3_ in _loc2_)
{
_loc1_.writeUTF(_loc3_.fontName);
_loc1_.writeUTF(_loc3_.fontStyle);
_loc1_.writeUTF(_loc3_.fontType);
}
_loc1_.position = 0;
while(_loc1_.bytesAvailable >= 4)
{
this.seed(_loc1_.readUnsignedInt());
}
}
public function nextBytes(param1:ByteArray, param2:int) : void
{
while(param2--)
{
param1.writeByte(this.nextByte());
}
}
public function nextByte() : int
{
if(!this.ready)
{
if(!this.seeded)
{
this.autoSeed();
}
this.state.init(this.pool);
this.pool.length = 0;
this.pptr = 0;
this.ready = true;
}
return this.state.next();
}
public function dispose() : void
{
var _loc1_:uint = 0;
while(_loc1_ < this.pool.length)
{
this.pool[_loc1_] = Math.random() * 256;
_loc1_++;
}
this.pool.length = 0;
this.pool = null;
this.state.dispose();
this.state = null;
this.psize = 0;
this.pptr = 0;
Memory.gc();
}
public function toString() : String
{
return "random-" + this.state.toString();
}
}
}
@@ -0,0 +1,318 @@
package com.hurlant.crypto.rsa
{
import com.hurlant.crypto.prng.Random;
import com.hurlant.math.BigInteger;
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
public class RSAKey
{
public var e:int;
public var n:BigInteger;
public var d:BigInteger;
public var p:BigInteger;
public var q:BigInteger;
public var dmp1:BigInteger;
public var dmq1:BigInteger;
public var coeff:BigInteger;
protected var canDecrypt:Boolean;
protected var canEncrypt:Boolean;
public function RSAKey(param1:BigInteger, param2:int, param3:BigInteger = null, param4:BigInteger = null, param5:BigInteger = null, param6:BigInteger = null, param7:BigInteger = null, param8:BigInteger = null)
{
super();
this.n = param1;
this.e = param2;
this.d = param3;
this.p = param4;
this.q = param5;
this.dmp1 = param6;
this.dmq1 = param7;
this.coeff = param8;
this.canEncrypt = this.n != null && this.e != 0;
this.canDecrypt = this.canEncrypt && this.d != null;
}
public static function parsePublicKey(param1:String, param2:String) : RSAKey
{
return new RSAKey(new BigInteger(param1,16),parseInt(param2,16));
}
public static function parsePrivateKey(param1:String, param2:String, param3:String, param4:String = null, param5:String = null, param6:String = null, param7:String = null, param8:String = null) : RSAKey
{
if(param4 == null)
{
return new RSAKey(new BigInteger(param1,16),parseInt(param2,16),new BigInteger(param3,16));
}
return new RSAKey(new BigInteger(param1,16),parseInt(param2,16),new BigInteger(param3,16),new BigInteger(param4,16),new BigInteger(param5,16),new BigInteger(param6,16),new BigInteger(param7),new BigInteger(param8));
}
public static function generate(param1:uint, param2:String) : RSAKey
{
var _loc7_:BigInteger = null;
var _loc8_:BigInteger = null;
var _loc9_:BigInteger = null;
var _loc10_:BigInteger = null;
var _loc3_:Random = new Random();
var _loc4_:uint = uint(param1 >> 1);
var _loc5_:RSAKey = new RSAKey(null,0,null);
_loc5_.e = parseInt(param2,16);
var _loc6_:BigInteger = new BigInteger(param2,16);
do
{
do
{
_loc5_.p = bigRandom(param1 - _loc4_,_loc3_);
}
while(!(_loc5_.p.subtract(BigInteger.ONE).gcd(_loc6_).compareTo(BigInteger.ONE) == 0 && _loc5_.p.isProbablePrime(10)));
do
{
_loc5_.q = bigRandom(_loc4_,_loc3_);
}
while(!(_loc5_.q.subtract(BigInteger.ONE).gcd(_loc6_).compareTo(BigInteger.ONE) == 0 && _loc5_.q.isProbablePrime(10)));
if(_loc5_.p.compareTo(_loc5_.q) <= 0)
{
_loc10_ = _loc5_.p;
_loc5_.p = _loc5_.q;
_loc5_.q = _loc10_;
}
_loc7_ = _loc5_.p.subtract(BigInteger.ONE);
_loc8_ = _loc5_.q.subtract(BigInteger.ONE);
}
while(_loc9_ = _loc7_.multiply(_loc8_), _loc9_.gcd(_loc6_).compareTo(BigInteger.ONE) != 0);
_loc5_.n = _loc5_.p.multiply(_loc5_.q);
_loc5_.d = _loc6_.modInverse(_loc9_);
_loc5_.dmp1 = _loc5_.d.mod(_loc7_);
_loc5_.dmq1 = _loc5_.d.mod(_loc8_);
_loc5_.coeff = _loc5_.q.modInverse(_loc5_.p);
return _loc5_;
}
protected static function bigRandom(param1:int, param2:Random) : BigInteger
{
if(param1 < 2)
{
return BigInteger.nbv(1);
}
var _loc3_:ByteArray = new ByteArray();
param2.nextBytes(_loc3_,param1 >> 3);
_loc3_.position = 0;
var _loc4_:BigInteger = new BigInteger(_loc3_);
_loc4_.primify(param1,1);
return _loc4_;
}
public function getBlockSize() : uint
{
return (this.n.bitLength() + 7) / 8;
}
public function dispose() : void
{
this.e = 0;
this.n.dispose();
this.n = null;
Memory.gc();
}
public function encrypt(param1:ByteArray, param2:ByteArray, param3:uint, param4:Function = null) : void
{
this._encrypt(this.doPublic,param1,param2,param3,param4,2);
}
public function decrypt(param1:ByteArray, param2:ByteArray, param3:uint, param4:Function = null) : void
{
this._decrypt(this.doPrivate2,param1,param2,param3,param4,2);
}
public function sign(param1:ByteArray, param2:ByteArray, param3:uint, param4:Function = null) : void
{
this._encrypt(this.doPrivate2,param1,param2,param3,param4,1);
}
public function verify(param1:ByteArray, param2:ByteArray, param3:uint, param4:Function = null) : void
{
this._decrypt(this.doPublic,param1,param2,param3,param4,1);
}
private function _encrypt(param1:Function, param2:ByteArray, param3:ByteArray, param4:uint, param5:Function, param6:int) : void
{
var _loc9_:BigInteger = null;
var _loc10_:BigInteger = null;
if(param5 == null)
{
param5 = this.pkcs1pad;
}
if(param2.position >= param2.length)
{
param2.position = 0;
}
var _loc7_:uint = this.getBlockSize();
var _loc8_:int = param2.position + param4;
while(param2.position < _loc8_)
{
_loc9_ = new BigInteger(param5(param2,_loc8_,_loc7_,param6),_loc7_);
_loc10_ = param1(_loc9_);
_loc10_.toArray(param3);
}
}
private function _decrypt(param1:Function, param2:ByteArray, param3:ByteArray, param4:uint, param5:Function, param6:int) : void
{
var _loc9_:BigInteger = null;
var _loc10_:BigInteger = null;
var _loc11_:ByteArray = null;
if(param5 == null)
{
param5 = this.pkcs1unpad;
}
if(param2.position >= param2.length)
{
param2.position = 0;
}
var _loc7_:uint = this.getBlockSize();
var _loc8_:int = param2.position + param4;
while(param2.position < _loc8_)
{
_loc9_ = new BigInteger(param2,param4);
_loc10_ = param1(_loc9_);
_loc11_ = param5(_loc10_,_loc7_);
param3.writeBytes(_loc11_);
}
}
private function pkcs1pad(param1:ByteArray, param2:int, param3:uint, param4:uint = 2) : ByteArray
{
var _loc9_:int = 0;
var _loc5_:ByteArray = new ByteArray();
var _loc6_:int = int(param1.position);
param2 = Math.min(param2,param1.length,_loc6_ + param3 - 11);
param1.position = param2;
var _loc7_:* = int(param2 - 1);
while(_loc7_ >= _loc6_ && param3 > 11)
{
var _loc10_:uint;
_loc5_[_loc10_ = --param3] = param1[_loc7_--];
}
_loc5_[_loc10_ = --param3] = 0;
var _loc8_:Random = new Random();
while(param3 > 2)
{
_loc9_ = 0;
while(_loc9_ == 0)
{
_loc9_ = param4 == 2 ? _loc8_.nextByte() : 255;
}
var _loc11_:uint;
_loc5_[_loc11_ = --param3] = _loc9_;
}
_loc5_[_loc11_ = --param3] = param4;
var _loc12_:uint;
_loc5_[_loc12_ = --param3] = 0;
return _loc5_;
}
private function pkcs1unpad(param1:BigInteger, param2:uint, param3:uint = 2) : ByteArray
{
var _loc4_:ByteArray = param1.toByteArray();
var _loc5_:ByteArray = new ByteArray();
var _loc6_:int = 0;
while(_loc6_ < _loc4_.length && _loc4_[_loc6_] == 0)
{
_loc6_++;
}
if(_loc4_.length - _loc6_ != param2 - 1 || _loc4_[_loc6_] > 2)
{
return null;
}
_loc6_++;
while(_loc4_[_loc6_] != 0)
{
if(++_loc6_ >= _loc4_.length)
{
return null;
}
}
while(++_loc6_ < _loc4_.length)
{
_loc5_.writeByte(_loc4_[_loc6_]);
}
_loc5_.position = 0;
return _loc5_;
}
private function rawpad(param1:ByteArray, param2:int, param3:uint) : ByteArray
{
return param1;
}
public function toString() : String
{
return "rsa";
}
public function dump() : String
{
var _loc1_:String = "N=" + this.n.toString(16) + "\n" + "E=" + this.e.toString(16) + "\n";
if(this.canDecrypt)
{
_loc1_ += "D=" + this.d.toString(16) + "\n";
if(this.p != null && this.q != null)
{
_loc1_ += "P=" + this.p.toString(16) + "\n";
_loc1_ += "Q=" + this.q.toString(16) + "\n";
_loc1_ += "DMP1=" + this.dmp1.toString(16) + "\n";
_loc1_ += "DMQ1=" + this.dmq1.toString(16) + "\n";
_loc1_ += "IQMP=" + this.coeff.toString(16) + "\n";
}
}
return _loc1_;
}
protected function doPublic(param1:BigInteger) : BigInteger
{
return param1.modPowInt(this.e,this.n);
}
protected function doPrivate2(param1:BigInteger) : BigInteger
{
if(this.p == null && this.q == null)
{
return param1.modPow(this.d,this.n);
}
var _loc2_:BigInteger = param1.mod(this.p).modPow(this.dmp1,this.p);
var _loc3_:BigInteger = param1.mod(this.q).modPow(this.dmq1,this.q);
while(_loc2_.compareTo(_loc3_) < 0)
{
_loc2_ = _loc2_.add(this.p);
}
return _loc2_.subtract(_loc3_).multiply(this.coeff).mod(this.p).multiply(this.q).add(_loc3_);
}
protected function doPrivate(param1:BigInteger) : BigInteger
{
if(this.p == null || this.q == null)
{
return param1.modPow(this.d,this.n);
}
var _loc2_:BigInteger = param1.mod(this.p).modPow(this.dmp1,this.p);
var _loc3_:BigInteger = param1.mod(this.q).modPow(this.dmq1,this.q);
while(_loc2_.compareTo(_loc3_) < 0)
{
_loc2_ = _loc2_.add(this.p);
}
return _loc2_.subtract(_loc3_).multiply(this.coeff).mod(this.p).multiply(this.q).add(_loc3_);
}
}
}
@@ -0,0 +1,337 @@
package com.hurlant.crypto.symmetric
{
import com.hurlant.crypto.prng.Random;
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
public class AESKey implements ISymmetricKey
{
private static const Nb:uint = 4;
private static const _Sbox:Array = [99,124,119,123,242,107,111,197,48,1,103,43,254,215,171,118,202,130,201,125,250,89,71,240,173,212,162,175,156,164,114,192,183,253,147,38,54,63,247,204,52,165,229,241,113,216,49,21,4,199,35,195,24,150,5,154,7,18,128,226,235,39,178,117,9,131,44,26,27,110,90,160,82,59,214,179,41,227,47,132,83,209,0,237,32,252,177,91,106,203,190,57,74,76,88,207,208,239,170,251,67,77,51,133,69,249,2,127,80,60,159,168,81,163,64,143,146,157,56,245,188,182,218,33,16,255,243,210,205,12,19,236,95,151,68,23,196,167,126,61,100,93,25,115,96,129,79,220,34,42,144,136,70,238,184,20,222,94,11,219,224,50,58,10,73,6,36,92,194,211,172,98,145,149,228,121,231,200,55,109,141,213,78,169,108,86,244,234,101,122,174,8,186,120,37,46,28,166,180,198,232,221,116,31,75,189,139,138,112,62,181,102,72,3,246,14,97,53,87,185,134,193,29,158,225,248,152,17,105,217,142,148,155,30,135,233,206,85,40,223,140,161,137,13,191,230,66,104,65,153,45,15,176,84,187,22];
private static const _InvSbox:Array = [82,9,106,213,48,54,165,56,191,64,163,158,129,243,215,251,124,227,57,130,155,47,255,135,52,142,67,68,196,222,233,203,84,123,148,50,166,194,35,61,238,76,149,11,66,250,195,78,8,46,161,102,40,217,36,178,118,91,162,73,109,139,209,37,114,248,246,100,134,104,152,22,212,164,92,204,93,101,182,146,108,112,72,80,253,237,185,218,94,21,70,87,167,141,157,132,144,216,171,0,140,188,211,10,247,228,88,5,184,179,69,6,208,44,30,143,202,63,15,2,193,175,189,3,1,19,138,107,58,145,17,65,79,103,220,234,151,242,207,206,240,180,230,115,150,172,116,34,231,173,53,133,226,249,55,232,28,117,223,110,71,241,26,113,29,41,197,137,111,183,98,14,170,24,190,27,252,86,62,75,198,210,121,32,154,219,192,254,120,205,90,244,31,221,168,51,136,7,199,49,177,18,16,89,39,128,236,95,96,81,127,169,25,181,74,13,45,229,122,159,147,201,156,239,160,224,59,77,174,42,245,176,200,235,187,60,131,83,153,97,23,43,4,126,186,119,214,38,225,105,20,99,85,33,12,125];
private static const _Xtime2Sbox:Array = [198,248,238,246,255,214,222,145,96,2,206,86,231,181,77,236,143,31,137,250,239,178,142,251,65,179,95,69,35,83,228,155,117,225,61,76,108,126,245,131,104,81,209,249,226,171,98,42,8,149,70,157,48,55,10,47,14,36,27,223,205,78,127,234,18,29,88,52,54,220,180,91,164,118,183,125,82,221,94,19,166,185,0,193,64,227,121,182,212,141,103,114,148,152,176,133,187,197,79,237,134,154,102,17,138,233,4,254,160,120,37,75,162,93,128,5,63,33,112,241,99,119,175,66,32,229,253,191,129,24,38,195,190,53,136,46,147,85,252,122,200,186,50,230,192,25,158,163,68,84,59,11,140,199,107,40,167,188,22,173,219,100,116,20,146,12,72,184,159,189,67,196,57,49,211,242,213,139,110,218,1,177,156,73,216,172,243,207,202,244,71,16,111,240,74,92,56,87,115,151,203,161,232,62,150,97,13,15,224,124,113,204,144,6,247,28,194,106,174,105,23,153,58,39,217,235,43,34,210,169,7,51,45,60,21,201,135,170,80,165,3,89,9,26,101,215,132,208,130,41,90,30,123,168,109,44];
private static const _Xtime3Sbox:Array = [165,132,153,141,13,189,177,84,80,3,169,125,25,98,230,154,69,157,64,135,21,235,201,11,236,103,253,234,191,247,150,91,194,28,174,106,90,65,2,79,92,244,52,8,147,115,83,63,12,82,101,94,40,161,15,181,9,54,155,61,38,105,205,159,27,158,116,46,45,178,238,251,246,77,97,206,123,62,113,151,245,104,0,44,96,31,200,237,190,70,217,75,222,212,232,74,107,42,229,22,197,215,85,148,207,16,6,129,240,68,186,227,243,254,192,138,173,188,72,4,223,193,117,99,48,26,14,109,76,20,53,47,225,162,204,57,87,242,130,71,172,231,43,149,160,152,209,127,102,126,171,131,202,41,211,60,121,226,29,118,59,86,78,30,219,10,108,228,93,110,239,166,168,164,55,139,50,67,89,183,140,100,210,224,180,250,7,37,175,142,233,24,213,136,111,114,36,241,199,81,35,124,156,33,221,220,134,133,144,66,196,170,216,5,1,18,163,95,249,208,145,88,39,185,56,19,179,51,187,112,137,167,182,34,146,32,73,255,120,122,143,248,128,23,218,49,198,184,195,176,119,17,203,252,214,58];
private static const _Xtime2:Array = [0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,192,194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,230,232,234,236,238,240,242,244,246,248,250,252,254,27,25,31,29,19,17,23,21,11,9,15,13,3,1,7,5,59,57,63,61,51,49,55,53,43,41,47,45,35,33,39,37,91,89,95,93,83,81,87,85,75,73,79,77,67,65,71,69,123,121,127,125,115,113,119,117,107,105,111,109,99,97,103,101,155,153,159,157,147,145,151,149,139,137,143,141,131,129,135,133,187,185,191,189,179,177,183,181,171,169,175,173,163,161,167,165,219,217,223,221,211,209,215,213,203,201,207,205,195,193,199,197,251,249,255,253,243,241,247,245,235,233,239,237,227,225,231,229];
private static const _Xtime9:Array = [0,9,18,27,36,45,54,63,72,65,90,83,108,101,126,119,144,153,130,139,180,189,166,175,216,209,202,195,252,245,238,231,59,50,41,32,31,22,13,4,115,122,97,104,87,94,69,76,171,162,185,176,143,134,157,148,227,234,241,248,199,206,213,220,118,127,100,109,82,91,64,73,62,55,44,37,26,19,8,1,230,239,244,253,194,203,208,217,174,167,188,181,138,131,152,145,77,68,95,86,105,96,123,114,5,12,23,30,33,40,51,58,221,212,207,198,249,240,235,226,149,156,135,142,177,184,163,170,236,229,254,247,200,193,218,211,164,173,182,191,128,137,146,155,124,117,110,103,88,81,74,67,52,61,38,47,16,25,2,11,215,222,197,204,243,250,225,232,159,150,141,132,187,178,169,160,71,78,85,92,99,106,113,120,15,6,29,20,43,34,57,48,154,147,136,129,190,183,172,165,210,219,192,201,246,255,228,237,10,3,24,17,46,39,60,53,66,75,80,89,102,111,116,125,161,168,179,186,133,140,151,158,233,224,251,242,205,196,223,214,49,56,35,42,21,28,7,14,121,112,107,98,93,84,79,70];
private static const _XtimeB:Array = [0,11,22,29,44,39,58,49,88,83,78,69,116,127,98,105,176,187,166,173,156,151,138,129,232,227,254,245,196,207,210,217,123,112,109,102,87,92,65,74,35,40,53,62,15,4,25,18,203,192,221,214,231,236,241,250,147,152,133,142,191,180,169,162,246,253,224,235,218,209,204,199,174,165,184,179,130,137,148,159,70,77,80,91,106,97,124,119,30,21,8,3,50,57,36,47,141,134,155,144,161,170,183,188,213,222,195,200,249,242,239,228,61,54,43,32,17,26,7,12,101,110,115,120,73,66,95,84,247,252,225,234,219,208,205,198,175,164,185,178,131,136,149,158,71,76,81,90,107,96,125,118,31,20,9,2,51,56,37,46,140,135,154,145,160,171,182,189,212,223,194,201,248,243,238,229,60,55,42,33,16,27,6,13,100,111,114,121,72,67,94,85,1,10,23,28,45,38,59,48,89,82,79,68,117,126,99,104,177,186,167,172,157,150,139,128,233,226,255,244,197,206,211,216,122,113,108,103,86,93,64,75,34,41,52,63,14,5,24,19,202,193,220,215,230,237,240,251,146,153,132,143,190,181,168,163];
private static const _XtimeD:Array = [0,13,26,23,52,57,46,35,104,101,114,127,92,81,70,75,208,221,202,199,228,233,254,243,184,181,162,175,140,129,150,155,187,182,161,172,143,130,149,152,211,222,201,196,231,234,253,240,107,102,113,124,95,82,69,72,3,14,25,20,55,58,45,32,109,96,119,122,89,84,67,78,5,8,31,18,49,60,43,38,189,176,167,170,137,132,147,158,213,216,207,194,225,236,251,246,214,219,204,193,226,239,248,245,190,179,164,169,138,135,144,157,6,11,28,17,50,63,40,37,110,99,116,121,90,87,64,77,218,215,192,205,238,227,244,249,178,191,168,165,134,139,156,145,10,7,16,29,62,51,36,41,98,111,120,117,86,91,76,65,97,108,123,118,85,88,79,66,9,4,19,30,61,48,39,42,177,188,171,166,133,136,159,146,217,212,195,206,237,224,247,250,183,186,173,160,131,142,153,148,223,210,197,200,235,230,241,252,103,106,125,112,83,94,73,68,15,2,21,24,59,54,33,44,12,1,22,27,56,53,34,47,100,105,126,115,80,93,74,71,220,209,198,203,232,229,242,255,180,185,174,163,128,141,154,151];
private static const _XtimeE:Array = [0,14,28,18,56,54,36,42,112,126,108,98,72,70,84,90,224,238,252,242,216,214,196,202,144,158,140,130,168,166,180,186,219,213,199,201,227,237,255,241,171,165,183,185,147,157,143,129,59,53,39,41,3,13,31,17,75,69,87,89,115,125,111,97,173,163,177,191,149,155,137,135,221,211,193,207,229,235,249,247,77,67,81,95,117,123,105,103,61,51,33,47,5,11,25,23,118,120,106,100,78,64,82,92,6,8,26,20,62,48,34,44,150,152,138,132,174,160,178,188,230,232,250,244,222,208,194,204,65,79,93,83,121,119,101,107,49,63,45,35,9,7,21,27,161,175,189,179,153,151,133,139,209,223,205,195,233,231,245,251,154,148,134,136,162,172,190,176,234,228,246,248,210,220,206,192,122,116,102,104,66,76,94,80,10,4,22,24,50,60,46,32,236,226,240,254,212,218,200,198,156,146,128,142,164,170,184,182,12,2,16,30,52,58,40,38,124,114,96,110,68,74,88,86,55,57,43,37,15,1,19,29,71,73,91,85,127,113,99,109,215,217,203,197,239,225,243,253,167,169,187,181,159,145,131,141];
private static var _Rcon:Array = [0,1,2,4,8,16,32,64,128,27,54];
private static var Sbox:ByteArray = new ByteArray();
private static var InvSbox:ByteArray = new ByteArray();
private static var Xtime2Sbox:ByteArray = new ByteArray();
private static var Xtime3Sbox:ByteArray = new ByteArray();
private static var Xtime2:ByteArray = new ByteArray();
private static var Xtime9:ByteArray = new ByteArray();
private static var XtimeB:ByteArray = new ByteArray();
private static var XtimeD:ByteArray = new ByteArray();
private static var XtimeE:ByteArray = new ByteArray();
private static var i:uint = 0;
while(i < 256)
{
Sbox[i] = _Sbox[i];
InvSbox[i] = _InvSbox[i];
Xtime2Sbox[i] = _Xtime2Sbox[i];
Xtime3Sbox[i] = _Xtime3Sbox[i];
Xtime2[i] = _Xtime2[i];
Xtime9[i] = _Xtime9[i];
XtimeB[i] = _XtimeB[i];
XtimeD[i] = _XtimeD[i];
XtimeE[i] = _XtimeE[i];
++i;
}
private static var Rcon:ByteArray = new ByteArray();
i = 0;
while(i < _Rcon.length)
{
Rcon[i] = _Rcon[i];
++i;
}
private var key:ByteArray;
private var keyLength:uint;
private var Nr:uint;
private var state:ByteArray;
private var tmp:ByteArray;
public function AESKey(param1:ByteArray)
{
super();
this.tmp = new ByteArray();
this.state = new ByteArray();
this.keyLength = param1.length;
this.key = new ByteArray();
this.key.writeBytes(param1);
this.expandKey();
}
private function expandKey() : void
{
var _loc1_:uint = 0;
var _loc2_:uint = 0;
var _loc3_:uint = 0;
var _loc4_:uint = 0;
var _loc5_:uint = 0;
var _loc6_:uint = 0;
var _loc7_:uint = this.key.length / 4;
this.Nr = _loc7_ + 6;
_loc6_ = _loc7_;
while(_loc6_ < Nb * (this.Nr + 1))
{
_loc1_ = uint(this.key[4 * _loc6_ - 4]);
_loc2_ = uint(this.key[4 * _loc6_ - 3]);
_loc3_ = uint(this.key[4 * _loc6_ - 2]);
_loc4_ = uint(this.key[4 * _loc6_ - 1]);
if(!(_loc6_ % _loc7_))
{
_loc5_ = _loc4_;
_loc4_ = uint(Sbox[_loc1_]);
_loc1_ = uint(Sbox[_loc2_] ^ Rcon[_loc6_ / _loc7_]);
_loc2_ = uint(Sbox[_loc3_]);
_loc3_ = uint(Sbox[_loc5_]);
}
else if(_loc7_ > 6 && _loc6_ % _loc7_ == 4)
{
_loc1_ = uint(Sbox[_loc1_]);
_loc2_ = uint(Sbox[_loc2_]);
_loc3_ = uint(Sbox[_loc3_]);
_loc4_ = uint(Sbox[_loc4_]);
}
this.key[4 * _loc6_ + 0] = this.key[4 * _loc6_ - 4 * _loc7_ + 0] ^ _loc1_;
this.key[4 * _loc6_ + 1] = this.key[4 * _loc6_ - 4 * _loc7_ + 1] ^ _loc2_;
this.key[4 * _loc6_ + 2] = this.key[4 * _loc6_ - 4 * _loc7_ + 2] ^ _loc3_;
this.key[4 * _loc6_ + 3] = this.key[4 * _loc6_ - 4 * _loc7_ + 3] ^ _loc4_;
_loc6_++;
}
}
public function getBlockSize() : uint
{
return 16;
}
public function encrypt(param1:ByteArray, param2:uint = 0) : void
{
var _loc3_:uint = 0;
this.state.position = 0;
this.state.writeBytes(param1,param2,Nb * 4);
this.addRoundKey(this.key,0);
_loc3_ = 1;
while(_loc3_ < this.Nr + 1)
{
if(_loc3_ < this.Nr)
{
this.mixSubColumns();
}
else
{
this.shiftRows();
}
this.addRoundKey(this.key,_loc3_ * Nb * 4);
_loc3_++;
}
param1.position = param2;
param1.writeBytes(this.state);
}
public function decrypt(param1:ByteArray, param2:uint = 0) : void
{
var _loc3_:uint = 0;
this.state.position = 0;
this.state.writeBytes(param1,param2,Nb * 4);
this.addRoundKey(this.key,this.Nr * Nb * 4);
this.invShiftRows();
_loc3_ = this.Nr;
while(_loc3_--)
{
this.addRoundKey(this.key,_loc3_ * Nb * 4);
if(_loc3_)
{
this.invMixSubColumns();
}
}
param1.position = param2;
param1.writeBytes(this.state);
}
public function dispose() : void
{
var _loc1_:uint = 0;
var _loc2_:Random = new Random();
_loc1_ = 0;
while(_loc1_ < this.key.length)
{
this.key[_loc1_] = _loc2_.nextByte();
_loc1_++;
}
this.Nr = _loc2_.nextByte();
_loc1_ = 0;
while(_loc1_ < this.state.length)
{
this.state[_loc1_] = _loc2_.nextByte();
_loc1_++;
}
_loc1_ = 0;
while(_loc1_ < this.tmp.length)
{
this.tmp[_loc1_] = _loc2_.nextByte();
_loc1_++;
}
this.key.length = 0;
this.keyLength = 0;
this.state.length = 0;
this.tmp.length = 0;
this.key = null;
this.state = null;
this.tmp = null;
this.Nr = 0;
Memory.gc();
}
protected function shiftRows() : void
{
var _loc1_:uint = 0;
this.state[0] = Sbox[this.state[0]];
this.state[4] = Sbox[this.state[4]];
this.state[8] = Sbox[this.state[8]];
this.state[12] = Sbox[this.state[12]];
_loc1_ = uint(Sbox[this.state[1]]);
this.state[1] = Sbox[this.state[5]];
this.state[5] = Sbox[this.state[9]];
this.state[9] = Sbox[this.state[13]];
this.state[13] = _loc1_;
_loc1_ = uint(Sbox[this.state[2]]);
this.state[2] = Sbox[this.state[10]];
this.state[10] = _loc1_;
_loc1_ = uint(Sbox[this.state[6]]);
this.state[6] = Sbox[this.state[14]];
this.state[14] = _loc1_;
_loc1_ = uint(Sbox[this.state[15]]);
this.state[15] = Sbox[this.state[11]];
this.state[11] = Sbox[this.state[7]];
this.state[7] = Sbox[this.state[3]];
this.state[3] = _loc1_;
}
protected function invShiftRows() : void
{
var _loc1_:uint = 0;
this.state[0] = InvSbox[this.state[0]];
this.state[4] = InvSbox[this.state[4]];
this.state[8] = InvSbox[this.state[8]];
this.state[12] = InvSbox[this.state[12]];
_loc1_ = uint(InvSbox[this.state[13]]);
this.state[13] = InvSbox[this.state[9]];
this.state[9] = InvSbox[this.state[5]];
this.state[5] = InvSbox[this.state[1]];
this.state[1] = _loc1_;
_loc1_ = uint(InvSbox[this.state[2]]);
this.state[2] = InvSbox[this.state[10]];
this.state[10] = _loc1_;
_loc1_ = uint(InvSbox[this.state[6]]);
this.state[6] = InvSbox[this.state[14]];
this.state[14] = _loc1_;
_loc1_ = uint(InvSbox[this.state[3]]);
this.state[3] = InvSbox[this.state[7]];
this.state[7] = InvSbox[this.state[11]];
this.state[11] = InvSbox[this.state[15]];
this.state[15] = _loc1_;
}
protected function mixSubColumns() : void
{
this.tmp.length = 0;
this.tmp[0] = Xtime2Sbox[this.state[0]] ^ Xtime3Sbox[this.state[5]] ^ Sbox[this.state[10]] ^ Sbox[this.state[15]];
this.tmp[1] = Sbox[this.state[0]] ^ Xtime2Sbox[this.state[5]] ^ Xtime3Sbox[this.state[10]] ^ Sbox[this.state[15]];
this.tmp[2] = Sbox[this.state[0]] ^ Sbox[this.state[5]] ^ Xtime2Sbox[this.state[10]] ^ Xtime3Sbox[this.state[15]];
this.tmp[3] = Xtime3Sbox[this.state[0]] ^ Sbox[this.state[5]] ^ Sbox[this.state[10]] ^ Xtime2Sbox[this.state[15]];
this.tmp[4] = Xtime2Sbox[this.state[4]] ^ Xtime3Sbox[this.state[9]] ^ Sbox[this.state[14]] ^ Sbox[this.state[3]];
this.tmp[5] = Sbox[this.state[4]] ^ Xtime2Sbox[this.state[9]] ^ Xtime3Sbox[this.state[14]] ^ Sbox[this.state[3]];
this.tmp[6] = Sbox[this.state[4]] ^ Sbox[this.state[9]] ^ Xtime2Sbox[this.state[14]] ^ Xtime3Sbox[this.state[3]];
this.tmp[7] = Xtime3Sbox[this.state[4]] ^ Sbox[this.state[9]] ^ Sbox[this.state[14]] ^ Xtime2Sbox[this.state[3]];
this.tmp[8] = Xtime2Sbox[this.state[8]] ^ Xtime3Sbox[this.state[13]] ^ Sbox[this.state[2]] ^ Sbox[this.state[7]];
this.tmp[9] = Sbox[this.state[8]] ^ Xtime2Sbox[this.state[13]] ^ Xtime3Sbox[this.state[2]] ^ Sbox[this.state[7]];
this.tmp[10] = Sbox[this.state[8]] ^ Sbox[this.state[13]] ^ Xtime2Sbox[this.state[2]] ^ Xtime3Sbox[this.state[7]];
this.tmp[11] = Xtime3Sbox[this.state[8]] ^ Sbox[this.state[13]] ^ Sbox[this.state[2]] ^ Xtime2Sbox[this.state[7]];
this.tmp[12] = Xtime2Sbox[this.state[12]] ^ Xtime3Sbox[this.state[1]] ^ Sbox[this.state[6]] ^ Sbox[this.state[11]];
this.tmp[13] = Sbox[this.state[12]] ^ Xtime2Sbox[this.state[1]] ^ Xtime3Sbox[this.state[6]] ^ Sbox[this.state[11]];
this.tmp[14] = Sbox[this.state[12]] ^ Sbox[this.state[1]] ^ Xtime2Sbox[this.state[6]] ^ Xtime3Sbox[this.state[11]];
this.tmp[15] = Xtime3Sbox[this.state[12]] ^ Sbox[this.state[1]] ^ Sbox[this.state[6]] ^ Xtime2Sbox[this.state[11]];
this.state.position = 0;
this.state.writeBytes(this.tmp,0,Nb * 4);
}
protected function invMixSubColumns() : void
{
var _loc1_:uint = 0;
this.tmp.length = 0;
this.tmp[0] = XtimeE[this.state[0]] ^ XtimeB[this.state[1]] ^ XtimeD[this.state[2]] ^ Xtime9[this.state[3]];
this.tmp[5] = Xtime9[this.state[0]] ^ XtimeE[this.state[1]] ^ XtimeB[this.state[2]] ^ XtimeD[this.state[3]];
this.tmp[10] = XtimeD[this.state[0]] ^ Xtime9[this.state[1]] ^ XtimeE[this.state[2]] ^ XtimeB[this.state[3]];
this.tmp[15] = XtimeB[this.state[0]] ^ XtimeD[this.state[1]] ^ Xtime9[this.state[2]] ^ XtimeE[this.state[3]];
this.tmp[4] = XtimeE[this.state[4]] ^ XtimeB[this.state[5]] ^ XtimeD[this.state[6]] ^ Xtime9[this.state[7]];
this.tmp[9] = Xtime9[this.state[4]] ^ XtimeE[this.state[5]] ^ XtimeB[this.state[6]] ^ XtimeD[this.state[7]];
this.tmp[14] = XtimeD[this.state[4]] ^ Xtime9[this.state[5]] ^ XtimeE[this.state[6]] ^ XtimeB[this.state[7]];
this.tmp[3] = XtimeB[this.state[4]] ^ XtimeD[this.state[5]] ^ Xtime9[this.state[6]] ^ XtimeE[this.state[7]];
this.tmp[8] = XtimeE[this.state[8]] ^ XtimeB[this.state[9]] ^ XtimeD[this.state[10]] ^ Xtime9[this.state[11]];
this.tmp[13] = Xtime9[this.state[8]] ^ XtimeE[this.state[9]] ^ XtimeB[this.state[10]] ^ XtimeD[this.state[11]];
this.tmp[2] = XtimeD[this.state[8]] ^ Xtime9[this.state[9]] ^ XtimeE[this.state[10]] ^ XtimeB[this.state[11]];
this.tmp[7] = XtimeB[this.state[8]] ^ XtimeD[this.state[9]] ^ Xtime9[this.state[10]] ^ XtimeE[this.state[11]];
this.tmp[12] = XtimeE[this.state[12]] ^ XtimeB[this.state[13]] ^ XtimeD[this.state[14]] ^ Xtime9[this.state[15]];
this.tmp[1] = Xtime9[this.state[12]] ^ XtimeE[this.state[13]] ^ XtimeB[this.state[14]] ^ XtimeD[this.state[15]];
this.tmp[6] = XtimeD[this.state[12]] ^ Xtime9[this.state[13]] ^ XtimeE[this.state[14]] ^ XtimeB[this.state[15]];
this.tmp[11] = XtimeB[this.state[12]] ^ XtimeD[this.state[13]] ^ Xtime9[this.state[14]] ^ XtimeE[this.state[15]];
_loc1_ = 0;
while(_loc1_ < 4 * Nb)
{
this.state[_loc1_] = InvSbox[this.tmp[_loc1_]];
_loc1_++;
}
}
protected function addRoundKey(param1:ByteArray, param2:uint) : void
{
var _loc3_:uint = 0;
_loc3_ = 0;
while(_loc3_ < 16)
{
this.state[_loc3_] ^= param1[_loc3_ + param2];
_loc3_++;
}
}
public function toString() : String
{
return "aes" + 8 * this.keyLength;
}
}
}
@@ -0,0 +1,235 @@
package com.hurlant.crypto.symmetric
{
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
public class BlowFishKey implements ISymmetricKey
{
private static const KP:Array = [608135816,2242054355,320440878,57701188,2752067618,698298832,137296536,3964562569,1160258022,953160567,3193202383,887688300,3232508343,3380367581,1065670069,3041331479,2450970073,2306472731];
private static const KS0:Array = [3509652390,2564797868,805139163,3491422135,3101798381,1780907670,3128725573,4046225305,614570311,3012652279,134345442,2240740374,1667834072,1901547113,2757295779,4103290238,227898511,1921955416,1904987480,2182433518,2069144605,3260701109,2620446009,720527379,3318853667,677414384,3393288472,3101374703,2390351024,1614419982,1822297739,2954791486,3608508353,3174124327,2024746970,1432378464,3864339955,2857741204,1464375394,1676153920,1439316330,715854006,3033291828,289532110,2706671279,2087905683,3018724369,1668267050,732546397,1947742710,3462151702,2609353502,2950085171,1814351708,2050118529,680887927,999245976,1800124847,3300911131,1713906067,1641548236,4213287313,1216130144,1575780402,4018429277,3917837745,3693486850,3949271944,596196993,3549867205,258830323,2213823033,772490370,2760122372,1774776394,2652871518,566650946,4142492826,1728879713,2882767088,1783734482,3629395816,2517608232,2874225571,1861159788,326777828,3124490320,2130389656,2716951837,967770486
,1724537150,2185432712,2364442137,1164943284,2105845187,998989502,3765401048,2244026483,1075463327,1455516326,1322494562,910128902,469688178,1117454909,936433444,3490320968,3675253459,1240580251,122909385,2157517691,634681816,4142456567,3825094682,3061402683,2540495037,79693498,3249098678,1084186820,1583128258,426386531,1761308591,1047286709,322548459,995290223,1845252383,2603652396,3431023940,2942221577,3202600964,3727903485,1712269319,422464435,3234572375,1170764815,3523960633,3117677531,1434042557,442511882,3600875718,1076654713,1738483198,4213154764,2393238008,3677496056,1014306527,4251020053,793779912,2902807211,842905082,4246964064,1395751752,1040244610,2656851899,3396308128,445077038,3742853595,3577915638,679411651,2892444358,2354009459,1767581616,3150600392,3791627101,3102740896,284835224,4246832056,1258075500,768725851,2589189241,3069724005,3532540348,1274779536,3789419226,2764799539,1660621633,3471099624,4011903706,913787905,3497959166,737222580,2514213453,2928710040,3937242737
,1804850592,3499020752,2949064160,2386320175,2390070455,2415321851,4061277028,2290661394,2416832540,1336762016,1754252060,3520065937,3014181293,791618072,3188594551,3933548030,2332172193,3852520463,3043980520,413987798,3465142937,3030929376,4245938359,2093235073,3534596313,375366246,2157278981,2479649556,555357303,3870105701,2008414854,3344188149,4221384143,3956125452,2067696032,3594591187,2921233993,2428461,544322398,577241275,1471733935,610547355,4027169054,1432588573,1507829418,2025931657,3646575487,545086370,48609733,2200306550,1653985193,298326376,1316178497,3007786442,2064951626,458293330,2589141269,3591329599,3164325604,727753846,2179363840,146436021,1461446943,4069977195,705550613,3059967265,3887724982,4281599278,3313849956,1404054877,2845806497,146425753,1854211946];
private static const KS1:Array = [1266315497,3048417604,3681880366,3289982499,2909710000,1235738493,2632868024,2414719590,3970600049,1771706367,1449415276,3266420449,422970021,1963543593,2690192192,3826793022,1062508698,1531092325,1804592342,2583117782,2714934279,4024971509,1294809318,4028980673,1289560198,2221992742,1669523910,35572830,157838143,1052438473,1016535060,1802137761,1753167236,1386275462,3080475397,2857371447,1040679964,2145300060,2390574316,1461121720,2956646967,4031777805,4028374788,33600511,2920084762,1018524850,629373528,3691585981,3515945977,2091462646,2486323059,586499841,988145025,935516892,3367335476,2599673255,2839830854,265290510,3972581182,2759138881,3795373465,1005194799,847297441,406762289,1314163512,1332590856,1866599683,4127851711,750260880,613907577,1450815602,3165620655,3734664991,3650291728,3012275730,3704569646,1427272223,778793252,1343938022,2676280711,2052605720,1946737175,3164576444,3914038668,3967478842,3682934266,1661551462,3294938066,4011595847,840292616
,3712170807,616741398,312560963,711312465,1351876610,322626781,1910503582,271666773,2175563734,1594956187,70604529,3617834859,1007753275,1495573769,4069517037,2549218298,2663038764,504708206,2263041392,3941167025,2249088522,1514023603,1998579484,1312622330,694541497,2582060303,2151582166,1382467621,776784248,2618340202,3323268794,2497899128,2784771155,503983604,4076293799,907881277,423175695,432175456,1378068232,4145222326,3954048622,3938656102,3820766613,2793130115,2977904593,26017576,3274890735,3194772133,1700274565,1756076034,4006520079,3677328699,720338349,1533947780,354530856,688349552,3973924725,1637815568,332179504,3949051286,53804574,2852348879,3044236432,1282449977,3583942155,3416972820,4006381244,1617046695,2628476075,3002303598,1686838959,431878346,2686675385,1700445008,1080580658,1009431731,832498133,3223435511,2605976345,2271191193,2516031870,1648197032,4164389018,2548247927,300782431,375919233,238389289,3353747414,2531188641,2019080857,1475708069,455242339,2609103871,448939670
,3451063019,1395535956,2413381860,1841049896,1491858159,885456874,4264095073,4001119347,1565136089,3898914787,1108368660,540939232,1173283510,2745871338,3681308437,4207628240,3343053890,4016749493,1699691293,1103962373,3625875870,2256883143,3830138730,1031889488,3479347698,1535977030,4236805024,3251091107,2132092099,1774941330,1199868427,1452454533,157007616,2904115357,342012276,595725824,1480756522,206960106,497939518,591360097,863170706,2375253569,3596610801,1814182875,2094937945,3421402208,1082520231,3463918190,2785509508,435703966,3908032597,1641649973,2842273706,3305899714,1510255612,2148256476,2655287854,3276092548,4258621189,236887753,3681803219,274041037,1734335097,3815195456,3317970021,1899903192,1026095262,4050517792,356393447,2410691914,3873677099,3682840055];
private static const KS2:Array = [3913112168,2491498743,4132185628,2489919796,1091903735,1979897079,3170134830,3567386728,3557303409,857797738,1136121015,1342202287,507115054,2535736646,337727348,3213592640,1301675037,2528481711,1895095763,1721773893,3216771564,62756741,2142006736,835421444,2531993523,1442658625,3659876326,2882144922,676362277,1392781812,170690266,3921047035,1759253602,3611846912,1745797284,664899054,1329594018,3901205900,3045908486,2062866102,2865634940,3543621612,3464012697,1080764994,553557557,3656615353,3996768171,991055499,499776247,1265440854,648242737,3940784050,980351604,3713745714,1749149687,3396870395,4211799374,3640570775,1161844396,3125318951,1431517754,545492359,4268468663,3499529547,1437099964,2702547544,3433638243,2581715763,2787789398,1060185593,1593081372,2418618748,4260947970,69676912,2159744348,86519011,2512459080,3838209314,1220612927,3339683548,133810670,1090789135,1078426020,1569222167,845107691,3583754449,4072456591,1091646820,628848692,1613405280
,3757631651,526609435,236106946,48312990,2942717905,3402727701,1797494240,859738849,992217954,4005476642,2243076622,3870952857,3732016268,765654824,3490871365,2511836413,1685915746,3888969200,1414112111,2273134842,3281911079,4080962846,172450625,2569994100,980381355,4109958455,2819808352,2716589560,2568741196,3681446669,3329971472,1835478071,660984891,3704678404,4045999559,3422617507,3040415634,1762651403,1719377915,3470491036,2693910283,3642056355,3138596744,1364962596,2073328063,1983633131,926494387,3423689081,2150032023,4096667949,1749200295,3328846651,309677260,2016342300,1779581495,3079819751,111262694,1274766160,443224088,298511866,1025883608,3806446537,1145181785,168956806,3641502830,3584813610,1689216846,3666258015,3200248200,1692713982,2646376535,4042768518,1618508792,1610833997,3523052358,4130873264,2001055236,3610705100,2202168115,4028541809,2961195399,1006657119,2006996926,3186142756,1430667929,3210227297,1314452623,4074634658,4101304120,2273951170,1399257539,3367210612,3027628629
,1190975929,2062231137,2333990788,2221543033,2438960610,1181637006,548689776,2362791313,3372408396,3104550113,3145860560,296247880,1970579870,3078560182,3769228297,1714227617,3291629107,3898220290,166772364,1251581989,493813264,448347421,195405023,2709975567,677966185,3703036547,1463355134,2715995803,1338867538,1343315457,2802222074,2684532164,233230375,2599980071,2000651841,3277868038,1638401717,4028070440,3237316320,6314154,819756386,300326615,590932579,1405279636,3267499572,3150704214,2428286686,3959192993,3461946742,1862657033,1266418056,963775037,2089974820,2263052895,1917689273,448879540,3550394620,3981727096,150775221,3627908307,1303187396,508620638,2975983352,2726630617,1817252668,1876281319,1457606340,908771278,3720792119,3617206836,2455994898,1729034894,1080033504];
private static const KS3:Array = [976866871,3556439503,2881648439,1522871579,1555064734,1336096578,3548522304,2579274686,3574697629,3205460757,3593280638,3338716283,3079412587,564236357,2993598910,1781952180,1464380207,3163844217,3332601554,1699332808,1393555694,1183702653,3581086237,1288719814,691649499,2847557200,2895455976,3193889540,2717570544,1781354906,1676643554,2592534050,3230253752,1126444790,2770207658,2633158820,2210423226,2615765581,2414155088,3127139286,673620729,2805611233,1269405062,4015350505,3341807571,4149409754,1057255273,2012875353,2162469141,2276492801,2601117357,993977747,3918593370,2654263191,753973209,36408145,2530585658,25011837,3520020182,2088578344,530523599,2918365339,1524020338,1518925132,3760827505,3759777254,1202760957,3985898139,3906192525,674977740,4174734889,2031300136,2019492241,3983892565,4153806404,3822280332,352677332,2297720250,60907813,90501309,3286998549,1016092578,2535922412,2839152426,457141659,509813237,4120667899,652014361,1966332200,2975202805
,55981186,2327461051,676427537,3255491064,2882294119,3433927263,1307055953,942726286,933058658,2468411793,3933900994,4215176142,1361170020,2001714738,2830558078,3274259782,1222529897,1679025792,2729314320,3714953764,1770335741,151462246,3013232138,1682292957,1483529935,471910574,1539241949,458788160,3436315007,1807016891,3718408830,978976581,1043663428,3165965781,1927990952,4200891579,2372276910,3208408903,3533431907,1412390302,2931980059,4132332400,1947078029,3881505623,4168226417,2941484381,1077988104,1320477388,886195818,18198404,3786409000,2509781533,112762804,3463356488,1866414978,891333506,18488651,661792760,1628790961,3885187036,3141171499,876946877,2693282273,1372485963,791857591,2686433993,3759982718,3167212022,3472953795,2716379847,445679433,3561995674,3504004811,3574258232,54117162,3331405415,2381918588,3769707343,4154350007,1140177722,4074052095,668550556,3214352940,367459370,261225585,2610173221,4209349473,3468074219,3265815641,314222801,3066103646,3808782860,282218597,3406013506
,3773591054,379116347,1285071038,846784868,2669647154,3771962079,3550491691,2305946142,453669953,1268987020,3317592352,3279303384,3744833421,2610507566,3859509063,266596637,3847019092,517658769,3462560207,3443424879,370717030,4247526661,2224018117,4143653529,4112773975,2788324899,2477274417,1456262402,2901442914,1517677493,1846949527,2295493580,3734397586,2176403920,1280348187,1908823572,3871786941,846861322,1172426758,3287448474,3383383037,1655181056,3139813346,901632758,1897031941,2986607138,3066810236,3447102507,1393639104,373351379,950779232,625454576,3124240540,4148612726,2007998917,544563296,2244738638,2330496472,2058025392,1291430526,424198748,50039436,29584100,3605783033,2429876329,2791104160,1057563949,3255363231,3075367218,3463963227,1469046755,985887462];
private static const ROUNDS:uint = 16;
private static const BLOCK_SIZE:uint = 8;
private static const SBOX_SK:uint = 256;
private static const P_SZ:uint = ROUNDS + 2;
private var S0:Array;
private var S1:Array;
private var S2:Array;
private var S3:Array;
private var P:Array;
private var key:ByteArray = null;
public function BlowFishKey(param1:ByteArray)
{
super();
this.key = param1;
this.setKey(param1);
}
public function getBlockSize() : uint
{
return BLOCK_SIZE;
}
public function decrypt(param1:ByteArray, param2:uint = 0) : void
{
this.decryptBlock(param1,param2,param1,param2);
}
public function dispose() : void
{
var _loc1_:uint = 0;
_loc1_ = 0;
while(_loc1_ < this.S0.length)
{
this.S0[_loc1_] = 0;
_loc1_++;
}
_loc1_ = 0;
while(_loc1_ < this.S1.length)
{
this.S1[_loc1_] = 0;
_loc1_++;
}
_loc1_ = 0;
while(_loc1_ < this.S2.length)
{
this.S2[_loc1_] = 0;
_loc1_++;
}
_loc1_ = 0;
while(_loc1_ < this.S3.length)
{
this.S3[_loc1_] = 0;
_loc1_++;
}
_loc1_ = 0;
while(_loc1_ < this.P.length)
{
this.P[_loc1_] = 0;
_loc1_++;
}
this.S0 = null;
this.S1 = null;
this.S2 = null;
this.S3 = null;
this.P = null;
_loc1_ = 0;
while(_loc1_ < this.key.length)
{
this.key[_loc1_] = 0;
_loc1_++;
}
this.key.length = 0;
this.key = null;
Memory.gc();
}
public function encrypt(param1:ByteArray, param2:uint = 0) : void
{
this.encryptBlock(param1,param2,param1,param2);
}
private function F(param1:uint) : uint
{
return (this.S0[param1 >>> 24] + this.S1[param1 >>> 16 & 0xFF] ^ this.S2[param1 >>> 8 & 0xFF]) + this.S3[param1 & 0xFF];
}
private function processTable(param1:uint, param2:uint, param3:Array) : void
{
var _loc6_:uint = 0;
var _loc4_:uint = param3.length;
var _loc5_:uint = 0;
while(_loc5_ < _loc4_)
{
param1 ^= this.P[0];
_loc6_ = 1;
while(_loc6_ < ROUNDS)
{
param2 ^= this.F(param1) ^ this.P[_loc6_];
param1 ^= this.F(param2) ^ this.P[_loc6_ + 1];
_loc6_ += 2;
}
param2 ^= this.P[ROUNDS + 1];
param3[_loc5_] = param2;
param3[_loc5_ + 1] = param1;
param2 = param1;
param1 = uint(param3[_loc5_]);
_loc5_ += 2;
}
}
private function setKey(param1:ByteArray) : void
{
var _loc5_:uint = 0;
var _loc6_:uint = 0;
this.S0 = KS0.concat();
this.S1 = KS1.concat();
this.S2 = KS2.concat();
this.S3 = KS3.concat();
this.P = KP.concat();
var _loc2_:uint = param1.length;
var _loc3_:uint = 0;
var _loc4_:uint = 0;
while(_loc4_ < P_SZ)
{
_loc5_ = 0;
_loc6_ = 0;
while(_loc6_ < 4)
{
_loc5_ = uint(_loc5_ << 8 | param1[_loc3_++] & 0xFF);
if(_loc3_ >= _loc2_)
{
_loc3_ = 0;
}
_loc6_++;
}
this.P[_loc4_] ^= _loc5_;
_loc4_++;
}
this.processTable(0,0,this.P);
this.processTable(this.P[P_SZ - 2],this.P[P_SZ - 1],this.S0);
this.processTable(this.S0[SBOX_SK - 2],this.S0[SBOX_SK - 1],this.S1);
this.processTable(this.S1[SBOX_SK - 2],this.S1[SBOX_SK - 1],this.S2);
this.processTable(this.S2[SBOX_SK - 2],this.S2[SBOX_SK - 1],this.S3);
}
private function encryptBlock(param1:ByteArray, param2:uint, param3:ByteArray, param4:uint) : void
{
var _loc5_:uint = this.BytesTo32bits(param1,param2);
var _loc6_:uint = this.BytesTo32bits(param1,param2 + 4);
_loc5_ ^= this.P[0];
var _loc7_:uint = 1;
while(_loc7_ < ROUNDS)
{
_loc6_ ^= this.F(_loc5_) ^ this.P[_loc7_];
_loc5_ ^= this.F(_loc6_) ^ this.P[_loc7_ + 1];
_loc7_ += 2;
}
_loc6_ ^= this.P[ROUNDS + 1];
this.Bits32ToBytes(_loc6_,param3,param4);
this.Bits32ToBytes(_loc5_,param3,param4 + 4);
}
private function decryptBlock(param1:ByteArray, param2:uint, param3:ByteArray, param4:uint) : void
{
var _loc5_:uint = this.BytesTo32bits(param1,param2);
var _loc6_:uint = this.BytesTo32bits(param1,param2 + 4);
_loc5_ ^= this.P[ROUNDS + 1];
var _loc7_:uint = ROUNDS;
while(_loc7_ > 0)
{
_loc6_ ^= this.F(_loc5_) ^ this.P[_loc7_];
_loc5_ ^= this.F(_loc6_) ^ this.P[_loc7_ - 1];
_loc7_ -= 2;
}
_loc6_ ^= this.P[0];
this.Bits32ToBytes(_loc6_,param3,param4);
this.Bits32ToBytes(_loc5_,param3,param4 + 4);
}
private function BytesTo32bits(param1:ByteArray, param2:uint) : uint
{
return (param1[param2] & 0xFF) << 24 | (param1[param2 + 1] & 0xFF) << 16 | (param1[param2 + 2] & 0xFF) << 8 | param1[param2 + 3] & 0xFF;
}
private function Bits32ToBytes(param1:uint, param2:ByteArray, param3:uint) : void
{
param2[param3 + 3] = param1;
param2[param3 + 2] = param1 >> 8;
param2[param3 + 1] = param1 >> 16;
param2[param3] = param1 >> 24;
}
public function toString() : String
{
return "blowfish";
}
}
}
@@ -0,0 +1,64 @@
package com.hurlant.crypto.symmetric
{
import flash.utils.ByteArray;
public class CBCMode extends IVMode implements IMode
{
public function CBCMode(param1:ISymmetricKey, param2:IPad = null)
{
super(param1,param2);
}
public function encrypt(param1:ByteArray) : void
{
var _loc4_:uint = 0;
padding.pad(param1);
var _loc2_:ByteArray = getIV4e();
var _loc3_:uint = 0;
while(_loc3_ < param1.length)
{
_loc4_ = 0;
while(_loc4_ < blockSize)
{
param1[_loc3_ + _loc4_] ^= _loc2_[_loc4_];
_loc4_++;
}
key.encrypt(param1,_loc3_);
_loc2_.position = 0;
_loc2_.writeBytes(param1,_loc3_,blockSize);
_loc3_ += blockSize;
}
}
public function decrypt(param1:ByteArray) : void
{
var _loc5_:uint = 0;
var _loc2_:ByteArray = getIV4d();
var _loc3_:ByteArray = new ByteArray();
var _loc4_:uint = 0;
while(_loc4_ < param1.length)
{
_loc3_.position = 0;
_loc3_.writeBytes(param1,_loc4_,blockSize);
key.decrypt(param1,_loc4_);
_loc5_ = 0;
while(_loc5_ < blockSize)
{
param1[_loc4_ + _loc5_] ^= _loc2_[_loc5_];
_loc5_++;
}
_loc2_.position = 0;
_loc2_.writeBytes(_loc3_,0,blockSize);
_loc4_ += blockSize;
}
padding.unpad(param1);
}
public function toString() : String
{
return key.toString() + "-cbc";
}
}
}
@@ -0,0 +1,67 @@
package com.hurlant.crypto.symmetric
{
import flash.utils.ByteArray;
public class CFB8Mode extends IVMode implements IMode
{
public function CFB8Mode(param1:ISymmetricKey, param2:IPad = null)
{
super(param1,null);
}
public function encrypt(param1:ByteArray) : void
{
var _loc5_:uint = 0;
var _loc2_:ByteArray = getIV4e();
var _loc3_:ByteArray = new ByteArray();
var _loc4_:uint = 0;
while(_loc4_ < param1.length)
{
_loc3_.position = 0;
_loc3_.writeBytes(_loc2_);
key.encrypt(_loc2_);
param1[_loc4_] ^= _loc2_[0];
_loc5_ = 0;
while(_loc5_ < blockSize - 1)
{
_loc2_[_loc5_] = _loc3_[_loc5_ + 1];
_loc5_++;
}
_loc2_[blockSize - 1] = param1[_loc4_];
_loc4_++;
}
}
public function decrypt(param1:ByteArray) : void
{
var _loc5_:uint = 0;
var _loc6_:uint = 0;
var _loc2_:ByteArray = getIV4d();
var _loc3_:ByteArray = new ByteArray();
var _loc4_:uint = 0;
while(_loc4_ < param1.length)
{
_loc5_ = uint(param1[_loc4_]);
_loc3_.position = 0;
_loc3_.writeBytes(_loc2_);
key.encrypt(_loc2_);
param1[_loc4_] ^= _loc2_[0];
_loc6_ = 0;
while(_loc6_ < blockSize - 1)
{
_loc2_[_loc6_] = _loc3_[_loc6_ + 1];
_loc6_++;
}
_loc2_[blockSize - 1] = _loc5_;
_loc4_++;
}
}
public function toString() : String
{
return key.toString() + "-cfb8";
}
}
}
@@ -0,0 +1,68 @@
package com.hurlant.crypto.symmetric
{
import flash.utils.ByteArray;
public class CFBMode extends IVMode implements IMode
{
public function CFBMode(param1:ISymmetricKey, param2:IPad = null)
{
super(param1,null);
}
public function encrypt(param1:ByteArray) : void
{
var _loc5_:uint = 0;
var _loc6_:uint = 0;
var _loc2_:uint = param1.length;
var _loc3_:ByteArray = getIV4e();
var _loc4_:uint = 0;
while(_loc4_ < param1.length)
{
key.encrypt(_loc3_);
_loc5_ = _loc4_ + blockSize < _loc2_ ? blockSize : uint(_loc2_ - _loc4_);
_loc6_ = 0;
while(_loc6_ < _loc5_)
{
param1[_loc4_ + _loc6_] ^= _loc3_[_loc6_];
_loc6_++;
}
_loc3_.position = 0;
_loc3_.writeBytes(param1,_loc4_,_loc5_);
_loc4_ += blockSize;
}
}
public function decrypt(param1:ByteArray) : void
{
var _loc6_:uint = 0;
var _loc7_:uint = 0;
var _loc2_:uint = param1.length;
var _loc3_:ByteArray = getIV4d();
var _loc4_:ByteArray = new ByteArray();
var _loc5_:uint = 0;
while(_loc5_ < param1.length)
{
key.encrypt(_loc3_);
_loc6_ = _loc5_ + blockSize < _loc2_ ? blockSize : uint(_loc2_ - _loc5_);
_loc4_.position = 0;
_loc4_.writeBytes(param1,_loc5_,_loc6_);
_loc7_ = 0;
while(_loc7_ < _loc6_)
{
param1[_loc5_ + _loc7_] ^= _loc3_[_loc7_];
_loc7_++;
}
_loc3_.position = 0;
_loc3_.writeBytes(_loc4_);
_loc5_ += blockSize;
}
}
public function toString() : String
{
return key.toString() + "-cfb";
}
}
}
@@ -0,0 +1,65 @@
package com.hurlant.crypto.symmetric
{
import flash.utils.ByteArray;
public class CTRMode extends IVMode implements IMode
{
public function CTRMode(param1:ISymmetricKey, param2:IPad = null)
{
super(param1,param2);
}
public function encrypt(param1:ByteArray) : void
{
padding.pad(param1);
var _loc2_:ByteArray = getIV4e();
this.core(param1,_loc2_);
}
public function decrypt(param1:ByteArray) : void
{
var _loc2_:ByteArray = getIV4d();
this.core(param1,_loc2_);
padding.unpad(param1);
}
private function core(param1:ByteArray, param2:ByteArray) : void
{
var _loc6_:uint = 0;
var _loc3_:ByteArray = new ByteArray();
var _loc4_:ByteArray = new ByteArray();
_loc3_.writeBytes(param2);
var _loc5_:uint = 0;
while(_loc5_ < param1.length)
{
_loc4_.position = 0;
_loc4_.writeBytes(_loc3_);
key.encrypt(_loc4_);
_loc6_ = 0;
while(_loc6_ < blockSize)
{
param1[_loc5_ + _loc6_] ^= _loc4_[_loc6_];
_loc6_++;
}
_loc6_ = blockSize - 1;
while(_loc6_ >= 0)
{
++_loc3_[_loc6_];
if(_loc3_[_loc6_] != 0)
{
break;
}
_loc6_--;
}
_loc5_ += blockSize;
}
}
public function toString() : String
{
return key.toString() + "-ctr";
}
}
}
@@ -0,0 +1,272 @@
package com.hurlant.crypto.symmetric
{
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
public class DESKey implements ISymmetricKey
{
private static const Df_Key:Array = [1,35,69,103,137,171,205,239,254,220,186,152,118,84,50,16,137,171,205,239,1,35,69,103];
private static const bytebit:Array = [128,64,32,16,8,4,2,1];
private static const bigbyte:Array = [8388608,4194304,2097152,1048576,524288,262144,131072,65536,32768,16384,8192,4096,2048,1024,512,256,128,64,32,16,8,4,2,1];
private static const pc1:Array = [56,48,40,32,24,16,8,0,57,49,41,33,25,17,9,1,58,50,42,34,26,18,10,2,59,51,43,35,62,54,46,38,30,22,14,6,61,53,45,37,29,21,13,5,60,52,44,36,28,20,12,4,27,19,11,3];
private static const totrot:Array = [1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28];
private static const pc2:Array = [13,16,10,23,0,4,2,27,14,5,20,9,22,18,11,3,25,7,15,6,26,19,12,1,40,51,30,36,46,54,29,39,50,44,32,47,43,48,38,55,33,52,45,41,49,35,28,31];
private static const SP1:Array = [16843776,0,65536,16843780,16842756,66564,4,65536,1024,16843776,16843780,1024,16778244,16842756,16777216,4,1028,16778240,16778240,66560,66560,16842752,16842752,16778244,65540,16777220,16777220,65540,0,1028,66564,16777216,65536,16843780,4,16842752,16843776,16777216,16777216,1024,16842756,65536,66560,16777220,1024,4,16778244,66564,16843780,65540,16842752,16778244,16777220,1028,66564,16843776,1028,16778240,16778240,0,65540,66560,0,16842756];
private static const SP2:Array = [2148565024,2147516416,32768,1081376,1048576,32,2148532256,2147516448,2147483680,2148565024,2148564992,2147483648,2147516416,1048576,32,2148532256,1081344,1048608,2147516448,0,2147483648,32768,1081376,2148532224,1048608,2147483680,0,1081344,32800,2148564992,2148532224,32800,0,1081376,2148532256,1048576,2147516448,2148532224,2148564992,32768,2148532224,2147516416,32,2148565024,1081376,32,32768,2147483648,32800,2148564992,1048576,2147483680,1048608,2147516448,2147483680,1048608,1081344,0,2147516416,32800,2147483648,2148532256,2148565024,1081344];
private static const SP3:Array = [520,134349312,0,134348808,134218240,0,131592,134218240,131080,134217736,134217736,131072,134349320,131080,134348800,520,134217728,8,134349312,512,131584,134348800,134348808,131592,134218248,131584,131072,134218248,8,134349320,512,134217728,134349312,134217728,131080,520,131072,134349312,134218240,0,512,131080,134349320,134218240,134217736,512,0,134348808,134218248,131072,134217728,134349320,8,131592,131584,134217736,134348800,134218248,520,134348800,131592,8,134348808,131584];
private static const SP4:Array = [8396801,8321,8321,128,8396928,8388737,8388609,8193,0,8396800,8396800,8396929,129,0,8388736,8388609,1,8192,8388608,8396801,128,8388608,8193,8320,8388737,1,8320,8388736,8192,8396928,8396929,129,8388736,8388609,8396800,8396929,129,0,0,8396800,8320,8388736,8388737,1,8396801,8321,8321,128,8396929,129,1,8192,8388609,8193,8396928,8388737,8193,8320,8388608,8396801,128,8388608,8192,8396928];
private static const SP5:Array = [256,34078976,34078720,1107296512,524288,256,1073741824,34078720,1074266368,524288,33554688,1074266368,1107296512,1107820544,524544,1073741824,33554432,1074266112,1074266112,0,1073742080,1107820800,1107820800,33554688,1107820544,1073742080,0,1107296256,34078976,33554432,1107296256,524544,524288,1107296512,256,33554432,1073741824,34078720,1107296512,1074266368,33554688,1073741824,1107820544,34078976,1074266368,256,33554432,1107820544,1107820800,524544,1107296256,1107820800,34078720,0,1074266112,1107296256,524544,33554688,1073742080,524288,0,1074266112,34078976,1073742080];
private static const SP6:Array = [536870928,541065216,16384,541081616,541065216,16,541081616,4194304,536887296,4210704,4194304,536870928,4194320,536887296,536870912,16400,0,4194320,536887312,16384,4210688,536887312,16,541065232,541065232,0,4210704,541081600,16400,4210688,541081600,536870912,536887296,16,541065232,4210688,541081616,4194304,16400,536870928,4194304,536887296,536870912,16400,536870928,541081616,4210688,541065216,4210704,541081600,0,541065232,16,16384,541065216,4210704,16384,4194320,536887312,0,541081600,536870912,4194320,536887312];
private static const SP7:Array = [2097152,69206018,67110914,0,2048,67110914,2099202,69208064,69208066,2097152,0,67108866,2,67108864,69206018,2050,67110912,2099202,2097154,67110912,67108866,69206016,69208064,2097154,69206016,2048,2050,69208066,2099200,2,67108864,2099200,67108864,2099200,2097152,67110914,67110914,69206018,69206018,2,2097154,67108864,67110912,2097152,69208064,2050,2099202,69208064,2050,67108866,69208066,69206016,2099200,0,2,69208066,0,2099202,69206016,2048,67108866,67110912,2048,2097154];
private static const SP8:Array = [268439616,4096,262144,268701760,268435456,268439616,64,268435456,262208,268697600,268701760,266240,268701696,266304,4096,64,268697600,268435520,268439552,4160,266240,262208,268697664,268701696,4160,0,0,268697664,268435520,268439552,266304,262144,266304,262144,268701696,4096,64,268697664,4096,266304,268439552,64,268435520,268697600,268697664,268435456,262144,268439616,0,268701760,262208,268435520,268697600,268439552,268439616,0,268701760,266240,266240,4160,4160,262208,268435456,268701696];
protected var key:ByteArray;
protected var encKey:Array;
protected var decKey:Array;
public function DESKey(param1:ByteArray)
{
super();
this.key = param1;
this.encKey = this.generateWorkingKey(true,param1,0);
this.decKey = this.generateWorkingKey(false,param1,0);
}
public function getBlockSize() : uint
{
return 8;
}
public function decrypt(param1:ByteArray, param2:uint = 0) : void
{
this.desFunc(this.decKey,param1,param2,param1,param2);
}
public function dispose() : void
{
var _loc1_:uint = 0;
_loc1_ = 0;
while(_loc1_ < this.encKey.length)
{
this.encKey[_loc1_] = 0;
_loc1_++;
}
_loc1_ = 0;
while(_loc1_ < this.decKey.length)
{
this.decKey[_loc1_] = 0;
_loc1_++;
}
this.encKey = null;
this.decKey = null;
_loc1_ = 0;
while(_loc1_ < this.key.length)
{
this.key[_loc1_] = 0;
_loc1_++;
}
this.key.length = 0;
this.key = null;
Memory.gc();
}
public function encrypt(param1:ByteArray, param2:uint = 0) : void
{
this.desFunc(this.encKey,param1,param2,param1,param2);
}
protected function generateWorkingKey(param1:Boolean, param2:ByteArray, param3:uint) : Array
{
var _loc7_:uint = 0;
var _loc10_:uint = 0;
var _loc11_:uint = 0;
var _loc12_:uint = 0;
var _loc13_:uint = 0;
var _loc4_:Array = [];
var _loc5_:ByteArray = new ByteArray();
var _loc6_:ByteArray = new ByteArray();
var _loc8_:uint = 0;
while(_loc8_ < 56)
{
_loc7_ = uint(pc1[_loc8_]);
_loc5_[_loc8_] = (param2[param3 + (_loc7_ >>> 3)] & bytebit[_loc7_ & 7]) != 0;
_loc8_++;
}
var _loc9_:uint = 0;
while(_loc9_ < 16)
{
if(param1)
{
_loc10_ = uint(_loc9_ << 1);
}
else
{
_loc10_ = uint(15 - _loc9_ << 1);
}
_loc11_ = _loc10_ + 1;
_loc4_[_loc10_] = _loc4_[_loc11_] = 0;
_loc8_ = 0;
while(_loc8_ < 28)
{
_loc7_ = _loc8_ + totrot[_loc9_];
if(_loc7_ < 28)
{
_loc6_[_loc8_] = _loc5_[_loc7_];
}
else
{
_loc6_[_loc8_] = _loc5_[_loc7_ - 28];
}
_loc8_++;
}
_loc8_ = 28;
while(_loc8_ < 56)
{
_loc7_ = _loc8_ + totrot[_loc9_];
if(_loc7_ < 56)
{
_loc6_[_loc8_] = _loc5_[_loc7_];
}
else
{
_loc6_[_loc8_] = _loc5_[_loc7_ - 28];
}
_loc8_++;
}
_loc8_ = 0;
while(_loc8_ < 24)
{
if(_loc6_[pc2[_loc8_]])
{
_loc4_[_loc10_] |= bigbyte[_loc8_];
}
if(_loc6_[pc2[_loc8_ + 24]])
{
_loc4_[_loc11_] |= bigbyte[_loc8_];
}
_loc8_++;
}
_loc9_++;
}
_loc9_ = 0;
while(_loc9_ != 32)
{
_loc12_ = uint(_loc4_[_loc9_]);
_loc13_ = uint(_loc4_[_loc9_ + 1]);
_loc4_[_loc9_] = (_loc12_ & 0xFC0000) << 6 | (_loc12_ & 0x0FC0) << 10 | (_loc13_ & 0xFC0000) >>> 10 | (_loc13_ & 0x0FC0) >>> 6;
_loc4_[_loc9_ + 1] = (_loc12_ & 0x03F000) << 12 | (_loc12_ & 0x3F) << 16 | (_loc13_ & 0x03F000) >>> 4 | _loc13_ & 0x3F;
_loc9_ += 2;
}
return _loc4_;
}
protected function desFunc(param1:Array, param2:ByteArray, param3:uint, param4:ByteArray, param5:uint) : void
{
var _loc6_:uint = 0;
var _loc7_:uint = 0;
var _loc8_:uint = 0;
var _loc10_:uint = 0;
_loc8_ = uint((param2[param3 + 0] & 0xFF) << 24);
_loc8_ = uint(_loc8_ | (param2[param3 + 1] & 0xFF) << 16);
_loc8_ = uint(_loc8_ | (param2[param3 + 2] & 0xFF) << 8);
_loc8_ = uint(_loc8_ | param2[param3 + 3] & 0xFF);
_loc7_ = uint((param2[param3 + 4] & 0xFF) << 24);
_loc7_ = uint(_loc7_ | (param2[param3 + 5] & 0xFF) << 16);
_loc7_ = uint(_loc7_ | (param2[param3 + 6] & 0xFF) << 8);
_loc7_ = uint(_loc7_ | param2[param3 + 7] & 0xFF);
_loc6_ = uint((_loc8_ >>> 4 ^ _loc7_) & 0x0F0F0F0F);
_loc7_ ^= _loc6_;
_loc8_ ^= _loc6_ << 4;
_loc6_ = uint((_loc8_ >>> 16 ^ _loc7_) & 0xFFFF);
_loc7_ ^= _loc6_;
_loc8_ ^= _loc6_ << 16;
_loc6_ = uint((_loc7_ >>> 2 ^ _loc8_) & 0x33333333);
_loc8_ ^= _loc6_;
_loc7_ ^= _loc6_ << 2;
_loc6_ = uint((_loc7_ >>> 8 ^ _loc8_) & 0xFF00FF);
_loc8_ ^= _loc6_;
_loc7_ ^= _loc6_ << 8;
_loc7_ = uint((_loc7_ << 1 | _loc7_ >>> 31 & 1) & 0xFFFFFFFF);
_loc6_ = uint((_loc8_ ^ _loc7_) & 0xAAAAAAAA);
_loc8_ ^= _loc6_;
_loc7_ ^= _loc6_;
_loc8_ = uint((_loc8_ << 1 | _loc8_ >>> 31 & 1) & 0xFFFFFFFF);
var _loc9_:uint = 0;
while(_loc9_ < 8)
{
_loc6_ = uint(_loc7_ << 28 | _loc7_ >>> 4);
_loc6_ = uint(_loc6_ ^ param1[_loc9_ * 4 + 0]);
_loc10_ = uint(SP7[_loc6_ & 0x3F]);
_loc10_ = uint(_loc10_ | SP5[_loc6_ >>> 8 & 0x3F]);
_loc10_ = uint(_loc10_ | SP3[_loc6_ >>> 16 & 0x3F]);
_loc10_ = uint(_loc10_ | SP1[_loc6_ >>> 24 & 0x3F]);
_loc6_ = uint(_loc7_ ^ param1[_loc9_ * 4 + 1]);
_loc10_ |= SP8[_loc6_ & 0x3F];
_loc10_ = uint(_loc10_ | SP6[_loc6_ >>> 8 & 0x3F]);
_loc10_ = uint(_loc10_ | SP4[_loc6_ >>> 16 & 0x3F]);
_loc10_ = uint(_loc10_ | SP2[_loc6_ >>> 24 & 0x3F]);
_loc8_ ^= _loc10_;
_loc6_ = uint(_loc8_ << 28 | _loc8_ >>> 4);
_loc6_ = uint(_loc6_ ^ param1[_loc9_ * 4 + 2]);
_loc10_ = uint(SP7[_loc6_ & 0x3F]);
_loc10_ = uint(_loc10_ | SP5[_loc6_ >>> 8 & 0x3F]);
_loc10_ = uint(_loc10_ | SP3[_loc6_ >>> 16 & 0x3F]);
_loc10_ = uint(_loc10_ | SP1[_loc6_ >>> 24 & 0x3F]);
_loc6_ = uint(_loc8_ ^ param1[_loc9_ * 4 + 3]);
_loc10_ |= SP8[_loc6_ & 0x3F];
_loc10_ = uint(_loc10_ | SP6[_loc6_ >>> 8 & 0x3F]);
_loc10_ = uint(_loc10_ | SP4[_loc6_ >>> 16 & 0x3F]);
_loc10_ = uint(_loc10_ | SP2[_loc6_ >>> 24 & 0x3F]);
_loc7_ ^= _loc10_;
_loc9_++;
}
_loc7_ = uint(_loc7_ << 31 | _loc7_ >>> 1);
_loc6_ = uint((_loc8_ ^ _loc7_) & 0xAAAAAAAA);
_loc8_ ^= _loc6_;
_loc7_ ^= _loc6_;
_loc8_ = uint(_loc8_ << 31 | _loc8_ >>> 1);
_loc6_ = uint((_loc8_ >>> 8 ^ _loc7_) & 0xFF00FF);
_loc7_ ^= _loc6_;
_loc8_ ^= _loc6_ << 8;
_loc6_ = uint((_loc8_ >>> 2 ^ _loc7_) & 0x33333333);
_loc7_ ^= _loc6_;
_loc8_ ^= _loc6_ << 2;
_loc6_ = uint((_loc7_ >>> 16 ^ _loc8_) & 0xFFFF);
_loc8_ ^= _loc6_;
_loc7_ ^= _loc6_ << 16;
_loc6_ = uint((_loc7_ >>> 4 ^ _loc8_) & 0x0F0F0F0F);
_loc8_ ^= _loc6_;
_loc7_ ^= _loc6_ << 4;
param4[param5 + 0] = _loc7_ >>> 24 & 0xFF;
param4[param5 + 1] = _loc7_ >>> 16 & 0xFF;
param4[param5 + 2] = _loc7_ >>> 8 & 0xFF;
param4[param5 + 3] = _loc7_ & 0xFF;
param4[param5 + 4] = _loc8_ >>> 24 & 0xFF;
param4[param5 + 5] = _loc8_ >>> 16 & 0xFF;
param4[param5 + 6] = _loc8_ >>> 8 & 0xFF;
param4[param5 + 7] = _loc8_ & 0xFF;
}
public function toString() : String
{
return "des";
}
}
}
@@ -0,0 +1,91 @@
package com.hurlant.crypto.symmetric
{
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
public class ECBMode implements IMode, ICipher
{
private var key:ISymmetricKey;
private var padding:IPad;
public function ECBMode(param1:ISymmetricKey, param2:IPad = null)
{
super();
this.key = param1;
if(param2 == null)
{
param2 = new PKCS5(param1.getBlockSize());
}
else
{
param2.setBlockSize(param1.getBlockSize());
}
this.padding = param2;
}
public function getBlockSize() : uint
{
return this.key.getBlockSize();
}
public function encrypt(param1:ByteArray) : void
{
this.padding.pad(param1);
param1.position = 0;
var _loc2_:uint = this.key.getBlockSize();
var _loc3_:ByteArray = new ByteArray();
var _loc4_:ByteArray = new ByteArray();
var _loc5_:uint = 0;
while(_loc5_ < param1.length)
{
_loc3_.length = 0;
param1.readBytes(_loc3_,0,_loc2_);
this.key.encrypt(_loc3_);
_loc4_.writeBytes(_loc3_);
_loc5_ += _loc2_;
}
param1.length = 0;
param1.writeBytes(_loc4_);
}
public function decrypt(param1:ByteArray) : void
{
param1.position = 0;
var _loc2_:uint = this.key.getBlockSize();
if(param1.length % _loc2_ != 0)
{
throw new Error("ECB mode cipher length must be a multiple of blocksize " + _loc2_);
}
var _loc3_:ByteArray = new ByteArray();
var _loc4_:ByteArray = new ByteArray();
var _loc5_:uint = 0;
while(_loc5_ < param1.length)
{
_loc3_.length = 0;
param1.readBytes(_loc3_,0,_loc2_);
this.key.decrypt(_loc3_);
_loc4_.writeBytes(_loc3_);
_loc5_ += _loc2_;
}
this.padding.unpad(_loc4_);
param1.length = 0;
param1.writeBytes(_loc4_);
}
public function dispose() : void
{
this.key.dispose();
this.key = null;
this.padding = null;
Memory.gc();
}
public function toString() : String
{
return this.key.toString() + "-ecb";
}
}
}
@@ -0,0 +1,19 @@
package com.hurlant.crypto.symmetric
{
import flash.utils.ByteArray;
public interface ICipher
{
function getBlockSize() : uint;
function encrypt(param1:ByteArray) : void;
function decrypt(param1:ByteArray) : void;
function dispose() : void;
function toString() : String;
}
}
@@ -0,0 +1,9 @@
package com.hurlant.crypto.symmetric
{
public interface IMode extends ICipher
{
}
}
@@ -0,0 +1,15 @@
package com.hurlant.crypto.symmetric
{
import flash.utils.ByteArray;
public interface IPad
{
function pad(param1:ByteArray) : void;
function unpad(param1:ByteArray) : void;
function setBlockSize(param1:uint) : void;
}
}
@@ -0,0 +1,9 @@
package com.hurlant.crypto.symmetric
{
public interface IStreamCipher extends ICipher
{
}
}
@@ -0,0 +1,19 @@
package com.hurlant.crypto.symmetric
{
import flash.utils.ByteArray;
public interface ISymmetricKey
{
function getBlockSize() : uint;
function encrypt(param1:ByteArray, param2:uint = 0) : void;
function decrypt(param1:ByteArray, param2:uint = 0) : void;
function dispose() : void;
function toString() : String;
}
}
@@ -0,0 +1,119 @@
package com.hurlant.crypto.symmetric
{
import com.hurlant.crypto.prng.Random;
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
public class IVMode
{
protected var key:ISymmetricKey;
protected var padding:IPad;
protected var prng:Random;
protected var iv:ByteArray;
protected var lastIV:ByteArray;
protected var blockSize:uint;
public function IVMode(param1:ISymmetricKey, param2:IPad = null)
{
super();
this.key = param1;
this.blockSize = param1.getBlockSize();
if(param2 == null)
{
param2 = new PKCS5(this.blockSize);
}
else
{
param2.setBlockSize(this.blockSize);
}
this.padding = param2;
this.prng = new Random();
this.iv = null;
this.lastIV = new ByteArray();
}
public function getBlockSize() : uint
{
return this.key.getBlockSize();
}
public function dispose() : void
{
var _loc1_:uint = 0;
if(this.iv != null)
{
_loc1_ = 0;
while(_loc1_ < this.iv.length)
{
this.iv[_loc1_] = this.prng.nextByte();
_loc1_++;
}
this.iv.length = 0;
this.iv = null;
}
if(this.lastIV != null)
{
_loc1_ = 0;
while(_loc1_ < this.iv.length)
{
this.lastIV[_loc1_] = this.prng.nextByte();
_loc1_++;
}
this.lastIV.length = 0;
this.lastIV = null;
}
this.key.dispose();
this.key = null;
this.padding = null;
this.prng.dispose();
this.prng = null;
Memory.gc();
}
public function set IV(param1:ByteArray) : void
{
this.iv = param1;
this.lastIV.length = 0;
this.lastIV.writeBytes(this.iv);
}
public function get IV() : ByteArray
{
return this.lastIV;
}
protected function getIV4e() : ByteArray
{
var _loc1_:ByteArray = new ByteArray();
if(this.iv)
{
_loc1_.writeBytes(this.iv);
}
else
{
this.prng.nextBytes(_loc1_,this.blockSize);
}
this.lastIV.length = 0;
this.lastIV.writeBytes(_loc1_);
return _loc1_;
}
protected function getIV4d() : ByteArray
{
var _loc1_:ByteArray = new ByteArray();
if(this.iv)
{
_loc1_.writeBytes(this.iv);
return _loc1_;
}
throw new Error("an IV must be set before calling decrypt()");
}
}
}
@@ -0,0 +1,26 @@
package com.hurlant.crypto.symmetric
{
import flash.utils.ByteArray;
public class NullPad implements IPad
{
public function NullPad()
{
super();
}
public function unpad(param1:ByteArray) : void
{
}
public function pad(param1:ByteArray) : void
{
}
public function setBlockSize(param1:uint) : void
{
}
}
}
@@ -0,0 +1,56 @@
package com.hurlant.crypto.symmetric
{
import flash.utils.ByteArray;
public class OFBMode extends IVMode implements IMode
{
public function OFBMode(param1:ISymmetricKey, param2:IPad = null)
{
super(param1,null);
}
public function encrypt(param1:ByteArray) : void
{
var _loc2_:ByteArray = getIV4e();
this.core(param1,_loc2_);
}
public function decrypt(param1:ByteArray) : void
{
var _loc2_:ByteArray = getIV4d();
this.core(param1,_loc2_);
}
private function core(param1:ByteArray, param2:ByteArray) : void
{
var _loc6_:uint = 0;
var _loc7_:uint = 0;
var _loc3_:uint = param1.length;
var _loc4_:ByteArray = new ByteArray();
var _loc5_:uint = 0;
while(_loc5_ < param1.length)
{
key.encrypt(param2);
_loc4_.position = 0;
_loc4_.writeBytes(param2);
_loc6_ = _loc5_ + blockSize < _loc3_ ? blockSize : uint(_loc3_ - _loc5_);
_loc7_ = 0;
while(_loc7_ < _loc6_)
{
param1[_loc5_ + _loc7_] ^= param2[_loc7_];
_loc7_++;
}
param2.position = 0;
param2.writeBytes(_loc4_);
_loc5_ += blockSize;
}
}
public function toString() : String
{
return key.toString() + "-ofb";
}
}
}
@@ -0,0 +1,55 @@
package com.hurlant.crypto.symmetric
{
import flash.utils.ByteArray;
public class PKCS5 implements IPad
{
private var blockSize:uint;
public function PKCS5(param1:uint = 0)
{
super();
this.blockSize = param1;
}
public function pad(param1:ByteArray) : void
{
var _loc2_:uint = this.blockSize - param1.length % this.blockSize;
var _loc3_:uint = 0;
while(_loc3_ < _loc2_)
{
param1[param1.length] = _loc2_;
_loc3_++;
}
}
public function unpad(param1:ByteArray) : void
{
var _loc4_:uint = 0;
var _loc2_:uint = param1.length % this.blockSize;
if(_loc2_ != 0)
{
throw new Error("PKCS#5::unpad: ByteArray.length isn\'t a multiple of the blockSize");
}
_loc2_ = uint(param1[param1.length - 1]);
var _loc3_:uint = _loc2_;
while(_loc3_ > 0)
{
_loc4_ = uint(param1[param1.length - 1]);
--param1.length;
if(_loc2_ != _loc4_)
{
throw new Error("PKCS#5:unpad: Invalid padding value. expected [" + _loc2_ + "], found [" + _loc4_ + "]");
}
_loc3_--;
}
}
public function setBlockSize(param1:uint) : void
{
this.blockSize = param1;
}
}
}
@@ -0,0 +1,61 @@
package com.hurlant.crypto.symmetric
{
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
public class SimpleIVMode implements IMode, ICipher
{
protected var mode:IVMode;
protected var cipher:ICipher;
public function SimpleIVMode(param1:IVMode)
{
super();
this.mode = param1;
this.cipher = param1 as ICipher;
}
public function getBlockSize() : uint
{
return this.mode.getBlockSize();
}
public function dispose() : void
{
this.mode.dispose();
this.mode = null;
this.cipher = null;
Memory.gc();
}
public function encrypt(param1:ByteArray) : void
{
this.cipher.encrypt(param1);
var _loc2_:ByteArray = new ByteArray();
_loc2_.writeBytes(this.mode.IV);
_loc2_.writeBytes(param1);
param1.position = 0;
param1.writeBytes(_loc2_);
}
public function decrypt(param1:ByteArray) : void
{
var _loc2_:ByteArray = new ByteArray();
_loc2_.writeBytes(param1,0,this.getBlockSize());
this.mode.IV = _loc2_;
_loc2_ = new ByteArray();
_loc2_.writeBytes(param1,this.getBlockSize());
this.cipher.decrypt(_loc2_);
param1.length = 0;
param1.writeBytes(_loc2_);
}
public function toString() : String
{
return "simple-" + this.cipher.toString();
}
}
}
@@ -0,0 +1,101 @@
package com.hurlant.crypto.symmetric
{
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
public class TripleDESKey extends DESKey
{
protected var encKey2:Array;
protected var encKey3:Array;
protected var decKey2:Array;
protected var decKey3:Array;
public function TripleDESKey(param1:ByteArray)
{
super(param1);
this.encKey2 = generateWorkingKey(false,param1,8);
this.decKey2 = generateWorkingKey(true,param1,8);
if(param1.length > 16)
{
this.encKey3 = generateWorkingKey(true,param1,16);
this.decKey3 = generateWorkingKey(false,param1,16);
}
else
{
this.encKey3 = encKey;
this.decKey3 = decKey;
}
}
override public function dispose() : void
{
super.dispose();
var _loc1_:uint = 0;
if(this.encKey2 != null)
{
_loc1_ = 0;
while(_loc1_ < this.encKey2.length)
{
this.encKey2[_loc1_] = 0;
_loc1_++;
}
this.encKey2 = null;
}
if(this.encKey3 != null)
{
_loc1_ = 0;
while(_loc1_ < this.encKey3.length)
{
this.encKey3[_loc1_] = 0;
_loc1_++;
}
this.encKey3 = null;
}
if(this.decKey2 != null)
{
_loc1_ = 0;
while(_loc1_ < this.decKey2.length)
{
this.decKey2[_loc1_] = 0;
_loc1_++;
}
this.decKey2 = null;
}
if(this.decKey3 != null)
{
_loc1_ = 0;
while(_loc1_ < this.decKey3.length)
{
this.decKey3[_loc1_] = 0;
_loc1_++;
}
this.decKey3 = null;
}
Memory.gc();
}
override public function encrypt(param1:ByteArray, param2:uint = 0) : void
{
desFunc(encKey,param1,param2,param1,param2);
desFunc(this.encKey2,param1,param2,param1,param2);
desFunc(this.encKey3,param1,param2,param1,param2);
}
override public function decrypt(param1:ByteArray, param2:uint = 0) : void
{
desFunc(this.decKey3,param1,param2,param1,param2);
desFunc(this.decKey2,param1,param2,param1,param2);
desFunc(decKey,param1,param2,param1,param2);
}
override public function toString() : String
{
return "3des";
}
}
}
@@ -0,0 +1,99 @@
package com.hurlant.crypto.symmetric
{
import com.hurlant.crypto.prng.Random;
import com.hurlant.util.Memory;
import flash.utils.ByteArray;
public class XTeaKey implements ISymmetricKey
{
public const NUM_ROUNDS:uint = 64;
private var k:Array;
public function XTeaKey(param1:ByteArray)
{
super();
param1.position = 0;
this.k = [param1.readUnsignedInt(),param1.readUnsignedInt(),param1.readUnsignedInt(),param1.readUnsignedInt()];
}
public static function parseKey(param1:String) : XTeaKey
{
var _loc2_:ByteArray = new ByteArray();
_loc2_.writeUnsignedInt(parseInt(param1.substr(0,8),16));
_loc2_.writeUnsignedInt(parseInt(param1.substr(8,8),16));
_loc2_.writeUnsignedInt(parseInt(param1.substr(16,8),16));
_loc2_.writeUnsignedInt(parseInt(param1.substr(24,8),16));
_loc2_.position = 0;
return new XTeaKey(_loc2_);
}
public function getBlockSize() : uint
{
return 8;
}
public function encrypt(param1:ByteArray, param2:uint = 0) : void
{
var _loc5_:uint = 0;
param1.position = param2;
var _loc3_:uint = param1.readUnsignedInt();
var _loc4_:uint = param1.readUnsignedInt();
var _loc6_:uint = 0;
var _loc7_:uint = 2654435769;
_loc5_ = 0;
while(_loc5_ < this.NUM_ROUNDS)
{
_loc3_ += (_loc4_ << 4 ^ _loc4_ >> 5) + _loc4_ ^ _loc6_ + this.k[_loc6_ & 3];
_loc6_ += _loc7_;
_loc4_ += (_loc3_ << 4 ^ _loc3_ >> 5) + _loc3_ ^ _loc6_ + this.k[_loc6_ >> 11 & 3];
_loc5_++;
}
param1.position -= 8;
param1.writeUnsignedInt(_loc3_);
param1.writeUnsignedInt(_loc4_);
}
public function decrypt(param1:ByteArray, param2:uint = 0) : void
{
var _loc5_:uint = 0;
param1.position = param2;
var _loc3_:uint = param1.readUnsignedInt();
var _loc4_:uint = param1.readUnsignedInt();
var _loc6_:uint = 2654435769;
var _loc7_:uint = _loc6_ * this.NUM_ROUNDS;
_loc5_ = 0;
while(_loc5_ < this.NUM_ROUNDS)
{
_loc4_ -= (_loc3_ << 4 ^ _loc3_ >> 5) + _loc3_ ^ _loc7_ + this.k[_loc7_ >> 11 & 3];
_loc7_ -= _loc6_;
_loc3_ -= (_loc4_ << 4 ^ _loc4_ >> 5) + _loc4_ ^ _loc7_ + this.k[_loc7_ & 3];
_loc5_++;
}
param1.position -= 8;
param1.writeUnsignedInt(_loc3_);
param1.writeUnsignedInt(_loc4_);
}
public function dispose() : void
{
var _loc1_:Random = new Random();
var _loc2_:uint = 0;
while(_loc2_ < this.k.length)
{
this.k[_loc2_] = _loc1_.nextByte();
delete this.k[_loc2_];
_loc2_++;
}
this.k = null;
Memory.gc();
}
public function toString() : String
{
return "xtea";
}
}
}
@@ -0,0 +1,83 @@
package com.hurlant.math
{
use namespace bi_internal;
internal class BarrettReduction implements IReduction
{
private var m:BigInteger;
private var r2:BigInteger;
private var q3:BigInteger;
private var mu:BigInteger;
public function BarrettReduction(param1:BigInteger)
{
super();
this.r2 = new BigInteger();
this.q3 = new BigInteger();
BigInteger.ONE.dlShiftTo(2 * param1.t,this.r2);
this.mu = this.r2.divide(param1);
this.m = param1;
}
public function revert(param1:BigInteger) : BigInteger
{
return param1;
}
public function mulTo(param1:BigInteger, param2:BigInteger, param3:BigInteger) : void
{
param1.multiplyTo(param2,param3);
this.reduce(param3);
}
public function sqrTo(param1:BigInteger, param2:BigInteger) : void
{
param1.squareTo(param2);
this.reduce(param2);
}
public function convert(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = null;
if(param1.s < 0 || param1.t > 2 * this.m.t)
{
return param1.mod(this.m);
}
if(param1.compareTo(this.m) < 0)
{
return param1;
}
_loc2_ = new BigInteger();
param1.copyTo(_loc2_);
this.reduce(_loc2_);
return _loc2_;
}
public function reduce(param1:BigInteger) : void
{
var _loc2_:BigInteger = param1 as BigInteger;
_loc2_.drShiftTo(this.m.t - 1,this.r2);
if(_loc2_.t > this.m.t + 1)
{
_loc2_.t = this.m.t + 1;
_loc2_.clamp();
}
this.mu.multiplyUpperTo(this.r2,this.m.t + 1,this.q3);
this.m.multiplyLowerTo(this.q3,this.m.t + 1,this.r2);
while(_loc2_.compareTo(this.r2) < 0)
{
_loc2_.dAddOffset(1,this.m.t + 1);
}
_loc2_.subTo(this.r2,_loc2_);
while(_loc2_.compareTo(this.m) >= 0)
{
_loc2_.subTo(this.m,_loc2_);
}
}
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,48 @@
package com.hurlant.math
{
use namespace bi_internal;
internal class ClassicReduction implements IReduction
{
private var m:BigInteger;
public function ClassicReduction(param1:BigInteger)
{
super();
this.m = param1;
}
public function convert(param1:BigInteger) : BigInteger
{
if(param1.s < 0 || param1.compareTo(this.m) >= 0)
{
return param1.mod(this.m);
}
return param1;
}
public function revert(param1:BigInteger) : BigInteger
{
return param1;
}
public function reduce(param1:BigInteger) : void
{
param1.divRemTo(this.m,null,param1);
}
public function mulTo(param1:BigInteger, param2:BigInteger, param3:BigInteger) : void
{
param1.multiplyTo(param2,param3);
this.reduce(param3);
}
public function sqrTo(param1:BigInteger, param2:BigInteger) : void
{
param1.squareTo(param2);
this.reduce(param2);
}
}
}
@@ -0,0 +1,17 @@
package com.hurlant.math
{
internal interface IReduction
{
function convert(param1:BigInteger) : BigInteger;
function revert(param1:BigInteger) : BigInteger;
function reduce(param1:BigInteger) : void;
function mulTo(param1:BigInteger, param2:BigInteger, param3:BigInteger) : void;
function sqrTo(param1:BigInteger, param2:BigInteger) : void;
}
}
@@ -0,0 +1,95 @@
package com.hurlant.math
{
use namespace bi_internal;
internal class MontgomeryReduction implements IReduction
{
private var m:BigInteger;
private var mp:int;
private var mpl:int;
private var mph:int;
private var um:int;
private var mt2:int;
public function MontgomeryReduction(param1:BigInteger)
{
super();
this.m = param1;
this.mp = param1.invDigit();
this.mpl = this.mp & 0x7FFF;
this.mph = this.mp >> 15;
this.um = (1 << BigInteger.DB - 15) - 1;
this.mt2 = 2 * param1.t;
}
public function convert(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
param1.abs().dlShiftTo(this.m.t,_loc2_);
_loc2_.divRemTo(this.m,null,_loc2_);
if(param1.s < 0 && _loc2_.compareTo(BigInteger.ZERO) > 0)
{
this.m.subTo(_loc2_,_loc2_);
}
return _loc2_;
}
public function revert(param1:BigInteger) : BigInteger
{
var _loc2_:BigInteger = new BigInteger();
param1.copyTo(_loc2_);
this.reduce(_loc2_);
return _loc2_;
}
public function reduce(param1:BigInteger) : void
{
var _loc3_:int = 0;
var _loc4_:int = 0;
while(param1.t <= this.mt2)
{
var _loc5_:Number;
param1.a[_loc5_ = param1.t++] = 0;
}
var _loc2_:int = 0;
while(_loc2_ < this.m.t)
{
_loc3_ = param1.a[_loc2_] & 0x7FFF;
_loc4_ = _loc3_ * this.mpl + ((_loc3_ * this.mph + (param1.a[_loc2_] >> 15) * this.mpl & this.um) << 15) & BigInteger.DM;
_loc3_ = _loc2_ + this.m.t;
param1.a[_loc3_] += this.m.am(0,_loc4_,param1,_loc2_,0,this.m.t);
while(param1.a[_loc3_] >= BigInteger.DV)
{
param1.a[_loc3_] -= BigInteger.DV;
++param1.a[++_loc3_];
}
_loc2_++;
}
param1.clamp();
param1.drShiftTo(this.m.t,param1);
if(param1.compareTo(this.m) >= 0)
{
param1.subTo(this.m,param1);
}
}
public function sqrTo(param1:BigInteger, param2:BigInteger) : void
{
param1.squareTo(param2);
this.reduce(param2);
}
public function mulTo(param1:BigInteger, param2:BigInteger, param3:BigInteger) : void
{
param1.multiplyTo(param2,param3);
this.reduce(param3);
}
}
}
@@ -0,0 +1,38 @@
package com.hurlant.math
{
use namespace bi_internal;
public class NullReduction implements IReduction
{
public function NullReduction()
{
super();
}
public function revert(param1:BigInteger) : BigInteger
{
return param1;
}
public function mulTo(param1:BigInteger, param2:BigInteger, param3:BigInteger) : void
{
param1.multiplyTo(param2,param3);
}
public function sqrTo(param1:BigInteger, param2:BigInteger) : void
{
param1.squareTo(param2);
}
public function convert(param1:BigInteger) : BigInteger
{
return param1;
}
public function reduce(param1:BigInteger) : void
{
}
}
}
@@ -0,0 +1,5 @@
package com.hurlant.math
{
public namespace bi_internal = "http://crypto.hurlant.com/BigInteger";
}
@@ -0,0 +1,105 @@
package com.hurlant.util
{
import flash.utils.ByteArray;
public class Base64
{
private static const BASE64_CHARS:String = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
public static const version:String = "1.0.0";
public function Base64()
{
super();
throw new Error("Base64 class is static container only");
}
public static function encode(param1:String) : String
{
var _loc2_:ByteArray = new ByteArray();
_loc2_.writeUTFBytes(param1);
return encodeByteArray(_loc2_);
}
public static function encodeByteArray(param1:ByteArray) : String
{
var _loc3_:Array = null;
var _loc5_:uint = 0;
var _loc6_:uint = 0;
var _loc7_:uint = 0;
var _loc2_:String = "";
var _loc4_:Array = new Array(4);
param1.position = 0;
while(param1.bytesAvailable > 0)
{
_loc3_ = new Array();
_loc5_ = 0;
while(_loc5_ < 3 && param1.bytesAvailable > 0)
{
_loc3_[_loc5_] = param1.readUnsignedByte();
_loc5_++;
}
_loc4_[0] = (_loc3_[0] & 0xFC) >> 2;
_loc4_[1] = (_loc3_[0] & 3) << 4 | _loc3_[1] >> 4;
_loc4_[2] = (_loc3_[1] & 0x0F) << 2 | _loc3_[2] >> 6;
_loc4_[3] = _loc3_[2] & 0x3F;
_loc6_ = _loc3_.length;
while(_loc6_ < 3)
{
_loc4_[_loc6_ + 1] = 64;
_loc6_++;
}
_loc7_ = 0;
while(_loc7_ < _loc4_.length)
{
_loc2_ += BASE64_CHARS.charAt(_loc4_[_loc7_]);
_loc7_++;
}
}
return _loc2_;
}
public static function decode(param1:String) : String
{
var _loc2_:ByteArray = decodeToByteArray(param1);
return _loc2_.readUTFBytes(_loc2_.length);
}
public static function decodeToByteArray(param1:String) : ByteArray
{
var _loc6_:uint = 0;
var _loc7_:uint = 0;
var _loc2_:ByteArray = new ByteArray();
var _loc3_:Array = new Array(4);
var _loc4_:Array = new Array(3);
var _loc5_:uint = 0;
while(_loc5_ < param1.length)
{
_loc6_ = 0;
while(_loc6_ < 4 && _loc5_ + _loc6_ < param1.length)
{
_loc3_[_loc6_] = BASE64_CHARS.indexOf(param1.charAt(_loc5_ + _loc6_));
_loc6_++;
}
_loc4_[0] = (_loc3_[0] << 2) + ((_loc3_[1] & 0x30) >> 4);
_loc4_[1] = ((_loc3_[1] & 0x0F) << 4) + ((_loc3_[2] & 0x3C) >> 2);
_loc4_[2] = ((_loc3_[2] & 3) << 6) + _loc3_[3];
_loc7_ = 0;
while(_loc7_ < _loc4_.length)
{
if(_loc3_[_loc7_ + 1] == 64)
{
break;
}
_loc2_.writeByte(_loc4_[_loc7_]);
_loc7_++;
}
_loc5_ += 4;
}
_loc2_.position = 0;
return _loc2_;
}
}
}
@@ -0,0 +1,63 @@
package com.hurlant.util
{
import flash.utils.ByteArray;
public class Hex
{
public function Hex()
{
super();
}
public static function toArray(param1:String) : ByteArray
{
param1 = param1.replace(/\s|:/gm,"");
var _loc2_:ByteArray = new ByteArray();
if(param1.length & 1 == 1)
{
param1 = "0" + param1;
}
var _loc3_:uint = 0;
while(_loc3_ < param1.length)
{
_loc2_[_loc3_ / 2] = parseInt(param1.substr(_loc3_,2),16);
_loc3_ += 2;
}
return _loc2_;
}
public static function fromArray(param1:ByteArray, param2:Boolean = false) : String
{
var _loc3_:String = "";
var _loc4_:uint = 0;
while(_loc4_ < param1.length)
{
_loc3_ += ("0" + param1[_loc4_].toString(16)).substr(-2,2);
if(param2)
{
if(_loc4_ < param1.length - 1)
{
_loc3_ += ":";
}
}
_loc4_++;
}
return _loc3_;
}
public static function toString(param1:String) : String
{
var _loc2_:ByteArray = toArray(param1);
return _loc2_.readUTFBytes(_loc2_.length);
}
public static function fromString(param1:String, param2:Boolean = false) : String
{
var _loc3_:ByteArray = new ByteArray();
_loc3_.writeUTFBytes(param1);
return fromArray(_loc3_,param2);
}
}
}
@@ -0,0 +1,32 @@
package com.hurlant.util
{
import flash.net.LocalConnection;
import flash.system.System;
public class Memory
{
public function Memory()
{
super();
}
public static function gc() : void
{
try
{
new LocalConnection().connect("foo");
new LocalConnection().connect("foo");
}
catch(e:*)
{
}
}
public static function get used() : uint
{
return System.totalMemory;
}
}
}
@@ -0,0 +1,424 @@
package com.sbi.analytics
{
import com.carlcalderon.arthropod.Debug;
import flash.events.DataEvent;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.events.TimerEvent;
import flash.external.ExternalInterface;
import flash.net.Socket;
import flash.utils.Timer;
import flash.utils.getTimer;
public class SBTracker
{
private static var _lastPage:String;
private static var _pageStack:Array;
private static var _batchTimer:Timer;
private static var _previousDurationTime:Number;
private static var _isExternalAvailable:Boolean;
private static var _couldNotConnect:Boolean;
private static var _containsAnUndefined:Boolean;
private static var _pageView:String;
private static var _socket:Socket;
private static var _timeOffset:Number;
private static var _isFromLogin:Boolean;
private static var _holdingObject:Object;
private static var _retryLimit:int;
private static var _latestTimeStamp:Number;
private static var _lastBatchCallback:Function;
private static var _errorPageView:String;
public function SBTracker()
{
super();
}
public static function create() : void
{
if(ExternalInterface.available && gMainFrame.clientInfo.sbTrackerIp != -1)
{
_isExternalAvailable = true;
ExternalInterface.addCallback("receiveClose",receiveClose);
if(!isNaN(gMainFrame.clientInfo.currentTimestamp))
{
_timeOffset = gMainFrame.clientInfo.currentTimestamp - new Date().valueOf() / 1000;
}
else
{
_timeOffset = 0;
}
_holdingObject = null;
_pageView = null;
_lastPage = null;
_pageStack = [];
_previousDurationTime = 0;
_latestTimeStamp = 0;
_socket = new Socket();
_socket.addEventListener(Event.CLOSE,closeHandler);
_socket.addEventListener(Event.CONNECT,connectHandler);
_socket.addEventListener(DataEvent.DATA,dataHandler);
_socket.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
_socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR,securityErrorHandler);
_batchTimer = new Timer(10000);
_batchTimer.addEventListener(TimerEvent.TIMER,onBatchTimer,false,0,true);
_batchTimer.start();
}
}
public static function receiveClose() : String
{
var _loc1_:Number = NaN;
var _loc2_:String = null;
_batchTimer.stop();
_batchTimer.removeEventListener(TimerEvent.TIMER,onBatchTimer);
if(_pageView != null)
{
if(_holdingObject != null)
{
_loc1_ = _previousDurationTime;
_previousDurationTime = getTimer();
_loc1_ = _previousDurationTime - _loc1_;
_loc2_ = _holdingObject.time + "\n" + _holdingObject.order + "\n" + Math.round(_loc1_ / 100) + "\n" + _holdingObject.sessionId + "\n" + _holdingObject.uri + "\n" + _holdingObject.uriParams + "\n" + _holdingObject.pop + "\n";
_pageView += _loc2_;
}
return _pageView;
}
return null;
}
public static function onError() : void
{
if(_isExternalAvailable)
{
ExternalInterface.call("reportAnalyticsError","Error Timeout",gMainFrame.clientInfo.sessionId);
}
Debug.log("Sending analytics error",Debug.RED);
}
public static function trackPageview(param1:String, param2:int = -1) : void
{
var _loc3_:Array = null;
var _loc4_:Number = NaN;
var _loc5_:int = 0;
var _loc6_:Number = NaN;
var _loc7_:Boolean = false;
var _loc8_:Object = null;
var _loc9_:String = null;
var _loc10_:String = null;
if(_isExternalAvailable && !_couldNotConnect)
{
_lastPage = param1;
param1 = param1.replace("\'","");
_loc3_ = param1.split(/#/i);
_loc4_ = _previousDurationTime;
_previousDurationTime = getTimer();
_loc4_ = _previousDurationTime - _loc4_;
if(gMainFrame.clientInfo.sessionId == undefined)
{
_containsAnUndefined = true;
_isFromLogin = param2 != -1;
if(_isFromLogin)
{
gMainFrame.clientInfo.sessionId = Math.floor(Math.random() * (int.MAX_VALUE + 1));
}
}
if(_isFromLogin)
{
_loc5_ = 0;
}
else if(gMainFrame.clientInfo.dbUserId == undefined)
{
_loc5_ = -1;
}
else
{
_loc5_ = int(gMainFrame.clientInfo.dbUserId);
}
_loc6_ = Math.floor(new Date().valueOf() / 1000 + _timeOffset);
_loc7_ = _loc6_ - _latestTimeStamp == 0;
_latestTimeStamp = _loc6_;
_loc8_ = {
"userId":_loc5_,
"time":_loc6_,
"order":(_holdingObject != null && _loc7_ ? (_holdingObject.order = _holdingObject.order + 1) : 0),
"duration":Math.round(_loc4_ / 100),
"sessionId":gMainFrame.clientInfo.sessionId,
"uri":_loc3_[0],
"uriParams":(_loc3_[1] != null ? _loc3_[1] : ""),
"pop":(_loc3_[2] != null ? 1 : 0)
};
if(_holdingObject != null)
{
_loc9_ = _holdingObject.userId + "\n" + _holdingObject.time + "\n" + _loc8_.order + "\n" + _loc8_.duration + "\n" + _holdingObject.sessionId + "\n" + _holdingObject.uri + "\n" + _holdingObject.uriParams + "\n" + _holdingObject.pop + "\n";
_holdingObject = {
"userId":_loc8_.userId,
"time":_loc8_.time,
"order":_loc8_.order,
"duration:":-1,
"sessionId":_loc8_.sessionId,
"uri":_loc8_.uri,
"uriParams":_loc8_.uriParams,
"pop":_loc8_.pop
};
if(_pageView != null)
{
_pageView += _loc9_;
}
else
{
_pageView = _loc9_;
}
}
else
{
_holdingObject = _loc8_;
}
_loc10_ = _loc8_.userId + "\n" + _loc8_.time + "\n" + _loc8_.order + "\n" + _loc8_.duration + "\n" + _loc8_.sessionId + "\n" + _loc8_.uri + "\n" + _loc8_.uriParams + "\n" + _loc8_.pop + "\n";
Debug.log(_loc10_,Debug.PINK);
}
}
public static function handleErrorTracking(param1:int, param2:int, param3:int, param4:int, param5:Number, param6:String, param7:String, param8:int) : void
{
if(_socket == null)
{
_socket = new Socket();
_socket.addEventListener(Event.CLOSE,closeHandler);
_socket.addEventListener(Event.CONNECT,errorConnectHandler);
_socket.addEventListener(DataEvent.DATA,dataHandler);
_socket.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
_socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR,securityErrorHandler);
}
else
{
_socket.removeEventListener(Event.CONNECT,connectHandler);
_socket.addEventListener(Event.CONNECT,errorConnectHandler);
}
var _loc9_:Number = Number(gMainFrame.clientInfo.sessionId);
if(gMainFrame.clientInfo.sessionId == undefined)
{
_loc9_ = Math.round(Math.random() * (int.MAX_VALUE + 1));
}
var _loc10_:Number = isNaN(_previousDurationTime) ? 0 : _previousDurationTime;
_previousDurationTime = getTimer();
_loc10_ = _previousDurationTime - _loc10_;
var _loc11_:Object = {
"userId":(param1 == -1 ? (gMainFrame.clientInfo.dbUserId != undefined ? gMainFrame.clientInfo.dbUserId : -1) : param1),
"time":(param2 == -1 ? Math.floor(new Date().valueOf() / 1000 + _timeOffset) : param2),
"order":param3,
"duration":(param4 == -1 ? _loc10_ : param4),
"sessionId":(param5 == -1 ? _loc9_ : param5),
"uri":param6,
"uriParams":param7,
"pop":(param8 == -1 ? 0 : param8)
};
var _loc12_:String = _loc11_.userId + "\n" + _loc11_.time + "\n" + _loc11_.order + "\n" + _loc11_.duration + "\n" + _loc11_.sessionId + "\n" + _loc11_.uri + "\n" + _loc11_.uriParams + "\n" + _loc11_.pop + "\n";
if(_errorPageView != null)
{
_errorPageView += _loc12_;
}
else
{
_errorPageView = _loc12_;
}
if(_errorPageView != null && Boolean(_socket))
{
if(_batchTimer)
{
_batchTimer.reset();
}
_socket.connect(gMainFrame.clientInfo.sbTrackerIp,5050);
}
}
public static function handleOnKickOrLogout() : void
{
if(_isExternalAvailable && _pageView != null)
{
ExternalInterface.call("handleLogout",_pageView);
}
}
public static function push() : void
{
if(Boolean(_pageStack) && _lastPage != null)
{
_pageStack.push(_lastPage + "#pop");
}
}
public static function pop() : void
{
if(Boolean(_pageStack) && Boolean(_pageStack.length))
{
trackPageview(_pageStack.pop());
}
}
public static function flush(param1:Boolean = false) : void
{
if(Boolean(_pageStack) && Boolean(_pageStack.length))
{
if(param1)
{
trackPageview(_pageStack[0]);
}
_pageStack = [];
}
}
public static function completeLastTrackingBatch(param1:Function) : void
{
_lastBatchCallback = param1;
if(_batchTimer)
{
_batchTimer.stop();
onBatchTimer(null);
}
}
private static function onBatchTimer(param1:TimerEvent) : void
{
if(!_isFromLogin)
{
if(gMainFrame.clientInfo.dbUserId == undefined)
{
return;
}
if(gMainFrame.clientInfo.dbUserId % gMainFrame.clientInfo.sbTrackerModulator != 0)
{
_batchTimer.stop();
_batchTimer.removeEventListener(TimerEvent.TIMER,onBatchTimer);
_couldNotConnect = true;
_pageView = null;
_socket = null;
_isExternalAvailable = false;
return;
}
}
if(_lastBatchCallback != null && _retryLimit > 0)
{
_lastBatchCallback();
_lastBatchCallback = null;
}
if(Boolean(_pageView != null) && Boolean(_socket) && (gMainFrame.clientInfo.sessionId != undefined || _isFromLogin))
{
if(_containsAnUndefined && !_isFromLogin)
{
_pageView = _pageView.replace(/undefined/gixm,gMainFrame.clientInfo.sessionId);
_pageView = _pageView.replace(/-1/gixm,gMainFrame.clientInfo.dbUserId);
}
_containsAnUndefined = false;
_batchTimer.reset();
_socket.connect(gMainFrame.clientInfo.sbTrackerIp,5050);
}
else if(_lastBatchCallback != null)
{
_lastBatchCallback();
_lastBatchCallback = null;
}
}
private static function closeHandler(param1:Event) : void
{
_socket.close();
}
private static function connectHandler(param1:Event) : void
{
Debug.log(_pageView,Debug.YELLOW);
_socket.writeUTFBytes(_pageView);
_socket.flush();
_socket.close();
_pageView = null;
_retryLimit = 0;
_batchTimer.start();
if(_lastBatchCallback != null)
{
_lastBatchCallback();
_lastBatchCallback = null;
}
}
private static function errorConnectHandler(param1:Event) : void
{
Debug.log(_errorPageView,Debug.RED);
_socket.writeUTFBytes(_errorPageView);
_socket.flush();
_socket.close();
_errorPageView = null;
_retryLimit = 0;
_socket.addEventListener(Event.CONNECT,connectHandler);
_socket.removeEventListener(Event.CONNECT,errorConnectHandler);
if(_batchTimer)
{
_batchTimer.start();
}
}
private static function dataHandler(param1:DataEvent) : void
{
}
private static function ioErrorHandler(param1:IOErrorEvent) : void
{
if(_lastBatchCallback != null)
{
_lastBatchCallback();
_lastBatchCallback = null;
}
if(_retryLimit < 3)
{
++_retryLimit;
Debug.log("IO error - retrying analytics connection",Debug.RED);
_socket.connect(gMainFrame.clientInfo.sbTrackerIp,5050);
return;
}
_couldNotConnect = true;
}
private static function securityErrorHandler(param1:SecurityErrorEvent) : void
{
if(_lastBatchCallback != null)
{
_lastBatchCallback();
_lastBatchCallback = null;
}
if(_retryLimit < 3)
{
Debug.log("Security error - retrying analytics connection",Debug.RED);
++_retryLimit;
_socket.connect(gMainFrame.clientInfo.sbTrackerIp,5050);
return;
}
if(_batchTimer)
{
_batchTimer.stop();
_batchTimer.removeEventListener(TimerEvent.TIMER,onBatchTimer);
}
_couldNotConnect = true;
_pageView = null;
_socket = null;
onError();
}
}
}
@@ -0,0 +1,163 @@
package com.sbi.client
{
import com.sbi.popup.SBOkPopup;
import flash.display.*;
import flash.events.*;
import flash.utils.Timer;
public class KeepAlive
{
public static var popupLayer:DisplayObjectContainer;
private static var _keepAliveTimer:Timer;
private static var _timeLeftTimer:Timer;
private static var _bInputReceived:Boolean;
private static var _mcsToKeepAlive:Array;
private static var _lastMsgSentToServer:Number;
private static var _inputTimer:Timer;
private static var _kickWarningPopupShowing:Boolean;
private static var _isConnected:Function;
private static var _disconnectClient:Function;
private static var _playIdleWarningSound:Function;
private static var KICK_INTERVAL:int = 300000;
private static var SEND_MSG_INTERVAL:int = 120000;
private static var NOTIFY_USER_INTERVAL:int = 10000;
private static var NOTIFY_USER_TIME:int = 30000;
public function KeepAlive()
{
super();
}
public static function init(param1:DisplayObjectContainer, param2:Function, param3:Function = null, param4:Function = null) : void
{
popupLayer = param1;
_keepAliveTimer = new Timer(SEND_MSG_INTERVAL);
_keepAliveTimer.addEventListener(TimerEvent.TIMER,sendKeepAliveMsg);
_timeLeftTimer = new Timer(NOTIFY_USER_INTERVAL);
_timeLeftTimer.addEventListener(TimerEvent.TIMER,timeLeftTimer);
_timeLeftTimer.start();
_lastMsgSentToServer = new Date().getTime();
_mcsToKeepAlive = new Array();
_isConnected = param2;
_disconnectClient = param3;
_playIdleWarningSound = param4;
}
public static function startKATimer(param1:DisplayObjectContainer) : void
{
param1.addEventListener(MouseEvent.MOUSE_DOWN,inputReceivedHandler,false,0,true);
param1.addEventListener(KeyboardEvent.KEY_DOWN,inputReceivedHandler,false,0,true);
_mcsToKeepAlive.push(param1);
_bInputReceived = true;
sendKeepAliveMsg(null);
_keepAliveTimer.start();
}
public static function stopKATimer(param1:DisplayObjectContainer) : void
{
gMainFrame.server.setXtObject_Str("ka",[],gMainFrame.server.isWorldZone);
_keepAliveTimer.stop();
var _loc2_:int = 0;
while(_loc2_ < _mcsToKeepAlive.length)
{
if(_mcsToKeepAlive[_loc2_] == param1)
{
_mcsToKeepAlive[_loc2_].removeEventListener(MouseEvent.MOUSE_DOWN,inputReceivedHandler);
_mcsToKeepAlive[_loc2_].removeEventListener(KeyboardEvent.KEY_DOWN,inputReceivedHandler);
_mcsToKeepAlive.splice(_loc2_,1);
break;
}
_loc2_++;
}
}
public static function restartTimeLeftTimer() : void
{
if(_timeLeftTimer)
{
_lastMsgSentToServer = new Date().getTime();
_timeLeftTimer.stop();
_timeLeftTimer.start();
}
}
private static function sendKeepAliveMsg(param1:TimerEvent) : void
{
if(_bInputReceived)
{
gMainFrame.server.setXtObject_Str("ka",[],gMainFrame.server.isWorldZone);
_lastMsgSentToServer = new Date().getTime();
_bInputReceived = false;
}
}
private static function timeLeftTimer(param1:TimerEvent) : void
{
var _loc3_:DisplayObject = null;
var _loc2_:Number = new Date().getTime() - _lastMsgSentToServer;
if(!_kickWarningPopupShowing && _loc2_ > KICK_INTERVAL - NOTIFY_USER_TIME)
{
_loc3_ = new SBOkPopup(popupLayer,"Are you still there? Click OK to keep playing.",true,onKickWarningPopup);
_kickWarningPopupShowing = true;
if(_playIdleWarningSound != null)
{
_playIdleWarningSound();
}
if(gMainFrame.userInfo.isModerator)
{
_bInputReceived = true;
sendKeepAliveMsg(null);
_kickWarningPopupShowing = false;
SBOkPopup.destroyInParentChain(_loc3_);
}
}
if(_loc2_ > KICK_INTERVAL)
{
if(_isConnected())
{
if(_disconnectClient != null)
{
_disconnectClient();
}
}
}
}
private static function onKickWarningPopup(param1:MouseEvent) : void
{
_bInputReceived = true;
sendKeepAliveMsg(null);
param1.stopPropagation();
SBOkPopup.destroyInParentChain(param1.target.parent);
_kickWarningPopupShowing = false;
}
public static function inputReceivedHandler(param1:Event) : void
{
if(!_bInputReceived)
{
_bInputReceived = true;
}
if(new Date().getTime() - _lastMsgSentToServer > SEND_MSG_INTERVAL)
{
sendKeepAliveMsg(null);
}
}
}
}
@@ -0,0 +1,962 @@
package com.sbi.client
{
import com.sbi.debug.DebugUtility;
import flash.events.EventDispatcher;
import flash.external.ExternalInterface;
import it.gotoandplay.smartfoxserver.SFSEvent;
import it.gotoandplay.smartfoxserver.SmartFoxClient;
import it.gotoandplay.smartfoxserver.data.Room;
import it.gotoandplay.smartfoxserver.data.User;
public class SFClient extends EventDispatcher
{
public static const STATUS_ONLINE:int = 1;
public static const STATUS_OFFLINE_ACTIVE:int = 0;
public static const STATUS_OFFLINE_ARCHIVED:int = -1;
public static const STATUS_OFFLINE_UNKNOWN:int = -2;
public static const INIT_ROOM_ID:int = 1;
protected var _sfs:SmartFoxClient;
protected var _serverIps:Array;
protected var _blueboxIps:Array;
protected var _serverIp:String;
protected var _serverPort:int;
private var _isConnected:Boolean;
private var _isLoggedIn:Boolean;
private var _isWorldLoggedIn:Boolean;
private var _currSubRoom:SFRoom;
private var _currRoom:SFRoom;
private var _currentPrimaryRoomId:int = -1;
private var _currentSubRoomId:int = -1;
private var _currentPrimaryRoomUsers:Object;
private var _currentSubRoomUsers:Object;
private var _triggerWhenWorldXtReadyCmd:String;
private var _triggerWhenWorldXtReadyObj:Array;
private var _roomIds:Array;
private var _userName:String;
private var _myUser:User;
private var _gemCount:int;
private var _password:String;
private var _zone:String;
private var _hashKey:String;
private var _isWorldZone:Boolean;
private var _pingTimeAvg:uint;
private var _pingTimeTotal:uint;
private var _pingTimeCount:uint;
public function SFClient()
{
super();
this._roomIds = new Array();
this.setUpServer();
}
private function setUpServer() : void
{
this._isConnected = false;
this._hashKey = null;
this._isLoggedIn = false;
this._isWorldLoggedIn = false;
this._sfs = new SmartFoxClient(false);
this._sfs.smartConnect = false;
this._sfs.addEventListener(SFSEvent.onConnection,this.onConnection);
this._sfs.addEventListener(SFSEvent.onConnectionLost,this.onConnectionLost);
this._sfs.addEventListener(SFSEvent.onLogin,this.onLogin);
this._sfs.addEventListener(SFSEvent.onExtensionResponse,this.onExtensionResponse);
this._sfs.addEventListener(SFSEvent.onLogout,this.onLogout);
this._sfs.addEventListener(SFSEvent.onRoomListUpdate,this.onRoomListUpdate);
this._sfs.addEventListener(SFSEvent.onRoomAdded,this.onRoomAdded);
this._sfs.addEventListener(SFSEvent.onCreateRoomError,this.onCreateRoomError);
this._sfs.addEventListener(SFSEvent.onRoomDeleted,this.onRoomDeleted);
this._sfs.addEventListener(SFSEvent.onUserEnterRoom,this.onUserEnterRoom);
this._sfs.addEventListener(SFSEvent.onUserLeaveRoom,this.onUserLeaveRoom);
this._sfs.addEventListener(SFSEvent.onRoomLeft,this.onRoomLeft);
this._sfs.addEventListener(SFSEvent.onUserCountChange,this.onUserCountChange);
this._sfs.addEventListener(SFSEvent.onBuddyList,this.onBuddyList);
this._sfs.addEventListener(SFSEvent.onBuddyListError,this.onBuddyListError);
this._sfs.addEventListener(SFSEvent.onBuddyListUpdate,this.onBuddyListUpdate);
this._sfs.addEventListener(SFSEvent.onBuddyPermissionRequest,this.onBuddyPermissionRequest);
this._sfs.addEventListener(SFSEvent.onBuddyRoom,this.onBuddyRoom);
this._sfs.addEventListener(SFSEvent.onAdminMessage,this.onAdminMessage);
this._sfs.addEventListener(SFSEvent.onModeratorMessage,this.onModeratorMessage);
this._sfs.addEventListener(SFSEvent.onPrivateMessage,this.onPrivateMessage);
this._sfs.addEventListener(SFSEvent.onPublicMessage,this.onPublicMessage);
this._sfs.addEventListener(SFSEvent.onRandomKey,this.onRandomKey);
}
public function setServerConfig(param1:Array, param2:int, param3:Array, param4:int, param5:String) : void
{
this._serverIps = param1;
this._serverIp = param1[0];
this._serverPort = param2;
this._blueboxIps = param3;
this._sfs.blueBoxIpAddress = param3[0];
this._sfs.blueBoxPort = param4;
this._sfs.debug = param5 == "true";
}
public function setNewServer(param1:int) : void
{
if(!this.autoAttemptHttp)
{
this._serverIp = this._serverIps[param1];
}
else
{
this._sfs.blueBoxIpAddress = this._serverIp = this._blueboxIps[param1];
}
}
public function switchServerNode(param1:String) : void
{
this._serverIp = param1;
if(this.autoAttemptHttp)
{
this._sfs.blueBoxIpAddress = this._serverIp;
}
}
public function isBlueboxMode() : Boolean
{
return this._sfs.getConnectionMode() == SmartFoxClient.CONNECTION_MODE_HTTP;
}
public function connect() : void
{
if(!this._isConnected)
{
this._sfs.connect(this._serverIp,this._serverPort);
}
else
{
this.getKey();
}
}
public function logIn(param1:String, param2:String, param3:String) : void
{
if(this._hashKey == null)
{
return;
}
this._userName = param2;
this._zone = param1;
this._isWorldZone = this._zone == "sbiLogin";
this._password = param3;
this._sfs.login(this._zone,param2,param3);
}
public function logOut() : void
{
this._sfs.logout();
}
public function disconnect() : void
{
this._isLoggedIn = false;
this._isWorldLoggedIn = false;
this._isConnected = false;
this._hashKey = null;
this._sfs.disconnect();
}
public function get serverIps() : Array
{
return this._serverIps;
}
public function get serverIp() : String
{
return this._serverIp;
}
public function get serverPort() : int
{
return this._sfs.port;
}
public function get blueboxIps() : Array
{
return this._blueboxIps;
}
public function get blueboxServerIp() : String
{
return this._sfs.blueBoxIpAddress;
}
public function get blueboxServerPort() : int
{
return this._sfs.blueBoxPort;
}
public function get isWorldXtReady() : Boolean
{
return this._isWorldLoggedIn;
}
public function triggerCmdWhenWorldXtReady(param1:String, param2:Array) : void
{
this._triggerWhenWorldXtReadyCmd = param1;
this._triggerWhenWorldXtReadyObj = param2;
}
public function triggerWorldXtReadyCmd() : void
{
if(this._triggerWhenWorldXtReadyCmd != null && this._triggerWhenWorldXtReadyObj != null)
{
this.setXtObject_Str(this._triggerWhenWorldXtReadyCmd,this._triggerWhenWorldXtReadyObj);
this._triggerWhenWorldXtReadyCmd = null;
this._triggerWhenWorldXtReadyObj = null;
}
}
public function setXtObject_Str(param1:String, param2:Array, param3:Boolean = true, param4:Boolean = false, param5:Boolean = true) : void
{
if(param2 == null)
{
param2 = [];
}
var _loc6_:String = param3 ? "o" : "a";
this._sfs.sendXtMessage(_loc6_,param1,param2,SmartFoxClient.XTMSG_TYPE_STR,this.getCurrentRoomId(param4));
if(param5)
{
KeepAlive.restartTimeLeftTimer();
}
}
public function setXtObject_XML(param1:String, param2:String, param3:Object, param4:Boolean = false) : void
{
if(param3 == null)
{
param3 = {};
}
this._sfs.sendXtMessage(param1,param2,param3,SmartFoxClient.XTMSG_TYPE_XML,this.getCurrentRoomId(param4));
}
public function setXtObject_JSON(param1:String, param2:Object, param3:Boolean = false) : void
{
if(param2 == null)
{
param2 = {};
}
this._sfs.sendXtMessage("a",param1,param2,SmartFoxClient.XTMSG_TYPE_JSON,this.getCurrentRoomId(param3));
}
public function getKey() : void
{
var _loc1_:SFEvent = null;
if(this._hashKey == null)
{
this._sfs.getRandomKey();
}
else
{
_loc1_ = new SFEvent(SFEvent.ON_CONNECT);
_loc1_.status = true;
dispatchEvent(_loc1_);
}
}
public function createRoom(param1:String, param2:uint, param3:uint, param4:Boolean, param5:Boolean, param6:String, param7:String) : void
{
throw new Error("createRoom on client should not be used if at all possible!");
}
public function setToJoinIRG(param1:Boolean) : void
{
this._currentSubRoomId = param1 ? 0 : -1;
}
public function leaveRoom(param1:int) : void
{
this._sfs.leaveRoom(param1);
}
public function leaveCurrentRoom(param1:Boolean = false) : void
{
this._sfs.leaveRoom(param1 ? this._currentSubRoomId : this._currentPrimaryRoomId);
this._currentSubRoomId = -1;
}
public function sendMessage(param1:String, param2:int = -2, param3:int = -1) : void
{
if(param3 >= 0)
{
this._sfs.sendPrivateMessage(param1,param3,param2);
}
else
{
if(param2 == -2)
{
param2 = this._currentPrimaryRoomId;
}
this._sfs.sendPublicMessage(param1,param2);
KeepAlive.restartTimeLeftTimer();
}
}
public function isInMyRoom(param1:int, param2:Boolean) : Boolean
{
if(!param2 && this._currentPrimaryRoomUsers == null)
{
return false;
}
if(param2 && this._currentSubRoomUsers == null)
{
return false;
}
return Boolean(param2 ? this._currentSubRoomUsers[param1] != undefined : this._currentPrimaryRoomUsers[param1] != undefined);
}
public function loadBuddyList() : void
{
this._sfs.loadBuddyList();
}
public function getBuddyById(param1:int) : Object
{
return this._sfs.getBuddyById(param1);
}
public function getBuddyByName(param1:String) : Object
{
return this._sfs.getBuddyByName(param1);
}
public function sendBuddyPermissionResponse(param1:Boolean, param2:String) : void
{
this._sfs.sendBuddyPermissionResponse(param1,param2);
}
public function setBuddyBlockStatus(param1:String, param2:Boolean) : void
{
this._sfs.setBuddyBlockStatus(param1,param2);
}
public function getBuddyRoomByName(param1:String) : void
{
var _loc2_:Object = this._sfs.getBuddyByName(param1);
this._sfs.getBuddyRoom(_loc2_);
}
public function getBuddyRoomById(param1:int) : void
{
var _loc2_:Object = this._sfs.getBuddyById(param1);
this._sfs.getBuddyRoom(_loc2_);
}
public function getBuddyRoom(param1:Object) : void
{
var _loc3_:Object = null;
if(!param1)
{
throw new Error("Invalid buddy obj used to request buddy room! userobj:" + param1);
}
if(!param1.hasOwnProperty("id"))
{
throw new Error("Invalid buddy obj used to request buddy room! userobj.hasOwnProperty(\"id\"):" + param1.hasOwnProperty("id"));
}
var _loc2_:Boolean = false;
for each(_loc3_ in this._sfs.buddyList)
{
if(_loc3_.id == param1.id)
{
_loc2_ = true;
break;
}
}
if(_loc2_)
{
this._sfs.getBuddyRoom(_loc3_);
return;
}
throw new Error("Invalid buddy obj used to request buddy room! Could not find match in client buddy list. userobj.id:" + param1.id);
}
public function removeBuddy(param1:String) : void
{
this._sfs.removeBuddy(param1);
}
public function getCurrentRoom(param1:Boolean = false) : SFRoom
{
return param1 ? this._currSubRoom : this._currRoom;
}
public function getCurrentRoomId(param1:Boolean = false) : int
{
if(!param1)
{
return this._currentPrimaryRoomId;
}
if(this._currentSubRoomId <= 0)
{
throw new Error("Attempt to send message to sub room without valid subRoomId! (no in-room game room currently joined?)");
}
return this._currentSubRoomId;
}
public function getPvpSubRoomId() : int
{
return this._currentSubRoomId;
}
public function setCurrSubRoomId(param1:int) : void
{
if(this._currentSubRoomId != -1)
{
DebugUtility.debugTrace("WARNING: setting currSubRoomId to " + param1 + " but _currSubRoomId was not -1. It was " + this._currentSubRoomId);
}
this._currentSubRoomId = param1;
}
public function getCurrentRoomName(param1:Boolean = false) : String
{
var _loc2_:SFRoom = this.getCurrentRoom(param1);
if(!_loc2_)
{
return null;
}
return _loc2_.name;
}
public function setInitRoom() : void
{
var _loc1_:Array = this._sfs.getAllRooms();
if(_loc1_.length > 0)
{
return;
}
_loc1_[INIT_ROOM_ID] = new Room(INIT_ROOM_ID,"_init",10000,0,false,false,false,true);
}
public function setRoomList(param1:Object) : void
{
var _loc6_:Room = null;
var _loc8_:int = 0;
var _loc2_:Array = this._sfs.getAllRooms();
_loc2_.splice(0,_loc2_.length);
var _loc3_:* = 2;
var _loc4_:int = int(param1[_loc3_++]);
var _loc5_:int = 0;
while(_loc5_ < _loc4_)
{
_loc8_ = int(param1[_loc3_++]);
_loc2_[_loc8_] = new Room(_loc8_,param1[_loc3_++],int(param1[_loc3_++]),0,param1[_loc3_++] == "1",param1[_loc3_++] == "1",false,_loc5_ < 1,int(param1[_loc3_++]));
_loc5_++;
}
this._roomIds.splice(0,this._roomIds.length);
for each(_loc6_ in _loc2_)
{
this._roomIds.push(_loc6_.getId());
}
if(this._currentPrimaryRoomId != -1)
{
this.setAPIUserList(this._currentPrimaryRoomId,this._currentPrimaryRoomUsers);
}
else if(this._roomIds.length == 1)
{
this._currentPrimaryRoomId = this.roomIds[0];
}
if(this._currentSubRoomId > 0)
{
this.setAPIUserList(this._currentSubRoomId,this._currentSubRoomUsers);
}
var _loc7_:SFEvent = new SFEvent(SFEvent.ON_ROOM_LIST);
_loc7_.status = true;
dispatchEvent(_loc7_);
}
public function setAPIUserList(param1:int, param2:Object) : void
{
var _loc5_:String = null;
var _loc3_:Room = this._sfs.getRoom(param1);
if(!_loc3_)
{
return;
}
var _loc4_:Array = _loc3_.getUserList();
if(!_loc4_)
{
return;
}
_loc4_.splice(0,_loc4_.length);
if(!param2)
{
return;
}
for(_loc5_ in param2)
{
_loc4_[_loc5_] = param2[_loc5_];
}
}
private function onConnection(param1:SFSEvent) : void
{
var _loc3_:SFEvent = null;
this._currentPrimaryRoomId = -1;
this._currentSubRoomId = -1;
if(ExternalInterface.available)
{
ExternalInterface.call("mrc",["dm","SFClient onConnection"]);
}
var _loc2_:Boolean = Boolean(param1.params.success);
if(_loc2_)
{
this._isConnected = true;
this.getKey();
}
else
{
_loc3_ = new SFEvent(SFEvent.ON_CONNECT);
_loc3_.status = false;
dispatchEvent(_loc3_);
}
}
private function onConnectionLost(param1:SFSEvent) : void
{
this._isConnected = false;
this._hashKey = null;
this._isLoggedIn = false;
this._isWorldLoggedIn = false;
this._currentPrimaryRoomId = -1;
this._currentSubRoomId = -1;
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_CONNECTION_LOST);
_loc2_.status = true;
dispatchEvent(_loc2_);
}
private function onLogin(param1:SFSEvent) : void
{
var _loc2_:Boolean = Boolean(param1.params.success);
if(_loc2_)
{
this._isLoggedIn = true;
}
this._currentPrimaryRoomId = -1;
this._currentSubRoomId = -1;
var _loc3_:SFEvent = new SFEvent(SFEvent.ON_LOGIN);
_loc3_.status = _loc2_;
_loc3_.userName = param1.params.name;
dispatchEvent(_loc3_);
}
private function onExtensionResponse(param1:SFSEvent) : void
{
var _loc2_:Object = param1.params.dataObj;
var _loc3_:SFEvent = null;
if(_loc2_._cmd == "login")
{
if(ExternalInterface.available)
{
ExternalInterface.call("mrc",["dm","SFClient xtResponse - ON_LOGIN"]);
}
_loc3_ = new SFEvent(SFEvent.ON_LOGIN);
_loc3_.status = true;
_loc3_.obj = _loc2_.params;
this._currentPrimaryRoomId = -1;
this._currentSubRoomId = -1;
if(_loc2_.status == "1")
{
this._myUser = new User(this._sfs.myUserId = _loc2_.params.userId,this._sfs.myUserName = _loc2_.params.userName);
_loc3_.userName = _loc2_.params.userName;
this._isLoggedIn = true;
this._isWorldLoggedIn = true;
}
else
{
_loc3_.status = false;
_loc3_.message = _loc2_.message;
_loc3_.statusId = _loc2_.statusId;
}
dispatchEvent(_loc3_);
}
else
{
_loc3_ = new SFEvent(SFEvent.ON_XT_REPLY);
_loc3_.status = true;
_loc3_.obj = param1.params.dataObj;
dispatchEvent(_loc3_);
}
}
private function onLogout(param1:SFSEvent) : void
{
this._isLoggedIn = false;
this._isWorldLoggedIn = false;
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_LOGOUT);
_loc2_.status = true;
dispatchEvent(_loc2_);
}
private function onRoomListUpdate(param1:SFSEvent) : void
{
var _loc2_:Room = null;
this._roomIds.splice(0,this._roomIds.length);
for each(_loc2_ in param1.params.roomList)
{
this._roomIds.push(_loc2_.getId());
}
if(this._currentPrimaryRoomId != -1)
{
this.setAPIUserList(this._currentPrimaryRoomId,this._currentPrimaryRoomUsers);
}
else if(this._roomIds.length == 1)
{
this._currentPrimaryRoomId = this.roomIds[0];
}
if(this._currentSubRoomId > 0)
{
this.setAPIUserList(this._currentSubRoomId,this._currentSubRoomUsers);
}
var _loc3_:SFEvent = new SFEvent(SFEvent.ON_ROOM_LIST);
_loc3_.status = true;
dispatchEvent(_loc3_);
}
private function onRoomAdded(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_ROOM_CREATED);
_loc2_.status = true;
_loc2_.roomId = param1.params.room.getId();
dispatchEvent(_loc2_);
}
private function onRoomDeleted(param1:SFSEvent) : void
{
this.setAPIUserList(this._currentPrimaryRoomId,this._currentPrimaryRoomUsers);
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_ROOM_DELETED);
_loc2_.status = true;
if(Boolean(param1) && Boolean(param1.params) && Boolean(param1.params.room))
{
_loc2_.roomId = param1.params.room.getId();
}
dispatchEvent(_loc2_);
}
private function onCreateRoomError(param1:SFSEvent) : void
{
this._currentSubRoomUsers = null;
this.setAPIUserList(this._currentSubRoomId,this._currentSubRoomUsers);
this._currentSubRoomId = -1;
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_ROOM_CREATED);
_loc2_.status = false;
_loc2_.message = param1.params.error;
dispatchEvent(_loc2_);
}
public function handleRoomJoin(param1:SFRoom) : void
{
var _loc4_:Room = null;
var _loc2_:int = param1.id;
if(this._currentSubRoomId == 0)
{
this._currSubRoom = param1;
this._currentSubRoomId = _loc2_;
}
else
{
this._currRoom = param1;
this._currentPrimaryRoomId = _loc2_;
}
if(ExternalInterface.available)
{
ExternalInterface.call("mrc",["dm","handleRoomJoin called"]);
}
var _loc3_:Array = this._sfs.getAllRooms();
(_loc3_[_loc2_] = new Room(_loc2_,param1.name,param1.maxUsers,param1.maxSpectators,param1.isTemp,param1.isGame,param1.isPrivate,param1.isLimbo,param1.users,param1.spectators)).addUser(this._myUser,this._myUser.getId());
this._sfs.activeRoomId = _loc2_;
var _loc5_:SFEvent = new SFEvent(SFEvent.ON_JOIN_ROOM);
_loc5_.status = true;
_loc5_.roomId = _loc2_;
_loc5_.obj = {};
_loc5_.obj.room = param1;
_loc5_.obj.subRoom = this._currSubRoom;
dispatchEvent(_loc5_);
}
public function handleRoomJoinError(param1:String, param2:String = "") : void
{
var _loc3_:SFEvent = new SFEvent(SFEvent.ON_JOIN_ROOM);
_loc3_.status = false;
_loc3_.message = param1;
_loc3_.obj = {};
_loc3_.obj.roomFull = param1 == "This room is currently full";
_loc3_.obj.denOwner = param2;
dispatchEvent(_loc3_);
}
public function handleSubRoomExit() : void
{
if(this._currentSubRoomId <= 0)
{
throw new Error("Trying to leave a sub room when not in one?");
}
this._currentSubRoomId = -1;
this._currSubRoom = null;
}
private function onRoomLeft(param1:SFSEvent) : void
{
if(this._currentSubRoomId == 0)
{
throw new Error("Left a room while in the middle of making a sub room?!");
}
if(param1.params.roomId == this._currentSubRoomId)
{
this._currentSubRoomUsers = null;
this._currentSubRoomId = -1;
}
else
{
this._currentPrimaryRoomUsers = null;
this.setAPIUserList(this._currentPrimaryRoomId,this._currentPrimaryRoomUsers);
}
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_LEFT_ROOM);
_loc2_.status = true;
_loc2_.roomId = param1.params.roomId;
dispatchEvent(_loc2_);
}
private function onUserEnterRoom(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_USER_ENTERED_ROOM);
_loc2_.status = true;
_loc2_.userId = param1.params.user.getId();
_loc2_.userName = param1.params.user.getName();
_loc2_.roomId = param1.params.roomId;
if(_loc2_.roomId == this._currentPrimaryRoomId)
{
this._currentPrimaryRoomUsers[_loc2_.userId] = param1.params.user;
this.setAPIUserList(this._currentPrimaryRoomId,this._currentPrimaryRoomUsers);
}
else if(_loc2_.roomId == this._currentSubRoomId)
{
this._currentSubRoomUsers[_loc2_.userId] = param1.params.user;
this.setAPIUserList(this._currentSubRoomId,this._currentSubRoomUsers);
}
dispatchEvent(_loc2_);
}
private function onUserLeaveRoom(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_USER_LEFT_ROOM);
_loc2_.status = true;
_loc2_.userId = param1.params.userId;
_loc2_.roomId = param1.params.roomId;
if(_loc2_.roomId == this._currentPrimaryRoomId)
{
delete this._currentPrimaryRoomUsers[_loc2_.userId];
this.setAPIUserList(this._currentPrimaryRoomId,this._currentPrimaryRoomUsers);
}
else if(_loc2_.roomId == this._currentSubRoomId)
{
delete this._currentSubRoomUsers[_loc2_.userId];
this.setAPIUserList(this._currentSubRoomId,this._currentSubRoomUsers);
}
dispatchEvent(_loc2_);
}
private function onUserCountChange(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_ROOM_POPULATION_CHANGE);
_loc2_.status = true;
_loc2_.roomId = param1.params.room.getId();
dispatchEvent(_loc2_);
}
private function onBuddyList(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_BUDDY_LIST);
_loc2_.status = true;
_loc2_.obj = param1.params.list;
_loc2_.message = param1.params.error;
dispatchEvent(_loc2_);
}
private function onBuddyListError(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_BUDDY_LIST);
_loc2_.status = false;
_loc2_.message = param1.params.error;
dispatchEvent(_loc2_);
}
private function onBuddyListUpdate(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_BUDDY_LIST_UPDATE);
_loc2_.status = true;
_loc2_.userName = param1.params.buddy.name;
_loc2_.obj = param1.params.buddy;
_loc2_.message = param1.params.error;
dispatchEvent(_loc2_);
}
private function onBuddyPermissionRequest(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_BUDDY_REQUEST);
_loc2_.status = true;
_loc2_.userName = param1.params.sender;
dispatchEvent(_loc2_);
}
private function onBuddyRoom(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_BUDDY_ROOM);
_loc2_.status = true;
_loc2_.roomId = param1.params.idList[0];
dispatchEvent(_loc2_);
}
private function onAdminMessage(param1:SFSEvent) : void
{
DebugUtility.debugTrace("onAdminMessage:" + param1.params.message);
}
private function onModeratorMessage(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_CHAT_MESSAGE);
_loc2_.status = true;
_loc2_.message = param1.params.message;
dispatchEvent(_loc2_);
}
private function onPrivateMessage(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_CHAT_MESSAGE);
_loc2_.status = true;
_loc2_.message = param1.params.message;
dispatchEvent(_loc2_);
}
private function onPublicMessage(param1:SFSEvent) : void
{
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_CHAT_MESSAGE);
_loc2_.status = true;
_loc2_.message = param1.params.message;
dispatchEvent(_loc2_);
}
private function onRandomKey(param1:SFSEvent) : void
{
this._hashKey = param1.params.key;
var _loc2_:SFEvent = new SFEvent(SFEvent.ON_CONNECT);
_loc2_.status = true;
dispatchEvent(_loc2_);
}
public function get autoAttemptHttp() : Boolean
{
return this._sfs.smartConnect;
}
public function set autoAttemptHttp(param1:Boolean) : void
{
this._sfs.smartConnect = param1;
}
public function get isWorldZone() : Boolean
{
return this._isWorldZone;
}
public function get userId() : int
{
return this._sfs.myUserId;
}
public function get userName() : String
{
return this._sfs.myUserName;
}
public function get gemCount() : int
{
return this._gemCount;
}
public function set gemCount(param1:int) : void
{
this._gemCount = param1;
}
public function get signInUserName() : String
{
return this._userName;
}
public function get password() : String
{
return this._password;
}
public function get roomIds() : Array
{
return this._roomIds;
}
public function get buddyList() : Array
{
return this._sfs.buddyList;
}
public function get rawProtocolSeparator() : String
{
return this._sfs.rawProtocolSeparator;
}
public function get isLoggedIn() : Boolean
{
return this._isLoggedIn;
}
public function get isConnected() : Boolean
{
return this._isConnected;
}
public function getIsConnected() : Boolean
{
return this._isConnected;
}
public function get hashKey() : String
{
return this._hashKey;
}
}
}
@@ -0,0 +1,75 @@
package com.sbi.client
{
import flash.events.Event;
public class SFEvent extends Event
{
public static const ON_CONNECT:String = "OnConnect";
public static const ON_LOGIN:String = "OnLogin";
public static const ON_LOGOUT:String = "OnLogOut";
public static const ON_CONNECTION_LOST:String = "OnConectionLost";
public static const ON_CHAT_MESSAGE:String = "OnChatMessage";
public static const ON_RECEIVED_OBJECT:String = "OnReceivedObject";
public static const ON_ROOM_LIST:String = "OnRoomList";
public static const ON_CREATE_ROOM:String = "OnCreateRoom";
public static const ON_ROOM_CREATED:String = "onRoomCreated";
public static const ON_JOIN_ROOM:String = "OnJoinRoom";
public static const ON_LEFT_ROOM:String = "OnLeftRoom";
public static const ON_USER_ENTERED_ROOM:String = "OnUserEnteredRoom";
public static const ON_USER_LEFT_ROOM:String = "OnUserLeftRoom";
public static const ON_ROOM_POPULATION_CHANGE:String = "onRoomPopulationChange";
public static const ON_BUDDY_LIST:String = "onBuddyList";
public static const ON_BUDDY_LIST_UPDATE:String = "onBuddyListUpdate";
public static const ON_BUDDY_REQUEST:String = "onBuddyRequest";
public static const ON_BUDDY_ROOM:String = "onBuddyRoom";
public static const ON_XT_REPLY:String = "OnXtReply";
public static const ON_ROOM_DELETED:String = "onRoomDeleted";
public static const ON_ROOM_VAR:String = "OnRoomVar";
public var status:Boolean;
public var message:String;
public var statusId:int;
public var userId:int;
public var roomId:int;
public var userName:String;
public var obj:*;
public function SFEvent(param1:String)
{
super(param1);
}
override public function clone() : Event
{
return new SFEvent(type);
}
}
}
@@ -0,0 +1,32 @@
package com.sbi.client
{
public class SFRoom
{
public var name:String;
public var id:int;
public var users:int;
public var maxUsers:int;
public var spectators:int;
public var maxSpectators:int;
public var isPrivate:Boolean;
public var isGame:Boolean;
public var isLimbo:Boolean;
public var isTemp:Boolean;
public function SFRoom()
{
super();
}
}
}
@@ -0,0 +1,109 @@
package com.sbi.corelib
{
import com.sbi.debug.DebugUtility;
import flash.utils.getDefinitionByName;
public class Utils
{
public function Utils()
{
super();
}
public static function getDefByName(param1:String) : Class
{
var returnClass:Class = null;
var getClassName:String = param1;
try
{
returnClass = getDefinitionByName(getClassName) as Class;
}
catch(re:ReferenceError)
{
DebugUtility.debugTrace("WARNING: Missing class definition \"" + getClassName + "\"!");
returnClass = null;
}
return returnClass;
}
public static function damerauLevenshteinDistance(param1:Array, param2:Array, param3:int) : int
{
var _loc11_:int = 0;
var _loc12_:int = 0;
var _loc13_:int = 0;
var _loc14_:int = 0;
var _loc15_:int = 0;
var _loc4_:int = param1.length + param2.length;
var _loc5_:SimpleMatrix = new SimpleMatrix(param1.length + 2,param2.length + 2);
_loc5_[0][0] = _loc4_;
var _loc6_:int = 0;
while(_loc6_ <= param1.length)
{
_loc5_[_loc6_ + 1][1] = _loc6_;
_loc5_[_loc6_ + 1][0] = _loc4_;
_loc6_++;
}
var _loc7_:int = 0;
while(_loc7_ <= param2.length)
{
_loc5_[1][_loc7_ + 1] = _loc7_;
_loc5_[0][_loc7_ + 1] = _loc4_;
_loc7_++;
}
var _loc8_:Array = new Array(param3);
var _loc9_:int = 0;
while(_loc9_ < param3)
{
_loc8_[_loc9_] = 0;
_loc9_++;
}
var _loc10_:int = 1;
while(_loc10_ <= param1.length)
{
_loc11_ = 0;
_loc12_ = 1;
while(_loc12_ <= param2.length)
{
_loc13_ = int(_loc8_[param2[_loc12_ - 1]]);
_loc14_ = _loc11_;
_loc15_ = param1[_loc10_ - 1] == param2[_loc12_ - 1] ? 0 : 1;
if(_loc15_ == 0)
{
_loc11_ = _loc12_;
}
_loc5_[_loc10_ + 1][_loc12_ + 1] = Math.min(_loc5_[_loc10_][_loc12_] + _loc15_,_loc5_[_loc10_ + 1][_loc12_] + 1,_loc5_[_loc10_][_loc12_ + 1] + 1,_loc5_[_loc13_][_loc14_] + (_loc10_ - _loc13_ - 1) + 1 + (_loc12_ - _loc14_ - 1));
_loc12_++;
}
_loc8_[param1[_loc10_ - 1]] = _loc10_;
_loc10_++;
}
return _loc5_[param1.length + 1][param2.length + 1];
}
}
}
dynamic class SimpleMatrix extends Array
{
public var rows:int;
public var cols:int;
public function SimpleMatrix(param1:int = 0, param2:int = -1)
{
super(param1);
if(param2 == -1)
{
param2 = param1;
}
var _loc3_:int = 0;
while(_loc3_ < param1)
{
this[_loc3_] = new Array(param2);
_loc3_++;
}
this.rows = param1;
this.cols = param2;
}
}
@@ -0,0 +1,358 @@
package com.sbi.corelib.audio
{
import flash.net.SharedObject;
import flash.utils.Dictionary;
public class SBAudio
{
private static var _cachedSounds:Dictionary;
private static var _sharedObj:SharedObject;
private static var _muteCallback:Function;
private static var _sounds:Array = [];
private static var _music:Array = [];
private static var _isMusicMuted:Boolean = false;
private static var _areSoundsMuted:Boolean = false;
private static var _isInitialized:Boolean = false;
public function SBAudio()
{
super();
}
public static function init(param1:Object, param2:Function) : void
{
var _loc3_:String = null;
var _loc4_:Object = null;
_cachedSounds = new Dictionary();
for(_loc3_ in param1)
{
_loc4_ = param1[_loc3_];
addCachedSound(_loc3_,_loc4_.className,_loc4_.volume);
}
_muteCallback = param2;
_isInitialized = true;
}
public static function setupSharedObject(param1:SharedObject) : void
{
if(_sharedObj == null && param1 != null)
{
_sharedObj = param1;
if(_sharedObj.data.isMusicMuted)
{
muteMusic();
}
if(_sharedObj.data.areSoundsMuted)
{
muteSounds();
}
}
}
public static function addCachedSound(param1:String, param2:Class, param3:Number = 0.3) : void
{
_cachedSounds[param1] = new SBSound(param2,false,param3);
}
public static function get isMusicMuted() : Boolean
{
return _isMusicMuted;
}
public static function get areSoundsMuted() : Boolean
{
return _areSoundsMuted;
}
public static function get isInitialized() : Boolean
{
return _isInitialized;
}
public static function addSound(param1:SBSound) : void
{
_sounds.push(param1);
}
public static function removeSound(param1:SBSound) : void
{
_sounds.splice(_sounds.indexOf(param1),1);
}
public static function addMusic(param1:Object) : void
{
_music.push(param1);
}
public static function removeMusic(param1:Object) : void
{
_music.splice(_music.indexOf(param1),1);
}
public static function playCachedSound(param1:String, param2:int = 1) : void
{
var _loc3_:SBSound = _cachedSounds[param1];
if(!_loc3_)
{
return;
}
_loc3_.play(0,param2);
}
public static function stopCachedSound(param1:String) : void
{
var _loc2_:SBSound = _cachedSounds[param1];
if(!_loc2_)
{
return;
}
_loc2_.stop();
}
public static function setVolumeAll(param1:Number) : void
{
setVolumeSounds(param1);
setVolumeMusic(param1);
}
public static function setVolumeSounds(param1:Number) : void
{
var _loc2_:SBSound = null;
for each(_loc2_ in _sounds)
{
_loc2_.volume = param1;
}
}
public static function getVolumeMusic() : Number
{
var _loc1_:Number = NaN;
var _loc2_:Object = null;
for each(_loc2_ in _music)
{
_loc1_ = Number(_loc2_.volume);
}
return _loc1_;
}
public static function setVolumeMusic(param1:Number) : void
{
var _loc2_:Object = null;
for each(_loc2_ in _music)
{
_loc2_.volume = param1;
}
}
private static function setSharedObjMusicMuted(param1:Boolean) : void
{
if(_sharedObj != null && _sharedObj.data.isMusicMuted != param1)
{
_sharedObj.data.isMusicMuted = param1;
try
{
_sharedObj.flush();
}
catch(e:Error)
{
}
}
}
private static function setSharedObjSoundsMuted(param1:Boolean) : void
{
if(_sharedObj != null && _sharedObj.data.areSoundsMuted != param1)
{
_sharedObj.data.areSoundsMuted = param1;
try
{
_sharedObj.flush();
}
catch(e:Error)
{
}
}
}
public static function toggleMuteAll() : void
{
toggleMuteSounds();
toggleMuteMusic();
_muteCallback(_isMusicMuted);
}
public static function muteAll() : void
{
muteSounds();
muteMusic();
}
public static function unmuteAll() : void
{
unmuteSounds();
unmuteMusic();
}
public static function toggleMuteSounds() : void
{
_areSoundsMuted = !_areSoundsMuted;
setSharedObjSoundsMuted(_areSoundsMuted);
}
public static function muteSounds() : void
{
_areSoundsMuted = true;
setSharedObjSoundsMuted(true);
}
public static function unmuteSounds() : void
{
_areSoundsMuted = false;
setSharedObjSoundsMuted(false);
}
public static function toggleMuteMusic() : void
{
var _loc1_:Object = null;
for each(_loc1_ in _music)
{
_loc1_.toggleMute();
}
_isMusicMuted = !_isMusicMuted;
setSharedObjMusicMuted(_isMusicMuted);
}
public static function muteMusic(param1:Boolean = true) : void
{
var _loc2_:Object = null;
for each(_loc2_ in _music)
{
_loc2_.mute();
}
if(param1)
{
_isMusicMuted = true;
setSharedObjMusicMuted(true);
}
}
public static function unmuteMusic(param1:Boolean = true) : void
{
var _loc2_:Object = null;
for each(_loc2_ in _music)
{
_loc2_.unmute();
}
if(param1)
{
_isMusicMuted = false;
setSharedObjMusicMuted(false);
}
}
public static function togglePauseAll() : void
{
togglePauseSounds();
togglePauseMusic();
}
public static function pauseAll() : void
{
pauseSounds();
pauseMusic();
}
public static function unpauseAll() : void
{
unpauseSounds();
unpauseMusic();
}
public static function togglePauseSounds() : void
{
var _loc1_:SBSound = null;
for each(_loc1_ in _sounds)
{
_loc1_.togglePause();
}
}
public static function pauseSounds() : void
{
var _loc1_:SBSound = null;
for each(_loc1_ in _sounds)
{
_loc1_.pause();
}
}
public static function unpauseSounds() : void
{
var _loc1_:SBSound = null;
for each(_loc1_ in _sounds)
{
_loc1_.unpause();
}
}
public static function togglePauseMusic() : void
{
var _loc1_:Object = null;
for each(_loc1_ in _music)
{
_loc1_.togglePause();
}
}
public static function pauseMusic() : void
{
var _loc1_:Object = null;
for each(_loc1_ in _music)
{
_loc1_.pause();
}
}
public static function unpauseMusic() : void
{
var _loc1_:Object = null;
for each(_loc1_ in _music)
{
_loc1_.unpause();
}
}
public static function stopAll() : void
{
stopSounds();
stopMusic();
}
public static function stopSounds() : void
{
var _loc1_:SBSound = null;
for each(_loc1_ in _sounds)
{
_loc1_.stop();
}
}
public static function stopMusic() : void
{
var _loc1_:Object = null;
for each(_loc1_ in _music)
{
_loc1_.stop();
}
}
}
}
@@ -0,0 +1,215 @@
package com.sbi.corelib.audio
{
import com.sbi.loader.LoaderCache;
import flash.events.IOErrorEvent;
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundLoaderContext;
import flash.media.SoundTransform;
import flash.net.URLRequest;
public class SBMusic
{
private var _hashKey:String;
private var _previouslyPlayedFilename:String;
private var _currFilename:String;
private var _previousVolume:Number;
private var _currVolume:Number;
public var paused:Boolean = false;
public var muted:Boolean = false;
public var mutedVolume:Number = 1;
public var playVolume:Number = 1;
public var s:Sound;
public var sc:SoundChannel;
public var position:Number;
public function SBMusic(param1:String, param2:Boolean = true, param3:Number = 1, param4:Number = 1000, param5:Boolean = true)
{
super();
this.playNewMusic(param1,param2,param3,param4,param5);
SBAudio.addMusic(this);
}
public function playNewMusic(param1:String, param2:Boolean = true, param3:Number = 1, param4:Number = 1000, param5:Boolean = true) : void
{
this._previouslyPlayedFilename = this._currFilename;
this._currFilename = param1;
this._previousVolume = this._currVolume;
this._currVolume = param3;
var _loc6_:URLRequest = LoaderCache.fetchCDNURLRequest("audio/" + param1);
if(this.s)
{
this.s.removeEventListener(IOErrorEvent.IO_ERROR,this.handleIOError);
this.s = null;
}
if(this.sc)
{
this.sc.stop();
this.sc = null;
}
this.s = new Sound(_loc6_,new SoundLoaderContext(param4,param5));
this.volume = param3;
if(param2)
{
this.play();
}
else
{
this.stop();
}
this.s.addEventListener(IOErrorEvent.IO_ERROR,this.handleIOError,false,0,true);
}
public function play(param1:Number = 0, param2:int = 2147483647, param3:SoundTransform = null) : void
{
if(this.s == null)
{
return;
}
this.sc = this.s.play(param1,param2,param3);
if(this.sc == null)
{
return;
}
this.setTransformVolume(this.playVolume);
}
public function get volume() : Number
{
return this.sc ? this.sc.soundTransform.volume : -1;
}
public function set volume(param1:Number) : void
{
if(this.muted)
{
this.mutedVolume = param1;
}
else
{
this.playVolume = param1;
}
if(this.sc)
{
this.setTransformVolume(param1);
}
}
public function toggleMute() : void
{
if(this.muted)
{
this.unmute();
}
else
{
this.mute();
}
}
public function mute() : void
{
if(!this.muted)
{
this.mutedVolume = this.volume;
this.volume = 0;
this.muted = true;
}
}
public function unmute() : void
{
if(this.muted)
{
this.volume = this.mutedVolume;
this.muted = false;
}
}
public function togglePause() : void
{
if(this.paused)
{
this.unpause();
}
else
{
this.pause();
}
}
public function pause() : void
{
if(Boolean(this.s) && Boolean(this.sc) && !this.paused)
{
this.position = this.sc.position;
this.sc.stop();
this.paused = true;
}
}
public function unpause() : void
{
if(Boolean(this.s) && Boolean(this.sc) && this.paused)
{
this.sc = this.s.play(this.position);
this.setTransformVolume(this.playVolume);
this.paused = false;
}
}
public function stop() : void
{
if(this.sc)
{
this.sc.stop();
}
this.paused = false;
this.muted = false;
}
public function get previouslyPlayedFilename() : String
{
return this._previouslyPlayedFilename;
}
public function get previousVolume() : Number
{
return this._previousVolume;
}
private function setTransformVolume(param1:Number) : void
{
var _loc2_:SoundTransform = this.sc.soundTransform;
_loc2_.volume = param1;
this.sc.soundTransform = _loc2_;
}
private function handleIOError(param1:IOErrorEvent) : void
{
if(this.s)
{
this.s = null;
}
if(this.sc)
{
this.sc.stop();
this.sc = null;
}
SBAudio.removeMusic(this);
}
}
}
@@ -0,0 +1,152 @@
package com.sbi.corelib.audio
{
import flash.events.Event;
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundTransform;
public class SBSound
{
public var paused:Boolean = false;
public var playVolume:Number = 1;
public var s:Sound;
public var sc:SoundChannel;
private var _soundPlaying:Boolean;
public function SBSound(param1:Class, param2:Boolean = true, param3:Number = 1)
{
super();
this.s = new param1();
this.volume = param3;
if(param2)
{
this.play();
}
else
{
this.stop();
}
SBAudio.addSound(this);
}
public function play(param1:Number = 0, param2:int = 0, param3:SoundTransform = null) : void
{
if(param2 == -1)
{
param2 = int.MAX_VALUE;
}
if(this.s == null)
{
return;
}
this.sc = this.s.play(param1,param2,param3);
if(this.sc == null)
{
return;
}
this._soundPlaying = true;
this.sc.addEventListener(Event.SOUND_COMPLETE,this.soundStoppedHandler,false,0,true);
this.setTransformVolume(this.playVolume);
}
public function destroy() : void
{
this.stop();
this.sc = null;
this.s = null;
SBAudio.removeSound(this);
}
public function get volume() : Number
{
return this.sc ? this.sc.soundTransform.volume : -1;
}
public function set volume(param1:Number) : void
{
this.playVolume = param1;
if(this.sc)
{
this.setTransformVolume(param1);
}
}
public function get isPlaying() : Boolean
{
return this._soundPlaying;
}
public function togglePause() : void
{
if(this.paused)
{
this.unpause();
}
else
{
this.pause();
}
}
public function pause() : void
{
if(Boolean(this.sc) && !this.paused)
{
this.sc.stop();
this.paused = true;
this._soundPlaying = false;
}
}
public function unpause() : void
{
if(Boolean(this.s) && Boolean(this.sc) && this.paused)
{
this.sc = this.s.play(this.sc.position);
if(this.sc == null)
{
return;
}
this._soundPlaying = true;
this.sc.addEventListener(Event.SOUND_COMPLETE,this.soundStoppedHandler,false,0,true);
this.setTransformVolume(this.playVolume);
this.paused = false;
}
}
public function stop() : void
{
if(this.sc)
{
this.sc.stop();
}
this.paused = false;
this._soundPlaying = false;
}
private function setTransformVolume(param1:Number) : void
{
var _loc2_:SoundTransform = this.sc.soundTransform;
if(SBAudio.isMusicMuted)
{
_loc2_.volume = 0;
}
else
{
_loc2_.volume = param1;
}
this.sc.soundTransform = _loc2_;
}
private function soundStoppedHandler(param1:Event) : void
{
this._soundPlaying = false;
}
}
}
@@ -0,0 +1,36 @@
package com.sbi.corelib.crypto
{
import com.hurlant.crypto.Crypto;
import com.hurlant.crypto.hash.SHA256;
import com.hurlant.crypto.symmetric.ICipher;
import com.hurlant.crypto.symmetric.IPad;
import com.hurlant.crypto.symmetric.IVMode;
import com.hurlant.crypto.symmetric.PKCS5;
import com.hurlant.util.Base64;
import com.hurlant.util.Hex;
import flash.utils.ByteArray;
public class SBCrypto
{
public function SBCrypto()
{
super();
}
public static function encrypt(param1:String, param2:String) : String
{
var _loc3_:SHA256 = new SHA256();
var _loc4_:ByteArray = _loc3_.hash(Hex.toArray(Hex.fromString(param2)));
var _loc5_:ByteArray = Hex.toArray(Hex.fromString(param1));
var _loc6_:IPad = new PKCS5();
var _loc7_:ICipher = Crypto.getCipher("aes-256-cbc",_loc4_,_loc6_);
_loc7_.encrypt(_loc5_);
var _loc8_:IVMode = _loc7_ as IVMode;
var _loc9_:ByteArray = _loc8_.IV;
_loc9_.writeBytes(_loc5_);
return Base64.encodeByteArray(_loc9_);
}
}
}
@@ -0,0 +1,451 @@
package com.sbi.corelib.input
{
import flash.display.MovieClip;
import flash.events.Event;
import flash.geom.Rectangle;
import flash.text.TextField;
import flash.text.TextFormat;
import flash.text.TextFormatAlign;
import flash.text.TextLineMetrics;
import flash.utils.setTimeout;
import gui.EmoticonUtility;
public class SBTextField extends MovieClip
{
private const CHAT_BUFFER_SIZE:int = 100;
private var _inputTxt:TextField;
private var _outputTxt:TextField;
private var _smileyHolder:MovieClip;
private var _smileyMask:MovieClip;
private var _smileyHistory:String;
private var _clearOutput:Boolean;
private var _smileyarray:Array;
private var _stringIndex:int;
private var _normalStringHistory:String;
private var _updateSizeFunction:Function;
private var updateAllEmotes:Boolean;
public function SBTextField(param1:TextField, param2:TextField, param3:MovieClip, param4:Boolean = false, param5:Boolean = false, param6:Function = null)
{
super();
this._inputTxt = param1;
this._outputTxt = param2;
this._clearOutput = param4;
this._updateSizeFunction = param6;
this._outputTxt.addEventListener(Event.SCROLL,this.scrollListener);
if(this._inputTxt)
{
this._inputTxt.text = "";
}
this._smileyHistory = "";
this._smileyarray = new Array();
this._stringIndex = 0;
this._smileyHolder = new MovieClip();
this._smileyHolder.graphics.beginFill(0,0);
this._smileyHolder.graphics.drawRect(param3.x,param3.y,param2.width,param2.height);
this._smileyHolder.graphics.endFill();
this._smileyHolder.mouseChildren = false;
this._smileyHolder.mouseEnabled = false;
if(!this._clearOutput)
{
this._smileyMask = new MovieClip();
this._smileyMask.graphics.beginFill(16777215,1);
this._smileyMask.graphics.drawRect(param3.x,param3.y,param3.width,param3.height);
this._smileyMask.graphics.endFill();
this._smileyHolder.mask = this._smileyMask;
}
if(param3.parent)
{
param3.parent.addChild(this._smileyHolder);
if(!this._clearOutput)
{
param3.parent.addChild(this._smileyMask);
}
}
else
{
param3.addChild(this._smileyHolder);
if(!this._clearOutput)
{
param3.addChild(this._smileyMask);
}
}
if(param2 == null || param3 == null)
{
throw new Error("Output Textfield and/or text display movie clip cannot be null. Output Textfield = " + param2 + " text Display MC = " + param3);
}
}
public function destroy() : void
{
}
public function trimHistory() : void
{
var _loc1_:String = this._outputTxt.text;
var _loc2_:int = _loc1_.indexOf("\r") + 1;
_loc1_ = _loc1_.substr(_loc2_);
this.clear();
this.appendText(_loc1_);
}
public function adjustSmileys(param1:Number) : void
{
this._smileyHolder.y -= param1;
}
public function get autoSize() : String
{
return this._outputTxt.autoSize;
}
public function set autoSize(param1:String) : void
{
this._outputTxt.autoSize = param1;
}
public function get text() : String
{
return this._outputTxt.text;
}
public function set text(param1:String) : void
{
if(this._clearOutput || param1 == "")
{
this.clear();
}
this.addText(param1);
}
public function get textColor() : uint
{
return this._outputTxt.textColor;
}
public function set textColor(param1:uint) : void
{
this._outputTxt.textColor = param1;
}
override public function get x() : Number
{
return this._outputTxt.x;
}
override public function set x(param1:Number) : void
{
this._outputTxt.x = param1;
}
override public function get y() : Number
{
return this._outputTxt.y;
}
override public function set y(param1:Number) : void
{
this._outputTxt.y = param1;
}
override public function get height() : Number
{
return this._outputTxt.height;
}
override public function set height(param1:Number) : void
{
this._outputTxt.height = param1;
}
override public function get width() : Number
{
return this._outputTxt.width;
}
override public function set width(param1:Number) : void
{
this._outputTxt.width = param1;
}
override public function get visible() : Boolean
{
return this._outputTxt.visible;
}
override public function set visible(param1:Boolean) : void
{
this._outputTxt.visible = param1;
}
override public function get alpha() : Number
{
return this._outputTxt.alpha;
}
override public function set alpha(param1:Number) : void
{
this._outputTxt.alpha = param1;
}
public function appendText(param1:String) : void
{
if(this._clearOutput || param1 == "")
{
this.clear();
}
this.addText(param1);
}
public function set scrollV(param1:int) : void
{
this._outputTxt.scrollV = param1;
}
public function get scrollV() : int
{
return this._outputTxt.scrollV;
}
public function get maxScrollV() : int
{
return this._outputTxt.maxScrollV;
}
public function get length() : int
{
return this._outputTxt.length;
}
public function set defaultTextFormat(param1:TextFormat) : void
{
param1.align = TextFormatAlign.LEFT;
this._outputTxt.defaultTextFormat = param1;
}
public function setTextFormat(param1:TextFormat, param2:int = -1, param3:int = -1) : void
{
param1.align = TextFormatAlign.LEFT;
this._outputTxt.setTextFormat(param1,param2,param3);
this._outputTxt.defaultTextFormat = param1;
}
public function get numLines() : int
{
return this._outputTxt.numLines;
}
public function get selectable() : Boolean
{
return this._outputTxt.selectable;
}
public function set selectable(param1:Boolean) : void
{
this._outputTxt.selectable = param1;
}
public function getTextFormat(param1:int = -1, param2:int = -1) : TextFormat
{
return this._outputTxt.getTextFormat(param1,param2);
}
private function addText(param1:String) : void
{
var _loc2_:String = null;
var _loc3_:String = null;
var _loc4_:int = 0;
var _loc5_:String = null;
var _loc6_:Boolean = false;
var _loc7_:Object = null;
var _loc8_:TextField = null;
var _loc9_:String = null;
var _loc10_:int = 0;
if(param1 != "")
{
this._normalStringHistory += param1;
_loc7_ = EmoticonUtility.formatStringForSmiley(param1,this._stringIndex,this._smileyarray,this.updateAllEmotes);
param1 = _loc7_.str;
this._stringIndex = _loc7_.stringIndex;
this._smileyarray = _loc7_.smileyArray;
this.updateAllEmotes = false;
this._outputTxt.appendText(param1);
if(this._outputTxt.scrollV + 1 >= this._outputTxt.maxScrollV)
{
this._outputTxt.scrollV = this._outputTxt.maxScrollV;
}
if(this.numLines >= this.CHAT_BUFFER_SIZE)
{
this._outputTxt.text = this._normalStringHistory;
_loc8_ = this._outputTxt;
while(_loc8_.numLines > this.CHAT_BUFFER_SIZE * 0.5)
{
_loc10_ = _loc8_.text.indexOf("\r") + 1;
_loc8_.text = _loc8_.text.substr(_loc10_);
}
_loc9_ = _loc8_.text.split("\r").join("\n");
this.updateAllEmotes = true;
this.clear();
this.text = _loc9_;
_loc8_ = null;
return;
}
setTimeout(this.setupSmileys,1000 / 24,param1);
}
}
private function setupSmileys(param1:String) : void
{
var _loc4_:int = 0;
var _loc5_:Rectangle = null;
var _loc6_:TextLineMetrics = null;
var _loc7_:MovieClip = null;
var _loc8_:Number = NaN;
var _loc2_:Number = 0;
var _loc3_:Array = [];
for(; _loc4_ < this._smileyarray.length; _loc4_++)
{
if(this._smileyarray[_loc4_] != null)
{
if(!this._smileyarray[_loc4_].added)
{
_loc5_ = this._outputTxt.getCharBoundaries(this._smileyarray[_loc4_].strindex);
if(_loc5_)
{
_loc6_ = this._outputTxt.getLineMetrics(this._outputTxt.numLines - 1);
_loc7_ = this._smileyarray[_loc4_].emoticon;
_loc7_.height = _loc6_.height;
_loc7_.scaleX = _loc7_.scaleY;
_loc8_ = _loc5_.x + _loc7_.width * 0.5;
if(_loc8_ > this._outputTxt.width)
{
_loc5_ = this._outputTxt.getCharBoundaries(this._smileyarray[_loc4_].strindex + 1);
if(!_loc5_)
{
continue;
}
_loc7_.x = _loc5_.x + this._outputTxt.x + _loc7_.width * 0.5 - 5;
_loc7_.y = _loc5_.y + this._outputTxt.y + _loc7_.height * 0.5;
}
else
{
_loc7_.x = _loc5_.x + this._outputTxt.x + _loc7_.width * 0.5;
_loc7_.y = _loc5_.y + this._outputTxt.y + _loc7_.height * 0.5;
}
this._smileyHolder.addChild(_loc7_);
this._smileyarray[_loc4_].added = true;
}
}
}
}
if(this._smileyHistory == "")
{
this._smileyHistory = param1;
}
else
{
this._smileyHistory += "\n" + param1;
}
this._smileyarray = [];
if(this._updateSizeFunction != null)
{
this._updateSizeFunction();
}
}
private function addSmileys(param1:Array) : void
{
var _loc2_:int = 0;
while(_loc2_ < param1.length)
{
this._smileyHolder.addChild(param1[_loc2_]);
_loc2_++;
}
}
private function clear() : void
{
if(this._inputTxt)
{
this._inputTxt.text = "";
}
this._smileyHolder.y = 0;
while(this._smileyHolder.numChildren > 0)
{
this._smileyHolder.removeChildAt(0);
}
this._outputTxt.text = "";
this._smileyarray = [];
this._smileyHistory = "";
this._stringIndex = 0;
this._normalStringHistory = "";
}
private function removeSpace(param1:String) : String
{
var _loc2_:int = 0;
var _loc3_:String = "";
var _loc4_:Array = param1.split("");
_loc2_ = 0;
while(_loc2_ < _loc4_.length)
{
if(_loc3_ == " ")
{
if(_loc4_[_loc2_] == " ")
{
_loc4_[_loc2_] = "";
_loc3_ = " ";
}
else
{
_loc3_ = _loc4_[_loc2_];
}
}
else
{
_loc3_ = _loc4_[_loc2_];
}
_loc2_++;
}
return _loc4_.join("");
}
private function scrollListener(param1:Event) : void
{
var _loc2_:int = 0;
var _loc3_:TextLineMetrics = null;
var _loc4_:Number = NaN;
if(!this._clearOutput)
{
_loc4_ = 0;
_loc2_ = 0;
while(_loc2_ < this._outputTxt.scrollV - 1)
{
_loc3_ = this._outputTxt.getLineMetrics(_loc2_);
_loc4_ += _loc3_.height;
_loc2_++;
}
this._smileyHolder.y = -_loc4_;
}
}
private function setSize(param1:Number, param2:Number) : void
{
this._smileyMask.width = param1;
this._smileyMask.height = param2 - 6;
}
}
}
@@ -0,0 +1,179 @@
package com.sbi.corelib.math
{
import flash.geom.Point;
public class Collision
{
public function Collision()
{
super();
}
public static function segIntersection(param1:Point, param2:Point, param3:Point, param4:Point) : Point
{
var _loc5_:Number = param2.x - param1.x;
var _loc6_:Number = param2.y - param1.y;
var _loc7_:Number = param4.x - param3.x;
var _loc8_:Number = param4.y - param3.y;
var _loc9_:Number = _loc5_ * _loc8_ - _loc6_ * _loc7_;
if(_loc9_ == 0)
{
return null;
}
var _loc10_:Number = param3.x - param1.x;
var _loc11_:Number = param3.y - param1.y;
var _loc12_:Number = (_loc10_ * _loc8_ - _loc11_ * _loc7_) / _loc9_;
if(_loc12_ < 0 || _loc12_ > 1)
{
return null;
}
var _loc13_:Number = (_loc10_ * _loc6_ - _loc11_ * _loc5_) / _loc9_;
if(_loc13_ < 0 || _loc13_ > 1)
{
return null;
}
return new Point(param1.x + _loc12_ * _loc5_,param1.y + _loc12_ * _loc6_);
}
public static function circleHitCircle(param1:Point, param2:Number, param3:Point, param4:Number) : Boolean
{
var _loc5_:Point = param3.subtract(param1);
var _loc6_:Number = _loc5_.x * _loc5_.x + _loc5_.y * _loc5_.y;
return Boolean(_loc6_ < (param2 + param4) * (param2 + param4));
}
public static function pointHitCircle(param1:Point, param2:Point, param3:Number) : Boolean
{
var _loc4_:Point = param1.subtract(param2);
var _loc5_:Number = _loc4_.x * _loc4_.x + _loc4_.y * _loc4_.y;
return Boolean(_loc5_ < param3 * param3);
}
public static function movingCircleVsRay(param1:Point, param2:Number, param3:Point, param4:Number, param5:Point, param6:Point) : Number
{
var _loc9_:Number = NaN;
var _loc15_:Number = NaN;
var _loc16_:Number = NaN;
var _loc17_:Number = NaN;
var _loc18_:Number = NaN;
var _loc19_:Number = NaN;
var _loc20_:Number = NaN;
var _loc21_:Number = NaN;
var _loc22_:Point = null;
var _loc23_:Point = null;
var _loc24_:Point = null;
var _loc7_:Point = param6.subtract(param5);
var _loc8_:Point = param1.subtract(param5);
var _loc10_:Point = new Point();
var _loc11_:Point = new Point(param3.x * param4,param3.y * param4);
var _loc12_:Number = param3.x * param3.y;
var _loc13_:Number;
var _loc14_:Number = _loc13_ = _loc11_.x * _loc7_.y - _loc11_.y * _loc7_.x;
if(_loc14_ == 0)
{
_loc9_ = _loc8_.x * _loc7_.x + _loc8_.y * _loc7_.y;
_loc10_.x = _loc8_.x - _loc7_.x * _loc9_;
_loc10_.y = _loc8_.y - _loc7_.y * _loc9_;
param4 = 0;
return _loc10_.x * _loc10_.y <= param2 ? -1 : 1;
}
_loc13_ /= _loc14_;
_loc9_ = 0;
if(_loc9_ <= param2)
{
_loc15_ = _loc8_.x * _loc7_.y - _loc8_.y * _loc7_.x;
_loc16_ = -(_loc15_ * _loc13_) / _loc14_;
_loc17_ = -(_loc13_ * _loc7_.y);
_loc18_ = _loc13_ * _loc7_.x;
_loc19_ = _loc17_ * _loc17_ + _loc18_ * _loc18_;
if(_loc19_)
{
_loc19_ = Math.sqrt(_loc19_);
_loc17_ /= _loc19_;
_loc18_ /= _loc19_;
}
_loc20_ = Math.abs(param2 / (_loc11_.x * _loc17_ + _loc11_.y * _loc18_));
if(_loc16_ < -_loc20_)
{
return -1;
}
if(_loc16_ - _loc20_ > 1)
{
return -1;
}
_loc21_ = _loc16_ - _loc20_ < 0 ? 0 : _loc16_ - _loc20_;
_loc22_ = new Point(param1.x + param3.x * _loc21_,param1.y + param3.y * _loc21_);
_loc23_ = _loc22_.subtract(param5);
_loc24_ = _loc22_.subtract(param6);
if(_loc23_.x * _loc7_.x + _loc23_.y * _loc7_.y < 0)
{
return Ray_Vs_Sphere(param1,param3,param4,param5,param2);
}
if(_loc24_.x * _loc7_.x + _loc24_.y * _loc7_.y > 0)
{
return Ray_Vs_Sphere(param1,param3,param4,param6,param2);
}
return _loc21_;
}
return -1;
}
public static function rayHitCircle(param1:Point, param2:Number, param3:Point, param4:Point) : Boolean
{
var _loc5_:Point = param1.subtract(param3);
var _loc6_:Point = param4.subtract(param3);
var _loc7_:Number = (_loc5_.x * _loc6_.x + _loc5_.y * _loc6_.y) / (_loc6_.x * _loc6_.x + _loc6_.y * _loc6_.y);
if(_loc7_ < 0)
{
_loc7_ = 0;
}
if(_loc7_ > 1)
{
_loc7_ = 1;
}
var _loc8_:Point = new Point(param3.x + _loc7_ * _loc6_.x,param3.y + _loc7_ * _loc6_.y);
var _loc9_:Point = param1.subtract(_loc8_);
var _loc10_:Number = _loc9_.x * _loc9_.x + _loc9_.y * _loc9_.y;
return Boolean(_loc10_ <= param2 * param2);
}
public static function Ray_Vs_Sphere(param1:Point, param2:Point, param3:Number, param4:Point, param5:Number) : Number
{
var _loc18_:Number = NaN;
var _loc19_:Number = NaN;
var _loc20_:Number = NaN;
var _loc21_:Point = null;
var _loc22_:Number = NaN;
var _loc23_:Number = NaN;
var _loc6_:Number = param5 * param5;
var _loc7_:Point = param4.subtract(param1);
var _loc8_:Number = _loc7_.x * _loc7_.x + _loc7_.y * _loc7_.y;
var _loc9_:Point = new Point(param2.x * param3,param2.y * param3);
var _loc10_:Point = _loc9_.add(param1);
var _loc11_:Number = _loc9_.x * _loc7_.x + _loc9_.y * _loc7_.y;
var _loc12_:Point = param4.subtract(_loc10_);
var _loc13_:Number = _loc9_.x * _loc12_.x + _loc9_.y * _loc12_.y;
var _loc14_:Number = (_loc12_.x + _loc12_.y) * (_loc12_.x + _loc12_.y);
var _loc15_:Number = _loc9_.x * _loc7_.y - _loc9_.y * _loc7_.x;
var _loc16_:Number = _loc15_ * _loc15_;
var _loc17_:Number = _loc9_.x * _loc9_.x + _loc9_.y * _loc9_.y;
if(_loc11_ > 0 && (_loc13_ < 0 || _loc14_ < _loc6_) && _loc16_ < _loc6_ * _loc17_ && _loc17_ > 0.00001)
{
_loc18_ = Math.sqrt(_loc6_ - _loc16_ / _loc17_);
_loc19_ = Math.sqrt(_loc17_);
_loc20_ = 1 / _loc19_;
_loc21_ = new Point(_loc9_.x * _loc20_,_loc9_.y * _loc20_);
_loc22_ = _loc21_.x * _loc7_.x + _loc21_.y * _loc7_.y;
_loc23_ = param3 * (_loc22_ - _loc18_) * _loc20_;
return _loc23_ < 0 ? 0 : _loc23_;
}
if(_loc8_ < _loc6_)
{
return 0;
}
return -1;
}
}
}
@@ -0,0 +1,32 @@
package com.sbi.debug
{
import com.carlcalderon.arthropod.Debug;
import flash.display.DisplayObjectContainer;
public class DebugUtility
{
public function DebugUtility()
{
super();
}
public static function debugTrace(param1:String, param2:uint = 16711422) : void
{
Debug.log(param1,param2);
}
public static function debugTraceObject(param1:String, param2:Object, param3:int = 0) : void
{
}
public static function debugTraceArray(param1:String, param2:Array, param3:Boolean = false) : void
{
}
public static function debugTraceDisplayObjectContainer(param1:String, param2:DisplayObjectContainer, param3:Boolean = false, param4:int = 0) : void
{
}
}
}
@@ -0,0 +1,466 @@
package com.sbi.graphics
{
import flash.display.BitmapData;
import flash.geom.Rectangle;
import flash.utils.ByteArray;
public class BitmapByteArray
{
private static const PALETTE_ALPHA_OFFSET:int = 25;
private static const SHADOW_GRADIENT_SCALE:int = 3;
private const TRANS:int = 0;
private var _palette:Array;
private var _h:int;
private var _w:int;
private var _offX:int;
private var _offY:int;
private var _ba:Vector.<int>;
public function BitmapByteArray()
{
super();
this._palette = PaletteHelper.getAnimalPalette();
}
public static function scaleAndPackImage(param1:BitmapData) : Object
{
var _loc2_:BitmapByteArray = new BitmapByteArray();
_loc2_.loadBitmap(param1);
_loc2_.halfImage();
_loc2_.crop();
return _loc2_.processPackImage();
}
public static function scaleAndPackShadow(param1:BitmapData, param2:int, param3:int, param4:int, param5:int) : Object
{
var _loc6_:BitmapByteArray = new BitmapByteArray();
return _loc6_.scaleShadow(param1,param2,param3,param4,param5);
}
private function loadBitmap(param1:BitmapData) : void
{
var _loc2_:uint = 0;
var _loc3_:uint = 0;
var _loc7_:uint = 0;
this._w = param1.width;
this._h = param1.height;
this._ba = new Vector.<int>(this._w * this._h,true);
var _loc4_:uint = 0;
var _loc5_:int = -1;
var _loc6_:* = 0;
_loc3_ = 0;
while(_loc3_ < this._h)
{
_loc2_ = 0;
while(_loc2_ < this._w)
{
_loc7_ = param1.getPixel32(_loc2_,_loc3_);
if(_loc4_ != _loc7_ || _loc5_ < 0)
{
_loc4_ = _loc7_;
_loc5_ = int(this.findPaletteColor(_loc7_));
}
var _loc8_:Number;
this._ba[_loc8_ = _loc6_++] = _loc5_;
_loc2_++;
}
_loc3_++;
}
}
private function scaleShadow(param1:BitmapData, param2:int, param3:int, param4:int, param5:int) : Object
{
var _loc7_:uint = 0;
var _loc8_:uint = 0;
var _loc9_:uint = 0;
var _loc10_:uint = 0;
var _loc16_:int = 0;
var _loc17_:* = 0;
this._w = param1.width;
this._h = param1.height;
var _loc6_:Vector.<uint> = param1.getVector(new Rectangle(0,0,this._w,this._h));
var _loc11_:Vector.<int> = new Vector.<int>(this._w * this._h * 0.25,true);
var _loc12_:int = 0;
var _loc13_:* = 0;
var _loc14_:int = 0;
while(_loc14_ < this._h)
{
_loc16_ = 0;
while(_loc16_ < this._w)
{
_loc12_ = _loc16_ + _loc14_ * this._w;
_loc7_ = _loc6_[_loc12_];
_loc8_ = _loc6_[_loc12_ + 1];
_loc12_ += this._w;
_loc9_ = _loc6_[_loc12_];
_loc10_ = _loc6_[_loc12_ + 1];
var _loc18_:Number;
_loc11_[_loc18_ = _loc13_++] = this.blendShadowColors(_loc7_,_loc8_,_loc9_,_loc10_);
_loc16_ += 2;
}
_loc14_ += 2;
}
this._ba = _loc11_;
this._h /= 2;
this._w /= 2;
if(param4 != this._w || param5 != this._h)
{
_loc13_ = 0;
_loc11_ = new Vector.<int>(param4 * param5,true);
_loc14_ = param3;
while(_loc14_ < param3 + param5)
{
_loc17_ = int(_loc14_ * this._w + param2);
_loc16_ = 0;
while(_loc16_ < param4)
{
_loc12_ = this._ba[_loc17_++];
_loc11_[_loc18_ = _loc13_++] = _loc12_;
_loc16_++;
}
_loc14_++;
}
this._w = param4;
this._h = param5;
this._offX = param2;
this._offY = param3;
this._ba = _loc11_;
}
var _loc15_:Object = this.processPackImage();
_loc15_.sm = SHADOW_GRADIENT_SCALE;
return _loc15_;
}
private function halfImage() : void
{
var _loc1_:int = 0;
var _loc2_:int = 0;
var _loc3_:int = 0;
var _loc4_:int = 0;
var _loc9_:int = 0;
var _loc5_:Vector.<int> = new Vector.<int>(this._w * this._h * 0.25,true);
var _loc6_:int = 0;
var _loc7_:* = 0;
var _loc8_:int = 0;
while(_loc8_ < this._h)
{
_loc9_ = 0;
while(_loc9_ < this._w)
{
_loc6_ = _loc9_ + _loc8_ * this._w;
_loc1_ = this._ba[_loc6_];
_loc2_ = this._ba[_loc6_ + 1];
_loc6_ += this._w;
_loc3_ = this._ba[_loc6_];
_loc4_ = this._ba[_loc6_ + 1];
var _loc10_:Number;
_loc5_[_loc10_ = _loc7_++] = this.blendColors(_loc1_,_loc2_,_loc3_,_loc4_);
_loc9_ += 2;
}
_loc8_ += 2;
}
this._ba = _loc5_;
this._h /= 2;
this._w /= 2;
}
private function crop() : void
{
var _loc1_:uint = 0;
var _loc2_:int = 0;
var _loc3_:int = 0;
var _loc11_:Vector.<int> = null;
var _loc12_:* = 0;
var _loc4_:int = this._w;
var _loc5_:int = 0;
var _loc6_:int = this._h;
var _loc7_:int = 0;
var _loc8_:* = 0;
_loc3_ = 0;
while(_loc3_ < this._h)
{
_loc2_ = 0;
while(_loc2_ < this._w)
{
_loc1_ = uint(this._ba[_loc8_++]);
if(_loc1_ > 0)
{
if(_loc2_ < _loc4_)
{
_loc4_ = _loc2_;
}
if(_loc2_ > _loc5_)
{
_loc5_ = _loc2_;
}
if(_loc3_ < _loc6_)
{
_loc6_ = _loc3_;
}
if(_loc3_ > _loc7_)
{
_loc7_ = _loc3_;
}
}
_loc2_++;
}
_loc3_++;
}
this._offX = _loc4_;
this._offY = _loc6_;
var _loc9_:uint = _loc5_ - _loc4_ + 1;
var _loc10_:uint = _loc7_ - _loc6_ + 1;
if(_loc4_ == this._w && _loc6_ == this._h)
{
this._w = 0;
this._h = 0;
this._ba = null;
return;
}
_loc8_ = 0;
if(_loc9_ != this._w || _loc10_ != this._h)
{
_loc11_ = new Vector.<int>(_loc9_ * _loc10_,true);
_loc3_ = _loc6_;
while(_loc3_ < _loc6_ + _loc10_)
{
_loc12_ = int(_loc3_ * this._w + this._offX);
_loc2_ = 0;
while(_loc2_ < _loc9_)
{
_loc1_ = uint(this._ba[_loc12_++]);
var _loc13_:Number;
_loc11_[_loc13_ = _loc8_++] = _loc1_;
_loc2_++;
}
_loc3_++;
}
this._w = _loc9_;
this._h = _loc10_;
this._ba = _loc11_;
}
}
private function processPackImage() : Object
{
var _loc2_:int = 0;
var _loc3_:int = 0;
var _loc4_:String = null;
var _loc10_:uint = 0;
if(this._ba == null)
{
return null;
}
var _loc1_:Object = {
"x":this._offX,
"y":this._offY,
"w":this._w,
"h":this._h
};
var _loc5_:ByteArray = new ByteArray();
_loc1_.b = _loc5_;
var _loc6_:int = int(this._ba.length);
var _loc7_:uint = 256;
var _loc8_:uint = 0;
var _loc9_:* = 0;
while(_loc9_ < _loc6_)
{
_loc10_ = uint(this._ba[_loc9_++]);
if(_loc7_ == 256)
{
_loc7_ = _loc10_;
}
else if(_loc10_ != _loc7_)
{
if(_loc8_)
{
_loc7_ |= 128;
while(_loc8_ > 255)
{
_loc5_.writeByte(_loc7_);
_loc5_.writeByte(uint(255));
_loc8_ -= 256;
}
if(_loc8_ > 0)
{
_loc5_.writeByte(_loc7_);
_loc5_.writeByte(_loc8_);
}
else
{
_loc5_.writeByte(uint(_loc7_ & 0x7F));
}
}
else
{
_loc5_.writeByte(_loc7_);
}
_loc7_ = _loc10_;
_loc8_ = 0;
}
else
{
_loc8_++;
}
}
if(Boolean(_loc8_) || _loc6_ == 1)
{
_loc7_ |= 128;
while(_loc8_ > 255)
{
_loc5_.writeByte(_loc7_);
_loc5_.writeByte(uint(255));
_loc8_ -= 256;
}
if(_loc8_ > 0)
{
_loc5_.writeByte(_loc7_);
_loc5_.writeByte(_loc8_);
}
else
{
_loc5_.writeByte(uint(_loc7_ & 0x7F));
}
}
return _loc1_;
}
private function findPaletteColor(param1:uint) : uint
{
var _loc2_:uint = uint((param1 & 0xFF000000) >> 24);
if(_loc2_ < 160)
{
return this.TRANS;
}
param1 |= 4278190080;
var _loc3_:uint = 0;
while(_loc3_ < PALETTE_ALPHA_OFFSET)
{
if(this._palette[_loc3_] == param1)
{
return _loc3_;
}
_loc3_++;
}
var _loc4_:int = param1 >> 16 & 0xFF;
var _loc5_:int = param1 >> 8 & 0xFF;
var _loc6_:int = param1 & 0xFF;
return this.findClosetPaletteIndex(_loc4_,_loc5_,_loc6_);
}
private function findClosetPaletteIndex(param1:int, param2:int, param3:int) : int
{
var _loc6_:int = 0;
var _loc7_:int = 0;
var _loc8_:int = 0;
var _loc9_:int = 0;
var _loc10_:int = 0;
var _loc12_:uint = 0;
var _loc4_:int = 10000000;
var _loc5_:int = 0;
var _loc11_:uint = 0;
while(_loc11_ < PALETTE_ALPHA_OFFSET)
{
_loc12_ = uint(this._palette[_loc11_]);
_loc7_ = (_loc12_ >> 16 & 0xFF) - param1;
_loc8_ = (_loc12_ >> 8 & 0xFF) - param2;
_loc9_ = (_loc12_ & 0xFF) - param3;
_loc10_ = _loc7_ * _loc7_ + _loc8_ * _loc8_ + _loc9_ * _loc9_;
if(_loc10_ < _loc4_)
{
_loc4_ = _loc10_;
_loc5_ = int(_loc11_);
}
_loc11_++;
}
return _loc5_;
}
private function blendColors(param1:uint, param2:uint, param3:uint, param4:uint) : uint
{
var _loc5_:uint = 0;
var _loc6_:int = 0;
var _loc7_:Array = null;
var _loc8_:int = 0;
var _loc9_:int = 0;
var _loc10_:int = 0;
var _loc11_:int = 0;
var _loc12_:int = 0;
if(param1 == this.TRANS)
{
_loc6_++;
}
if(param2 == this.TRANS)
{
_loc6_++;
}
if(param3 == this.TRANS)
{
_loc6_++;
}
if(param4 == this.TRANS)
{
_loc6_++;
}
if(_loc6_ == 4)
{
return 0;
}
if(param1 == param2 && param1 == param3 && param1 == param4)
{
_loc5_ = param1;
}
else
{
_loc7_ = [param1,param2,param3,param4];
while(_loc12_ < 4)
{
if(_loc7_[_loc12_] != this.TRANS)
{
param1 = uint(this._palette[_loc7_[_loc12_]]);
_loc9_ += param1 >> 16 & 0xFF;
_loc10_ += param1 >> 8 & 0xFF;
_loc11_ += param1 & 0xFF;
_loc8_++;
}
_loc12_++;
}
_loc9_ /= _loc8_;
_loc10_ /= _loc8_;
_loc11_ /= _loc8_;
_loc5_ = uint(this.findClosetPaletteIndex(_loc9_,_loc10_,_loc11_));
}
return uint(_loc5_ + _loc6_ * PALETTE_ALPHA_OFFSET);
}
private function blendShadowColors(param1:uint, param2:uint, param3:uint, param4:uint) : int
{
var _loc5_:uint = ((param1 >> 24 & 0xFF) + (param2 >> 24 & 0xFF) + (param3 >> 24 & 0xFF) + (param4 >> 24 & 0xFF)) / 4;
var _loc6_:uint = ((param1 & 0xFF & 0xFF) + (param2 & 0xFF & 0xFF) + (param3 & 0xFF & 0xFF) + (param4 & 0xFF & 0xFF)) / 4;
if(_loc5_)
{
_loc6_ += (255 - _loc6_) * ((255 - _loc5_) / 255);
_loc6_ = uint(_loc6_ >> BitmapByteArray.SHADOW_GRADIENT_SCALE);
if(_loc6_ == 0)
{
_loc6_ = 1;
}
}
else
{
_loc6_ = 0;
}
return _loc6_;
}
}
}
@@ -0,0 +1,100 @@
package com.sbi.graphics
{
import flash.display.BitmapData;
import flash.utils.ByteArray;
public class ImageArray
{
public static const VERSION:uint = 117967104;
private var _frames:Array;
public function ImageArray()
{
super();
this._frames = new Array();
}
public function get length() : int
{
return this._frames.length;
}
public function release() : void
{
this._frames.splice(0,this._frames.length);
}
public function addBitmap(param1:BitmapData) : void
{
var _loc2_:Object = BitmapByteArray.scaleAndPackImage(param1);
this._frames.push(_loc2_);
}
public function attachShadow(param1:BitmapData) : void
{
var _loc2_:Object = null;
var _loc3_:Object = null;
if(this._frames.length)
{
_loc2_ = this._frames[this._frames.length - 1];
_loc3_ = BitmapByteArray.scaleAndPackShadow(param1,_loc2_.x,_loc2_.y,_loc2_.w,_loc2_.h);
_loc2_.s = _loc3_.b;
_loc2_.sm = _loc3_.sm;
}
}
public function addFrame(param1:Object) : void
{
this._frames.push(param1);
}
public function loadPackage(param1:ByteArray) : void
{
this.release();
param1.position = 0;
try
{
param1.uncompress();
}
catch(err:Error)
{
}
var _loc2_:Object = param1.readObject();
if(_loc2_.v == ImageArray.VERSION)
{
this._frames = _loc2_.f;
return;
}
}
public function getFrame(param1:int) : Object
{
return this._frames[param1];
}
public function getPackage(param1:Boolean = true) : ByteArray
{
var _loc2_:int = 0;
var _loc3_:ByteArray = null;
var _loc4_:Object = null;
if(this._frames.length)
{
_loc4_ = {
"v":ImageArray.VERSION,
"f":this._frames
};
_loc3_ = new ByteArray();
_loc3_.writeObject(_loc4_);
_loc3_.position = 0;
if(param1)
{
_loc3_.compress();
}
}
return _loc3_;
}
}
}
@@ -0,0 +1,32 @@
package com.sbi.graphics
{
public class ImageArrayHelper
{
public function ImageArrayHelper()
{
super();
}
public static function packId(param1:int, param2:int, param3:int) : uint
{
return param1 << 24 | param2 << 16 | param3;
}
public static function avatarId(param1:uint) : int
{
return param1 >> 24 & 0xFF;
}
public static function categoryId(param1:uint) : int
{
return param1 >> 16 & 0xFF;
}
public static function layerId(param1:uint) : int
{
return param1 & 0xFFFF;
}
}
}
@@ -0,0 +1,20 @@
package com.sbi.graphics
{
import flash.events.Event;
import flash.utils.ByteArray;
public class JPEGAsyncCompleteEvent extends Event
{
public static const JPEGASYNC_COMPLETE:String = "JPEGAsyncComplete";
public var ImageData:ByteArray;
public function JPEGAsyncCompleteEvent(param1:ByteArray)
{
this.ImageData = param1;
super(JPEGASYNC_COMPLETE);
}
}
}
@@ -0,0 +1,756 @@
package com.sbi.graphics
{
import flash.display.BitmapData;
import flash.events.EventDispatcher;
import flash.events.ProgressEvent;
import flash.utils.ByteArray;
import flash.utils.setTimeout;
public class JpegAsynchEncoder extends EventDispatcher
{
public static const CONTENT_TYPE:String = "image/jpeg";
private var ZigZag:Array = [0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18,24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63];
private var std_dc_luminance_nrcodes:Array = [0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0];
private var std_dc_luminance_values:Array = [0,1,2,3,4,5,6,7,8,9,10,11];
private var std_ac_luminance_nrcodes:Array = [0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,125];
private var std_ac_luminance_values:Array = [1,2,3,0,4,17,5,18,33,49,65,6,19,81,97,7,34,113,20,50,129,145,161,8,35,66,177,193,21,82,209,240,36,51,98,114,130,9,10,22,23,24,25,26,37,38,39,40,41,42,52,53,54,55,56,57,58,67,68,69,70,71,72,73,74,83,84,85,86,87,88,89,90,99,100,101,102,103,104,105,106,115,116,117,118,119,120,121,122,131,132,133,134,135,136,137,138,146,147,148,149,150,151,152,153,154,162,163,164,165,166,167,168,169,170,178,179,180,181,182,183,184,185,186,194,195,196,197,198,199,200,201,202,210,211,212,213,214,215,216,217,218,225,226,227,228,229,230,231,232,233,234,241,242,243,244,245,246,247,248,249,250];
private var std_dc_chrominance_nrcodes:Array = [0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0];
private var std_dc_chrominance_values:Array = [0,1,2,3,4,5,6,7,8,9,10,11];
private var std_ac_chrominance_nrcodes:Array = [0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,119];
private var std_ac_chrominance_values:Array = [0,1,2,3,17,4,5,33,49,6,18,65,81,7,97,113,19,34,50,129,8,20,66,145,161,177,193,9,35,51,82,240,21,98,114,209,10,22,36,52,225,37,241,23,24,25,26,38,39,40,41,42,53,54,55,56,57,58,67,68,69,70,71,72,73,74,83,84,85,86,87,88,89,90,99,100,101,102,103,104,105,106,115,116,117,118,119,120,121,122,130,131,132,133,134,135,136,137,138,146,147,148,149,150,151,152,153,154,162,163,164,165,166,167,168,169,170,178,179,180,181,182,183,184,185,186,194,195,196,197,198,199,200,201,202,210,211,212,213,214,215,216,217,218,226,227,228,229,230,231,232,233,234,242,243,244,245,246,247,248,249,250];
private var YTable:Array = new Array(64);
private var UVTable:Array = new Array(64);
private var fdtbl_Y:Array = new Array(64);
private var fdtbl_UV:Array = new Array(64);
private var YDC_HT:Array;
private var UVDC_HT:Array;
private var YAC_HT:Array;
private var UVAC_HT:Array;
private var YDU:Array = new Array(64);
private var UDU:Array = new Array(64);
private var VDU:Array = new Array(64);
private var DU:Array = new Array(64);
private var bitcode:Array = new Array(65535);
private var category:Array = new Array(65535);
private var byteout:ByteArray;
private var bytenew:int = 0;
private var bytepos:int = 7;
private var DCY:Number = 0;
private var DCU:Number = 0;
private var DCV:Number = 0;
private var SrcWidth:int = 0;
private var SrcHeight:int = 0;
private var Source:Object = null;
private var TotalSize:int = 0;
private var PixelsPerIter:int = 128;
private var PercentageInc:int = 0;
private var NextProgressAt:int = 0;
private var CurrentTotalPos:int = 0;
private var Working:Boolean = false;
public function JpegAsynchEncoder()
{
super();
}
public function JPEGAsyncEncoder(param1:Number = 50) : void
{
if(param1 <= 0)
{
param1 = 1;
}
if(param1 > 100)
{
param1 = 100;
}
var _loc2_:int = 0;
if(param1 < 50)
{
_loc2_ = int(5000 / param1);
}
else
{
_loc2_ = int(200 - param1 * 2);
}
this.initHuffmanTbl();
this.initCategoryNumber();
this.initQuantTables(_loc2_);
}
public function get contentType() : String
{
return CONTENT_TYPE;
}
public function get PixelsPerIteration() : int
{
return this.PixelsPerIter;
}
public function set PixelsPerIteration(param1:int) : void
{
this.PixelsPerIter = param1;
}
public function get ImageData() : ByteArray
{
return this.byteout;
}
public function encodeByteArray(param1:ByteArray, param2:int, param3:int) : Boolean
{
return this.internalEncode(param1,param2,param3);
}
public function encode(param1:BitmapData) : Boolean
{
return this.internalEncode(param1,param1.width,param1.height);
}
private function internalEncode(param1:Object, param2:int, param3:int) : Boolean
{
if(this.Working)
{
return false;
}
this.Working = true;
this.Source = param1;
this.SrcWidth = param2;
this.SrcHeight = param3;
this.TotalSize = param2 * param3;
this.PercentageInc = this.TotalSize / 100;
this.NextProgressAt = this.PercentageInc;
this.CurrentTotalPos = 0;
setTimeout(this.StartEncode,10);
return true;
}
private function StartEncode() : void
{
this.byteout = new ByteArray();
this.bytenew = 0;
this.bytepos = 7;
this.writeWord(65496);
this.writeAPP0();
this.writeDQT();
this.writeSOF0(this.SrcWidth,this.SrcHeight);
this.writeDHT();
this.writeSOS();
this.DCY = 0;
this.DCV = 0;
this.DCU = 0;
this.bytenew = 0;
this.bytepos = 7;
this.dispatchEvent(new ProgressEvent(ProgressEvent.PROGRESS,false,false,0,this.TotalSize));
setTimeout(this.AsyncLoop,10,0,0);
}
private function AsyncLoop(param1:int, param2:int) : void
{
var _loc3_:int = 0;
while(_loc3_ < this.PixelsPerIter)
{
this.RGB2YUV(this.Source,param1,param2,this.SrcWidth,this.SrcHeight);
this.DCY = this.processDU(this.YDU,this.fdtbl_Y,this.DCY,this.YDC_HT,this.YAC_HT);
this.DCU = this.processDU(this.UDU,this.fdtbl_UV,this.DCU,this.UVDC_HT,this.UVAC_HT);
this.DCV = this.processDU(this.VDU,this.fdtbl_UV,this.DCV,this.UVDC_HT,this.UVAC_HT);
param1 += 8;
if(param1 >= this.SrcWidth)
{
param1 = 0;
param2 += 8;
}
if(param2 >= this.SrcHeight)
{
setTimeout(this.FinishEncode,10);
return;
}
this.CurrentTotalPos += 64;
if(this.CurrentTotalPos >= this.NextProgressAt)
{
this.dispatchEvent(new ProgressEvent(ProgressEvent.PROGRESS,false,false,this.CurrentTotalPos,this.TotalSize));
this.NextProgressAt += this.PercentageInc;
}
_loc3_++;
}
setTimeout(this.AsyncLoop,10,param1,param2);
}
private function FinishEncode() : void
{
var _loc1_:BitString = null;
if(this.bytepos >= 0)
{
_loc1_ = new BitString();
_loc1_.len = this.bytepos + 1;
_loc1_.val = (1 << this.bytepos + 1) - 1;
this.writeBits(_loc1_);
}
this.writeWord(65497);
this.dispatchEvent(new ProgressEvent(ProgressEvent.PROGRESS,false,false,this.TotalSize,this.TotalSize));
this.dispatchEvent(new JPEGAsyncCompleteEvent(this.byteout));
this.Working = false;
}
private function initQuantTables(param1:int) : void
{
var _loc3_:Number = NaN;
var _loc8_:int = 0;
var _loc2_:int = 0;
var _loc4_:Array = [16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22,37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99];
_loc2_ = 0;
while(_loc2_ < 64)
{
_loc3_ = Math.floor((_loc4_[_loc2_] * param1 + 50) / 100);
if(_loc3_ < 1)
{
_loc3_ = 1;
}
else if(_loc3_ > 255)
{
_loc3_ = 255;
}
this.YTable[this.ZigZag[_loc2_]] = _loc3_;
_loc2_++;
}
var _loc5_:Array = [17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99];
_loc2_ = 0;
while(_loc2_ < 64)
{
_loc3_ = Math.floor((_loc5_[_loc2_] * param1 + 50) / 100);
if(_loc3_ < 1)
{
_loc3_ = 1;
}
else if(_loc3_ > 255)
{
_loc3_ = 255;
}
this.UVTable[this.ZigZag[_loc2_]] = _loc3_;
_loc2_++;
}
var _loc6_:Array = [1,1.387039845,1.306562965,1.175875602,1,0.785694958,0.5411961,0.275899379];
_loc2_ = 0;
var _loc7_:int = 0;
while(_loc7_ < 8)
{
_loc8_ = 0;
while(_loc8_ < 8)
{
this.fdtbl_Y[_loc2_] = 1 / (this.YTable[this.ZigZag[_loc2_]] * _loc6_[_loc7_] * _loc6_[_loc8_] * 8);
this.fdtbl_UV[_loc2_] = 1 / (this.UVTable[this.ZigZag[_loc2_]] * _loc6_[_loc7_] * _loc6_[_loc8_] * 8);
_loc2_++;
_loc8_++;
}
_loc7_++;
}
}
private function computeHuffmanTbl(param1:Array, param2:Array) : Array
{
var _loc7_:int = 0;
var _loc3_:int = 0;
var _loc4_:int = 0;
var _loc5_:Array = new Array();
var _loc6_:int = 1;
while(_loc6_ <= 16)
{
_loc7_ = 1;
while(_loc7_ <= param1[_loc6_])
{
_loc5_[param2[_loc4_]] = new BitString();
_loc5_[param2[_loc4_]].val = _loc3_;
_loc5_[param2[_loc4_]].len = _loc6_;
_loc4_++;
_loc3_++;
_loc7_++;
}
_loc3_ *= 2;
_loc6_++;
}
return _loc5_;
}
private function initHuffmanTbl() : void
{
this.YDC_HT = this.computeHuffmanTbl(this.std_dc_luminance_nrcodes,this.std_dc_luminance_values);
this.UVDC_HT = this.computeHuffmanTbl(this.std_dc_chrominance_nrcodes,this.std_dc_chrominance_values);
this.YAC_HT = this.computeHuffmanTbl(this.std_ac_luminance_nrcodes,this.std_ac_luminance_values);
this.UVAC_HT = this.computeHuffmanTbl(this.std_ac_chrominance_nrcodes,this.std_ac_chrominance_values);
}
private function initCategoryNumber() : void
{
var _loc1_:int = 0;
var _loc2_:int = 1;
var _loc3_:int = 2;
var _loc4_:int = 1;
while(_loc4_ <= 15)
{
_loc1_ = _loc2_;
while(_loc1_ < _loc3_)
{
this.category[32767 + _loc1_] = _loc4_;
this.bitcode[32767 + _loc1_] = new BitString();
this.bitcode[32767 + _loc1_].len = _loc4_;
this.bitcode[32767 + _loc1_].val = _loc1_;
_loc1_++;
}
_loc1_ = -(_loc3_ - 1);
while(_loc1_ <= -_loc2_)
{
this.category[32767 + _loc1_] = _loc4_;
this.bitcode[32767 + _loc1_] = new BitString();
this.bitcode[32767 + _loc1_].len = _loc4_;
this.bitcode[32767 + _loc1_].val = _loc3_ - 1 + _loc1_;
_loc1_++;
}
_loc2_ <<= 1;
_loc3_ <<= 1;
_loc4_++;
}
}
private function writeBits(param1:BitString) : void
{
var _loc2_:int = param1.val;
var _loc3_:* = int(param1.len - 1);
while(_loc3_ >= 0)
{
if(_loc2_ & uint(1 << _loc3_))
{
this.bytenew |= uint(1 << this.bytepos);
}
_loc3_--;
--this.bytepos;
if(this.bytepos < 0)
{
if(this.bytenew == 255)
{
this.writeByte(255);
this.writeByte(0);
}
else
{
this.writeByte(this.bytenew);
}
this.bytepos = 7;
this.bytenew = 0;
}
}
}
private function writeByte(param1:int) : void
{
this.byteout.writeByte(param1);
}
private function writeWord(param1:int) : void
{
this.writeByte(param1 >> 8 & 0xFF);
this.writeByte(param1 & 0xFF);
}
private function fDCTQuant(param1:Array, param2:Array) : Array
{
var _loc4_:int = 0;
var _loc5_:Number = NaN;
var _loc6_:Number = NaN;
var _loc7_:Number = NaN;
var _loc8_:Number = NaN;
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc13_:Number = NaN;
var _loc14_:Number = NaN;
var _loc15_:Number = NaN;
var _loc16_:Number = NaN;
var _loc17_:Number = NaN;
var _loc18_:Number = NaN;
var _loc19_:Number = NaN;
var _loc20_:Number = NaN;
var _loc21_:Number = NaN;
var _loc22_:Number = NaN;
var _loc23_:Number = NaN;
var _loc3_:int = 0;
_loc4_ = 0;
while(_loc4_ < 8)
{
_loc5_ = param1[_loc3_ + 0] + param1[_loc3_ + 7];
_loc6_ = param1[_loc3_ + 0] - param1[_loc3_ + 7];
_loc7_ = param1[_loc3_ + 1] + param1[_loc3_ + 6];
_loc8_ = param1[_loc3_ + 1] - param1[_loc3_ + 6];
_loc9_ = param1[_loc3_ + 2] + param1[_loc3_ + 5];
_loc10_ = param1[_loc3_ + 2] - param1[_loc3_ + 5];
_loc11_ = param1[_loc3_ + 3] + param1[_loc3_ + 4];
_loc12_ = param1[_loc3_ + 3] - param1[_loc3_ + 4];
_loc13_ = _loc5_ + _loc11_;
_loc14_ = _loc5_ - _loc11_;
_loc15_ = _loc7_ + _loc9_;
_loc16_ = _loc7_ - _loc9_;
param1[_loc3_ + 0] = _loc13_ + _loc15_;
param1[_loc3_ + 4] = _loc13_ - _loc15_;
_loc17_ = (_loc16_ + _loc14_) * 0.707106781;
param1[_loc3_ + 2] = _loc14_ + _loc17_;
param1[_loc3_ + 6] = _loc14_ - _loc17_;
_loc13_ = _loc12_ + _loc10_;
_loc15_ = _loc10_ + _loc8_;
_loc16_ = _loc8_ + _loc6_;
_loc18_ = (_loc13_ - _loc16_) * 0.382683433;
_loc19_ = 0.5411961 * _loc13_ + _loc18_;
_loc20_ = 1.306562965 * _loc16_ + _loc18_;
_loc21_ = _loc15_ * 0.707106781;
_loc22_ = _loc6_ + _loc21_;
_loc23_ = _loc6_ - _loc21_;
param1[_loc3_ + 5] = _loc23_ + _loc19_;
param1[_loc3_ + 3] = _loc23_ - _loc19_;
param1[_loc3_ + 1] = _loc22_ + _loc20_;
param1[_loc3_ + 7] = _loc22_ - _loc20_;
_loc3_ += 8;
_loc4_++;
}
_loc3_ = 0;
_loc4_ = 0;
while(_loc4_ < 8)
{
_loc5_ = param1[_loc3_ + 0] + param1[_loc3_ + 56];
_loc6_ = param1[_loc3_ + 0] - param1[_loc3_ + 56];
_loc7_ = param1[_loc3_ + 8] + param1[_loc3_ + 48];
_loc8_ = param1[_loc3_ + 8] - param1[_loc3_ + 48];
_loc9_ = param1[_loc3_ + 16] + param1[_loc3_ + 40];
_loc10_ = param1[_loc3_ + 16] - param1[_loc3_ + 40];
_loc11_ = param1[_loc3_ + 24] + param1[_loc3_ + 32];
_loc12_ = param1[_loc3_ + 24] - param1[_loc3_ + 32];
_loc13_ = _loc5_ + _loc11_;
_loc14_ = _loc5_ - _loc11_;
_loc15_ = _loc7_ + _loc9_;
_loc16_ = _loc7_ - _loc9_;
param1[_loc3_ + 0] = _loc13_ + _loc15_;
param1[_loc3_ + 32] = _loc13_ - _loc15_;
_loc17_ = (_loc16_ + _loc14_) * 0.707106781;
param1[_loc3_ + 16] = _loc14_ + _loc17_;
param1[_loc3_ + 48] = _loc14_ - _loc17_;
_loc13_ = _loc12_ + _loc10_;
_loc15_ = _loc10_ + _loc8_;
_loc16_ = _loc8_ + _loc6_;
_loc18_ = (_loc13_ - _loc16_) * 0.382683433;
_loc19_ = 0.5411961 * _loc13_ + _loc18_;
_loc20_ = 1.306562965 * _loc16_ + _loc18_;
_loc21_ = _loc15_ * 0.707106781;
_loc22_ = _loc6_ + _loc21_;
_loc23_ = _loc6_ - _loc21_;
param1[_loc3_ + 40] = _loc23_ + _loc19_;
param1[_loc3_ + 24] = _loc23_ - _loc19_;
param1[_loc3_ + 8] = _loc22_ + _loc20_;
param1[_loc3_ + 56] = _loc22_ - _loc20_;
_loc3_++;
_loc4_++;
}
_loc4_ = 0;
while(_loc4_ < 64)
{
param1[_loc4_] = Math.round(param1[_loc4_] * param2[_loc4_]);
_loc4_++;
}
return param1;
}
private function writeAPP0() : void
{
this.writeWord(65504);
this.writeWord(16);
this.writeByte(74);
this.writeByte(70);
this.writeByte(73);
this.writeByte(70);
this.writeByte(0);
this.writeByte(1);
this.writeByte(1);
this.writeByte(0);
this.writeWord(1);
this.writeWord(1);
this.writeByte(0);
this.writeByte(0);
}
private function writeSOF0(param1:int, param2:int) : void
{
this.writeWord(65472);
this.writeWord(17);
this.writeByte(8);
this.writeWord(param2);
this.writeWord(param1);
this.writeByte(3);
this.writeByte(1);
this.writeByte(17);
this.writeByte(0);
this.writeByte(2);
this.writeByte(17);
this.writeByte(1);
this.writeByte(3);
this.writeByte(17);
this.writeByte(1);
}
private function writeDQT() : void
{
var _loc1_:int = 0;
this.writeWord(65499);
this.writeWord(132);
this.writeByte(0);
_loc1_ = 0;
while(_loc1_ < 64)
{
this.writeByte(this.YTable[_loc1_]);
_loc1_++;
}
this.writeByte(1);
_loc1_ = 0;
while(_loc1_ < 64)
{
this.writeByte(this.UVTable[_loc1_]);
_loc1_++;
}
}
private function writeDHT() : void
{
var _loc1_:int = 0;
this.writeWord(65476);
this.writeWord(418);
this.writeByte(0);
_loc1_ = 0;
while(_loc1_ < 16)
{
this.writeByte(this.std_dc_luminance_nrcodes[_loc1_ + 1]);
_loc1_++;
}
_loc1_ = 0;
while(_loc1_ <= 11)
{
this.writeByte(this.std_dc_luminance_values[_loc1_]);
_loc1_++;
}
this.writeByte(16);
_loc1_ = 0;
while(_loc1_ < 16)
{
this.writeByte(this.std_ac_luminance_nrcodes[_loc1_ + 1]);
_loc1_++;
}
_loc1_ = 0;
while(_loc1_ <= 161)
{
this.writeByte(this.std_ac_luminance_values[_loc1_]);
_loc1_++;
}
this.writeByte(1);
_loc1_ = 0;
while(_loc1_ < 16)
{
this.writeByte(this.std_dc_chrominance_nrcodes[_loc1_ + 1]);
_loc1_++;
}
_loc1_ = 0;
while(_loc1_ <= 11)
{
this.writeByte(this.std_dc_chrominance_values[_loc1_]);
_loc1_++;
}
this.writeByte(17);
_loc1_ = 0;
while(_loc1_ < 16)
{
this.writeByte(this.std_ac_chrominance_nrcodes[_loc1_ + 1]);
_loc1_++;
}
_loc1_ = 0;
while(_loc1_ <= 161)
{
this.writeByte(this.std_ac_chrominance_values[_loc1_]);
_loc1_++;
}
}
private function writeSOS() : void
{
this.writeWord(65498);
this.writeWord(12);
this.writeByte(3);
this.writeByte(1);
this.writeByte(0);
this.writeByte(2);
this.writeByte(17);
this.writeByte(3);
this.writeByte(17);
this.writeByte(0);
this.writeByte(63);
this.writeByte(0);
}
private function processDU(param1:Array, param2:Array, param3:Number, param4:Array, param5:Array) : Number
{
var _loc8_:int = 0;
var _loc12_:int = 0;
var _loc13_:int = 0;
var _loc14_:int = 0;
var _loc6_:BitString = param5[0];
var _loc7_:BitString = param5[240];
var _loc9_:Array = this.fDCTQuant(param1,param2);
_loc8_ = 0;
while(_loc8_ < 64)
{
this.DU[this.ZigZag[_loc8_]] = _loc9_[_loc8_];
_loc8_++;
}
var _loc10_:int = this.DU[0] - param3;
param3 = Number(this.DU[0]);
if(_loc10_ == 0)
{
this.writeBits(param4[0]);
}
else
{
this.writeBits(param4[this.category[32767 + _loc10_]]);
this.writeBits(this.bitcode[32767 + _loc10_]);
}
var _loc11_:* = 63;
while(_loc11_ > 0 && this.DU[_loc11_] == 0)
{
_loc11_--;
}
if(_loc11_ == 0)
{
this.writeBits(_loc6_);
return param3;
}
_loc8_ = 1;
while(_loc8_ <= _loc11_)
{
_loc12_ = _loc8_;
while(this.DU[_loc8_] == 0 && _loc8_ <= _loc11_)
{
_loc8_++;
}
_loc13_ = _loc8_ - _loc12_;
if(_loc13_ >= 16)
{
_loc14_ = 1;
while(_loc14_ <= _loc13_ / 16)
{
this.writeBits(_loc7_);
_loc14_++;
}
_loc13_ = int(_loc13_ & 0x0F);
}
this.writeBits(param5[_loc13_ * 16 + this.category[32767 + this.DU[_loc8_]]]);
this.writeBits(this.bitcode[32767 + this.DU[_loc8_]]);
_loc8_++;
}
if(_loc11_ != 63)
{
this.writeBits(_loc6_);
}
return param3;
}
private function RGB2YUV(param1:Object, param2:int, param3:int, param4:int = 0, param5:int = 0) : void
{
var _loc8_:int = 0;
var _loc9_:uint = 0;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc6_:int = 0;
var _loc7_:int = 0;
while(_loc7_ < 8)
{
_loc8_ = 0;
while(_loc8_ < 8)
{
_loc9_ = this.getPixel32(param1,param2 + _loc8_,param3 + _loc7_,param4,param5);
_loc10_ = Number(_loc9_ >> 16 & 0xFF);
_loc11_ = Number(_loc9_ >> 8 & 0xFF);
_loc12_ = Number(_loc9_ & 0xFF);
this.YDU[_loc6_] = 0.299 * _loc10_ + 0.587 * _loc11_ + 0.114 * _loc12_ - 128;
this.UDU[_loc6_] = -0.16874 * _loc10_ + -0.33126 * _loc11_ + 0.5 * _loc12_;
this.VDU[_loc6_] = 0.5 * _loc10_ + -0.41869 * _loc11_ + -0.08131 * _loc12_;
_loc6_++;
_loc8_++;
}
_loc7_++;
}
}
private function getPixel32(param1:Object, param2:int, param3:int, param4:int = 0, param5:int = 0) : uint
{
var _loc6_:BitmapData = null;
var _loc7_:ByteArray = null;
if(param1 is BitmapData)
{
_loc6_ = param1 as BitmapData;
return _loc6_.getPixel32(param2,param3);
}
if(param1 is ByteArray)
{
_loc7_ = param1 as ByteArray;
_loc7_.position = param3 * param4 * 4 + param2 * 4;
return _loc7_.readUnsignedInt();
}
throw new ArgumentError("The source argument must be an instance of flash.display.BitmapData or flash.utils.ByteArray.");
}
}
}
class BitString
{
public var len:int = 0;
public var val:int = 0;
public function BitString()
{
super();
}
}
@@ -0,0 +1,700 @@
package com.sbi.graphics
{
import com.sbi.loader.ImageServerEvent;
import com.sbi.loader.ImageServerURL;
import flash.display.DisplayObjectContainer;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;
public class LayerAnim
{
private static var _activePool:Array;
private static var _freePool:Array;
private static var _avOffsets:Array;
private static var _lastEntry:int;
private static var _useMaxThrottle:Function;
public static const PLAY_LOOP:int = 0;
public static const PLAY_ONE_SHOT:int = 1;
public static const PLAY_LOOP__KEEP_CURRENT_FRAME:int = 2;
public static const AN_SIT_NNE:int = 1;
public static const AN_SIT_NE:int = 2;
public static const AN_SIT_E:int = 3;
public static const AN_SIT_SE:int = 4;
public static const AN_SIT_SSE:int = 5;
public static const AN_MOVE_NNE:int = 7;
public static const AN_MOVE_NE:int = 8;
public static const AN_MOVE_E:int = 9;
public static const AN_MOVE_SE:int = 10;
public static const AN_MOVE_SSE:int = 11;
public static const AN_BBCARD:int = 13;
public static const AN_IDLE_SE:int = 14;
public static const AN_HUD_AVT:int = 15;
public static const AN_IDLE_NE:int = 16;
public static const AN_HOP:int = 17;
public static const AN_SLEEP:int = 22;
public static const AN_DANCE:int = 23;
public static const AN_PLAY:int = 6;
public static const AN_SWIM_N:int = 36;
public static const AN_SWIM_NE:int = 34;
public static const AN_SWIM_E:int = 29;
public static const AN_SWIM_SE:int = 35;
public static const AN_SWIM_S:int = 37;
public static const AN_FLOAT:int = 32;
public static const AN_WATER_DIVE:int = 41;
public static const AN_WATER_PLAY:int = 39;
public static const AN_WATER_SPIN:int = 33;
public static const AN_WATER_JIG:int = 38;
public static const AN_WATER_POSE:int = 40;
public static const AN_PHOTO:int = 42;
public static const AN_PARACHUTE_IDLE:int = 19;
public static const AN_PARACHUTE_JUMP:int = 24;
public static const AN_PARACHUTE_DISTRESS:int = 20;
public static const AN_PARACHUTE_LAND:int = 21;
public static const AN_WINDRIDER_JUMP:int = 28;
public static const AN_WINDRIDER_IDLE:int = 29;
public static const AN_WINDRIDER_FALL:int = 30;
public static const AN_WINDRIDER_START:int = 31;
public static const AN_WINDRIDER_DISTRESS:int = 20;
public static const AVATAR_BITMAP_OFFSET_X:int = 375;
public static const AVATAR_BITMAP_OFFSET_Y:int = 365;
private static var _throttle:int = 8;
private var _bitmap:LayerBitmap;
private var _avDefId:int;
private var _animId:int;
private var _frame:int;
private var _hFlip:Boolean;
private var _totalFrames:int;
private var _x:int;
private var _y:int;
private var _rotation:int;
private var _xOff:int;
private var _yOff:int;
private var _bPause:Boolean;
private var _layers:Array;
private var _colors:Array;
private var _callback:Function;
private var _mode:int;
private var _tStep:int;
private var _bRedraw:Boolean;
private var _bReload:Boolean;
private var _bBaseLayer:Boolean;
private var _bNewAnim:Boolean;
private var _requestAnimId:int;
private var _receivedData:Array;
private var _requestedIds:Array;
private var _requestCallback:Function;
private var _requestMode:int;
private var _preloadRequestedIds:Array;
private var _preloadCallback:Function;
public function LayerAnim(param1:Class)
{
super();
if(param1 != SingletonLock)
{
throw new Error("Invalid access. Use LayerAnim.getNew");
}
this._requestedIds = new Array();
this._colors = new Array();
}
public static function set avOffsets(param1:Array) : void
{
_avOffsets = param1;
}
public static function getAvOffset(param1:int) : Point
{
if(_avOffsets[param1])
{
return _avOffsets[param1];
}
return new Point(-100,-100);
}
public static function set throttle(param1:int) : void
{
_throttle = param1;
}
public static function getNew() : LayerAnim
{
var _loc1_:LayerAnim = null;
if(!_activePool)
{
_activePool = new Array();
_freePool = new Array();
}
if(_freePool.length)
{
_loc1_ = _freePool.pop();
}
else
{
_loc1_ = new LayerAnim(SingletonLock);
}
_activePool.push(_loc1_);
_loc1_.init();
return _loc1_;
}
public static function destroy(param1:LayerAnim) : void
{
var _loc2_:int = _activePool.indexOf(param1);
if(_loc2_ >= 0)
{
_activePool.splice(_loc2_,1);
param1.destroy();
_freePool.push(param1);
}
}
public static function heartbeat() : void
{
var _loc1_:int = 0;
var _loc2_:* = 0;
var _loc3_:* = 0;
var _loc4_:* = 0;
var _loc5_:LayerAnim = null;
var _loc6_:int = 0;
if(Boolean(_activePool) && Boolean(_activePool.length))
{
_loc1_ = int(_activePool.length);
_loc2_ = _loc1_;
_loc3_ = int(_loc1_ * 0.5);
if(_loc3_ < 1 || Boolean(_useMaxThrottle) && Boolean(_useMaxThrottle()))
{
_loc3_ = 1;
}
if(_loc3_ > _throttle)
{
_loc3_ = _throttle;
}
_loc4_ = _lastEntry;
for each(_loc5_ in _activePool)
{
++_loc5_._tStep;
}
while(_loc3_ > 0 && _loc2_ > 0)
{
if(_loc4_ >= _loc1_)
{
_loc4_ = 0;
}
_loc5_ = _activePool[_loc4_++];
_loc6_ = _loc5_._tStep;
if(_loc6_ >= 2)
{
if((_loc5_._requestMode == PLAY_ONE_SHOT || isOnscreen(_loc5_)) && _loc5_.heartbeat())
{
_loc5_._tStep = 0;
_loc3_--;
}
}
_loc2_--;
}
_lastEntry = _loc4_;
}
}
private static function isOnscreen(param1:LayerAnim) : Boolean
{
var _loc3_:int = 0;
var _loc4_:int = 0;
var _loc5_:int = 0;
var _loc6_:int = 0;
var _loc7_:Rectangle = null;
var _loc2_:DisplayObjectContainer = param1.bitmap.parent;
if(_loc2_)
{
_loc3_ = 0;
_loc4_ = 900;
_loc5_ = 0;
_loc6_ = 550;
_loc7_ = _loc2_.getBounds(gMainFrame.stage);
return _loc7_.height == 0 || !(_loc6_ < _loc7_.top || _loc5_ > _loc7_.bottom || _loc4_ < _loc7_.left || _loc3_ > _loc7_.right);
}
return true;
}
public static function set useMaxThrottle(param1:Function) : void
{
_useMaxThrottle = param1;
}
private function init() : void
{
this._bitmap = new LayerBitmap();
this._layers = null;
this._requestAnimId = -1;
this._avDefId = -1;
this._animId = -1;
this._bNewAnim = false;
this._totalFrames = 0;
this._bReload = true;
this._tStep = 1;
}
private function destroy() : void
{
this._bitmap = null;
this._layers = null;
if(this._requestedIds.length != 0)
{
ImageServerURL.instance.removeEventListener(ImageServerEvent.ON_NEW_DATA,this.onReceiveData);
this._requestedIds.splice(0,this._requestedIds.length);
}
}
public function set avDefId(param1:int) : void
{
if(param1 != this._avDefId)
{
this._avDefId = param1;
this._xOff = -getAvOffset(this._avDefId).x - AVATAR_BITMAP_OFFSET_X;
this._yOff = -getAvOffset(this._avDefId).y - AVATAR_BITMAP_OFFSET_Y;
this._bReload = true;
}
}
public function get layers() : Array
{
return this._layers;
}
public function get avDefId() : int
{
return this._avDefId;
}
public function get animId() : int
{
return this._animId;
}
public function get hFlip() : Boolean
{
return this._hFlip;
}
public function get frame() : int
{
return this._frame;
}
public function set frame(param1:int) : void
{
this._frame = param1;
}
public function set layers(param1:Array) : void
{
var _loc2_:int = 0;
var _loc5_:Object = null;
var _loc6_:int = 0;
var _loc3_:Boolean = true;
var _loc4_:Boolean = false;
if(Boolean(this._layers) && this._layers.length == param1.length)
{
_loc3_ = false;
_loc2_ = 0;
while(_loc2_ < param1.length)
{
if(this._layers[_loc2_].l != param1[_loc2_].l)
{
_loc3_ = true;
break;
}
if(this._layers[_loc2_].c != param1[_loc2_].c)
{
_loc4_ = true;
}
_loc2_++;
}
if(!_loc3_ && !_loc4_)
{
return;
}
}
if(param1.length > 0)
{
this._layers = param1;
if(_loc3_)
{
this._bReload = true;
}
else if(_loc4_)
{
for each(_loc5_ in param1)
{
_loc6_ = ImageServerURL.instance.getLayerIndex(_loc5_.l);
this._bitmap.setLayerColor(_loc6_,_loc5_.c);
}
this._bRedraw = true;
}
}
}
public function get x() : int
{
return this._x;
}
public function get y() : int
{
return this._y;
}
public function set x(param1:int) : void
{
this._x = param1;
}
public function set y(param1:int) : void
{
this._y = param1;
}
public function set alpha(param1:Number) : void
{
this._bitmap.alpha = param1;
}
public function set rotation(param1:Number) : void
{
this._rotation = param1;
}
public function set hFlip(param1:Boolean) : void
{
if(param1 != this._hFlip)
{
this._hFlip = param1;
this._bRedraw = true;
}
}
public function set visible(param1:Boolean) : void
{
this._bitmap.visible = param1;
}
public function set pause(param1:Boolean) : void
{
this._bPause = param1;
}
public function get bitmap() : LayerBitmap
{
return this._bitmap;
}
public function playAnim(param1:int, param2:int = 0, param3:Function = null) : void
{
if(this._requestAnimId == -1 && param1 != this._animId || this._requestAnimId != param1)
{
this._requestCallback = param3;
this._requestMode = param2;
this._requestAnimId = param1;
this._bReload = true;
}
}
public function preload(param1:Array, param2:Function) : void
{
var _loc3_:int = 0;
this._preloadCallback = param2;
this._preloadRequestedIds = [];
while(_loc3_ < param1.length)
{
this.buildRequestArray(param1[_loc3_],this._preloadRequestedIds,null);
_loc3_++;
}
ImageServerURL.instance.addEventListener(ImageServerEvent.ON_NEW_DATA,this.onReceiveData);
ImageServerURL.instance.requestImages(this._preloadRequestedIds.slice());
}
private function heartbeat() : Boolean
{
var _loc1_:Boolean = false;
if(this._bReload)
{
this.loadAnim();
}
if(this._totalFrames == 0)
{
return false;
}
if(this._frame >= this._totalFrames)
{
if(this._mode == PLAY_ONE_SHOT)
{
this._frame = this._totalFrames > 0 ? int(this._totalFrames - 1) : 0;
}
else
{
this._frame = 0;
}
if(this._callback != null)
{
this._callback(this,this._animId);
if(this._mode == PLAY_ONE_SHOT)
{
this._callback = null;
}
}
}
if(this._bRedraw)
{
this._bitmap.invalidate();
this._bRedraw = false;
}
_loc1_ = this._bitmap.paint(this._frame,this._hFlip);
this.updateBitmapPos();
if(!this._bPause)
{
++this._frame;
}
return _loc1_;
}
private function loadAnim() : void
{
var _loc1_:int = 0;
if(this._layers != null && this._layers.length > 0)
{
_loc1_ = this._requestAnimId != -1 ? this._requestAnimId : this._animId;
if(_loc1_ >= 0)
{
this._requestAnimId = _loc1_;
this.requestAnim(_loc1_);
}
}
}
public function updateBitmapPos() : void
{
var _loc4_:Matrix = null;
var _loc1_:Point = this._bitmap.anchorPoint;
var _loc2_:int = this._x + _loc1_.x + this._xOff;
var _loc3_:int = this._y + _loc1_.y + this._yOff;
if(this._rotation)
{
_loc4_ = this._bitmap.transform.matrix;
_loc4_.identity();
_loc4_.translate(_loc1_.x + this._xOff,_loc1_.y + this._yOff);
_loc4_.rotate(this._rotation * (Math.PI / 180));
_loc4_.translate(_loc2_,_loc3_);
this._bitmap.transform.matrix = _loc4_;
}
else
{
if(this._bitmap.rotation != this._rotation)
{
this._bitmap.rotation = this._rotation;
}
this._bitmap.x = _loc2_;
this._bitmap.y = _loc3_;
}
}
private function requestAnim(param1:int) : void
{
this._bNewAnim = false;
this._requestedIds.splice(0,this._requestedIds.length);
this._colors = [];
this._receivedData = [];
this.buildRequestArray(param1,this._requestedIds,this._colors);
ImageServerURL.instance.addEventListener(ImageServerEvent.ON_NEW_DATA,this.onReceiveData);
ImageServerURL.instance.requestImages(this._requestedIds.slice());
this._bReload = false;
this._bBaseLayer = false;
}
private function buildRequestArray(param1:int, param2:Array, param3:Array) : void
{
var _loc4_:Object = null;
var _loc5_:uint = 0;
param2.push(ImageArrayHelper.packId(this._avDefId,param1,0));
for each(_loc4_ in this._layers)
{
_loc5_ = ImageArrayHelper.packId(this._avDefId,param1,_loc4_.l);
param2.push(_loc5_);
if(param3)
{
param3[_loc5_] = _loc4_.c;
}
}
}
private function onReceiveData(param1:ImageServerEvent) : void
{
var _loc2_:int = 0;
var _loc4_:uint = 0;
var _loc5_:Object = null;
var _loc3_:int = param1.layer;
if(Boolean(this._preloadRequestedIds) && Boolean(this._preloadRequestedIds.length))
{
_loc2_ = this._preloadRequestedIds.indexOf(param1.id);
if(_loc2_ >= 0)
{
this._preloadRequestedIds.splice(_loc2_,1);
if(this._preloadRequestedIds.length == 0)
{
this._preloadRequestedIds = null;
if(this._requestedIds.length == 0)
{
ImageServerURL.instance.removeEventListener(ImageServerEvent.ON_NEW_DATA,this.onReceiveData);
}
if(this._preloadCallback != null)
{
this._preloadCallback(this);
}
}
return;
}
}
_loc2_ = this._requestedIds.indexOf(param1.id);
if(_loc2_ >= 0)
{
this._requestedIds.splice(_loc2_,1);
if(_loc3_ > 0)
{
_loc4_ = uint(this._colors[param1.id]);
}
if(param1.success)
{
this._receivedData.push({
"l":_loc3_,
"d":param1.imageData,
"c":_loc4_
});
}
if(this._requestedIds.length == 0)
{
this._bNewAnim = true;
if(this._preloadRequestedIds == null)
{
ImageServerURL.instance.removeEventListener(ImageServerEvent.ON_NEW_DATA,this.onReceiveData);
}
}
if(_loc3_ == 1 || this._bNewAnim)
{
this._bBaseLayer = true;
if(this._mode == LayerAnim.PLAY_LOOP__KEEP_CURRENT_FRAME)
{
this._mode == LayerAnim.PLAY_LOOP;
}
else
{
this._frame = 0;
}
if(this._requestAnimId >= 0)
{
this._animId = this._requestAnimId;
}
this._callback = this._requestCallback;
this._mode = this._requestMode;
this._requestAnimId = -1;
this._bitmap.release();
}
if(this._bBaseLayer)
{
for each(_loc5_ in this._receivedData)
{
this._bitmap.setLayer(_loc5_.l,_loc5_.d,_loc5_.c);
}
this._totalFrames = this._bitmap.length;
}
}
}
}
}
class SingletonLock
{
public function SingletonLock()
{
super();
}
}
@@ -0,0 +1,651 @@
package com.sbi.graphics
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.utils.ByteArray;
public class LayerBitmap extends Bitmap
{
private const _backgroundColor:uint = 0;
private var _anchorPoint:Point;
private var _layers:Array;
private var _bmin:Point;
private var _bmax:Point;
private var _lastFrame:int;
private var _lastHFlip:Boolean;
private var _blendColor:uint;
private var _bColorChanged:Boolean;
public function LayerBitmap()
{
super();
this._layers = new Array();
this._anchorPoint = new Point();
this._bmin = new Point();
this._bmax = new Point();
}
public function get length() : int
{
var _loc1_:Object = this._layers[0];
if(!_loc1_)
{
_loc1_ = this._layers[1];
}
if(!_loc1_)
{
return 0;
}
return _loc1_.o.f.length;
}
public function release() : void
{
this._layers.splice(0,this._layers.length);
this._lastFrame = -1;
this._bColorChanged = false;
}
public function invalidate() : void
{
this._lastFrame = -1;
}
public function setLayer(param1:int, param2:Object, param3:uint) : void
{
if(param1 < 0 || param1 > 10)
{
return;
}
if(param2)
{
if(this._layers[param1] == null)
{
this._layers[param1] = {
"c":-1,
"lastColor":-1,
"blendColor":0
};
}
this._layers[param1].o = param2;
}
else
{
this._layers[param1] = null;
}
this.setLayerColor(param1,param3);
this._lastFrame = -1;
}
public function setLayerColor(param1:int, param2:uint) : void
{
var _loc3_:Object = this._layers[param1];
if(Boolean(_loc3_) && param2 != _loc3_.c)
{
_loc3_.c = param2;
this._bColorChanged = true;
}
}
public function setBlendColor(param1:uint) : void
{
if(this._blendColor != param1)
{
this._blendColor = param1;
this._bColorChanged = true;
}
}
public function get anchorPoint() : Point
{
return this._anchorPoint;
}
private function refreshLayerPalette(param1:int) : void
{
var _loc3_:uint = 0;
var _loc4_:Array = null;
var _loc5_:int = 0;
var _loc6_:int = 0;
var _loc7_:int = 0;
var _loc8_:int = 0;
var _loc9_:int = 0;
var _loc2_:Object = this._layers[param1];
if(Boolean(_loc2_) && (_loc2_.lastColor != _loc2_.c || _loc2_.blendColor != this._blendColor))
{
_loc3_ = uint(_loc2_.c);
_loc4_ = PaletteHelper.gamePalette;
_loc5_ = _loc3_ >> 24 & 0xFF;
_loc6_ = _loc3_ >> 16 & 0xFF;
_loc7_ = _loc3_ >> 8 & 0xFF;
_loc8_ = _loc3_ & 0xFF;
if(!_loc2_.pal)
{
_loc2_.pal = [];
}
PaletteHelper.BuildAnimalPalette(_loc2_.pal,_loc4_[_loc5_],_loc4_[_loc6_],_loc4_[_loc7_],_loc4_[_loc8_]);
_loc9_ = this._blendColor >> 24 & 0xFF;
if(param1 != 3)
{
if(_loc9_ > 0)
{
PaletteHelper.adjustPaletteColor(_loc2_.pal,this._blendColor);
}
_loc2_.blendColor = this._blendColor;
}
_loc2_.lastColor = _loc3_;
this._lastFrame = -1;
}
}
private function refreshAllPalettes() : void
{
var _loc1_:int = 1;
while(_loc1_ <= 10)
{
this.refreshLayerPalette(_loc1_);
_loc1_++;
}
this._bColorChanged = false;
}
private function calcBounds(param1:int) : void
{
var _loc3_:Object = null;
var _loc4_:Object = null;
var _loc5_:int = 0;
var _loc6_:Object = null;
var _loc7_:int = 0;
var _loc8_:int = 0;
var _loc9_:int = 0;
var _loc10_:int = 0;
this._bmin.x = 1000;
this._bmin.y = 1000;
this._bmax.x = 0;
this._bmax.y = 0;
var _loc2_:int = 1;
while(_loc2_ < this._layers.length)
{
_loc3_ = this._layers[_loc2_];
if(_loc3_ != null)
{
_loc4_ = _loc3_.o;
if(_loc4_.v != ImageArray.VERSION)
{
return;
}
_loc5_ = int(_loc4_.f.length);
if(param1 < _loc5_)
{
_loc6_ = _loc4_.f[param1];
if(_loc6_)
{
_loc7_ = int(_loc6_.x);
_loc8_ = int(_loc6_.y);
_loc9_ = int(_loc6_.w);
_loc10_ = int(_loc6_.h);
if(_loc7_ < this._bmin.x)
{
this._bmin.x = _loc7_;
}
if(_loc8_ < this._bmin.y)
{
this._bmin.y = _loc8_;
}
if(_loc7_ + _loc9_ > this._bmax.x)
{
this._bmax.x = _loc7_ + _loc9_;
}
if(_loc8_ + _loc10_ > this._bmax.y)
{
this._bmax.y = _loc8_ + _loc10_;
}
}
}
}
_loc2_++;
}
if(this._bmin.x == 1000 || this._bmin.y == 1000)
{
if(this.bitmapData)
{
this.bitmapData = new BitmapData(1,1,true,this._backgroundColor);
}
return;
}
this.resizeBitmap(1 + this._bmax.x - this._bmin.x,1 + this._bmax.y - this._bmin.y,true);
this._anchorPoint.x = this._bmin.x;
this._anchorPoint.y = this._bmin.y;
}
public function paint(param1:int, param2:Boolean = false, param3:Boolean = true) : Boolean
{
var _loc4_:Object = null;
var _loc5_:Boolean = false;
var _loc6_:int = 0;
if(param3 && this._layers[0] != null)
{
_loc4_ = this._layers[0];
param1 = int(_loc4_.o.f[param1]);
}
if(param1 != this._lastFrame || param2 != this._lastHFlip || this._bColorChanged)
{
if(this._bColorChanged)
{
this.refreshAllPalettes();
}
this._lastFrame = param1;
this._lastHFlip = param2;
this.calcBounds(param1);
_loc6_ = 1;
while(_loc6_ < this._layers.length)
{
_loc4_ = this._layers[_loc6_];
if(_loc4_ != null)
{
this.paintFrame(_loc4_.o,param1,_loc4_.pal,param2);
}
_loc6_++;
}
_loc5_ = true;
if(param2)
{
this._anchorPoint.x = 500 - this._bmax.x;
}
}
return _loc5_;
}
private function paintFrame(param1:Object, param2:int, param3:Array, param4:Boolean) : void
{
var _loc15_:int = 0;
var _loc16_:int = 0;
var _loc17_:uint = 0;
var _loc18_:uint = 0;
var _loc19_:int = 0;
var _loc20_:int = 0;
var _loc21_:int = 0;
var _loc22_:int = 0;
var _loc23_:int = 0;
var _loc24_:int = 0;
var _loc25_:int = 0;
var _loc26_:int = 0;
var _loc28_:int = 0;
var _loc29_:Number = NaN;
var _loc30_:uint = 0;
var _loc31_:int = 0;
if(param2 >= param1.f.length)
{
return;
}
var _loc5_:Object = param1.f[param2];
if(!_loc5_)
{
return;
}
var _loc6_:BitmapData = this.bitmapData;
var _loc7_:ByteArray = _loc5_.b;
var _loc8_:int = int(_loc5_.x);
var _loc9_:int = int(_loc5_.y);
var _loc10_:int = int(_loc5_.w);
var _loc11_:int = int(_loc5_.h);
_loc8_ -= this._bmin.x;
_loc9_ -= this._bmin.y;
_loc10_ += _loc8_;
_loc7_.position = 0;
var _loc12_:int = int(_loc7_.length);
var _loc13_:* = _loc8_;
var _loc14_:int = _loc9_;
this.bitmapData.lock();
var _loc27_:int = _loc10_ - _loc8_;
if(!param4)
{
while(_loc7_.position < _loc12_)
{
_loc15_ = int(_loc7_.readUnsignedByte());
_loc16_ = 1;
if((_loc15_ & 0x80) == 128)
{
_loc15_ &= 127;
_loc16_ = _loc7_.readUnsignedByte() + 1;
}
if(_loc15_ == 0)
{
_loc13_ += _loc16_;
if(_loc13_ >= _loc10_)
{
_loc16_ = _loc13_ - _loc10_;
_loc13_ = int(_loc8_ + _loc16_ % _loc27_);
_loc14_ += _loc16_ / _loc27_ + 1;
}
}
else
{
_loc17_ = uint(param3[_loc15_]);
if(_loc17_ >= 4278190080)
{
if(_loc13_ + _loc16_ < _loc10_)
{
while(--_loc16_ > -1)
{
_loc6_.setPixel32(_loc13_++,_loc14_,_loc17_);
}
}
else
{
while(--_loc16_ > -1)
{
_loc6_.setPixel32(_loc13_++,_loc14_,_loc17_);
if(_loc13_ == _loc10_)
{
_loc13_ = _loc8_;
_loc14_++;
}
}
}
}
else
{
while(--_loc16_ > -1)
{
_loc18_ = _loc6_.getPixel32(_loc13_,_loc14_);
if(_loc18_ != this._backgroundColor)
{
_loc19_ = _loc17_ >> 24 & 0xFF;
_loc20_ = _loc17_ >> 16 & 0xFF;
_loc21_ = _loc17_ >> 8 & 0xFF;
_loc22_ = _loc17_ & 0xFF;
_loc23_ = _loc18_ >> 24 & 0xFF;
_loc24_ = _loc18_ >> 16 & 0xFF;
_loc25_ = _loc18_ >> 8 & 0xFF;
_loc26_ = _loc18_ & 0xFF;
if(_loc19_ == 192)
{
_loc20_ = (_loc20_ + _loc20_ + _loc20_ + _loc24_) * 0.25;
_loc21_ = (_loc21_ + _loc21_ + _loc21_ + _loc25_) * 0.25;
_loc22_ = (_loc22_ + _loc22_ + _loc22_ + _loc26_) * 0.25;
}
else if(_loc19_ == 128)
{
_loc20_ = (_loc20_ + _loc24_) * 0.5;
_loc21_ = (_loc21_ + _loc25_) * 0.5;
_loc22_ = (_loc22_ + _loc26_) * 0.5;
}
else
{
_loc20_ = (_loc20_ + _loc24_ + _loc24_ + _loc24_) * 0.25;
_loc21_ = (_loc21_ + _loc25_ + _loc25_ + _loc25_) * 0.25;
_loc22_ = (_loc22_ + _loc26_ + _loc26_ + _loc26_) * 0.25;
}
if(_loc23_ > _loc19_)
{
_loc19_ = _loc23_;
}
_loc17_ = uint(_loc19_ << 24 | _loc20_ << 16 | _loc21_ << 8 | _loc22_);
}
_loc6_.setPixel32(_loc13_++,_loc14_,_loc17_);
if(_loc13_ == _loc10_)
{
_loc13_ = _loc8_;
_loc14_++;
}
}
}
}
}
}
else
{
_loc28_ = this._bmax.x - this._bmin.x;
while(_loc7_.position < _loc12_)
{
_loc15_ = int(_loc7_.readUnsignedByte());
_loc16_ = 1;
if((_loc15_ & 0x80) == 128)
{
_loc15_ &= 127;
_loc16_ = _loc7_.readUnsignedByte() + 1;
}
if(_loc15_ == 0)
{
_loc13_ += _loc16_;
if(_loc13_ >= _loc10_)
{
_loc16_ = _loc13_ - _loc10_;
_loc13_ = int(_loc8_ + _loc16_ % _loc27_);
_loc14_ += _loc16_ / _loc27_ + 1;
}
}
else
{
_loc17_ = uint(param3[_loc15_]);
if(_loc17_ >= 4278190080)
{
if(_loc13_ + _loc16_ < _loc10_)
{
while(--_loc16_ > -1)
{
_loc6_.setPixel32(_loc28_ - _loc13_++,_loc14_,_loc17_);
}
}
else
{
while(--_loc16_ > -1)
{
_loc6_.setPixel32(_loc28_ - _loc13_++,_loc14_,_loc17_);
if(_loc13_ == _loc10_)
{
_loc13_ = _loc8_;
_loc14_++;
}
}
}
}
else
{
while(--_loc16_ > -1)
{
_loc18_ = _loc6_.getPixel32(_loc28_ - _loc13_,_loc14_);
if(_loc18_ != this._backgroundColor)
{
_loc19_ = _loc17_ >> 24 & 0xFF;
_loc20_ = _loc17_ >> 16 & 0xFF;
_loc21_ = _loc17_ >> 8 & 0xFF;
_loc22_ = _loc17_ & 0xFF;
_loc23_ = _loc18_ >> 24 & 0xFF;
_loc24_ = _loc18_ >> 16 & 0xFF;
_loc25_ = _loc18_ >> 8 & 0xFF;
_loc26_ = _loc18_ & 0xFF;
switch(_loc19_)
{
case 192:
_loc20_ = (_loc20_ + _loc20_ + _loc20_ + _loc24_) * 0.25;
_loc21_ = (_loc21_ + _loc21_ + _loc21_ + _loc25_) * 0.25;
_loc22_ = (_loc22_ + _loc22_ + _loc22_ + _loc26_) * 0.25;
break;
case 128:
_loc20_ = (_loc20_ + _loc24_) * 0.5;
_loc21_ = (_loc21_ + _loc25_) * 0.5;
_loc22_ = (_loc22_ + _loc26_) * 0.5;
break;
case 64:
_loc20_ = (_loc20_ + _loc24_ + _loc24_ + _loc24_) * 0.25;
_loc21_ = (_loc21_ + _loc25_ + _loc25_ + _loc25_) * 0.25;
_loc22_ = (_loc22_ + _loc26_ + _loc26_ + _loc26_) * 0.25;
}
if(_loc23_ > _loc19_)
{
_loc19_ = _loc23_;
}
_loc17_ = uint(_loc19_ << 24 | _loc20_ << 16 | _loc21_ << 8 | _loc22_);
}
_loc6_.setPixel32(_loc28_ - _loc13_++,_loc14_,_loc17_);
if(_loc13_ == _loc10_)
{
_loc13_ = _loc8_;
_loc14_++;
}
}
}
}
}
}
if(_loc5_.hasOwnProperty("s"))
{
_loc31_ = int(_loc5_.sm);
_loc7_ = _loc5_.s;
_loc12_ = int(_loc7_.length);
_loc7_.position = 0;
_loc13_ = _loc8_;
_loc14_ = _loc9_;
if(!param4)
{
while(_loc7_.position < _loc12_)
{
_loc15_ = int(_loc7_.readUnsignedByte());
_loc16_ = 1;
if((_loc15_ & 0x80) == 128)
{
_loc15_ &= 127;
_loc16_ = _loc7_.readUnsignedByte() + 1;
}
if(_loc15_ == 0)
{
_loc13_ += _loc16_;
if(_loc13_ >= _loc10_)
{
_loc16_ = _loc13_ - _loc10_;
_loc13_ = int(_loc8_ + _loc16_ % _loc27_);
_loc14_ += _loc16_ / _loc27_ + 1;
}
}
else
{
_loc17_ = uint(_loc15_ << _loc31_);
_loc17_ = _loc17_ + 24;
if(_loc17_ > 255)
{
_loc29_ = 1;
}
else
{
_loc29_ = _loc17_ / 255;
}
while(--_loc16_ > -1)
{
_loc18_ = _loc6_.getPixel32(_loc13_,_loc14_);
if(_loc18_ != this._backgroundColor)
{
_loc19_ = _loc18_ >> 24 & 0xFF;
_loc20_ = (_loc18_ >> 16 & 0xFF) * _loc29_;
_loc21_ = (_loc18_ >> 8 & 0xFF) * _loc29_;
_loc22_ = (_loc18_ & 0xFF) * _loc29_;
_loc30_ = uint(_loc19_ << 24 | _loc20_ << 16 | _loc21_ << 8 | _loc22_);
_loc6_.setPixel32(_loc13_,_loc14_,_loc30_);
}
if(++_loc13_ == _loc10_)
{
_loc13_ = _loc8_;
_loc14_++;
}
}
}
}
}
else
{
_loc28_ = this._bmax.x - this._bmin.x;
while(_loc7_.position < _loc12_)
{
_loc15_ = int(_loc7_.readUnsignedByte());
_loc16_ = 1;
if((_loc15_ & 0x80) == 128)
{
_loc15_ &= 127;
_loc16_ = _loc7_.readUnsignedByte() + 1;
}
if(_loc15_ == 0)
{
_loc13_ += _loc16_;
if(_loc13_ >= _loc10_)
{
_loc16_ = _loc13_ - _loc10_;
_loc13_ = int(_loc8_ + _loc16_ % _loc27_);
_loc14_ += _loc16_ / _loc27_ + 1;
}
}
else
{
_loc17_ = uint(_loc15_ << _loc31_);
_loc17_ = _loc17_ + 24;
if(_loc17_ > 255)
{
_loc29_ = 1;
}
else
{
_loc29_ = _loc17_ / 255;
}
while(--_loc16_ > -1)
{
_loc18_ = _loc6_.getPixel32(_loc28_ - _loc13_,_loc14_);
if(_loc18_ != this._backgroundColor)
{
_loc19_ = _loc18_ >> 24 & 0xFF;
_loc20_ = (_loc18_ >> 16 & 0xFF) * _loc29_;
_loc21_ = (_loc18_ >> 8 & 0xFF) * _loc29_;
_loc22_ = (_loc18_ & 0xFF) * _loc29_;
_loc30_ = uint(_loc19_ << 24 | _loc20_ << 16 | _loc21_ << 8 | _loc22_);
_loc6_.setPixel32(_loc28_ - _loc13_,_loc14_,_loc30_);
}
if(++_loc13_ == _loc10_)
{
_loc13_ = _loc8_;
_loc14_++;
}
}
}
}
}
}
_loc6_.unlock();
}
private function resizeBitmap(param1:int, param2:int, param3:Boolean) : void
{
var _loc4_:int = param1;
var _loc5_:int = param2;
if(!this.bitmapData)
{
param3 = true;
}
var _loc6_:Rectangle = new Rectangle(0,0,_loc4_,_loc5_);
var _loc7_:ByteArray = null;
if(!param3)
{
_loc7_ = this.bitmapData.getPixels(_loc6_);
}
if(this.bitmapData)
{
this.bitmapData.dispose();
}
this.bitmapData = new BitmapData(param1,param2,true,this._backgroundColor);
if(!param3)
{
this.bitmapData.setPixels(_loc6_,_loc7_);
}
}
}
}
@@ -0,0 +1,246 @@
package com.sbi.graphics
{
import flash.utils.ByteArray;
public class PaletteHelper
{
public static var gamePalette:Array;
public static var avatarPalette1:Array;
public static var avatarPalette2:Array;
private static const PALETTE_ALPHA_OFFSET:int = 25;
public function PaletteHelper()
{
super();
}
public static function setGamePalette(param1:ByteArray, param2:ByteArray = null, param3:ByteArray = null) : void
{
var _loc4_:int = param1.length / 4;
gamePalette = new Array(_loc4_);
var _loc5_:* = 0;
while(_loc5_ < _loc4_)
{
var _loc6_:Number;
gamePalette[_loc6_ = _loc5_++] = param1.readUnsignedInt();
}
if(param2)
{
_loc4_ = int(param2.length);
avatarPalette1 = new Array(_loc4_);
_loc5_ = 0;
while(_loc5_ < _loc4_)
{
avatarPalette1[_loc6_ = _loc5_++] = param2.readUnsignedByte();
}
}
if(param3)
{
param3.position = 0;
_loc4_ = int(param3.length);
avatarPalette2 = new Array(_loc4_);
_loc5_ = 0;
while(_loc5_ < _loc4_)
{
avatarPalette2[_loc6_ = _loc5_++] = param3.readUnsignedByte();
}
}
}
public static function mixColors(param1:uint, param2:uint) : uint
{
var _loc3_:uint = uint(param1 >> 16 & 0xFF);
var _loc4_:uint = uint(param1 >> 8 & 0xFF);
var _loc5_:uint = uint(param1 & 0xFF);
var _loc6_:uint = uint(param2 >> 16 & 0xFF);
var _loc7_:uint = uint(param2 >> 8 & 0xFF);
var _loc8_:uint = uint(param2 & 0xFF);
_loc3_ = (_loc3_ + _loc6_) / 2;
_loc4_ = (_loc4_ + _loc7_) / 2;
_loc5_ = (_loc5_ + _loc8_) / 2;
return _loc3_ << 16 | _loc4_ << 8 | _loc5_;
}
public static function setColorGradient(param1:Array, param2:uint, param3:uint, param4:uint) : void
{
var _loc13_:uint = 0;
var _loc5_:uint = uint(param2 >> 16 & 0xFF);
var _loc6_:uint = uint(param2 >> 8 & 0xFF);
var _loc7_:uint = uint(param2 & 0xFF);
var _loc8_:uint = _loc5_ / (param4 + 2);
var _loc9_:uint = _loc6_ / (param4 + 2);
var _loc10_:uint = _loc7_ / (param4 + 2);
var _loc11_:* = int(param3 + param4 - 1);
var _loc12_:uint = 0;
while(_loc12_ < param4)
{
_loc13_ = uint(_loc5_ << 16 | _loc6_ << 8 | _loc7_);
param1[_loc11_] = _loc13_ | 255 << 24;
param1[_loc11_ + PALETTE_ALPHA_OFFSET] = _loc13_ | 192 << 24;
param1[_loc11_ + PALETTE_ALPHA_OFFSET * 2] = _loc13_ | 128 << 24;
param1[_loc11_ + PALETTE_ALPHA_OFFSET * 3] = _loc13_ | 64 << 24;
_loc5_ -= _loc8_;
_loc6_ -= _loc9_;
_loc7_ -= _loc10_;
_loc11_--;
_loc12_++;
}
}
public static function AddRGB(param1:uint, param2:int, param3:int, param4:int) : uint
{
var _loc5_:int = param1 >> 24 & 0xFF;
var _loc6_:int = param1 >> 16 & 0xFF;
var _loc7_:int = param1 >> 8 & 0xFF;
var _loc8_:int = param1 & 0xFF;
_loc6_ += param2;
if(_loc6_ < 0)
{
_loc6_ = 0;
}
else if(_loc6_ > 255)
{
_loc6_ = 255;
}
_loc7_ += param3;
if(_loc7_ < 0)
{
_loc7_ = 0;
}
else if(_loc7_ > 255)
{
_loc7_ = 255;
}
_loc8_ += param4;
if(_loc8_ < 0)
{
_loc8_ = 0;
}
else if(_loc8_ > 255)
{
_loc8_ = 255;
}
return uint(_loc5_ << 24 | _loc6_ << 16 | _loc7_ << 8 | _loc8_);
}
public static function getAnimalPalette() : Array
{
var _loc4_:int = 0;
var _loc5_:uint = 0;
var _loc6_:uint = 0;
var _loc1_:Array = new Array(uint(4278255615),uint(4286513152),uint(4290707456),uint(4294901760),uint(4278222592),uint(4278238976),uint(4278255360),uint(4278190207),uint(4278190271),uint(4278190335),uint(4286545791),uint(4290756543),uint(4294967295),uint(4282400768),uint(4286611456),uint(4278206528),uint(4278222976),uint(4282384448),uint(4286578816),uint(4286595136),uint(4294934656),uint(4282417216),uint(4286644096),uint(4282400896),uint(4286611711),uint(4278190080));
var _loc2_:uint = uint(192 << 24);
var _loc3_:int = 0;
while(_loc3_ < 3)
{
_loc4_ = 1;
while(_loc4_ <= PALETTE_ALPHA_OFFSET)
{
_loc5_ = uint(_loc1_[_loc4_] & 0xFFFFFF);
_loc6_ = uint(_loc5_ | _loc2_);
_loc1_.push(_loc6_);
_loc4_++;
}
_loc2_ -= 64 << 24;
_loc3_++;
}
return _loc1_;
}
public static function BuildAnimalPalette(param1:Array, param2:uint, param3:uint, param4:uint, param5:uint) : void
{
setColorGradient(param1,param2,1,3);
setColorGradient(param1,param3,4,3);
setColorGradient(param1,param4,7,3);
setColorGradient(param1,param5,10,3);
setColorGradient(param1,PaletteHelper.mixColors(param2,param3),13,2);
setColorGradient(param1,PaletteHelper.mixColors(param3,param4),15,2);
setColorGradient(param1,PaletteHelper.mixColors(param2,param4),17,2);
setColorGradient(param1,PaletteHelper.mixColors(param2,param5),19,2);
setColorGradient(param1,PaletteHelper.mixColors(param3,param5),21,2);
setColorGradient(param1,PaletteHelper.mixColors(param4,param5),23,2);
}
public static function adjustPaletteColor(param1:Array, param2:uint) : void
{
var _loc7_:int = 0;
var _loc8_:uint = 0;
var _loc9_:int = 0;
var _loc10_:int = 0;
var _loc11_:int = 0;
var _loc12_:int = 0;
var _loc13_:Number = NaN;
var _loc3_:Number = (param2 >> 24 & 0xFF) / 255;
var _loc4_:int = param2 >> 16 & 0xFF;
var _loc5_:int = param2 >> 8 & 0xFF;
var _loc6_:int = param2 & 0xFF;
while(_loc7_ < param1.length)
{
_loc8_ = uint(param1[_loc7_]);
_loc9_ = _loc8_ >> 24 & 0xFF;
_loc10_ = _loc8_ >> 16 & 0xFF;
_loc11_ = _loc8_ >> 8 & 0xFF;
_loc12_ = _loc8_ & 0xFF;
_loc13_ = _loc4_ - _loc10_;
_loc13_ = _loc13_ * _loc3_;
_loc10_ += _loc13_;
if(_loc10_ < 0)
{
_loc10_ = 0;
}
else if(_loc10_ > 255)
{
_loc10_ = 255;
}
_loc13_ = _loc5_ - _loc11_;
_loc13_ = _loc13_ * _loc3_;
_loc11_ += _loc13_;
if(_loc11_ < 0)
{
_loc11_ = 0;
}
else if(_loc11_ > 255)
{
_loc11_ = 255;
}
_loc13_ = _loc6_ - _loc12_;
_loc13_ = _loc13_ * _loc3_;
_loc12_ += _loc13_;
if(_loc12_ < 0)
{
_loc12_ = 0;
}
else if(_loc12_ > 255)
{
_loc12_ = 255;
}
param1[_loc7_] = uint(_loc9_ << 24 | _loc10_ << 16 | _loc11_ << 8 | _loc12_);
_loc7_++;
}
}
public static function getRGBColors(param1:uint) : Array
{
var _loc2_:Array = [];
_loc2_[0] = decToRGBObj(gamePalette[param1 >> 24 & 0xFF]);
_loc2_[1] = decToRGBObj(gamePalette[param1 >> 16 & 0xFF]);
_loc2_[2] = decToRGBObj(gamePalette[param1 >> 8 & 0xFF]);
_loc2_[3] = decToRGBObj(gamePalette[param1 & 0xFF]);
return _loc2_;
}
private static function decToRGBObj(param1:uint) : Object
{
return {
"r":param1 >> 16 & 0xFF,
"g":param1 >> 8 & 0xFF,
"b":param1 & 0xFF
};
}
}
}
@@ -0,0 +1,194 @@
package com.sbi.graphics
{
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.geom.Rectangle;
import flash.utils.Dictionary;
public class SortLayer extends Sprite
{
private var _bottoms:Dictionary;
private var _nudge:Number = 0;
public function SortLayer()
{
super();
this._bottoms = new Dictionary(true);
}
override public function addChild(param1:DisplayObject) : DisplayObject
{
var _loc2_:int = int(param1.name);
param1.name = (this.getNudge() + _loc2_).toString();
return super.addChild(param1);
}
override public function addChildAt(param1:DisplayObject, param2:int) : DisplayObject
{
var _loc3_:int = int(param1.name);
param1.name = (this.getNudge() + _loc3_).toString();
return super.addChildAt(param1,param2);
}
public function release() : void
{
this._nudge = 0;
this._bottoms = new Dictionary(true);
}
public function depthSort(param1:DisplayObject, param2:DisplayObject) : int
{
return this._bottoms[param1] - this._bottoms[param2];
}
public function heartbeat() : void
{
var _loc1_:int = 0;
var _loc3_:Rectangle = null;
var _loc4_:Boolean = false;
var _loc7_:DisplayObject = null;
var _loc8_:Number = NaN;
var _loc9_:Number = NaN;
var _loc2_:int = this.numChildren;
var _loc5_:Number = -999999999;
if(_loc2_ < 2)
{
return;
}
var _loc6_:Array = [_loc2_];
_loc1_ = 0;
while(_loc1_ < _loc2_)
{
_loc7_ = this.getChildAt(_loc1_);
_loc6_[_loc1_] = _loc7_;
_loc3_ = _loc7_.getBounds(this);
_loc8_ = _loc3_.bottom;
_loc9_ = Number(_loc7_.name);
if(!_loc9_)
{
_loc9_ = this.getNudge();
_loc7_.name = _loc9_.toString();
}
_loc8_ -= _loc9_;
this._bottoms[_loc7_] = _loc8_;
if(!_loc4_)
{
if(_loc8_ < _loc5_)
{
_loc4_ = true;
}
_loc5_ = _loc8_;
}
_loc1_++;
}
if(_loc4_)
{
_loc6_.sort(this.depthSort);
_loc1_ = 0;
while(_loc1_ < _loc2_)
{
this.setChildIndex(_loc6_[_loc1_],_loc1_);
_loc1_++;
}
}
}
private function getNudge() : Number
{
this._nudge += 0.001;
if(this._nudge > 0.9)
{
this._nudge = 0;
}
return this._nudge;
}
private function sort(param1:Vector.<Number>) : void
{
this.quickSort(param1,0,param1.length - 1);
this.InsertionSort(param1,0,param1.length - 1);
}
private function quickSort(param1:Vector.<Number>, param2:int, param3:int) : void
{
var _loc5_:int = 0;
var _loc6_:int = 0;
var _loc7_:Number = NaN;
var _loc4_:int = 4;
if(param3 - param2 > _loc4_)
{
_loc5_ = (param3 + param2) / 2;
if(param1[param2] > param1[_loc5_])
{
this.swap(param1,param2,_loc5_);
}
if(param1[param2] > param1[param3])
{
this.swap(param1,param2,param3);
}
if(param1[_loc5_] > param1[param3])
{
this.swap(param1,_loc5_,param3);
}
_loc6_ = param3 - 1;
this.swap(param1,_loc5_,_loc6_);
_loc5_ = param2;
_loc7_ = param1[_loc6_];
while(true)
{
while(param1[++_loc5_] < _loc7_)
{
}
while(param1[--_loc6_] > _loc7_)
{
}
if(_loc6_ < _loc5_)
{
break;
}
this.swap(param1,_loc5_,_loc6_);
}
this.swap(param1,_loc5_,param3 - 1);
this.quickSort(param1,param2,_loc6_);
this.quickSort(param1,_loc5_ + 1,param3);
}
}
private function swap(param1:Vector.<Number>, param2:int, param3:int) : void
{
var _loc4_:Number = NaN;
_loc4_ = param1[param2];
param1[param2] = param1[param3];
param1[param3] = _loc4_;
swapChildrenAt(param2,param3);
}
private function move(param1:Vector.<Number>, param2:int, param3:int) : void
{
param1[param3] = param1[param2];
this.addChildAt(getChildAt(param2),param3);
}
private function InsertionSort(param1:Vector.<Number>, param2:int, param3:int) : void
{
var _loc4_:int = 0;
var _loc5_:* = 0;
var _loc6_:Number = NaN;
_loc4_ = param2 + 1;
while(_loc4_ <= param3)
{
_loc6_ = param1[_loc4_];
_loc5_ = _loc4_;
while(_loc5_ > param2 && param1[_loc5_ - 1] > _loc6_)
{
this.move(param1,_loc5_ - 1,_loc5_);
_loc5_--;
}
_loc4_++;
}
}
}
}
@@ -0,0 +1,181 @@
package com.sbi.graphics
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.Rectangle;
import flash.system.System;
import flash.text.StyleSheet;
import flash.text.TextField;
import flash.utils.getTimer;
public class Stats extends Sprite
{
protected const WIDTH:uint = 70;
protected const HEIGHT:uint = 100;
protected var xml:XML;
protected var text:TextField;
protected var style:StyleSheet;
protected var timer:uint;
protected var fps:uint;
protected var ms:uint;
protected var ms_prev:uint;
protected var mem:Number;
protected var mem_max:Number;
protected var graph:Bitmap;
protected var rectangle:Rectangle;
protected var fps_graph:uint;
protected var mem_graph:uint;
protected var mem_max_graph:uint;
protected var theme:Object = {
"bg":51,
"fps":16776960,
"ms":65280,
"mem":65535,
"memmax":16711792
};
public function Stats(param1:Object = null)
{
super();
if(param1)
{
if(param1.bg != null)
{
this.theme.bg = param1.bg;
}
if(param1.fps != null)
{
this.theme.fps = param1.fps;
}
if(param1.ms != null)
{
this.theme.ms = param1.ms;
}
if(param1.mem != null)
{
this.theme.mem = param1.mem;
}
if(param1.memmax != null)
{
this.theme.memmax = param1.memmax;
}
}
this.mem_max = 0;
this.xml = <xml><fps>FPS:</fps><ms>MS:</ms><mem>MEM:</mem><memMax>MAX:</memMax></xml>;
this.style = new StyleSheet();
this.style.setStyle("xml",{
"fontSize":"9px",
"fontFamily":"_sans",
"leading":"-2px"
});
this.style.setStyle("fps",{"color":this.hex2css(this.theme.fps)});
this.style.setStyle("ms",{"color":this.hex2css(this.theme.ms)});
this.style.setStyle("mem",{"color":this.hex2css(this.theme.mem)});
this.style.setStyle("memMax",{"color":this.hex2css(this.theme.memmax)});
this.text = new TextField();
this.text.width = this.WIDTH;
this.text.height = 50;
this.text.styleSheet = this.style;
this.text.condenseWhite = true;
this.text.selectable = false;
this.text.mouseEnabled = false;
this.graph = new Bitmap();
this.graph.y = 50;
this.rectangle = new Rectangle(this.WIDTH - 1,0,1,this.HEIGHT - 50);
addEventListener(Event.ADDED_TO_STAGE,this.init,false,0,true);
addEventListener(Event.REMOVED_FROM_STAGE,this.destroy,false,0,true);
}
private function init(param1:Event) : void
{
graphics.beginFill(this.theme.bg);
graphics.drawRect(0,0,this.WIDTH,this.HEIGHT);
graphics.endFill();
addChild(this.text);
this.graph.bitmapData = new BitmapData(this.WIDTH,this.HEIGHT - 50,false,this.theme.bg);
addChild(this.graph);
addEventListener(MouseEvent.CLICK,this.onClick);
addEventListener(Event.ENTER_FRAME,this.update);
}
private function destroy(param1:Event) : void
{
graphics.clear();
while(numChildren > 0)
{
removeChildAt(0);
}
this.graph.bitmapData.dispose();
removeEventListener(MouseEvent.CLICK,this.onClick);
removeEventListener(Event.ENTER_FRAME,this.update);
}
private function update(param1:Event) : void
{
this.timer = getTimer();
if(this.timer - 1000 > this.ms_prev)
{
this.ms_prev = this.timer;
this.mem = Number((System.totalMemory * 9.54e-7).toFixed(3));
this.mem_max = this.mem_max > this.mem ? this.mem_max : this.mem;
this.fps_graph = Math.min(this.graph.height,this.fps / stage.frameRate * this.graph.height);
this.mem_graph = Math.min(this.graph.height,Math.sqrt(Math.sqrt(this.mem * 5000))) - 2;
this.mem_max_graph = Math.min(this.graph.height,Math.sqrt(Math.sqrt(this.mem_max * 5000))) - 2;
this.graph.bitmapData.scroll(-1,0);
this.graph.bitmapData.fillRect(this.rectangle,this.theme.bg);
this.graph.bitmapData.setPixel(this.graph.width - 1,this.graph.height - this.fps_graph,this.theme.fps);
this.graph.bitmapData.setPixel(this.graph.width - 1,this.graph.height - (this.timer - this.ms >> 1),this.theme.ms);
this.graph.bitmapData.setPixel(this.graph.width - 1,this.graph.height - this.mem_graph,this.theme.mem);
this.graph.bitmapData.setPixel(this.graph.width - 1,this.graph.height - this.mem_max_graph,this.theme.memmax);
this.xml.fps = "FPS: " + this.fps + " / " + stage.frameRate;
this.xml.mem = "MEM: " + this.mem;
this.xml.memMax = "MAX: " + this.mem_max;
this.fps = 0;
}
++this.fps;
this.xml.ms = "MS: " + (this.timer - this.ms);
this.ms = this.timer;
this.text.htmlText = this.xml;
}
private function onClick(param1:MouseEvent) : void
{
if(mouseY / height > 0.5)
{
--stage.frameRate;
}
else
{
++stage.frameRate;
}
this.xml.fps = "FPS: " + this.fps + " / " + stage.frameRate;
this.text.htmlText = this.xml;
}
private function hex2css(param1:int) : String
{
return "#" + param1.toString(16);
}
}
}
@@ -0,0 +1,154 @@
package com.sbi.loader
{
import flash.events.EventDispatcher;
public class BaseFileServer extends EventDispatcher
{
private var _contentPath:String;
private var _loaderArray:Array;
private var _cacheArray:Array;
public function BaseFileServer(param1:String)
{
super();
this._contentPath = param1;
this._loaderArray = new Array();
this._cacheArray = new Array();
}
public function updatePath(param1:String) : void
{
this._contentPath = param1;
}
public function clearFromCache(param1:String, param2:int) : void
{
if(this._cacheArray[param1])
{
if(this._cacheArray[param1][param2])
{
delete this._cacheArray[param1][param2];
}
}
if(this._loaderArray[param1])
{
if(this._loaderArray[param1][param2])
{
delete this._loaderArray[param1][param2];
}
}
}
public function requestFile(param1:uint, param2:Boolean = false, param3:int = 0, param4:Boolean = true) : void
{
var _loc5_:LoaderCacheEntry_URL = null;
if(param2 || this.getFromCache(param1) == false)
{
if(!(this._loaderArray[this._contentPath] ? this._loaderArray[this._contentPath][param1] : false))
{
_loc5_ = new LoaderCacheEntry_URL(this._contentPath + param1,false);
_loc5_.id = param1;
_loc5_.contentType = param3;
_loc5_.addEventListener(LoaderEvent.ON_LOAD_COMPLETE,this.onResultGetData);
_loc5_.load("binary",param4);
if(this._loaderArray[this._contentPath] == null)
{
this._loaderArray[this._contentPath] = [];
}
this._loaderArray[this._contentPath][param1] = {
"l":_loc5_,
"c":1
};
}
else
{
++this._loaderArray[this._contentPath][param1].c;
}
}
}
public function requestFiles(param1:Array) : void
{
var _loc2_:int = 0;
while(_loc2_ < param1.length)
{
this.requestFile(param1[_loc2_]);
_loc2_++;
}
}
private function getFromCache(param1:uint) : Boolean
{
var _loc2_:Object = this.searchCache(param1);
if(_loc2_)
{
this.newEvent(_loc2_.id,_loc2_.data,true,_loc2_.contentType);
}
return _loc2_ == null ? false : true;
}
private function searchCache(param1:uint) : Object
{
return this._cacheArray[this._contentPath] ? this._cacheArray[this._contentPath][param1] : null;
}
private function onResultGetData(param1:LoaderEvent) : void
{
var _loc5_:* = 0;
var _loc2_:FileServerEvent = new FileServerEvent(FileServerEvent.ON_NEW_DATA);
_loc2_.id = param1.entry.id;
_loc2_.contentType = param1.entry.contentType;
var _loc3_:Object = param1.entry.data;
if(_loc3_ == null)
{
_loc2_.success = false;
}
else
{
_loc2_.data = _loc3_;
if(this._cacheArray[this._contentPath] == null)
{
this._cacheArray[this._contentPath] = [];
}
this._cacheArray[this._contentPath][_loc2_.id] = {
"id":_loc2_.id,
"data":_loc3_,
"contentType":_loc2_.contentType
};
}
var _loc4_:Object = this._loaderArray[this._contentPath][_loc2_.id];
if(_loc4_)
{
_loc4_.l.removeEventListener(LoaderEvent.ON_LOAD_COMPLETE,this.onResultGetData);
_loc5_ = int(_loc4_.c);
this._loaderArray[this._contentPath][_loc2_.id] = null;
while(_loc5_-- > 0)
{
this.newEvent(_loc2_.id,_loc2_.data,_loc2_.success,_loc2_.contentType);
}
}
}
private function newEvent(param1:int, param2:*, param3:Boolean, param4:int = 0) : void
{
var _loc5_:FileServerEvent = new FileServerEvent(FileServerEvent.ON_NEW_DATA);
_loc5_.id = param1;
_loc5_.data = param2;
_loc5_.success = param3;
_loc5_.contentType = param4;
dispatchEvent(_loc5_);
}
}
}
class SingletonLock
{
public function SingletonLock()
{
super();
}
}
@@ -0,0 +1,35 @@
package com.sbi.loader
{
import flash.events.Event;
public class FileServerEvent extends Event
{
public static const ON_NEW_DATA:String = "OnNewData";
public static const JSON_TYPE:int = 0;
public static const PLAIN_TEXT_TYPE:int = 1;
public static const AMF3_TYPE:int = 2;
public var id:uint;
public var data:*;
public var success:Boolean = true;
public var contentType:int = 0;
public function FileServerEvent(param1:String)
{
super(param1);
}
override public function clone() : Event
{
return new FileServerEvent(type);
}
}
}
@@ -0,0 +1,9 @@
package com.sbi.loader
{
public interface IResourceStackable
{
function init(param1:Function) : void;
}
}
@@ -0,0 +1,37 @@
package com.sbi.loader
{
import flash.events.Event;
public class ImageServerEvent extends Event
{
public static const ON_NEW_DATA:String = "OnNewData";
public static const ON_GLOBAL_PALETTE:String = "OnGlobalPalette";
public var id:uint;
public var layer:int;
public var imageData:*;
public var versionNum:int;
public var genericData:*;
public var frames:int;
public var success:Boolean = true;
public function ImageServerEvent(param1:String)
{
super(param1);
}
override public function clone() : Event
{
return new ImageServerEvent(type);
}
}
}
@@ -0,0 +1,235 @@
package com.sbi.loader
{
import com.sbi.graphics.ImageArray;
import com.sbi.graphics.ImageArrayHelper;
import com.sbi.graphics.PaletteHelper;
import flash.events.EventDispatcher;
import flash.utils.ByteArray;
public class ImageServerURL extends EventDispatcher
{
private static var _instance:ImageServerURL;
private static const IMAGE_ARRAY_PATH:String = "imageArrays/";
private static const PALETTE_NAME:String = "paletteData";
private var _imageCacheArray:Array;
private var _loaderCacheArray:Array;
private var _layerInfo:Object;
public function ImageServerURL(param1:Class)
{
super();
if(param1 != SingletonLock)
{
throw new Error("Invalid Singleton access. Use ImageServerURL.instance.");
}
this._imageCacheArray = new Array();
this._loaderCacheArray = new Array();
}
public static function get instance() : ImageServerURL
{
if(!_instance)
{
_instance = new ImageServerURL(SingletonLock);
}
return _instance;
}
public function set layerInfo(param1:Object) : void
{
this._layerInfo = param1;
}
public function getLayerIndex(param1:int) : int
{
return this._layerInfo[param1];
}
public function requestGlobalPalette() : void
{
var _loc1_:ImageServerEvent = null;
var _loc2_:LoaderCacheEntry_URL = null;
if(this.isGlobalPaletteCached())
{
_loc1_ = new ImageServerEvent(ImageServerEvent.ON_GLOBAL_PALETTE);
_loc1_.imageData = null;
dispatchEvent(_loc1_);
}
else
{
_loc2_ = new LoaderCacheEntry_URL(PALETTE_NAME);
_loc2_.addEventListener(LoaderEvent.ON_LOAD_COMPLETE,this.onResultGetGamePalette);
_loc2_.load();
this._loaderCacheArray["palette"] = {"l":_loc2_};
}
}
public function requestImage(param1:uint, param2:Boolean = true) : void
{
var _loc3_:LoaderCacheEntry_URL = null;
if(!param2 || this.getFromCache(param1) == false)
{
if(!this._loaderCacheArray[param1])
{
_loc3_ = new LoaderCacheEntry_URL(IMAGE_ARRAY_PATH + param1);
_loc3_.id = param1;
_loc3_.addEventListener(LoaderEvent.ON_LOAD_COMPLETE,this.onResultGetImageData);
_loc3_.load();
this._loaderCacheArray[param1] = {
"l":_loc3_,
"c":1
};
}
else
{
++this._loaderCacheArray[param1].c;
}
}
}
public function requestImages(param1:Array) : void
{
var _loc2_:int = 0;
while(_loc2_ < param1.length)
{
this.requestImage(param1[_loc2_]);
_loc2_++;
}
}
private function getFromCache(param1:uint) : Boolean
{
var _loc3_:ImageServerEvent = null;
var _loc2_:Object = this.searchCache(param1);
if(_loc2_)
{
_loc3_ = new ImageServerEvent(ImageServerEvent.ON_NEW_DATA);
_loc3_.id = _loc2_.id;
_loc3_.imageData = _loc2_.imageData;
_loc3_.frames = _loc2_.frames;
_loc3_.layer = _loc2_.layer;
_loc3_.success = _loc3_.imageData == null ? false : true;
dispatchEvent(_loc3_);
}
return _loc2_ == null ? false : true;
}
private function isGlobalPaletteCached() : Boolean
{
return Boolean(PaletteHelper.gamePalette);
}
private function searchCache(param1:uint) : Object
{
return this._imageCacheArray[param1];
}
private function onResultGetGamePalette(param1:LoaderEvent) : void
{
var _loc2_:ImageServerEvent = null;
var _loc3_:ByteArray = null;
var _loc4_:ByteArray = null;
var _loc5_:ByteArray = null;
var _loc6_:ByteArray = null;
var _loc7_:int = 0;
var _loc8_:int = 0;
if(param1)
{
this._loaderCacheArray["palette"].l.removeEventListener(LoaderEvent.ON_LOAD_COMPLETE,this.onResultGetGamePalette);
this._loaderCacheArray["palette"] = null;
_loc2_ = new ImageServerEvent(ImageServerEvent.ON_GLOBAL_PALETTE);
_loc3_ = param1.entry.data as ByteArray;
_loc4_ = new ByteArray();
_loc5_ = new ByteArray();
_loc6_ = new ByteArray();
_loc3_.position = 0;
_loc7_ = _loc3_.readInt();
_loc8_ = 4;
_loc4_.writeBytes(_loc3_,_loc8_,_loc7_);
_loc4_.position = 0;
_loc8_ += _loc7_;
_loc3_.position = _loc8_;
_loc7_ = _loc3_.readInt();
_loc8_ += 4;
_loc5_.writeBytes(_loc3_,_loc8_,_loc7_);
_loc5_.position = 0;
_loc8_ += _loc7_;
_loc3_.position = _loc8_;
_loc7_ = _loc3_.readInt();
_loc8_ += 4;
_loc6_.writeBytes(_loc3_,_loc8_,_loc7_);
_loc6_.position = 0;
_loc2_.genericData = {
"palette":_loc4_,
"avatarPalette1":_loc5_,
"avatarPalette2":_loc6_
};
dispatchEvent(_loc2_);
return;
}
throw new Error("Got 0 for GetGamePalette request!");
}
private function onResultGetImageData(param1:LoaderEvent) : void
{
var _loc5_:ImageServerEvent = null;
var _loc2_:ImageServerEvent = new ImageServerEvent(ImageServerEvent.ON_NEW_DATA);
_loc2_.id = param1.entry.id;
var _loc3_:Object = param1.entry.data;
if(_loc3_ == null)
{
this._imageCacheArray[_loc2_.id] = {
"id":_loc2_.id,
"imageData":null,
"layer":0,
"frames":0
};
_loc2_.success = false;
}
else
{
if(_loc3_.v != ImageArray.VERSION)
{
throw new Error("ERROR: Unrecognized version number(" + _loc3_.v.toString(16) + ")!");
}
_loc2_.imageData = _loc3_;
_loc2_.layer = this._layerInfo[ImageArrayHelper.layerId(_loc2_.id)];
_loc2_.frames = _loc3_.f.length;
this._imageCacheArray[_loc2_.id] = {
"id":_loc2_.id,
"imageData":_loc3_,
"layer":_loc2_.layer,
"frames":_loc2_.frames
};
}
this._loaderCacheArray[_loc2_.id].l.removeEventListener(LoaderEvent.ON_LOAD_COMPLETE,this.onResultGetImageData);
var _loc4_:* = int(this._loaderCacheArray[_loc2_.id].c);
this._loaderCacheArray[_loc2_.id] = null;
while(_loc4_-- > 0)
{
_loc5_ = new ImageServerEvent(ImageServerEvent.ON_NEW_DATA);
_loc5_.id = _loc2_.id;
_loc5_.imageData = _loc2_.imageData;
_loc5_.layer = _loc2_.layer;
_loc5_.frames = _loc2_.frames;
_loc5_.success = _loc2_.success;
dispatchEvent(_loc5_);
}
}
}
}
class SingletonLock
{
public function SingletonLock()
{
super();
}
}
@@ -0,0 +1,148 @@
package com.sbi.loader
{
import com.adobe.crypto.MD5;
import com.sbi.debug.DebugUtility;
import flash.net.URLRequest;
public class LoaderCache
{
public static var cdnSalt:String;
public static var mainClassNames:Array;
public static var _contentURL:String = "http://dev-sfs01.smartbombinteractive.com:8008/animal/";
public static var buildVersion:String = "0";
public static var deployVersion:String = "0";
public static var localMode:Boolean = true;
private static var _clientIp:String = "127.0.0.1";
private var _list:Array = null;
public function LoaderCache()
{
super();
this._list = new Array();
}
public static function get contentURL() : String
{
return _contentURL;
}
public static function set contentURL(param1:String) : void
{
_contentURL = param1;
}
public static function get clientIp() : String
{
return _clientIp;
}
public static function set clientIp(param1:String) : void
{
_clientIp = param1;
}
public static function fetchCDNHash(param1:String, param2:String = "/") : String
{
var _loc3_:String = cdnSalt + param2 + param1 + clientIp;
return MD5.hash(_loc3_);
}
public static function fetchCDNURL(param1:String, param2:String = "/", param3:Boolean = true) : String
{
var _loc8_:String = null;
var _loc4_:String = param2;
var _loc5_:String = "";
var _loc6_:String = deployVersion;
if(_loc6_ != "0" && param3)
{
_loc5_ = _loc6_ + "/";
_loc4_ += _loc5_;
}
var _loc7_:String = fetchCDNHash(param1,_loc4_);
if(param3)
{
_loc8_ = contentURL + _loc5_ + param1 + "?px-hash=" + _loc7_ + "&v=" + LoaderCache.buildVersion;
}
else
{
_loc8_ = contentURL + _loc5_ + param1 + "?px-hash=" + _loc7_;
}
return _loc8_;
}
public static function fetchCDNURLRequest(param1:String, param2:String = "/", param3:Boolean = true) : URLRequest
{
var _loc4_:String = fetchCDNURL(param1,param2,param3);
return new URLRequest(_loc4_);
}
public function openFile(param1:String, param2:Function, param3:Function = null, param4:String = "binary") : void
{
var _loc5_:* = undefined;
if(!this.findFile(param1))
{
_loc5_ = this.createLoaderCacheEntry(param1);
this._list[param1] = _loc5_;
}
else
{
DebugUtility.debugTrace("*LoaderCache name collision: " + param1);
}
this._list[param1].setCompleteCallback(param2);
if(param3 != null)
{
this._list[param1].setProgressCallback(param3);
}
this._list[param1].load(param4);
}
public function destroy() : void
{
var _loc1_:Object = null;
for(_loc1_ in this._list)
{
this.remove(String(_loc1_));
}
}
private function findFile(param1:String) : Boolean
{
return this._list[param1] == null ? false : true;
}
public function remove(param1:String) : void
{
this._list[param1].destroy();
this._list[param1] = null;
}
private function createLoaderCacheEntry(param1:String) : *
{
var _loc4_:* = undefined;
var _loc2_:int = param1.lastIndexOf(".");
var _loc3_:String = param1.slice(_loc2_ + 1,param1.length).toLowerCase();
switch(_loc3_)
{
case "swf":
case "png":
case "jpg":
case "jpeg":
_loc4_ = new LoaderCacheEntry_Loader(param1);
break;
default:
_loc4_ = new LoaderCacheEntry_URL(param1);
}
_loc4_.parent = this;
return _loc4_;
}
}
}
@@ -0,0 +1,160 @@
package com.sbi.loader
{
import flash.display.Loader;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
public class LoaderCacheEntry_Base extends EventDispatcher
{
protected var _parent:LoaderCache;
protected var _loader:*;
protected var _swf:String;
protected var _isLoaded:Boolean;
protected var _completeCallback:Function;
protected var _data:Object;
protected var _id:*;
protected var _contentType:int;
private var _percent:Number;
private var _err:String;
private var _progressCallback:Function;
public function LoaderCacheEntry_Base(param1:String)
{
super();
this._swf = param1;
}
public function set parent(param1:LoaderCache) : void
{
this._parent = param1;
}
public function set id(param1:*) : void
{
this._id = param1;
}
public function get id() : *
{
return this._id;
}
public function set contentType(param1:int) : void
{
this._contentType = param1;
}
public function get contentType() : int
{
return this._contentType;
}
public function get name() : String
{
return this._swf;
}
public function destroy() : void
{
}
public function load(param1:String = "binary", param2:Boolean = true) : void
{
}
public function setCompleteCallback(param1:Function) : void
{
if(this._completeCallback != param1)
{
if(this._completeCallback != null)
{
removeEventListener(LoaderEvent.ON_LOAD_COMPLETE,this._completeCallback);
}
addEventListener(LoaderEvent.ON_LOAD_COMPLETE,param1,false,0,true);
this._completeCallback = param1;
}
}
public function setProgressCallback(param1:Function) : void
{
if(this._progressCallback != param1)
{
if(this._progressCallback != null)
{
removeEventListener(LoaderEvent.ON_LOAD_PROGRESS,this._progressCallback);
}
addEventListener(LoaderEvent.ON_LOAD_PROGRESS,param1,false,0,true);
this._progressCallback = param1;
}
}
public function get progress() : Number
{
return this._percent;
}
public function get loader() : Loader
{
return this._loader;
}
public function get data() : Object
{
return this._data;
}
protected function onLoadCompleteEvent() : void
{
var _loc1_:LoaderEvent = new LoaderEvent(LoaderEvent.ON_LOAD_COMPLETE);
_loc1_.status = true;
_loc1_.entry = this;
dispatchEvent(_loc1_);
if(this._parent)
{
this._parent.remove(this._swf);
}
}
protected function onLoadProgressEvent() : void
{
var _loc1_:LoaderEvent = new LoaderEvent(LoaderEvent.ON_LOAD_PROGRESS);
_loc1_.status = true;
_loc1_.entry = this;
_loc1_.percent = this._percent;
dispatchEvent(_loc1_);
}
protected function loadProgress(param1:ProgressEvent) : void
{
this._percent = param1.bytesLoaded / param1.bytesTotal;
this._percent = Math.round(this._percent * 100);
this.onLoadProgressEvent();
}
protected function ioError(param1:IOErrorEvent) : void
{
var _loc2_:LoaderEvent = new LoaderEvent(LoaderEvent.ON_LOAD_COMPLETE);
_loc2_.status = false;
_loc2_.entry = this;
_loc2_.message = param1.text;
dispatchEvent(_loc2_);
if(this._parent)
{
this._parent.remove(this._swf);
}
}
}
}
@@ -0,0 +1,73 @@
package com.sbi.loader
{
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import flash.system.SecurityDomain;
public class LoaderCacheEntry_Loader extends LoaderCacheEntry_Base
{
public function LoaderCacheEntry_Loader(param1:String)
{
super(param1);
_loader = new Loader();
_loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,loadProgress,false,0,true);
_loader.contentLoaderInfo.addEventListener(Event.COMPLETE,this.loadComplete,false,0,true);
_loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,ioError,false,0,true);
}
override public function destroy() : void
{
_loader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS,loadProgress);
_loader.contentLoaderInfo.removeEventListener(Event.COMPLETE,this.loadComplete);
_loader.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,ioError);
if(_completeCallback != null)
{
removeEventListener(LoaderEvent.ON_LOAD_COMPLETE,_completeCallback);
_completeCallback = null;
}
}
override public function load(param1:String = "binary", param2:Boolean = true) : void
{
var _loc3_:URLRequest = null;
var _loc4_:LoaderContext = null;
if(!_isLoaded)
{
if(LoaderCache.localMode && (_swf.slice(0,7) == "assets/" || _swf.slice(0,6) == "games/" || _swf.indexOf("/") == -1))
{
_loc3_ = new URLRequest(_swf);
}
else
{
_loc3_ = LoaderCache.fetchCDNURLRequest(_swf,"/",param2);
}
_loc4_ = new LoaderContext(true,ApplicationDomain.currentDomain);
if(!LoaderCache.localMode)
{
_loc4_.securityDomain = SecurityDomain.currentDomain;
}
_loader.load(_loc3_,_loc4_);
}
else
{
onLoadCompleteEvent();
}
}
private function loadComplete(param1:Event) : void
{
_isLoaded = true;
var _loc2_:LoaderInfo = param1.target as LoaderInfo;
_data = _loc2_.content;
onLoadCompleteEvent();
}
}
}
@@ -0,0 +1,91 @@
package com.sbi.loader
{
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.utils.ByteArray;
public class LoaderCacheEntry_URL extends LoaderCacheEntry_Base
{
private var _isObj:Boolean;
public function LoaderCacheEntry_URL(param1:String, param2:Boolean = true)
{
super(param1);
this._isObj = param2;
_loader = new URLLoader();
_loader.addEventListener(ProgressEvent.PROGRESS,loadProgress,false,0,true);
_loader.addEventListener(Event.COMPLETE,this.loadComplete,false,0,true);
_loader.addEventListener(IOErrorEvent.IO_ERROR,ioError,false,0,true);
}
override public function destroy() : void
{
_loader.removeEventListener(ProgressEvent.PROGRESS,loadProgress);
_loader.removeEventListener(Event.COMPLETE,this.loadComplete);
_loader.removeEventListener(IOErrorEvent.IO_ERROR,ioError);
if(_completeCallback != null)
{
removeEventListener(LoaderEvent.ON_LOAD_COMPLETE,_completeCallback);
_completeCallback = null;
}
}
override public function load(param1:String = "binary", param2:Boolean = true) : void
{
var _loc3_:URLRequest = null;
if(!_isLoaded)
{
_loc3_ = LoaderCache.fetchCDNURLRequest(_swf,"/",param2);
_loader.dataFormat = param1;
_loader.load(_loc3_);
}
else
{
onLoadCompleteEvent();
}
}
private function loadComplete(param1:Event) : void
{
var _loc2_:ByteArray = null;
var _loc3_:Object = null;
_isLoaded = true;
_data = _loader.data;
if(_data is ByteArray)
{
_loc2_ = _loader.data as ByteArray;
try
{
_loc2_.uncompress();
}
catch(err:Error)
{
}
_loc2_.position = 0;
if(this._isObj)
{
_loc3_ = _loc2_.readObject();
if(_loc2_.bytesAvailable == 0)
{
_data = _loc3_;
}
else
{
_loc2_.position = 0;
_data = _loc2_;
}
}
else
{
_data = _loc2_;
}
}
onLoadCompleteEvent();
}
}
}
@@ -0,0 +1,31 @@
package com.sbi.loader
{
import flash.events.Event;
public class LoaderEvent extends Event
{
public static const ON_LOAD_COMPLETE:String = "OnLoadComplete";
public static const ON_LOAD_PROGRESS:String = "OnLoadProgress";
public var status:Boolean;
public var entry:LoaderCacheEntry_Base;
public var message:String;
public var percent:Number;
public function LoaderEvent(param1:String)
{
super(param1);
}
override public function clone() : Event
{
return new LoaderEvent(type);
}
}
}
@@ -0,0 +1,138 @@
package com.sbi.loader
{
import com.sbi.debug.DebugUtility;
public class ResourceStack
{
private var _stack:Array;
private var _callback:Function;
private var _path:String;
private var _openFile:Function;
public function ResourceStack(param1:String, param2:Function)
{
super();
this._path = param1;
this._openFile = param2;
this._stack = new Array();
}
public function pushFile(param1:String, param2:Boolean = false) : void
{
this._stack.push({
"type":"file",
"data":param1,
"isBlocking":param2,
"inProgress":false
});
}
public function pushClass(param1:IResourceStackable, param2:Boolean = false) : void
{
this._stack.push({
"type":"class",
"data":param1,
"isBlocking":param2,
"inProgress":false
});
}
public function start(param1:Function) : void
{
this._callback = param1;
this.fifo();
}
private function fifo() : void
{
var _loc2_:int = 0;
var _loc3_:Object = null;
var _loc1_:int = int(this._stack.length);
DebugUtility.debugTrace("ResourceStack fifo len:" + _loc1_);
if(!_loc1_)
{
if(this._callback != null)
{
this._callback();
this._callback = null;
}
}
else
{
_loc2_ = 0;
while(_loc2_ < _loc1_)
{
_loc3_ = this._stack[_loc2_];
if(!_loc3_.inProgress)
{
_loc3_.inProgress = true;
switch(_loc3_.type)
{
case "file":
this.loadFile(_loc3_.data);
break;
case "class":
_loc3_.data.init(this.onInitClassComplete);
}
_loc2_ = -1;
_loc1_ = int(this._stack.length);
}
else if(_loc3_.isBlocking)
{
break;
}
_loc2_++;
}
}
}
private function loadFile(param1:String) : void
{
var _loc2_:String = this._path + param1;
this._openFile(_loc2_,this.onLoadComplete,this.onLoadProgress);
}
private function onLoadComplete(param1:LoaderEvent) : void
{
if(param1.status)
{
this.removeResource("file",param1.entry.name);
this.fifo();
return;
}
throw new Error("could not load required resource!!! msg:" + param1.message);
}
private function onLoadProgress(param1:LoaderEvent) : void
{
}
private function onInitClassComplete(param1:IResourceStackable) : void
{
this.removeResource("class",param1);
this.fifo();
}
private function removeResource(param1:String, param2:*) : void
{
var _loc5_:Object = null;
var _loc3_:int = int(this._stack.length);
var _loc4_:int = 0;
while(_loc4_ < _loc3_)
{
_loc5_ = this._stack[_loc4_];
if(_loc5_.type == param1 && _loc5_.data == param2)
{
this._stack.splice(_loc4_,1);
break;
}
_loc4_++;
}
}
}
}
@@ -0,0 +1,255 @@
package com.sbi.loader
{
import flash.display.DisplayObject;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.display.MovieClip;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
public class SceneLoader extends EventDispatcher
{
private var _offset:Point;
private var _scene:Object;
private var _loaderCount:int;
private var _loader:Array;
public function SceneLoader()
{
super();
this._loader = new Array();
}
public function getOffset(param1:DisplayObject) : Point
{
var _loc2_:Object = null;
var _loc4_:Loader = null;
var _loc5_:Rectangle = null;
var _loc3_:Array = this.getActorList("ActorLayer");
for each(_loc2_ in _loc3_)
{
_loc4_ = _loc2_.s;
_loc5_ = _loc4_.getBounds(param1);
if(_loc5_.x < this._offset.x)
{
this._offset.x = _loc5_.x;
}
if(_loc5_.y < this._offset.y)
{
this._offset.y = _loc5_.y;
}
}
return this._offset;
}
public function get isValid() : Boolean
{
return this._scene != null;
}
public function setScene(param1:Object) : void
{
this.release();
this._scene = param1;
if(param1)
{
this.loadLayers();
}
}
public function getActorList(param1:String) : Array
{
return this._scene.actors[param1];
}
public function getLayer(param1:String) : Object
{
return this.findLayer(param1);
}
public function cloneAsset(param1:String) : Object
{
var _loc3_:Loader = null;
var _loc2_:Object = this.findLayer(param1);
if(_loc2_)
{
_loc3_ = this.newAsset(_loc2_.assetName);
_loc3_.x = _loc2_.x;
_loc3_.y = _loc2_.y;
_loc2_.loader = _loc3_;
}
return _loc2_;
}
public function release() : void
{
var _loc1_:Loader = null;
while(this._loader.length)
{
_loc1_ = this._loader.pop();
_loc1_.unloadAndStop();
}
}
public function releaseCloneAsset(param1:Loader) : void
{
var _loc2_:int = 0;
var _loc3_:Loader = null;
while(_loc2_ < this._loader.length)
{
_loc3_ = this._loader[_loc2_];
if(_loc3_ == param1)
{
param1.unloadAndStop();
this._loader.splice(_loc2_,1);
break;
}
_loc2_++;
}
}
private function findLayer(param1:String) : Object
{
var _loc2_:Object = null;
var _loc4_:int = 0;
var _loc3_:Array = this.getActorList("ActorLayer");
param1 = param1.toLowerCase();
_loc4_ = 0;
while(_loc4_ < _loc3_.length)
{
if(_loc3_[_loc4_].name == param1)
{
_loc2_ = new Object();
_loc2_.assetName = _loc3_[_loc4_].assetName;
_loc2_.loader = _loc3_[_loc4_].s;
_loc2_.height = _loc3_[_loc4_].s.height;
_loc2_.width = _loc3_[_loc4_].s.width;
_loc2_.x = _loc3_[_loc4_].s.x;
_loc2_.y = _loc3_[_loc4_].s.y;
_loc2_.flip = _loc3_[_loc4_].flip;
break;
}
_loc4_++;
}
if(_loc2_ == null)
{
}
return _loc2_;
}
private function newAsset(param1:String) : Loader
{
var _loc2_:Loader = null;
var _loc4_:int = 0;
param1 = param1.toLowerCase();
var _loc3_:Array = this._scene.assets;
while(_loc4_ < _loc3_.length)
{
if(_loc3_[_loc4_].name.toLowerCase() == param1)
{
_loc2_ = new Loader();
_loc2_.loadBytes(_loc3_[_loc4_].ba);
_loc2_.contentLoaderInfo.addEventListener(Event.COMPLETE,this.onNewLoaderComplete);
_loc2_.cacheAsBitmap = true;
this._loader.push(_loc2_);
return _loc2_;
}
_loc4_++;
}
return _loc2_;
}
private function onNewLoaderComplete(param1:Event) : void
{
var _loc2_:LoaderInfo = param1.target as LoaderInfo;
_loc2_.removeEventListener(Event.COMPLETE,this.onLoaderComplete);
if(_loc2_.content is MovieClip && MovieClip(_loc2_.content).totalFrames > 1)
{
_loc2_.content.cacheAsBitmap = false;
}
dispatchEvent(param1);
}
private function loadLayers() : void
{
var _loc2_:int = 0;
var _loc3_:Object = null;
var _loc4_:Loader = null;
this._offset = new Point(9999999,9999999);
var _loc1_:Array = this.getActorList("ActorLayer");
this._loaderCount = _loc1_.length;
_loc2_ = 0;
while(_loc2_ < _loc1_.length)
{
_loc3_ = _loc1_[_loc2_];
_loc3_.dx = _loc3_.scrollX;
_loc3_.dy = _loc3_.scrollY;
_loc4_ = this.loadAsset(_loc3_.assetName);
_loc3_.s = _loc4_;
_loc4_.x = Math.round(_loc3_.x);
_loc4_.y = Math.round(_loc3_.y);
_loc4_.rotation = _loc3_.rot;
_loc4_.scaleX = _loc3_.scaleX;
_loc4_.scaleY = _loc3_.scaleY;
_loc2_++;
}
}
private function loadAsset(param1:String) : Loader
{
var _loc2_:Loader = null;
var _loc4_:int = 0;
var _loc5_:LoaderContext = null;
param1 = param1.toLowerCase();
var _loc3_:Array = this._scene.assets;
while(_loc4_ < _loc3_.length)
{
if(_loc3_[_loc4_].name.toLowerCase() == param1)
{
_loc2_ = new Loader();
if(_loc3_[_loc4_].ba)
{
_loc5_ = new LoaderContext(false,ApplicationDomain.currentDomain);
_loc2_.loadBytes(_loc3_[_loc4_].ba,_loc5_);
_loc2_.contentLoaderInfo.addEventListener(Event.COMPLETE,this.onLoaderComplete);
_loc2_.cacheAsBitmap = true;
this._loader.push(_loc2_);
}
return _loc2_;
}
_loc4_++;
}
return _loc2_;
}
private function onLoaderComplete(param1:Event) : void
{
var _loc2_:LoaderInfo = param1.target as LoaderInfo;
_loc2_.removeEventListener(Event.COMPLETE,this.onLoaderComplete);
if(_loc2_.content is MovieClip && MovieClip(_loc2_.content).totalFrames > 1)
{
_loc2_.content.cacheAsBitmap = false;
}
--this._loaderCount;
if(this._loaderCount == 0)
{
this.allLoadingComplete();
}
}
private function allLoadingComplete() : void
{
var _loc1_:Event = new Event(Event.COMPLETE);
dispatchEvent(_loc1_);
}
}
}
@@ -0,0 +1,113 @@
package com.sbi.popup
{
import flash.display.*;
import flash.events.*;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.utils.getDefinitionByName;
public dynamic class SBAJOkPopup extends SBPopup
{
protected var _messageText:TextField;
protected var _titleText:TextField;
protected var _skin:MovieClip;
protected var _content:MovieClip;
protected var _top:MovieClip;
protected var _mid:MovieClip;
protected var _bot:MovieClip;
private var _titleToMessageDifference:int = 5;
private var _btnTxtGap:int = 10;
private var _verticalOffset:int = 13;
private var _okBtn:MovieClip;
private var _okBtnCallback:Function;
public function SBAJOkPopup(param1:DisplayObjectContainer, param2:String = null, param3:String = null, param4:Function = null, param5:Boolean = true, param6:MovieClip = null, param7:MovieClip = null, param8:Boolean = true, param9:Boolean = true, param10:Boolean = false, param11:Boolean = false, param12:Number = undefined, param13:Number = undefined, param14:Number = undefined, param15:Number = undefined, param16:Array = null)
{
if(param4 != null)
{
this._okBtnCallback = param4;
}
else
{
this._okBtnCallback = this.onOkBtn;
}
this._skin = new (getDefinitionByName("BroadcastPopupSkin") as Class)();
this._content = new (getDefinitionByName("BroadcastPopupContent") as Class)();
this._top = this._skin.ba.t;
this._mid = this._skin.ba.m;
this._bot = this._skin.ba.b;
this._okBtn = this._content.okBtn;
this._okBtn.addEventListener(MouseEvent.MOUSE_DOWN,this._okBtnCallback,false,0,true);
this._messageText = this._content.text;
this._titleText = this._content.titleTxt;
this._messageText.autoSize = TextFieldAutoSize.CENTER;
this._titleText.autoSize = TextFieldAutoSize.CENTER;
this.setMessageText(param2);
if(param3)
{
this._titleText.text = param3;
}
super(param1,this._skin,this._content,param8,param9,param10,param11,param5,param3,param12,param13,param14,param15,param16);
}
public static function destroyInParentChain(param1:DisplayObject) : void
{
while(Boolean(param1) && Boolean(param1 != gMainFrame.stage) && !(param1 is SBOkPopup))
{
param1 = param1.parent;
}
if(param1 is SBOkPopup)
{
SBOkPopup(param1).destroy();
}
}
override public function destroy() : void
{
this._okBtn.removeEventListener(MouseEvent.MOUSE_DOWN,this._okBtnCallback);
super.destroy();
}
public function setMessageText(param1:String) : void
{
this._messageText.text = param1;
this.resize();
}
private function resize() : void
{
this._mid.height = Math.floor(this._messageText.height);
this._mid.y = Math.floor(-(this._mid.height * 0.5));
this._top.y = this._mid.y - this._top.height;
this._bot.y = this._mid.y + this._mid.height;
this._titleText.y = 0;
this._messageText.y = this._titleText.height + this._titleToMessageDifference;
this._okBtn.y = this._messageText.y + this._messageText.height + this._btnTxtGap + this._okBtn.height * 0.5;
this._skin.c.height = this._titleText.height + this._titleToMessageDifference + this._messageText.height + this._btnTxtGap + this._okBtn.height;
this._skin.c.y = -(this._skin.ba.height * 0.5) + this._verticalOffset;
this._content.x = this._skin.c.x;
this._content.y = this._skin.c.y;
this._content.width = this._skin.c.width;
this._content.height = this._skin.c.height;
}
private function onOkBtn(param1:MouseEvent) : void
{
param1.stopPropagation();
this.destroy();
}
}
}
@@ -0,0 +1,19 @@
package com.sbi.popup
{
import flash.display.DisplayObjectContainer;
import flash.display.MovieClip;
import flash.text.TextField;
public dynamic class SBMessage extends SBPopup
{
public var messageTxt:TextField = new TextField();
public function SBMessage(param1:DisplayObjectContainer, param2:MovieClip, param3:String, param4:Boolean = true, param5:Boolean = true, param6:Boolean = false, param7:Boolean = true, param8:Boolean = false, param9:String = null, param10:Number = undefined, param11:Number = undefined, param12:Number = undefined, param13:Number = undefined, param14:Array = null)
{
this.messageTxt.text = param3;
super(param1,param2,this.messageTxt,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14);
}
}
}
@@ -0,0 +1,65 @@
package com.sbi.popup
{
import flash.display.*;
import flash.events.*;
import flash.utils.getDefinitionByName;
public dynamic class SBOkPopup extends SBStandardPopup
{
private var _okBtn:MovieClip;
private var _okBtnCallback:Function;
public function SBOkPopup(param1:DisplayObjectContainer, param2:String = null, param3:Boolean = true, param4:Function = null, param5:Boolean = true, param6:Boolean = true, param7:Boolean = false, param8:Boolean = false, param9:String = null, param10:Number = undefined, param11:Number = undefined, param12:Number = undefined, param13:Number = undefined, param14:Array = null)
{
_verticalOffset = -20;
_btnTxtGap = 6;
_btnHeight = 44;
if(param4 != null)
{
this._okBtnCallback = param4;
}
else
{
this._okBtnCallback = this.onOkBtn;
}
var _loc15_:MovieClip = new (getDefinitionByName("OkPopupSkin") as Class)();
var _loc16_:MovieClip = new (getDefinitionByName("OkPopupContent") as Class)();
this._okBtn = _loc16_.okBtn;
this._okBtn.addEventListener(MouseEvent.MOUSE_DOWN,this._okBtnCallback,false,0,true);
_resizeCallback = this.onResize;
super(param1,param2,param3,_loc16_,_loc15_,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14);
}
public static function destroyInParentChain(param1:DisplayObject) : void
{
while(Boolean(param1) && Boolean(param1 != gMainFrame.stage) && !(param1 is SBOkPopup))
{
param1 = param1.parent;
}
if(param1 is SBOkPopup)
{
SBOkPopup(param1).destroy();
}
}
override public function destroy() : void
{
this._okBtn.removeEventListener(MouseEvent.MOUSE_DOWN,this._okBtnCallback);
super.destroy();
}
private function onResize() : void
{
this._okBtn.y = _text.height + _btnTxtGap + 0.5 * _btnHeight;
}
private function onOkBtn(param1:MouseEvent) : void
{
param1.stopPropagation();
this.destroy();
}
}
}
@@ -0,0 +1,184 @@
package com.sbi.popup
{
import flash.display.DisplayObjectContainer;
import flash.display.MovieClip;
import flash.events.MouseEvent;
import flash.text.TextFieldAutoSize;
import gui.DarkenManager;
import loader.MediaHelper;
public dynamic class SBParchmentPopup
{
public static const TYPE_OK:int = 0;
public static const TYPE_YES_NO:int = 1;
public static const TYPE_CONTINUE_EXIT:int = 2;
public static const TYPE_CONTINUE_ONLY:int = 3;
private var _parent:DisplayObjectContainer;
private var _type:int;
private var _message:String;
private var _darken:Boolean;
private var _confirmCallback:Function;
private var _passback:Object;
private var _mediaHelper:MediaHelper;
private var _popup:MovieClip;
public function SBParchmentPopup(param1:DisplayObjectContainer, param2:int = 0, param3:String = null, param4:Boolean = true, param5:Function = null, param6:Object = null)
{
super();
DarkenManager.showLoadingSpiral(true);
this._parent = param1;
this._type = param2;
this._message = param3;
this._darken = param4;
this._confirmCallback = param5;
this._passback = param6;
this._mediaHelper = new MediaHelper();
this._mediaHelper.init(2106,this.onMediaLoaded);
}
public function destroy() : void
{
var _loc1_:int = 0;
if(this._popup)
{
DarkenManager.unDarken(this._popup);
if(Boolean(this._parent) && Boolean(this._popup.parent) && this._popup.parent == this._parent)
{
this._parent.removeChild(this._popup);
}
this._popup.removeEventListener(MouseEvent.MOUSE_DOWN,this.onPopup);
switch(this._type)
{
case TYPE_CONTINUE_EXIT:
this._popup.contBtn.removeEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown);
this._popup.exitBtn.removeEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown);
break;
case TYPE_CONTINUE_ONLY:
this._popup.contOnlyBtn.removeEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown);
break;
case TYPE_OK:
this._popup.okBtn.removeEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown);
break;
case TYPE_YES_NO:
this._popup.yesBtn.removeEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown);
this._popup.noBtn.removeEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown);
}
_loc1_ = SBPopupManager.nonSBPopups.indexOf(this);
if(_loc1_ >= 0)
{
SBPopupManager.nonSBPopups.splice(_loc1_,1);
}
this._popup = null;
}
}
private function onMediaLoaded(param1:MovieClip) : void
{
var img:MovieClip = param1;
if(img)
{
DarkenManager.showLoadingSpiral(false);
this._popup = MovieClip(img.getChildAt(0));
this._mediaHelper.destroy();
this._mediaHelper = null;
switch(this._type)
{
case TYPE_CONTINUE_EXIT:
this._popup.okBtn.visible = false;
this._popup.yesBtn.visible = false;
this._popup.noBtn.visible = false;
this._popup.contOnlyBtn.visible = false;
this._popup.contBtn.addEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown,false,0,true);
this._popup.exitBtn.addEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown,false,0,true);
break;
case TYPE_CONTINUE_ONLY:
this._popup.okBtn.visible = false;
this._popup.yesBtn.visible = false;
this._popup.noBtn.visible = false;
this._popup.exitBtn.visible = false;
this._popup.contBtn.visible = false;
this._popup.contOnlyBtn.addEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown,false,0,true);
break;
case TYPE_OK:
this._popup.yesBtn.visible = false;
this._popup.noBtn.visible = false;
this._popup.contBtn.visible = false;
this._popup.exitBtn.visible = false;
this._popup.contOnlyBtn.visible = false;
this._popup.okBtn.addEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown,false,0,true);
break;
case TYPE_YES_NO:
this._popup.okBtn.visible = false;
this._popup.contBtn.visible = false;
this._popup.exitBtn.visible = false;
this._popup.contOnlyBtn.visible = false;
this._popup.yesBtn.addEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown,false,0,true);
this._popup.noBtn.addEventListener(MouseEvent.MOUSE_DOWN,this.onBtnDown,false,0,true);
}
this._popup.txt.autoSize = TextFieldAutoSize.CENTER;
this._popup.txt.text = this._message;
with(this._popup.ba)
{
m.height = Math.floor(_popup.txt.height) + 44 + 8;
m.y = Math.floor(-(m.height * 0.5));
t.y = m.y - t.height;
b.y = m.y + m.height;
_popup.txt.y = m.y + 4;
_popup.yesBtn.y = m.y + _popup.txt.height + 13;
_popup.noBtn.y = m.y + _popup.txt.height + 13;
_popup.okBtn.y = m.y + _popup.txt.height + 9;
_popup.contBtn.y = m.y + _popup.txt.height + 13;
_popup.exitBtn.y = m.y + _popup.txt.height + 13;
_popup.contOnlyBtn.y = m.y + _popup.txt.height + 13;
}
this._popup.addEventListener(MouseEvent.MOUSE_DOWN,this.onPopup,false,0,true);
this._popup.x = MainFrame.VIEW_WIDTH * 0.5;
this._popup.y = MainFrame.VIEW_HEIGHT * 0.5;
this._parent.addChild(this._popup);
if(this._darken)
{
DarkenManager.darken(this._popup);
}
SBPopupManager.nonSBPopups.push(this);
}
}
private function onPopup(param1:MouseEvent) : void
{
param1.stopPropagation();
}
private function onBtnDown(param1:MouseEvent) : void
{
var _loc2_:Object = null;
param1.stopPropagation();
if(this._confirmCallback != null)
{
_loc2_ = {
"status":param1.currentTarget == this._popup.contBtn || param1.currentTarget == this._popup.contOnlyBtn || param1.currentTarget == this._popup.yesBtn || param1.currentTarget == this._popup.okBtn,
"passback":this._passback
};
this.destroy();
this._confirmCallback(_loc2_);
}
else
{
this.destroy();
}
}
}
}
@@ -0,0 +1,218 @@
package com.sbi.popup
{
import flash.display.DisplayObjectContainer;
import flash.display.MovieClip;
import flash.events.MouseEvent;
import gui.DarkenManager;
import gui.GuiRadioButtonGroup;
import loader.MediaHelper;
public dynamic class SBPollPopup
{
private static const POLL_POPUP_MEDIA_ID:int = 369;
private static const POLL_TY_POPUP_MEDIA_ID:int = 370;
private var _popupLayer:DisplayObjectContainer;
private var _tab:MovieClip;
private var _pollDef:Object;
private var _onVoteCallback:Function;
private var _onDoneCallback:Function;
private var _pollPopup:MovieClip;
private var _pollMediaHelper:MediaHelper;
private var _thankYouPopup:SBStandardTitlePopup;
private var _numOptions:int;
private var _randomizeOrder:Boolean;
private var _randOptionLookup:Array;
private var _answerSection:MovieClip;
private var _optionsGroup:GuiRadioButtonGroup;
public function SBPollPopup()
{
super();
}
public function init(param1:DisplayObjectContainer, param2:MovieClip, param3:Function, param4:Function, param5:Boolean) : void
{
this._popupLayer = param1;
this._tab = param2;
this._onVoteCallback = param3;
this._onDoneCallback = param4;
this._randomizeOrder = param5;
this._pollDef = this._tab.def;
this._randOptionLookup = [0,1,2,3];
this._thankYouPopup = new SBStandardTitlePopup(this._popupLayer,"We\'ll share all the Jammers\' results soon!",null,370,this._onDoneCallback,false);
this._pollMediaHelper = new MediaHelper();
this._pollMediaHelper.init(POLL_POPUP_MEDIA_ID,this.onMediaLoaded,true);
}
public function destroy() : void
{
this._pollPopup.bx.removeEventListener(MouseEvent.MOUSE_DOWN,this.onCloseBtnDown);
this._pollPopup.removeEventListener(MouseEvent.MOUSE_DOWN,this.onPopupDown);
this._pollPopup = null;
this._thankYouPopup.destroy();
this._thankYouPopup = null;
}
private function onMediaLoaded(param1:MovieClip) : void
{
if(param1)
{
if(param1.mediaHelper.id == POLL_POPUP_MEDIA_ID)
{
this._pollMediaHelper.destroy();
this._pollMediaHelper = null;
this._pollPopup = MovieClip(param1.getChildAt(0));
this.setUpPollPopup();
}
}
}
private function setUpPollPopup() : void
{
this._pollPopup.bx.addEventListener(MouseEvent.MOUSE_DOWN,this.onCloseBtnDown,false,0,true);
this._pollPopup.addEventListener(MouseEvent.MOUSE_DOWN,this.onPopupDown,false,0,true);
var _loc1_:String = this._pollDef.poll;
var _loc2_:int = _loc1_.indexOf("|");
this._pollPopup.bodyTxt.text = _loc1_.substring(0,_loc2_);
var _loc3_:Array = _loc1_.substring(_loc2_ + 1,_loc1_.length).split("|");
if(this._randomizeOrder)
{
_loc3_ = this.shuffleArray(_loc3_);
}
this._numOptions = _loc3_.length;
this._pollPopup.titleTxt.text = this._pollDef.title;
if(this._numOptions == 2)
{
this._answerSection = this._pollPopup.answer2;
this._pollPopup.answer2.visible = true;
this._pollPopup.answer3.visible = false;
this._pollPopup.answer4.visible = false;
}
else if(this._numOptions == 3)
{
this._answerSection = this._pollPopup.answer3;
this._pollPopup.answer2.visible = false;
this._pollPopup.answer3.visible = true;
this._pollPopup.answer4.visible = false;
}
else
{
this._answerSection = this._pollPopup.answer4;
this._pollPopup.answer2.visible = false;
this._pollPopup.answer3.visible = false;
this._pollPopup.answer4.visible = true;
}
this._optionsGroup = new GuiRadioButtonGroup(this._answerSection.options);
this._answerSection.voteBtn.activateGrayState(true);
this._answerSection.voteBtn.addEventListener(MouseEvent.MOUSE_DOWN,this.onVoteBtnDown,false,0,true);
var _loc4_:int = 1;
while(_loc4_ < this._numOptions + 1)
{
this._answerSection["answer" + _loc4_ + "Txt"].text = _loc3_[_loc4_ - 1];
this._answerSection.options["option" + _loc4_].addEventListener(MouseEvent.MOUSE_DOWN,this.onOptionSelected,false,0,true);
_loc4_++;
}
DarkenManager.showLoadingSpiral(false);
this.open(this._pollPopup);
}
private function shuffleArray(param1:Array) : Array
{
var _loc4_:String = null;
var _loc5_:int = 0;
var _loc6_:int = 0;
var _loc7_:int = 0;
var _loc2_:int = int(param1.length);
var _loc3_:Array = param1.slice();
while(_loc5_ < _loc2_)
{
_loc4_ = _loc3_[_loc5_];
_loc6_ = Math.floor(Math.random() * _loc2_);
if(_loc5_ != _loc6_)
{
_loc3_[_loc5_] = _loc3_[_loc6_];
_loc3_[_loc6_] = _loc4_;
_loc7_ = int(this._randOptionLookup[_loc5_]);
this._randOptionLookup[_loc5_] = this._randOptionLookup[_loc6_];
this._randOptionLookup[_loc6_] = _loc7_;
}
_loc5_++;
}
return _loc3_;
}
private function open(param1:MovieClip) : void
{
this._popupLayer.addChild(param1);
param1.x = MainFrame.VIEW_WIDTH * 0.5;
param1.y = MainFrame.VIEW_HEIGHT * 0.5;
DarkenManager.darken(param1);
param1.visible = true;
}
private function close(param1:MovieClip) : void
{
param1.visible = false;
DarkenManager.unDarken(param1);
this._popupLayer.removeChild(param1);
}
private function onVoteBtnDown(param1:MouseEvent) : void
{
param1.stopPropagation();
if(!param1.currentTarget.isGray)
{
if(this._onVoteCallback != null)
{
this._onVoteCallback(this._tab,this._randOptionLookup[this._optionsGroup.selected] + 1);
}
this.close(this._pollPopup);
this._thankYouPopup.open();
}
}
private function onCloseBtnDown(param1:MouseEvent) : void
{
param1.stopPropagation();
this.close(param1.currentTarget.parent);
this._onDoneCallback();
}
private function onOptionSelected(param1:MouseEvent) : void
{
param1.stopPropagation();
if(param1.currentTarget == this._answerSection.options.option1)
{
this._answerSection.options.option1._circle.visible = true;
}
var _loc2_:int = 1;
while(_loc2_ < this._numOptions + 1)
{
this._answerSection.options["option" + _loc2_].removeEventListener(MouseEvent.MOUSE_DOWN,this.onOptionSelected);
_loc2_++;
}
this._answerSection.voteBtn.activateGrayState(false);
}
private function onPopupDown(param1:MouseEvent) : void
{
param1.stopPropagation();
}
}
}
@@ -0,0 +1,353 @@
package com.sbi.popup
{
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.events.MouseEvent;
public dynamic class SBPopup extends Sprite
{
public var skin:SBPopupSkin;
public var content:DisplayObject;
public var popupFilters:Array;
public var _enabled:Boolean = true;
public var _selected:Boolean = true;
public var _modal:Boolean = false;
public var _darken:Boolean = false;
public var suppressMouseDown:Boolean = false;
public var closeCallback:Function;
public var restoreLastPos:Boolean = true;
public var lastPosX:Number;
public var lastPosY:Number;
public var draggable:Boolean = true;
public var soundsEnabled:Boolean = true;
public var bxClosesPopup:Boolean = true;
public function SBPopup(param1:DisplayObjectContainer, param2:MovieClip, param3:DisplayObject, param4:Boolean = true, param5:Boolean = true, param6:Boolean = false, param7:Boolean = false, param8:Boolean = false, param9:String = null, param10:Number = undefined, param11:Number = undefined, param12:Number = undefined, param13:Number = undefined, param14:Array = null, param15:Array = null)
{
super();
this.skin = new SBPopupSkin(param2);
this.addChild(this.skin.s);
if(param3)
{
this.content = param3;
this.content.name = "content";
this.content.x = this.skin.s["c"].x;
this.content.y = this.skin.s["c"].y;
this.content.width = this.skin.s["c"].width;
this.content.height = this.skin.s["c"].height;
this.skin.s.addChildAt(this.content,this.skin.s.getChildIndex(this.skin.s["c"]));
}
this.skin.s["c"].visible = false;
if(this.skin.s.getChildByName("bx"))
{
this.skin.s["bx"].addEventListener(MouseEvent.MOUSE_DOWN,this.bxHandler,false,0,true);
}
param1.addChild(this);
this.visible = false;
width = param12 ? param12 : this.skin.s.width;
height = param13 ? param13 : this.skin.s.height;
if(parent.stage)
{
x = param10 ? param10 : MainFrame.VIEW_WIDTH * 0.5;
y = param11 ? param11 : MainFrame.VIEW_HEIGHT * 0.5;
}
this.lastPosX = x;
this.lastPosY = y;
this.modal = param6;
this.draggable = param7;
this.enabled = param5;
this.suppressMouseDown = false;
this.popupFilters = param14;
SBPopupManager.popups.push(this);
if(param8)
{
this._darken = true;
}
if(param4)
{
this.open();
}
}
public static function isChildOf(param1:DisplayObjectContainer, param2:DisplayObjectContainer, param3:DisplayObject) : Boolean
{
var _loc4_:DisplayObject = param3;
while(_loc4_ != param2)
{
if(_loc4_ == param1)
{
return true;
}
_loc4_ = _loc4_.parent;
}
return false;
}
public function get darken() : Boolean
{
return this._darken;
}
public function get selected() : Boolean
{
return this._selected;
}
public function set selected(param1:Boolean) : void
{
if(param1)
{
}
this._selected = param1;
}
public function get enabled() : Boolean
{
return this._enabled;
}
public function set enabled(param1:Boolean) : void
{
if(param1)
{
mouseChildren = true;
}
else
{
mouseChildren = false;
}
this._enabled = param1;
}
override public function set visible(param1:Boolean) : void
{
if(param1)
{
if(this._modal)
{
SBPopupManager.modalSBPopup = this;
}
if(this._darken && SBPopupManager.darken != null)
{
SBPopupManager.darken(this);
}
}
else
{
if(this._modal && SBPopupManager.modalSBPopup == this)
{
SBPopupManager.modalSBPopup = null;
}
if(!this._darken && SBPopupManager.lighten != null)
{
SBPopupManager.lighten(this);
}
}
super.visible = param1;
}
public function get modal() : Boolean
{
return Boolean(this._modal && visible);
}
public function set modal(param1:Boolean) : void
{
if(param1)
{
if(visible)
{
if(Boolean(SBPopupManager.modalSBPopup) && Boolean(SBPopupManager.modalSBPopup != this) && SBPopupManager.modalSBPopup.modal)
{
throw new Error("Attempted to make two or more modal dialogs active at once!");
}
SBPopupManager.modalSBPopup = this;
}
}
else if(SBPopupManager.modalSBPopup == this)
{
SBPopupManager.modalSBPopup = null;
}
this._modal = param1;
}
public function addListeners() : void
{
addEventListener(MouseEvent.MOUSE_DOWN,this.mouseDownHandler,false,0,true);
addEventListener(MouseEvent.MOUSE_UP,this.mouseUpHandler,false,0,true);
}
public function removeListeners() : void
{
removeEventListener(MouseEvent.MOUSE_DOWN,this.mouseDownHandler);
removeEventListener(MouseEvent.MOUSE_UP,this.mouseUpHandler);
}
public function open() : void
{
if(visible)
{
return;
}
if(this._darken)
{
if(Boolean(SBPopupManager) && SBPopupManager.darken != null)
{
SBPopupManager.darken(this);
}
}
this.addListeners();
this.setFilters(this.popupFilters);
if(0)
{
x = this.lastPosX;
y = this.lastPosY;
}
this.visible = true;
if(parent)
{
this.bringToFront();
}
if(this._modal)
{
SBPopupManager.modalSBPopup = this;
}
}
public function close() : void
{
if(!visible)
{
return;
}
if(this._darken)
{
if(Boolean(SBPopupManager) && SBPopupManager.lighten != null)
{
SBPopupManager.lighten(this);
}
}
this.removeListeners();
this.setFilters([]);
this.lastPosX = x;
this.lastPosY = y;
this.visible = false;
if(this._modal)
{
if(SBPopupManager.modalSBPopup == this)
{
SBPopupManager.modalSBPopup = null;
}
}
if(this.closeCallback != null)
{
this.closeCallback();
}
}
public function destroy() : void
{
if(visible)
{
this.close();
}
if(Boolean(this.skin) && Boolean(this.skin.s))
{
removeChild(this.skin.s);
if(this.content)
{
this.skin.s.removeChild(this.content);
this.content = null;
}
this.skin.s = null;
}
this.closeCallback = null;
if(parent)
{
parent.removeChild(this);
}
var _loc1_:int = SBPopupManager.popups.indexOf(this);
if(_loc1_ > 0)
{
SBPopupManager.popups.splice(_loc1_,1);
}
}
public function setFilters(param1:Array = null) : void
{
}
public function bxHandler(param1:MouseEvent) : void
{
param1.stopPropagation();
if(visible && this.bxClosesPopup)
{
this.close();
}
}
public function bringContentToFront() : void
{
this.skin.s.setChildIndex(this.content,this.skin.s.getChildIndex(this.skin.s["c"]));
}
public function mouseDownHandler(param1:MouseEvent) : void
{
param1.stopPropagation();
if(this.suppressMouseDown)
{
this.suppressMouseDown = false;
return;
}
if(!(param1.target is DisplayObject))
{
throw new Error("mouseDownHandler mouse event got a non-DisplayObject object!");
}
if(this.draggable && SBPopupManager.checkModalSBPopup(this,true) && (Boolean(SBPopup.isChildOf(this.skin.s["ba"],this,DisplayObject(param1.target)) || param1.target == this.content) || Boolean(this.content is DisplayObjectContainer && DisplayObjectContainer(this.content).getChildByName("titleDragBar") && param1.target == this.content["titleDragBar"])))
{
startDrag();
}
}
public function bringToFront() : void
{
parent.setChildIndex(this,parent.numChildren - 1);
}
public function mouseUpHandler(param1:MouseEvent) : void
{
param1.stopPropagation();
if(!(param1.target is DisplayObject))
{
throw new Error("mouseDownHandler mouse event got a non-DisplayObject object!");
}
if(this.draggable && SBPopupManager.checkModalSBPopup(this,false) && (Boolean(SBPopup.isChildOf(this.skin.s["ba"],this,DisplayObject(param1.target)) || param1.target == this.content) || Boolean(this.content is DisplayObjectContainer && DisplayObjectContainer(this.content).getChildByName("titleDragBar") && param1.target == this.content["titleDragBar"])))
{
stopDrag();
}
}
public function get closeBtn() : MovieClip
{
return this.skin.s["bx"];
}
}
}
@@ -0,0 +1,175 @@
package com.sbi.popup
{
import flash.filters.*;
public class SBPopupManager
{
public static var _selected:SBPopup;
public static var _modalSBPopup:SBPopup;
public static var _prevModalSBPopup:SBPopup;
public static var darken:Function;
public static var lighten:Function;
public static var popups:Array = [];
public static var nonSBPopups:Array = [];
public static var enabled:Boolean = true;
public function SBPopupManager()
{
super();
}
public static function get selected() : SBPopup
{
return _selected;
}
public static function set selected(param1:SBPopup) : void
{
if(param1.selected)
{
return;
}
param1.selected = true;
_selected = param1;
}
public static function get modalSBPopup() : SBPopup
{
return _modalSBPopup;
}
public static function set modalSBPopup(param1:SBPopup) : void
{
var _loc2_:SBPopup = null;
var _loc3_:SBPopup = null;
for each(_loc2_ in popups)
{
if(_loc2_ != param1)
{
_loc2_.enabled = param1 == null;
}
}
_loc3_ = _prevModalSBPopup;
if(Boolean(param1) && Boolean(_modalSBPopup) && param1 != _modalSBPopup)
{
_prevModalSBPopup = _modalSBPopup;
}
_modalSBPopup = param1;
if(_modalSBPopup == null && Boolean(_loc3_))
{
_modalSBPopup = _loc3_;
_prevModalSBPopup = null;
}
}
public static function checkModalSBPopup(param1:SBPopup, param2:Boolean) : Boolean
{
if(_modalSBPopup == null)
{
return true;
}
if(_modalSBPopup != param1)
{
if(param2)
{
_modalSBPopup.alpha = 0.5;
}
else
{
_modalSBPopup.alpha = 1;
}
return false;
}
return true;
}
public static function getBlurFilter(param1:Number = 2, param2:Number = 2, param3:int = 3) : BlurFilter
{
var _loc4_:BlurFilter = new BlurFilter();
_loc4_.blurX = param1;
_loc4_.blurY = param2;
_loc4_.quality = param3;
return _loc4_;
}
public static function getColorFilter(param1:Number = 1, param2:Number = 1, param3:Number = 1, param4:Number = 1) : ColorMatrixFilter
{
var _loc5_:Array = new Array();
_loc5_ = _loc5_.concat([param2,0,0,0,0]);
_loc5_ = _loc5_.concat([0,param3,0,0,0]);
_loc5_ = _loc5_.concat([0,0,param4,0,0]);
_loc5_ = _loc5_.concat([0,0,0,param1,0]);
return new ColorMatrixFilter(_loc5_);
}
public static function setAllPopupEffects(param1:Array = null) : void
{
var _loc2_:SBPopup = null;
for each(_loc2_ in popups)
{
_loc2_.setFilters(param1);
}
}
public static function setAllModalPopupEffects(param1:Array = null) : void
{
var _loc2_:SBPopup = null;
for each(_loc2_ in popups)
{
if(_loc2_.modal)
{
_loc2_.setFilters(param1);
}
}
}
public static function closeAll() : void
{
var _loc1_:SBPopup = null;
modalSBPopup = null;
for each(_loc1_ in popups)
{
if(_loc1_.visible)
{
_loc1_.close();
}
}
}
public static function destroyAll() : void
{
var _loc1_:SBPopup = null;
modalSBPopup = null;
for each(_loc1_ in popups)
{
_loc1_.destroy();
}
while(popups.length > 0)
{
popups.pop();
}
}
public static function destroyNonSBPopups() : void
{
var _loc1_:Object = null;
for each(_loc1_ in nonSBPopups)
{
_loc1_.destroy();
}
while(nonSBPopups.length > 0)
{
nonSBPopups.pop();
}
}
}
}
@@ -0,0 +1,21 @@
package com.sbi.popup
{
import flash.display.MovieClip;
public dynamic class SBPopupSkin
{
public var s:MovieClip;
public function SBPopupSkin(param1:MovieClip)
{
super();
this.s = param1;
if(!(Boolean(this.s["c"]) && Boolean(this.s["ba"])))
{
throw new Error("skin " + this.s.name + " is missing parts!");
}
}
}
}
@@ -0,0 +1,38 @@
package com.sbi.popup
{
import flash.display.MovieClip;
public class SBScreen
{
public var screenClip:MovieClip;
public var parentWizard:SBWizard;
public var onEnterFromPrev:Function;
public var onEnterFromNext:Function;
public var onLeaveToPrev:Function;
public var onLeaveToNext:Function;
public var onPlay:Function;
public var onClose:Function;
public function SBScreen(param1:MovieClip, param2:SBWizard)
{
super();
this.screenClip = param1;
this.parentWizard = param2;
}
public function destroy() : void
{
this.screenClip = null;
this.parentWizard = null;
}
}
}
Loaded 100 of 7925 files, more files were not shown because too many files have changed in this diff. Show more