code
stringlengths 57
237k
|
|---|
package controls {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.GoogleButton_pressedBitmapGoogle.png")]
public class GoogleButton_pressedBitmapGoogle extends BitmapAsset {
public function GoogleButton_pressedBitmapGoogle() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.payment.types.PaymentRequestUrl;
public class VectorCodecPaymentRequestUrlLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecPaymentRequestUrlLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(PaymentRequestUrl,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<PaymentRequestUrl> = new Vector.<PaymentRequestUrl>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = PaymentRequestUrl(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:PaymentRequestUrl = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<PaymentRequestUrl> = Vector.<PaymentRequestUrl>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.model.quest.daily {
import alternativa.tanks.model.quest.common.MissionsWindowsService;
import alternativa.tanks.model.quest.common.gui.window.events.QuestGetPrizeEvent;
import alternativa.tanks.service.money.IMoneyService;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadPostListener;
import projects.tanks.client.panel.model.quest.QuestTypeEnum;
import projects.tanks.client.panel.model.quest.daily.DailyQuestInfo;
import projects.tanks.client.panel.model.quest.daily.DailyQuestShowingModelBase;
import projects.tanks.client.panel.model.quest.daily.IDailyQuestShowingModelBase;
[ModelInfo]
public class DailyQuestShowingModel extends DailyQuestShowingModelBase implements IDailyQuestShowingModelBase, ObjectLoadListener, ObjectUnloadPostListener {
[Inject]
public static var moneyService:IMoneyService;
[Inject]
public static var dailyQuestService:DailyQuestsService;
[Inject]
public static var missionsWindowsService:MissionsWindowsService;
public function DailyQuestShowingModel() {
super();
}
public function objectLoaded() : void {
dailyQuestService.addEventListener(DailyQuestChangeEvent.DAILY_QUEST_CHANGE,getFunctionWrapper(this.onDailyQuestChange));
dailyQuestService.addEventListener(QuestGetPrizeEvent.GET_QUEST_PRIZE,getFunctionWrapper(this.onQuestGetPrize));
dailyQuestService.addEventListener(DailyQuestEvent.REQUEST_DATA,getFunctionWrapper(this.onDataRequest));
dailyQuestService.setTimeToNextQuest(getInitParam().timeToNextQuest);
missionsWindowsService.initWindow();
if(getInitParam().hasNewQuests && !missionsWindowsService.isWindowOpen()) {
missionsWindowsService.openInTab(QuestTypeEnum.DAILY);
}
}
private function onDailyQuestChange(param1:DailyQuestChangeEvent) : void {
var local2:DailyQuestInfo = param1.dailyQuestInfo;
if(local2.canSkipForFree) {
server.skipQuestForFree(local2.questId);
} else {
moneyService.spend(local2.skipCost);
server.skipQuestForCrystals(local2.questId,local2.skipCost);
}
}
private function onQuestGetPrize(param1:QuestGetPrizeEvent) : void {
server.givePrize(param1.questId);
}
private function onDataRequest(param1:DailyQuestEvent) : void {
server.openWindow();
}
public function openDailyQuest(param1:Vector.<DailyQuestInfo>) : void {
dailyQuestService.questInfoChanged(param1);
missionsWindowsService.openInTab(QuestTypeEnum.DAILY);
}
public function prizeGiven(param1:Long) : void {
dailyQuestService.takePrize(param1);
}
public function skipQuest(param1:Long, param2:DailyQuestInfo) : void {
dailyQuestService.changeSkippedQuest(param1,param2);
}
public function objectUnloadedPost() : void {
dailyQuestService.removeEventListener(DailyQuestChangeEvent.DAILY_QUEST_CHANGE,getFunctionWrapper(this.onDailyQuestChange));
dailyQuestService.removeEventListener(QuestGetPrizeEvent.GET_QUEST_PRIZE,getFunctionWrapper(this.onQuestGetPrize));
dailyQuestService.removeEventListener(DailyQuestEvent.REQUEST_DATA,getFunctionWrapper(this.onDataRequest));
}
}
}
|
package {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol862")]
public dynamic class ScrollArrowDown_downSkin extends MovieClip {
public function ScrollArrowDown_downSkin() {
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.featuring {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
public class ShopItemFeaturingModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ShopItemFeaturingModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package platform.client.fp10.core.service.errormessage.errors {
import platform.client.fp10.core.network.connection.ConnectionCloseStatus;
public class ConnectionClosedError implements ErrorType {
private var closeStatus:ConnectionCloseStatus;
public function ConnectionClosedError(param1:ConnectionCloseStatus) {
super();
this.closeStatus = param1;
}
public function getMessage() : String {
return this.closeStatus.defaultMessage;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.bonus.battle.bonusregions {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.bonus.battle.bonusregions.BonusRegionData;
import projects.tanks.client.battlefield.models.bonus.bonus.BonusesType;
import projects.tanks.client.battlefield.types.Vector3d;
public class CodecBonusRegionData implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_position:ICodec;
private var codec_regionType:ICodec;
private var codec_rotation:ICodec;
public function CodecBonusRegionData() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_position = param1.getCodec(new TypeCodecInfo(Vector3d,false));
this.codec_regionType = param1.getCodec(new EnumCodecInfo(BonusesType,false));
this.codec_rotation = param1.getCodec(new TypeCodecInfo(Vector3d,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BonusRegionData = new BonusRegionData();
local2.position = this.codec_position.decode(param1) as Vector3d;
local2.regionType = this.codec_regionType.decode(param1) as BonusesType;
local2.rotation = this.codec_rotation.decode(param1) as Vector3d;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BonusRegionData = BonusRegionData(param2);
this.codec_position.encode(param1,local3.position);
this.codec_regionType.encode(param1,local3.regionType);
this.codec_rotation.encode(param1,local3.rotation);
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p5 extends BitmapAsset
{
public function RangsIcon_p5()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.firebird {
public interface IFlameThrowingSFXModelBase {
}
}
|
package alternativa.tanks.model.quest.challenge.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.quest.challenge.gui.ChallengesProgressView_progressBarBgClass.png")]
public class ChallengesProgressView_progressBarBgClass extends BitmapAsset {
public function ChallengesProgressView_progressBarBgClass() {
super();
}
}
}
|
package {
import flash.display.BitmapData;
[Embed(source="/_assets/goldButtonLeft_pressed.png")]
public dynamic class goldButtonLeft_pressed extends BitmapData {
public function goldButtonLeft_pressed(param1:int = 6, param2:int = 29) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.gui.settings.controls {
import alternativa.tanks.gui.settings.SettingsCategoryEnum;
import controls.buttons.IconButton;
public class TabButton extends IconButton {
private var category:SettingsCategoryEnum;
public function TabButton(param1:SettingsCategoryEnum, param2:String, param3:Class) {
super(param2,param3);
this.category = param1;
}
public function getCategory() : SettingsCategoryEnum {
return this.category;
}
}
}
|
package alternativa.engine3d.core
{
import alternativa.engine3d.alternativa3d;
import flash.events.Event;
import flash.events.IEventDispatcher;
import flash.geom.ColorTransform;
import flash.geom.Matrix3D;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
import flash.utils.getQualifiedClassName;
use namespace alternativa3d;
[Event(name="click",type="alternativa.engine3d.core.MouseEvent3D")]
[Event(name="doubleClick",type="alternativa.engine3d.core.MouseEvent3D")]
[Event(name="mouseDown",type="alternativa.engine3d.core.MouseEvent3D")]
[Event(name="mouseUp",type="alternativa.engine3d.core.MouseEvent3D")]
[Event(name="mouseOver",type="alternativa.engine3d.core.MouseEvent3D")]
[Event(name="mouseOut",type="alternativa.engine3d.core.MouseEvent3D")]
[Event(name="rollOver",type="alternativa.engine3d.core.MouseEvent3D")]
[Event(name="rollOut",type="alternativa.engine3d.core.MouseEvent3D")]
[Event(name="mouseMove",type="alternativa.engine3d.core.MouseEvent3D")]
[Event(name="mouseWheel",type="alternativa.engine3d.core.MouseEvent3D")]
public class Object3D implements IEventDispatcher
{
alternativa3d static const boundVertexList:Vertex = Vertex.createList(8);
alternativa3d static const tA:Object3D = new Object3D();
alternativa3d static const tB:Object3D = new Object3D();
private static const staticSphere:Vector3D = new Vector3D();
public var x:Number = 0;
public var y:Number = 0;
public var z:Number = 0;
public var rotationX:Number = 0;
public var rotationY:Number = 0;
public var rotationZ:Number = 0;
public var scaleX:Number = 1;
public var scaleY:Number = 1;
public var scaleZ:Number = 1;
public var name:String;
public var visible:Boolean = true;
public var alpha:Number = 1;
public var blendMode:String = "normal";
public var colorTransform:ColorTransform = null;
public var filters:Array = null;
public var mouseEnabled:Boolean = true;
public var doubleClickEnabled:Boolean = false;
public var useHandCursor:Boolean = false;
public var depthMapAlphaThreshold:Number = 1;
public var shadowMapAlphaThreshold:Number = 1;
public var softAttenuation:Number = 0;
public var useShadowMap:Boolean = true;
public var useLight:Boolean = true;
public var boundMinX:Number = -1.0E22;
public var boundMinY:Number = -1.0E22;
public var boundMinZ:Number = -1.0E22;
public var boundMaxX:Number = 1.0E22;
public var boundMaxY:Number = 1.0E22;
public var boundMaxZ:Number = 1.0E22;
alternativa3d var ma:Number;
alternativa3d var mb:Number;
alternativa3d var mc:Number;
alternativa3d var md:Number;
alternativa3d var me:Number;
alternativa3d var mf:Number;
alternativa3d var mg:Number;
alternativa3d var mh:Number;
alternativa3d var mi:Number;
alternativa3d var mj:Number;
alternativa3d var mk:Number;
alternativa3d var ml:Number;
alternativa3d var ima:Number;
alternativa3d var imb:Number;
alternativa3d var imc:Number;
alternativa3d var imd:Number;
alternativa3d var ime:Number;
alternativa3d var imf:Number;
alternativa3d var img:Number;
alternativa3d var imh:Number;
alternativa3d var imi:Number;
alternativa3d var imj:Number;
alternativa3d var imk:Number;
alternativa3d var iml:Number;
alternativa3d var _parent:Object3DContainer;
alternativa3d var next:Object3D;
alternativa3d var culling:int = 0;
alternativa3d var transformId:int = 0;
alternativa3d var distance:Number;
alternativa3d var concatenatedAlpha:Number = 1;
alternativa3d var concatenatedBlendMode:String = "normal";
alternativa3d var concatenatedColorTransform:ColorTransform = null;
alternativa3d var bubbleListeners:Object;
alternativa3d var captureListeners:Object;
alternativa3d var useDepth:Boolean = false;
alternativa3d var transformConst:Vector.<Number>;
alternativa3d var colorConst:Vector.<Number>;
public function Object3D()
{
this.transformConst = new Vector.<Number>(12);
this.colorConst = Vector.<Number>([0,0,0,1,0,0,0,1]);
super();
}
public function get matrix() : Matrix3D
{
tA.composeMatrixFromSource(this);
return new Matrix3D(Vector.<Number>([tA.ma,tA.me,tA.mi,0,tA.mb,tA.mf,tA.mj,0,tA.mc,tA.mg,tA.mk,0,tA.md,tA.mh,tA.ml,1]));
}
public function set matrix(param1:Matrix3D) : void
{
var _loc2_:Vector.<Vector3D> = param1.decompose();
var _loc3_:Vector3D = _loc2_[0];
var _loc4_:Vector3D = _loc2_[1];
var _loc5_:Vector3D = _loc2_[2];
this.x = _loc3_.x;
this.y = _loc3_.y;
this.z = _loc3_.z;
this.rotationX = _loc4_.x;
this.rotationY = _loc4_.y;
this.rotationZ = _loc4_.z;
this.scaleX = _loc5_.x;
this.scaleY = _loc5_.y;
this.scaleZ = _loc5_.z;
}
public function get concatenatedMatrix() : Matrix3D
{
tA.composeMatrixFromSource(this);
var _loc1_:Object3D = this;
while(_loc1_._parent != null)
{
_loc1_ = _loc1_._parent;
tB.composeMatrixFromSource(_loc1_);
tA.appendMatrix(tB);
}
return new Matrix3D(Vector.<Number>([tA.ma,tA.me,tA.mi,0,tA.mb,tA.mf,tA.mj,0,tA.mc,tA.mg,tA.mk,0,tA.md,tA.mh,tA.ml,1]));
}
public function localToGlobal(param1:Vector3D) : Vector3D
{
var _loc3_:Vector3D = null;
tA.composeMatrixFromSource(this);
var _loc2_:Object3D = this;
while(_loc2_._parent != null)
{
_loc2_ = _loc2_._parent;
tB.composeMatrixFromSource(_loc2_);
tA.appendMatrix(tB);
}
_loc3_ = new Vector3D();
_loc3_.x = tA.ma * param1.x + tA.mb * param1.y + tA.mc * param1.z + tA.md;
_loc3_.y = tA.me * param1.x + tA.mf * param1.y + tA.mg * param1.z + tA.mh;
_loc3_.z = tA.mi * param1.x + tA.mj * param1.y + tA.mk * param1.z + tA.ml;
return _loc3_;
}
public function globalToLocal(param1:Vector3D) : Vector3D
{
tA.composeMatrixFromSource(this);
var _loc2_:Object3D = this;
while(_loc2_._parent != null)
{
_loc2_ = _loc2_._parent;
tB.composeMatrixFromSource(_loc2_);
tA.appendMatrix(tB);
}
tA.invertMatrix();
var _loc3_:Vector3D = new Vector3D();
_loc3_.x = tA.ma * param1.x + tA.mb * param1.y + tA.mc * param1.z + tA.md;
_loc3_.y = tA.me * param1.x + tA.mf * param1.y + tA.mg * param1.z + tA.mh;
_loc3_.z = tA.mi * param1.x + tA.mj * param1.y + tA.mk * param1.z + tA.ml;
return _loc3_;
}
public function get parent() : Object3DContainer
{
return this._parent;
}
alternativa3d function setParent(param1:Object3DContainer) : void
{
this._parent = param1;
}
public function calculateBounds() : void
{
this.boundMinX = 1e+22;
this.boundMinY = 1e+22;
this.boundMinZ = 1e+22;
this.boundMaxX = -1e+22;
this.boundMaxY = -1e+22;
this.boundMaxZ = -1e+22;
this.updateBounds(this,null);
if(this.boundMinX > this.boundMaxX)
{
this.boundMinX = -1e+22;
this.boundMinY = -1e+22;
this.boundMinZ = -1e+22;
this.boundMaxX = 1e+22;
this.boundMaxY = 1e+22;
this.boundMaxZ = 1e+22;
}
}
public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
{
var _loc6_:Object = null;
if(param2 == null)
{
throw new TypeError("Parameter listener must be non-null.");
}
if(param3)
{
if(this.captureListeners == null)
{
this.captureListeners = new Object();
}
_loc6_ = this.captureListeners;
}
else
{
if(this.bubbleListeners == null)
{
this.bubbleListeners = new Object();
}
_loc6_ = this.bubbleListeners;
}
var _loc7_:Vector.<Function> = _loc6_[param1];
if(_loc7_ == null)
{
_loc7_ = new Vector.<Function>();
_loc6_[param1] = _loc7_;
}
if(_loc7_.indexOf(param2) < 0)
{
_loc7_.push(param2);
}
}
public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
{
var _loc5_:Vector.<Function> = null;
var _loc6_:int = 0;
var _loc7_:int = 0;
var _loc8_:int = 0;
var _loc9_:* = undefined;
if(param2 == null)
{
throw new TypeError("Parameter listener must be non-null.");
}
var _loc4_:Object = !!param3 ? this.captureListeners : this.bubbleListeners;
if(_loc4_ != null)
{
_loc5_ = _loc4_[param1];
if(_loc5_ != null)
{
_loc6_ = _loc5_.indexOf(param2);
if(_loc6_ >= 0)
{
_loc7_ = _loc5_.length;
_loc8_ = _loc6_ + 1;
while(_loc8_ < _loc7_)
{
_loc5_[_loc6_] = _loc5_[_loc8_];
_loc8_++;
_loc6_++;
}
if(_loc7_ > 1)
{
_loc5_.length = _loc7_ - 1;
}
else
{
delete _loc4_[param1];
for(_loc9_ in _loc4_)
{
}
if(!_loc9_)
{
if(_loc4_ == this.captureListeners)
{
this.captureListeners = null;
}
else
{
this.bubbleListeners = null;
}
}
}
}
}
}
}
public function hasEventListener(param1:String) : Boolean
{
return this.captureListeners != null && this.captureListeners[param1] || this.bubbleListeners != null && this.bubbleListeners[param1];
}
public function willTrigger(param1:String) : Boolean
{
var _loc2_:Object3D = this;
while(_loc2_ != null)
{
if(_loc2_.captureListeners != null && _loc2_.captureListeners[param1] || _loc2_.bubbleListeners != null && _loc2_.bubbleListeners[param1])
{
return true;
}
_loc2_ = _loc2_._parent;
}
return false;
}
public function dispatchEvent(param1:Event) : Boolean
{
var _loc4_:Object3D = null;
var _loc6_:Vector.<Function> = null;
var _loc7_:int = 0;
var _loc8_:int = 0;
var _loc9_:Vector.<Function> = null;
if(param1 == null)
{
throw new TypeError("Parameter event must be non-null.");
}
if(param1 is MouseEvent3D)
{
MouseEvent3D(param1)._target = this;
}
var _loc2_:Vector.<Object3D> = new Vector.<Object3D>();
var _loc3_:int = 0;
_loc4_ = this;
while(_loc4_ != null)
{
_loc2_[_loc3_] = _loc4_;
_loc3_++;
_loc4_ = _loc4_._parent;
}
var _loc5_:int = 0;
while(_loc5_ < _loc3_)
{
_loc4_ = _loc2_[_loc5_];
if(param1 is MouseEvent3D)
{
MouseEvent3D(param1)._currentTarget = _loc4_;
}
if(this.bubbleListeners != null)
{
_loc6_ = this.bubbleListeners[param1.type];
if(_loc6_ != null)
{
_loc8_ = _loc6_.length;
_loc9_ = new Vector.<Function>();
_loc7_ = 0;
while(_loc7_ < _loc8_)
{
_loc9_[_loc7_] = _loc6_[_loc7_];
_loc7_++;
}
_loc7_ = 0;
while(_loc7_ < _loc8_)
{
(_loc9_[_loc7_] as Function).call(null,param1);
_loc7_++;
}
}
}
if(!param1.bubbles)
{
break;
}
_loc5_++;
}
return true;
}
public function calculateResolution(param1:int, param2:int, param3:int = 1, param4:Matrix3D = null) : Number
{
return 1;
}
public function intersectRay(param1:Vector3D, param2:Vector3D, param3:Dictionary = null, param4:Camera3D = null) : RayIntersectionData
{
return null;
}
alternativa3d function checkIntersection(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Dictionary) : Boolean
{
return false;
}
alternativa3d function boundCheckIntersection(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Number, param11:Number, param12:Number, param13:Number) : Boolean
{
var _loc17_:Number = NaN;
var _loc18_:Number = NaN;
var _loc19_:Number = NaN;
var _loc20_:Number = NaN;
var _loc14_:Number = param1 + param4 * param7;
var _loc15_:Number = param2 + param5 * param7;
var _loc16_:Number = param3 + param6 * param7;
if(param1 >= param8 && param1 <= param11 && param2 >= param9 && param2 <= param12 && param3 >= param10 && param3 <= param13 || _loc14_ >= param8 && _loc14_ <= param11 && _loc15_ >= param9 && _loc15_ <= param12 && _loc16_ >= param10 && _loc16_ <= param13)
{
return true;
}
if(param1 < param8 && _loc14_ < param8 || param1 > param11 && _loc14_ > param11 || param2 < param9 && _loc15_ < param9 || param2 > param12 && _loc15_ > param12 || param3 < param10 && _loc16_ < param10 || param3 > param13 && _loc16_ > param13)
{
return false;
}
if(param4 > 0.000001)
{
_loc17_ = (param8 - param1) / param4;
_loc18_ = (param11 - param1) / param4;
}
else if(param4 < -0.000001)
{
_loc17_ = (param11 - param1) / param4;
_loc18_ = (param8 - param1) / param4;
}
else
{
_loc17_ = 0;
_loc18_ = param7;
}
if(param5 > 0.000001)
{
_loc19_ = (param9 - param2) / param5;
_loc20_ = (param12 - param2) / param5;
}
else if(param5 < -0.000001)
{
_loc19_ = (param12 - param2) / param5;
_loc20_ = (param9 - param2) / param5;
}
else
{
_loc19_ = 0;
_loc20_ = param7;
}
if(_loc19_ >= _loc18_ || _loc20_ <= _loc17_)
{
return false;
}
if(_loc19_ < _loc17_)
{
if(_loc20_ < _loc18_)
{
_loc18_ = _loc20_;
}
}
else
{
_loc17_ = _loc19_;
if(_loc20_ < _loc18_)
{
_loc18_ = _loc20_;
}
}
if(param6 > 0.000001)
{
_loc19_ = (param10 - param3) / param6;
_loc20_ = (param13 - param3) / param6;
}
else if(param6 < -0.000001)
{
_loc19_ = (param13 - param3) / param6;
_loc20_ = (param10 - param3) / param6;
}
else
{
_loc19_ = 0;
_loc20_ = param7;
}
if(_loc19_ >= _loc18_ || _loc20_ <= _loc17_)
{
return false;
}
return true;
}
public function clone() : Object3D
{
var _loc1_:Object3D = new Object3D();
_loc1_.clonePropertiesFrom(this);
return _loc1_;
}
protected function clonePropertiesFrom(param1:Object3D) : void
{
this.name = param1.name;
this.visible = param1.visible;
this.alpha = param1.alpha;
this.blendMode = param1.blendMode;
this.mouseEnabled = param1.mouseEnabled;
this.doubleClickEnabled = param1.doubleClickEnabled;
this.useHandCursor = param1.useHandCursor;
this.depthMapAlphaThreshold = param1.depthMapAlphaThreshold;
this.shadowMapAlphaThreshold = param1.shadowMapAlphaThreshold;
this.softAttenuation = param1.softAttenuation;
this.useShadowMap = param1.useShadowMap;
this.useLight = param1.useLight;
this.transformId = param1.transformId;
this.distance = param1.distance;
if(param1.colorTransform != null)
{
this.colorTransform = new ColorTransform();
this.colorTransform.concat(param1.colorTransform);
}
if(param1.filters != null)
{
this.filters = new Array().concat(param1.filters);
}
this.x = param1.x;
this.y = param1.y;
this.z = param1.z;
this.rotationX = param1.rotationX;
this.rotationY = param1.rotationY;
this.rotationZ = param1.rotationZ;
this.scaleX = param1.scaleX;
this.scaleY = param1.scaleY;
this.scaleZ = param1.scaleZ;
this.boundMinX = param1.boundMinX;
this.boundMinY = param1.boundMinY;
this.boundMinZ = param1.boundMinZ;
this.boundMaxX = param1.boundMaxX;
this.boundMaxY = param1.boundMaxY;
this.boundMaxZ = param1.boundMaxZ;
}
public function toString() : String
{
var _loc1_:String = getQualifiedClassName(this);
return "[" + _loc1_.substr(_loc1_.indexOf("::") + 2) + " " + this.name + "]";
}
alternativa3d function draw(param1:Camera3D) : void
{
}
alternativa3d function getVG(param1:Camera3D) : VG
{
return null;
}
alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void
{
}
alternativa3d function concat(param1:Object3DContainer) : void
{
this.concatenatedAlpha = param1.concatenatedAlpha * this.alpha;
this.concatenatedBlendMode = param1.concatenatedBlendMode != "normal" ? param1.concatenatedBlendMode : this.blendMode;
if(param1.concatenatedColorTransform != null)
{
if(this.colorTransform != null)
{
this.concatenatedColorTransform = new ColorTransform();
this.concatenatedColorTransform.redMultiplier = param1.concatenatedColorTransform.redMultiplier;
this.concatenatedColorTransform.greenMultiplier = param1.concatenatedColorTransform.greenMultiplier;
this.concatenatedColorTransform.blueMultiplier = param1.concatenatedColorTransform.blueMultiplier;
this.concatenatedColorTransform.redOffset = param1.concatenatedColorTransform.redOffset;
this.concatenatedColorTransform.greenOffset = param1.concatenatedColorTransform.greenOffset;
this.concatenatedColorTransform.blueOffset = param1.concatenatedColorTransform.blueOffset;
this.concatenatedColorTransform.concat(this.colorTransform);
}
else
{
this.concatenatedColorTransform = param1.concatenatedColorTransform;
}
}
else
{
this.concatenatedColorTransform = this.colorTransform;
}
if(this.concatenatedColorTransform != null)
{
this.colorConst[0] = this.concatenatedColorTransform.redMultiplier;
this.colorConst[1] = this.concatenatedColorTransform.greenMultiplier;
this.colorConst[2] = this.concatenatedColorTransform.blueMultiplier;
this.colorConst[3] = this.concatenatedAlpha;
this.colorConst[4] = this.concatenatedColorTransform.redOffset / 255;
this.colorConst[5] = this.concatenatedColorTransform.greenOffset / 255;
this.colorConst[6] = this.concatenatedColorTransform.blueOffset / 255;
}
else
{
this.colorConst[3] = this.concatenatedAlpha;
}
}
alternativa3d function boundIntersectRay(param1:Vector3D, param2:Vector3D, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number) : Boolean
{
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
if(param1.x >= param3 && param1.x <= param6 && param1.y >= param4 && param1.y <= param7 && param1.z >= param5 && param1.z <= param8)
{
return true;
}
if(param1.x < param3 && param2.x <= 0 || param1.x > param6 && param2.x >= 0 || param1.y < param4 && param2.y <= 0 || param1.y > param7 && param2.y >= 0 || param1.z < param5 && param2.z <= 0 || param1.z > param8 && param2.z >= 0)
{
return false;
}
if(param2.x > 0.000001)
{
_loc9_ = (param3 - param1.x) / param2.x;
_loc10_ = (param6 - param1.x) / param2.x;
}
else if(param2.x < -0.000001)
{
_loc9_ = (param6 - param1.x) / param2.x;
_loc10_ = (param3 - param1.x) / param2.x;
}
else
{
_loc9_ = 0;
_loc10_ = 1e+22;
}
if(param2.y > 0.000001)
{
_loc11_ = (param4 - param1.y) / param2.y;
_loc12_ = (param7 - param1.y) / param2.y;
}
else if(param2.y < -0.000001)
{
_loc11_ = (param7 - param1.y) / param2.y;
_loc12_ = (param4 - param1.y) / param2.y;
}
else
{
_loc11_ = 0;
_loc12_ = 1e+22;
}
if(_loc11_ >= _loc10_ || _loc12_ <= _loc9_)
{
return false;
}
if(_loc11_ < _loc9_)
{
if(_loc12_ < _loc10_)
{
_loc10_ = _loc12_;
}
}
else
{
_loc9_ = _loc11_;
if(_loc12_ < _loc10_)
{
_loc10_ = _loc12_;
}
}
if(param2.z > 0.000001)
{
_loc11_ = (param5 - param1.z) / param2.z;
_loc12_ = (param8 - param1.z) / param2.z;
}
else if(param2.z < -0.000001)
{
_loc11_ = (param8 - param1.z) / param2.z;
_loc12_ = (param5 - param1.z) / param2.z;
}
else
{
_loc11_ = 0;
_loc12_ = 1e+22;
}
if(_loc11_ >= _loc10_ || _loc12_ <= _loc9_)
{
return false;
}
return true;
}
alternativa3d function collectPlanes(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Vector3D, param5:Vector3D, param6:Vector.<Face>, param7:Dictionary = null) : void
{
}
alternativa3d function calculateSphere(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Vector3D, param5:Vector3D, param6:Vector3D = null) : Vector3D
{
this.calculateInverseMatrix();
var _loc7_:Number = this.ima * param1.x + this.imb * param1.y + this.imc * param1.z + this.imd;
var _loc8_:Number = this.ime * param1.x + this.imf * param1.y + this.img * param1.z + this.imh;
var _loc9_:Number = this.imi * param1.x + this.imj * param1.y + this.imk * param1.z + this.iml;
var _loc10_:Number = this.ima * param2.x + this.imb * param2.y + this.imc * param2.z + this.imd;
var _loc11_:Number = this.ime * param2.x + this.imf * param2.y + this.img * param2.z + this.imh;
var _loc12_:Number = this.imi * param2.x + this.imj * param2.y + this.imk * param2.z + this.iml;
var _loc13_:Number = this.ima * param3.x + this.imb * param3.y + this.imc * param3.z + this.imd;
var _loc14_:Number = this.ime * param3.x + this.imf * param3.y + this.img * param3.z + this.imh;
var _loc15_:Number = this.imi * param3.x + this.imj * param3.y + this.imk * param3.z + this.iml;
var _loc16_:Number = this.ima * param4.x + this.imb * param4.y + this.imc * param4.z + this.imd;
var _loc17_:Number = this.ime * param4.x + this.imf * param4.y + this.img * param4.z + this.imh;
var _loc18_:Number = this.imi * param4.x + this.imj * param4.y + this.imk * param4.z + this.iml;
var _loc19_:Number = this.ima * param5.x + this.imb * param5.y + this.imc * param5.z + this.imd;
var _loc20_:Number = this.ime * param5.x + this.imf * param5.y + this.img * param5.z + this.imh;
var _loc21_:Number = this.imi * param5.x + this.imj * param5.y + this.imk * param5.z + this.iml;
var _loc22_:Number = _loc10_ - _loc7_;
var _loc23_:Number = _loc11_ - _loc8_;
var _loc24_:Number = _loc12_ - _loc9_;
var _loc25_:Number = _loc22_ * _loc22_ + _loc23_ * _loc23_ + _loc24_ * _loc24_;
_loc22_ = _loc13_ - _loc7_;
_loc23_ = _loc14_ - _loc8_;
_loc24_ = _loc15_ - _loc9_;
var _loc26_:Number = _loc22_ * _loc22_ + _loc23_ * _loc23_ + _loc24_ * _loc24_;
if(_loc26_ > _loc25_)
{
_loc25_ = _loc26_;
}
_loc22_ = _loc16_ - _loc7_;
_loc23_ = _loc17_ - _loc8_;
_loc24_ = _loc18_ - _loc9_;
_loc26_ = _loc22_ * _loc22_ + _loc23_ * _loc23_ + _loc24_ * _loc24_;
if(_loc26_ > _loc25_)
{
_loc25_ = _loc26_;
}
_loc22_ = _loc19_ - _loc7_;
_loc23_ = _loc20_ - _loc8_;
_loc24_ = _loc21_ - _loc9_;
_loc26_ = _loc22_ * _loc22_ + _loc23_ * _loc23_ + _loc24_ * _loc24_;
if(_loc26_ > _loc25_)
{
_loc25_ = _loc26_;
}
if(param6 == null)
{
param6 = staticSphere;
}
param6.x = _loc7_;
param6.y = _loc8_;
param6.z = _loc9_;
param6.w = Math.sqrt(_loc25_);
return param6;
}
alternativa3d function boundIntersectSphere(param1:Vector3D, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number) : Boolean
{
return param1.x + param1.w > param2 && param1.x - param1.w < param5 && param1.y + param1.w > param3 && param1.y - param1.w < param6 && param1.z + param1.w > param4 && param1.z - param1.w < param7;
}
alternativa3d function split(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Number) : Vector.<Object3D>
{
return new Vector.<Object3D>(2);
}
alternativa3d function testSplit(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Number) : int
{
var _loc5_:Vector3D = this.calculatePlane(param1,param2,param3);
if(_loc5_.x >= 0)
{
if(_loc5_.y >= 0)
{
if(_loc5_.z >= 0)
{
if(this.boundMaxX * _loc5_.x + this.boundMaxY * _loc5_.y + this.boundMaxZ * _loc5_.z <= _loc5_.w + param4)
{
return -1;
}
if(this.boundMinX * _loc5_.x + this.boundMinY * _loc5_.y + this.boundMinZ * _loc5_.z >= _loc5_.w - param4)
{
return 1;
}
}
else
{
if(this.boundMaxX * _loc5_.x + this.boundMaxY * _loc5_.y + this.boundMinZ * _loc5_.z <= _loc5_.w + param4)
{
return -1;
}
if(this.boundMinX * _loc5_.x + this.boundMinY * _loc5_.y + this.boundMaxZ * _loc5_.z >= _loc5_.w - param4)
{
return 1;
}
}
}
else if(_loc5_.z >= 0)
{
if(this.boundMaxX * _loc5_.x + this.boundMinY * _loc5_.y + this.boundMaxZ * _loc5_.z <= _loc5_.w + param4)
{
return -1;
}
if(this.boundMinX * _loc5_.x + this.boundMaxY * _loc5_.y + this.boundMinZ * _loc5_.z >= _loc5_.w - param4)
{
return 1;
}
}
else
{
if(this.boundMaxX * _loc5_.x + this.boundMinY * _loc5_.y + this.boundMinZ * _loc5_.z <= _loc5_.w + param4)
{
return -1;
}
if(this.boundMinX * _loc5_.x + this.boundMaxY * _loc5_.y + this.boundMaxZ * _loc5_.z >= _loc5_.w - param4)
{
return 1;
}
}
}
else if(_loc5_.y >= 0)
{
if(_loc5_.z >= 0)
{
if(this.boundMinX * _loc5_.x + this.boundMaxY * _loc5_.y + this.boundMaxZ * _loc5_.z <= _loc5_.w + param4)
{
return -1;
}
if(this.boundMaxX * _loc5_.x + this.boundMinY * _loc5_.y + this.boundMinZ * _loc5_.z >= _loc5_.w - param4)
{
return 1;
}
}
else
{
if(this.boundMinX * _loc5_.x + this.boundMaxY * _loc5_.y + this.boundMinZ * _loc5_.z <= _loc5_.w + param4)
{
return -1;
}
if(this.boundMaxX * _loc5_.x + this.boundMinY * _loc5_.y + this.boundMaxZ * _loc5_.z >= _loc5_.w - param4)
{
return 1;
}
}
}
else if(_loc5_.z >= 0)
{
if(this.boundMinX * _loc5_.x + this.boundMinY * _loc5_.y + this.boundMaxZ * _loc5_.z <= _loc5_.w + param4)
{
return -1;
}
if(this.boundMaxX * _loc5_.x + this.boundMaxY * _loc5_.y + this.boundMinZ * _loc5_.z >= _loc5_.w - param4)
{
return 1;
}
}
else
{
if(this.boundMinX * _loc5_.x + this.boundMinY * _loc5_.y + this.boundMinZ * _loc5_.z <= _loc5_.w + param4)
{
return -1;
}
if(this.boundMaxX * _loc5_.x + this.boundMaxY * _loc5_.y + this.boundMaxZ * _loc5_.z >= _loc5_.w - param4)
{
return 1;
}
}
return 0;
}
alternativa3d function calculatePlane(param1:Vector3D, param2:Vector3D, param3:Vector3D) : Vector3D
{
var _loc4_:Vector3D = new Vector3D();
var _loc5_:Number = param2.x - param1.x;
var _loc6_:Number = param2.y - param1.y;
var _loc7_:Number = param2.z - param1.z;
var _loc8_:Number = param3.x - param1.x;
var _loc9_:Number = param3.y - param1.y;
var _loc10_:Number = param3.z - param1.z;
_loc4_.x = _loc10_ * _loc6_ - _loc9_ * _loc7_;
_loc4_.y = _loc8_ * _loc7_ - _loc10_ * _loc5_;
_loc4_.z = _loc9_ * _loc5_ - _loc8_ * _loc6_;
var _loc11_:Number = _loc4_.x * _loc4_.x + _loc4_.y * _loc4_.y + _loc4_.z * _loc4_.z;
if(_loc11_ > 0.0001)
{
_loc11_ = Math.sqrt(_loc11_);
_loc4_.x = _loc4_.x / _loc11_;
_loc4_.y = _loc4_.y / _loc11_;
_loc4_.z = _loc4_.z / _loc11_;
}
_loc4_.w = param1.x * _loc4_.x + param1.y * _loc4_.y + param1.z * _loc4_.z;
return _loc4_;
}
alternativa3d function composeMatrix() : void
{
var cosX:Number = Math.cos(this.rotationX);
var sinX:Number = Math.sin(this.rotationX);
var cosY:Number = Math.cos(this.rotationY);
var sinY:Number = Math.sin(this.rotationY);
var cosZ:Number = Math.cos(this.rotationZ);
var sinZ:Number = Math.sin(this.rotationZ);
var cosZsinY:Number = cosZ * sinY;
var sinZsinY:Number = sinZ * sinY;
var cosYscaleX:Number = cosY * this.scaleX;
var sinXscaleY:Number = sinX * this.scaleY;
var cosXscaleY:Number = cosX * this.scaleY;
var cosXscaleZ:Number = cosX * this.scaleZ;
var sinXscaleZ:Number = sinX * this.scaleZ;
this.ma = cosZ * cosYscaleX;
this.mb = cosZsinY * sinXscaleY - sinZ * cosXscaleY;
this.mc = cosZsinY * cosXscaleZ + sinZ * sinXscaleZ;
this.md = this.x;
this.me = sinZ * cosYscaleX;
this.mf = sinZsinY * sinXscaleY + cosZ * cosXscaleY;
this.mg = sinZsinY * cosXscaleZ - cosZ * sinXscaleZ;
this.mh = this.y;
this.mi = -sinY * this.scaleX;
this.mj = cosY * sinXscaleY;
this.mk = cosY * cosXscaleZ;
this.ml = this.z;
}
alternativa3d function composeMatrixFromSource(param1:Object3D) : void
{
var _loc2_:Number = Math.cos(param1.rotationX);
var _loc3_:Number = Math.sin(param1.rotationX);
var _loc4_:Number = Math.cos(param1.rotationY);
var _loc5_:Number = Math.sin(param1.rotationY);
var _loc6_:Number = Math.cos(param1.rotationZ);
var _loc7_:Number = Math.sin(param1.rotationZ);
var _loc8_:Number = _loc6_ * _loc5_;
var _loc9_:Number = _loc7_ * _loc5_;
var _loc10_:Number = _loc4_ * param1.scaleX;
var _loc11_:Number = _loc3_ * param1.scaleY;
var _loc12_:Number = _loc2_ * param1.scaleY;
var _loc13_:Number = _loc2_ * param1.scaleZ;
var _loc14_:Number = _loc3_ * param1.scaleZ;
this.ma = _loc6_ * _loc10_;
this.mb = _loc8_ * _loc11_ - _loc7_ * _loc12_;
this.mc = _loc8_ * _loc13_ + _loc7_ * _loc14_;
this.md = param1.x;
this.me = _loc7_ * _loc10_;
this.mf = _loc9_ * _loc11_ + _loc6_ * _loc12_;
this.mg = _loc9_ * _loc13_ - _loc6_ * _loc14_;
this.mh = param1.y;
this.mi = -_loc5_ * param1.scaleX;
this.mj = _loc4_ * _loc11_;
this.mk = _loc4_ * _loc13_;
this.ml = param1.z;
}
alternativa3d function appendMatrix(transform:Object3D) : void
{
var ta:Number = this.ma;
var tb:Number = this.mb;
var tc:Number = this.mc;
var td:Number = this.md;
var te:Number = this.me;
var tf:Number = this.mf;
var tg:Number = this.mg;
var th:Number = this.mh;
var ti:Number = this.mi;
var tj:Number = this.mj;
var tk:Number = this.mk;
var tl:Number = this.ml;
this.ma = transform.ma * ta + transform.mb * te + transform.mc * ti;
this.mb = transform.ma * tb + transform.mb * tf + transform.mc * tj;
this.mc = transform.ma * tc + transform.mb * tg + transform.mc * tk;
this.md = transform.ma * td + transform.mb * th + transform.mc * tl + transform.md;
this.me = transform.me * ta + transform.mf * te + transform.mg * ti;
this.mf = transform.me * tb + transform.mf * tf + transform.mg * tj;
this.mg = transform.me * tc + transform.mf * tg + transform.mg * tk;
this.mh = transform.me * td + transform.mf * th + transform.mg * tl + transform.mh;
this.mi = transform.mi * ta + transform.mj * te + transform.mk * ti;
this.mj = transform.mi * tb + transform.mj * tf + transform.mk * tj;
this.mk = transform.mi * tc + transform.mj * tg + transform.mk * tk;
this.ml = transform.mi * td + transform.mj * th + transform.mk * tl + transform.ml;
}
alternativa3d function composeAndAppend(param1:Object3D) : void
{
var _loc2_:Number = Math.cos(this.rotationX);
var _loc3_:Number = Math.sin(this.rotationX);
var _loc4_:Number = Math.cos(this.rotationY);
var _loc5_:Number = Math.sin(this.rotationY);
var _loc6_:Number = Math.cos(this.rotationZ);
var _loc7_:Number = Math.sin(this.rotationZ);
var _loc8_:Number = _loc6_ * _loc5_;
var _loc9_:Number = _loc7_ * _loc5_;
var _loc10_:Number = _loc4_ * this.scaleX;
var _loc11_:Number = _loc3_ * this.scaleY;
var _loc12_:Number = _loc2_ * this.scaleY;
var _loc13_:Number = _loc2_ * this.scaleZ;
var _loc14_:Number = _loc3_ * this.scaleZ;
var _loc15_:Number = _loc6_ * _loc10_;
var _loc16_:Number = _loc8_ * _loc11_ - _loc7_ * _loc12_;
var _loc17_:Number = _loc8_ * _loc13_ + _loc7_ * _loc14_;
var _loc18_:Number = this.x;
var _loc19_:Number = _loc7_ * _loc10_;
var _loc20_:Number = _loc9_ * _loc11_ + _loc6_ * _loc12_;
var _loc21_:Number = _loc9_ * _loc13_ - _loc6_ * _loc14_;
var _loc22_:Number = this.y;
var _loc23_:Number = -_loc5_ * this.scaleX;
var _loc24_:Number = _loc4_ * _loc11_;
var _loc25_:Number = _loc4_ * _loc13_;
var _loc26_:Number = this.z;
this.ma = param1.ma * _loc15_ + param1.mb * _loc19_ + param1.mc * _loc23_;
this.mb = param1.ma * _loc16_ + param1.mb * _loc20_ + param1.mc * _loc24_;
this.mc = param1.ma * _loc17_ + param1.mb * _loc21_ + param1.mc * _loc25_;
this.md = param1.ma * _loc18_ + param1.mb * _loc22_ + param1.mc * _loc26_ + param1.md;
this.me = param1.me * _loc15_ + param1.mf * _loc19_ + param1.mg * _loc23_;
this.mf = param1.me * _loc16_ + param1.mf * _loc20_ + param1.mg * _loc24_;
this.mg = param1.me * _loc17_ + param1.mf * _loc21_ + param1.mg * _loc25_;
this.mh = param1.me * _loc18_ + param1.mf * _loc22_ + param1.mg * _loc26_ + param1.mh;
this.mi = param1.mi * _loc15_ + param1.mj * _loc19_ + param1.mk * _loc23_;
this.mj = param1.mi * _loc16_ + param1.mj * _loc20_ + param1.mk * _loc24_;
this.mk = param1.mi * _loc17_ + param1.mj * _loc21_ + param1.mk * _loc25_;
this.ml = param1.mi * _loc18_ + param1.mj * _loc22_ + param1.mk * _loc26_ + param1.ml;
}
alternativa3d function copyAndAppend(param1:Object3D, param2:Object3D) : void
{
this.ma = param2.ma * param1.ma + param2.mb * param1.me + param2.mc * param1.mi;
this.mb = param2.ma * param1.mb + param2.mb * param1.mf + param2.mc * param1.mj;
this.mc = param2.ma * param1.mc + param2.mb * param1.mg + param2.mc * param1.mk;
this.md = param2.ma * param1.md + param2.mb * param1.mh + param2.mc * param1.ml + param2.md;
this.me = param2.me * param1.ma + param2.mf * param1.me + param2.mg * param1.mi;
this.mf = param2.me * param1.mb + param2.mf * param1.mf + param2.mg * param1.mj;
this.mg = param2.me * param1.mc + param2.mf * param1.mg + param2.mg * param1.mk;
this.mh = param2.me * param1.md + param2.mf * param1.mh + param2.mg * param1.ml + param2.mh;
this.mi = param2.mi * param1.ma + param2.mj * param1.me + param2.mk * param1.mi;
this.mj = param2.mi * param1.mb + param2.mj * param1.mf + param2.mk * param1.mj;
this.mk = param2.mi * param1.mc + param2.mj * param1.mg + param2.mk * param1.mk;
this.ml = param2.mi * param1.md + param2.mj * param1.mh + param2.mk * param1.ml + param2.ml;
}
alternativa3d function invertMatrix() : void
{
var _loc1_:Number = this.ma;
var _loc2_:Number = this.mb;
var _loc3_:Number = this.mc;
var _loc4_:Number = this.md;
var _loc5_:Number = this.me;
var _loc6_:Number = this.mf;
var _loc7_:Number = this.mg;
var _loc8_:Number = this.mh;
var _loc9_:Number = this.mi;
var _loc10_:Number = this.mj;
var _loc11_:Number = this.mk;
var _loc12_:Number = this.ml;
var _loc13_:Number = 1 / (-_loc3_ * _loc6_ * _loc9_ + _loc2_ * _loc7_ * _loc9_ + _loc3_ * _loc5_ * _loc10_ - _loc1_ * _loc7_ * _loc10_ - _loc2_ * _loc5_ * _loc11_ + _loc1_ * _loc6_ * _loc11_);
this.ma = (-_loc7_ * _loc10_ + _loc6_ * _loc11_) * _loc13_;
this.mb = (_loc3_ * _loc10_ - _loc2_ * _loc11_) * _loc13_;
this.mc = (-_loc3_ * _loc6_ + _loc2_ * _loc7_) * _loc13_;
this.md = (_loc4_ * _loc7_ * _loc10_ - _loc3_ * _loc8_ * _loc10_ - _loc4_ * _loc6_ * _loc11_ + _loc2_ * _loc8_ * _loc11_ + _loc3_ * _loc6_ * _loc12_ - _loc2_ * _loc7_ * _loc12_) * _loc13_;
this.me = (_loc7_ * _loc9_ - _loc5_ * _loc11_) * _loc13_;
this.mf = (-_loc3_ * _loc9_ + _loc1_ * _loc11_) * _loc13_;
this.mg = (_loc3_ * _loc5_ - _loc1_ * _loc7_) * _loc13_;
this.mh = (_loc3_ * _loc8_ * _loc9_ - _loc4_ * _loc7_ * _loc9_ + _loc4_ * _loc5_ * _loc11_ - _loc1_ * _loc8_ * _loc11_ - _loc3_ * _loc5_ * _loc12_ + _loc1_ * _loc7_ * _loc12_) * _loc13_;
this.mi = (-_loc6_ * _loc9_ + _loc5_ * _loc10_) * _loc13_;
this.mj = (_loc2_ * _loc9_ - _loc1_ * _loc10_) * _loc13_;
this.mk = (-_loc2_ * _loc5_ + _loc1_ * _loc6_) * _loc13_;
this.ml = (_loc4_ * _loc6_ * _loc9_ - _loc2_ * _loc8_ * _loc9_ - _loc4_ * _loc5_ * _loc10_ + _loc1_ * _loc8_ * _loc10_ + _loc2_ * _loc5_ * _loc12_ - _loc1_ * _loc6_ * _loc12_) * _loc13_;
}
alternativa3d function calculateInverseMatrix() : void
{
var _loc1_:Number = 1 / (-this.mc * this.mf * this.mi + this.mb * this.mg * this.mi + this.mc * this.me * this.mj - this.ma * this.mg * this.mj - this.mb * this.me * this.mk + this.ma * this.mf * this.mk);
this.ima = (-this.mg * this.mj + this.mf * this.mk) * _loc1_;
this.imb = (this.mc * this.mj - this.mb * this.mk) * _loc1_;
this.imc = (-this.mc * this.mf + this.mb * this.mg) * _loc1_;
this.imd = (this.md * this.mg * this.mj - this.mc * this.mh * this.mj - this.md * this.mf * this.mk + this.mb * this.mh * this.mk + this.mc * this.mf * this.ml - this.mb * this.mg * this.ml) * _loc1_;
this.ime = (this.mg * this.mi - this.me * this.mk) * _loc1_;
this.imf = (-this.mc * this.mi + this.ma * this.mk) * _loc1_;
this.img = (this.mc * this.me - this.ma * this.mg) * _loc1_;
this.imh = (this.mc * this.mh * this.mi - this.md * this.mg * this.mi + this.md * this.me * this.mk - this.ma * this.mh * this.mk - this.mc * this.me * this.ml + this.ma * this.mg * this.ml) * _loc1_;
this.imi = (-this.mf * this.mi + this.me * this.mj) * _loc1_;
this.imj = (this.mb * this.mi - this.ma * this.mj) * _loc1_;
this.imk = (-this.mb * this.me + this.ma * this.mf) * _loc1_;
this.iml = (this.md * this.mf * this.mi - this.mb * this.mh * this.mi - this.md * this.me * this.mj + this.ma * this.mh * this.mj + this.mb * this.me * this.ml - this.ma * this.mf * this.ml) * _loc1_;
}
alternativa3d function cullingInCamera(param1:Camera3D, param2:int) : int
{
var _loc4_:Vertex = null;
var _loc5_:Number = NaN;
var _loc6_:Number = NaN;
var _loc7_:Number = NaN;
var _loc8_:Boolean = false;
var _loc9_:Boolean = false;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:int = 0;
var _loc13_:Vertex = null;
if(param1.occludedAll)
{
return -1;
}
var _loc3_:int = param1.numOccluders;
if(param2 > 0 || _loc3_ > 0)
{
_loc4_ = boundVertexList;
_loc4_.x = this.boundMinX;
_loc4_.y = this.boundMinY;
_loc4_.z = this.boundMinZ;
_loc4_ = _loc4_.next;
_loc4_.x = this.boundMaxX;
_loc4_.y = this.boundMinY;
_loc4_.z = this.boundMinZ;
_loc4_ = _loc4_.next;
_loc4_.x = this.boundMinX;
_loc4_.y = this.boundMaxY;
_loc4_.z = this.boundMinZ;
_loc4_ = _loc4_.next;
_loc4_.x = this.boundMaxX;
_loc4_.y = this.boundMaxY;
_loc4_.z = this.boundMinZ;
_loc4_ = _loc4_.next;
_loc4_.x = this.boundMinX;
_loc4_.y = this.boundMinY;
_loc4_.z = this.boundMaxZ;
_loc4_ = _loc4_.next;
_loc4_.x = this.boundMaxX;
_loc4_.y = this.boundMinY;
_loc4_.z = this.boundMaxZ;
_loc4_ = _loc4_.next;
_loc4_.x = this.boundMinX;
_loc4_.y = this.boundMaxY;
_loc4_.z = this.boundMaxZ;
_loc4_ = _loc4_.next;
_loc4_.x = this.boundMaxX;
_loc4_.y = this.boundMaxY;
_loc4_.z = this.boundMaxZ;
_loc4_ = boundVertexList;
while(_loc4_ != null)
{
_loc5_ = _loc4_.x;
_loc6_ = _loc4_.y;
_loc7_ = _loc4_.z;
_loc4_.cameraX = this.ma * _loc5_ + this.mb * _loc6_ + this.mc * _loc7_ + this.md;
_loc4_.cameraY = this.me * _loc5_ + this.mf * _loc6_ + this.mg * _loc7_ + this.mh;
_loc4_.cameraZ = this.mi * _loc5_ + this.mj * _loc6_ + this.mk * _loc7_ + this.ml;
_loc4_ = _loc4_.next;
}
}
if(param2 > 0)
{
if(param2 & 1)
{
_loc10_ = param1.nearClipping;
_loc4_ = boundVertexList;
_loc8_ = false;
_loc9_ = false;
while(_loc4_ != null)
{
if(_loc4_.cameraZ > _loc10_)
{
_loc8_ = true;
if(_loc9_)
{
break;
}
}
else
{
_loc9_ = true;
if(_loc8_)
{
break;
}
}
_loc4_ = _loc4_.next;
}
if(_loc9_)
{
if(!_loc8_)
{
return -1;
}
}
else
{
param2 = param2 & 62;
}
}
if(param2 & 2)
{
_loc11_ = param1.farClipping;
_loc4_ = boundVertexList;
_loc8_ = false;
_loc9_ = false;
while(_loc4_ != null)
{
if(_loc4_.cameraZ < _loc11_)
{
_loc8_ = true;
if(_loc9_)
{
break;
}
}
else
{
_loc9_ = true;
if(_loc8_)
{
break;
}
}
_loc4_ = _loc4_.next;
}
if(_loc9_)
{
if(!_loc8_)
{
return -1;
}
}
else
{
param2 = param2 & 61;
}
}
if(param2 & 4)
{
_loc4_ = boundVertexList;
_loc8_ = false;
_loc9_ = false;
while(_loc4_ != null)
{
if(-_loc4_.cameraX < _loc4_.cameraZ)
{
_loc8_ = true;
if(_loc9_)
{
break;
}
}
else
{
_loc9_ = true;
if(_loc8_)
{
break;
}
}
_loc4_ = _loc4_.next;
}
if(_loc9_)
{
if(!_loc8_)
{
return -1;
}
}
else
{
param2 = param2 & 59;
}
}
if(param2 & 8)
{
_loc4_ = boundVertexList;
_loc8_ = false;
_loc9_ = false;
while(_loc4_ != null)
{
if(_loc4_.cameraX < _loc4_.cameraZ)
{
_loc8_ = true;
if(_loc9_)
{
break;
}
}
else
{
_loc9_ = true;
if(_loc8_)
{
break;
}
}
_loc4_ = _loc4_.next;
}
if(_loc9_)
{
if(!_loc8_)
{
return -1;
}
}
else
{
param2 = param2 & 55;
}
}
if(param2 & 16)
{
_loc4_ = boundVertexList;
_loc8_ = false;
_loc9_ = false;
while(_loc4_ != null)
{
if(-_loc4_.cameraY < _loc4_.cameraZ)
{
_loc8_ = true;
if(_loc9_)
{
break;
}
}
else
{
_loc9_ = true;
if(_loc8_)
{
break;
}
}
_loc4_ = _loc4_.next;
}
if(_loc9_)
{
if(!_loc8_)
{
return -1;
}
}
else
{
param2 = param2 & 47;
}
}
if(param2 & 32)
{
_loc4_ = boundVertexList;
_loc8_ = false;
_loc9_ = false;
while(_loc4_ != null)
{
if(_loc4_.cameraY < _loc4_.cameraZ)
{
_loc8_ = true;
if(_loc9_)
{
break;
}
}
else
{
_loc9_ = true;
if(_loc8_)
{
break;
}
}
_loc4_ = _loc4_.next;
}
if(_loc9_)
{
if(!_loc8_)
{
return -1;
}
}
else
{
param2 = param2 & 31;
}
}
}
if(_loc3_ > 0)
{
_loc12_ = 0;
while(true)
{
if(_loc12_ < _loc3_)
{
_loc13_ = param1.occluders[_loc12_];
while(_loc13_ != null)
{
_loc4_ = boundVertexList;
while(_loc4_ != null)
{
if(_loc13_.cameraX * _loc4_.cameraX + _loc13_.cameraY * _loc4_.cameraY + _loc13_.cameraZ * _loc4_.cameraZ >= 0)
{
break;
}
_loc4_ = _loc4_.next;
}
if(_loc4_ != null)
{
break;
}
_loc13_ = _loc13_.next;
}
if(_loc13_ == null)
{
break;
}
_loc12_++;
}
}
return -1;
}
this.culling = param2;
return param2;
}
alternativa3d function removeFromParent() : void
{
var o:Object3D = null;
if(this._parent != null)
{
o = this._parent.removeChild(this);
o = null;
null;
}
}
public function destroy() : void
{
this.captureListeners = null;
this.bubbleListeners = null;
}
}
}
|
package projects.tanks.clients.flash.commons.services.notification.sound {
import flash.media.Sound;
public class NotificationSoundService implements INotificationSoundService {
private var _notificationSound:Sound;
public function NotificationSoundService() {
super();
}
public function set notificationSound(param1:Sound) : void {
this._notificationSound = param1;
}
public function playNotificationSound() : void {
if(this._notificationSound != null) {
this._notificationSound.play();
}
}
}
}
|
package alternativa.tanks.gui.settings {
import alternativa.tanks.AbstractEnum;
public class SettingsCategoryEnum extends AbstractEnum {
private static var _values:Vector.<SettingsCategoryEnum>;
public static const GRAPHIC:SettingsCategoryEnum = new SettingsCategoryEnum(0,"GRAPHIC");
public static const ACCOUNT:SettingsCategoryEnum = new SettingsCategoryEnum(1,"ACCOUNT");
public static const SOUND:SettingsCategoryEnum = new SettingsCategoryEnum(2,"SOUND");
public static const GAME:SettingsCategoryEnum = new SettingsCategoryEnum(3,"GAME");
public static const CONTROL:SettingsCategoryEnum = new SettingsCategoryEnum(4,"CONTROL");
public function SettingsCategoryEnum(param1:int, param2:String) {
super(param1,param2);
}
public static function get values() : Vector.<SettingsCategoryEnum> {
if(!_values) {
_values = new Vector.<SettingsCategoryEnum>(5,true);
_values[GRAPHIC.value] = GRAPHIC;
_values[ACCOUNT.value] = ACCOUNT;
_values[SOUND.value] = SOUND;
_values[GAME.value] = GAME;
_values[CONTROL.value] = CONTROL;
}
return _values;
}
}
}
|
package _codec.projects.tanks.client.clans.clan.clanflag {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
public class CodecClanFlag implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_flagImage:ICodec;
private var codec_id:ICodec;
private var codec_name:ICodec;
public function CodecClanFlag() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_flagImage = param1.getCodec(new TypeCodecInfo(ImageResource,false));
this.codec_id = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ClanFlag = new ClanFlag();
local2.flagImage = this.codec_flagImage.decode(param1) as ImageResource;
local2.id = this.codec_id.decode(param1) as Long;
local2.name = this.codec_name.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ClanFlag = ClanFlag(param2);
this.codec_flagImage.encode(param1,local3.flagImage);
this.codec_id.encode(param1,local3.id);
this.codec_name.encode(param1,local3.name);
}
}
}
|
package alternativa.tanks.models.weapon.artillery.rotation {
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.WeaponMount;
import alternativa.tanks.battle.objects.tank.controllers.BarrelElevator;
import alternativa.tanks.models.tank.AddToBattleListener;
import alternativa.tanks.models.tank.DestroyTankPart;
import alternativa.tanks.models.tank.InitTankPart;
import alternativa.tanks.models.tank.RemoveFromBattleListener;
import alternativa.tanks.models.tank.WeaponMountProvider;
import alternativa.tanks.models.weapon.angles.verticals.VerticalAngles;
import alternativa.tanks.models.weapon.artillery.IArtilleryModel;
import alternativa.tanks.models.weapon.artillery.VerticalAngleView;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapon.common.asWeaponCommon;
import alternativa.tanks.models.weapon.turret.TurretStateSender;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation.ArtilleryElevatingBarrelCC;
import projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation.ArtilleryElevatingBarrelModelBase;
import projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation.BarrelElevationCommand;
import projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation.IArtilleryElevatingBarrelModelBase;
[ModelInfo]
public class ArtilleryElevatingBarrelModel extends ArtilleryElevatingBarrelModelBase implements IArtilleryElevatingBarrelModelBase, ObjectLoadListener, InitTankPart, DestroyTankPart, TurretStateSender, WeaponMountProvider, AddToBattleListener, RemoveFromBattleListener {
[Inject]
public static var battleService:BattleService;
public function ArtilleryElevatingBarrelModel() {
super();
}
public function objectLoaded() : void {
var local1:ArtilleryElevatingBarrelCC = getInitParam();
var local2:BarrelElevationCommand = new BarrelElevationCommand(local1.control,local1.elevation);
this.saveState(local2);
}
public function createWeaponMount(param1:IGameObject) : WeaponMount {
var local2:Number = Number(this.asArtilleryModel().getDefaultElevation());
var local3:WeaponCommonData = asWeaponCommon(object).getCommonData();
var local4:VerticalAngles = VerticalAngles(object.adapt(VerticalAngles));
var local5:BarrelElevator = new BarrelElevator(local2,-local4.getAngleDown(),local4.getAngleUp(),local3.getMaxTurretRotationSpeed(),local3.getTurretRotationAcceleration());
putData(BarrelElevator,local5);
local5.setBarrelElevation(this.getState().elevation);
local5.setUserControl(this.getState().control);
return local5;
}
private function asArtilleryModel() : IArtilleryModel {
return IArtilleryModel(object.adapt(IArtilleryModel));
}
public function initTankPart(param1:Tank) : void {
var local2:BarrelElevationController = null;
var local3:BarrelStateUpdater = null;
putData(Tank,param1);
if(BattleUtils.isLocalTank(param1.user)) {
local2 = new BarrelElevationController(param1,this.getBarrelElevator());
putData(BarrelElevationController,local2);
local2.enable();
local3 = new BarrelStateUpdater(this.getBarrelElevator(),getFunctionWrapper(this.updateStateOnServer));
putData(BarrelStateUpdater,local3);
putData(VerticalAngleView,new VerticalAngleView(param1.user,this.asArtilleryModel().getWeapon()));
}
}
private function getBarrelElevator() : BarrelElevator {
return BarrelElevator(getData(BarrelElevator));
}
private function getBarrelStateUpdater() : BarrelStateUpdater {
return BarrelStateUpdater(getData(BarrelStateUpdater));
}
public function destroyTankPart() : void {
var local1:BarrelElevationController = BarrelElevationController(getData(BarrelElevationController));
if(local1 != null) {
local1.disable();
}
var local2:VerticalAngleView = VerticalAngleView(getData(VerticalAngleView));
if(local2 != null) {
local2.close();
}
}
private function updateStateOnServer() : void {
var local1:BarrelElevator = this.getBarrelElevator();
var local2:BarrelElevationCommand = this.getState();
local2.elevation = local1.getBarrelPhysicsElevation();
local2.control = local1.getRealControl();
server.update(battleService.getPhysicsTime(),this.getTank().incarnation,local2);
}
public function onAddToBattle() : void {
var local1:BarrelStateUpdater = this.getBarrelStateUpdater();
if(local1 != null) {
local1.reset();
battleService.getBattleRunner().addLogicUnit(local1);
}
var local2:BarrelElevationController = BarrelElevationController(getData(BarrelElevationController));
if(local2 != null) {
local2.onAddToBattle();
}
}
public function onRemoveFromBattle() : void {
var local1:BarrelStateUpdater = this.getBarrelStateUpdater();
if(local1 != null) {
battleService.getBattleRunner().removeLogicUnit(local1);
} else {
this.getBarrelElevator().setUserControl(BarrelElevator.STOP);
}
}
public function sendTurretState() : void {
this.getBarrelStateUpdater().reset();
this.updateStateOnServer();
}
public function update(param1:BarrelElevationCommand) : void {
this.saveState(param1);
var local2:BarrelElevator = this.getBarrelElevator();
local2.setBarrelElevation(param1.elevation);
local2.setUserControl(param1.control);
}
private function getTank() : Tank {
return Tank(getData(Tank));
}
private function saveState(param1:BarrelElevationCommand) : void {
putData(BarrelElevationCommand,param1);
}
private function getState() : BarrelElevationCommand {
return BarrelElevationCommand(getData(BarrelElevationCommand));
}
}
}
|
package alternativa.tanks.animations {
public interface AnimatedValue {
function setAnimatedValue(param1:Number) : void;
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class SocialNetworksWindow_iconBitmap extends BitmapAsset
{
public function SocialNetworksWindow_iconBitmap()
{
super();
}
}
}
|
package alternativa.tanks.help.achievements {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.BubbleHelper;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperAlign;
public class FirstPurchaseHelper extends BubbleHelper {
public function FirstPurchaseHelper() {
super();
var local1:ILocaleService = ILocaleService(OSGi.getInstance().getService(ILocaleService));
text = local1.getText(TanksLocale.TEXT_HELP_PANEL_ACHIEVEMENTS_FIRST_PURCHASE_TEXT);
arrowLehgth = int(local1.getText(TanksLocale.TEXT_HELP_PANEL_ACHIEVEMENTS_FIRST_PURCHASE_ARROW_LENGTH));
arrowAlign = HelperAlign.TOP_LEFT;
_showLimit = 3;
}
}
}
|
package projects.tanks.clients.flash.commons.models.layout.notify {
import projects.tanks.client.commons.models.layout.LayoutState;
[ModelInterface]
public interface ILobbyLayoutNotify {
function layoutSwitchPredicted() : void;
function isSwitchInProgress() : Boolean;
function getCurrentState() : LayoutState;
function inBattle() : Boolean;
}
}
|
package alternativa.tanks.servermodels.socialnetwork {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IExternalEntranceModelAdapt implements IExternalEntranceModel {
private var object:IGameObject;
private var impl:IExternalEntranceModel;
public function IExternalEntranceModelAdapt(param1:IGameObject, param2:IExternalEntranceModel) {
super();
this.object = param1;
this.impl = param2;
}
public function startExternalRegisterUser(param1:String, param2:Boolean, param3:String) : void {
var socialNetworkId:String = param1;
var rememberMe:Boolean = param2;
var domain:String = param3;
try {
Model.object = this.object;
this.impl.startExternalRegisterUser(socialNetworkId,rememberMe,domain);
}
finally {
Model.popObject();
}
}
public function startExternalLoginUser(param1:String, param2:Boolean, param3:String) : void {
var socialNetworkId:String = param1;
var rememberMe:Boolean = param2;
var domain:String = param3;
try {
Model.object = this.object;
this.impl.startExternalLoginUser(socialNetworkId,rememberMe,domain);
}
finally {
Model.popObject();
}
}
public function finishExternalRegisterUser(param1:String, param2:String) : void {
var uid:String = param1;
var referralHash:String = param2;
try {
Model.object = this.object;
this.impl.finishExternalRegisterUser(uid,referralHash);
}
finally {
Model.popObject();
}
}
public function login(param1:String, param2:String) : void {
var uid:String = param1;
var password:String = param2;
try {
Model.object = this.object;
this.impl.login(uid,password);
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.battleselect.model.matchmaking.group.invitewindow {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class GroupInviteWindowModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:GroupInviteWindowModelServer;
private var client:IGroupInviteWindowModelBase = IGroupInviteWindowModelBase(this);
private var modelId:Long = Long.getLong(443203981,347316300);
private var _setAvailableToInviteUsersId:Long = Long.getLong(64042174,-63295164);
private var _setAvailableToInviteUsers_friendsCodec:ICodec;
private var _showId:Long = Long.getLong(1229034573,1475867490);
private var _show_allowedFromFriendsCodec:ICodec;
private var _show_allowedFromClanCodec:ICodec;
public function GroupInviteWindowModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new GroupInviteWindowModelServer(IModel(this));
this._setAvailableToInviteUsers_friendsCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchMakingUserInfo,false),false,1));
this._show_allowedFromFriendsCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Long,false),false,1));
this._show_allowedFromClanCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Long,false),false,1));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._setAvailableToInviteUsersId:
this.client.setAvailableToInviteUsers(this._setAvailableToInviteUsers_friendsCodec.decode(param2) as Vector.<MatchMakingUserInfo>);
break;
case this._showId:
this.client.show(this._show_allowedFromFriendsCodec.decode(param2) as Vector.<Long>,this._show_allowedFromClanCodec.decode(param2) as Vector.<Long>);
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package mx.core {
public namespace mx_internal = "http://www.adobe.com/2006/flex/mx/internal";
}
|
package alternativa.tanks.models.battle.assault {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.assault.AssaultHudIndicators_emptyBase.png")]
public class AssaultHudIndicators_emptyBase extends BitmapAsset {
public function AssaultHudIndicators_emptyBase() {
super();
}
}
}
|
package alternativa.tanks.model.payment.shop.specialkit.view {
[ModelInterface]
public interface PayPalKitView {
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _ef274a15b74bf271ee112dc651525de9ee80ec52973dd545b21d4c1bd48252cd_flash_display_Sprite extends Sprite {
public function _ef274a15b74bf271ee112dc651525de9ee80ec52973dd545b21d4c1bd48252cd_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package _codec.platform.client.models.commons.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.EnumCodecInfo;
import platform.client.models.commons.types.ValidationStatus;
public class VectorCodecValidationStatusLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecValidationStatusLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(ValidationStatus,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<ValidationStatus> = new Vector.<ValidationStatus>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ValidationStatus(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ValidationStatus = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ValidationStatus> = Vector.<ValidationStatus>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package _codec.projects.tanks.client.battleselect.model.matchmaking.group.invitewindow {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battleselect.model.matchmaking.group.invitewindow.MatchMakingUserInfo;
public class VectorCodecMatchMakingUserInfoLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecMatchMakingUserInfoLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(MatchMakingUserInfo,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<MatchMakingUserInfo> = new Vector.<MatchMakingUserInfo>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = MatchMakingUserInfo(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:MatchMakingUserInfo = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<MatchMakingUserInfo> = Vector.<MatchMakingUserInfo>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_overdriveMammothIconClass.png")]
public class HudInventoryIcon_overdriveMammothIconClass extends BitmapAsset {
public function HudInventoryIcon_overdriveMammothIconClass() {
super();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.clan {
import alternativa.types.Long;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.client.clans.notifier.ClanNotifierData;
public class UserClanInfo {
public var userId:Long;
public var isInClan:Boolean;
public var clanId:Long;
public var clanName:String;
public var clanTag:String;
public var clanActions:Vector.<ClanAction>;
public var clanUserIncoming:Vector.<Long>;
public var clanUserOutgoing:Vector.<Long>;
public var minRankForJoinClan:int;
public function UserClanInfo(param1:ClanNotifierData) {
super();
this.userId = param1.userId;
this.isInClan = param1.clanMember;
this.clanId = param1.clanId;
this.clanName = param1.clanName;
this.clanTag = param1.clanTag;
this.clanActions = param1.clanAction;
this.clanUserIncoming = param1.clanIncoming;
this.clanUserOutgoing = param1.clanOutgoing;
this.minRankForJoinClan = param1.minRankForJoinClan;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.user.damageindicator {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.battlefield.models.user.damageindicator.DamageIndicatorType;
public class CodecDamageIndicatorType implements ICodec {
public function CodecDamageIndicatorType() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:DamageIndicatorType = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = DamageIndicatorType.NORMAL;
break;
case 1:
local2 = DamageIndicatorType.CRITICAL;
break;
case 2:
local2 = DamageIndicatorType.FATAL;
break;
case 3:
local2 = DamageIndicatorType.HEAL;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package _codec.projects.tanks.client.panel.model.socialnetwork {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.socialnetwork.SocialNetworkPanelParams;
public class VectorCodecSocialNetworkPanelParamsLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecSocialNetworkPanelParamsLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(SocialNetworkPanelParams,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<SocialNetworkPanelParams> = new Vector.<SocialNetworkPanelParams>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = SocialNetworkPanelParams(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:SocialNetworkPanelParams = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<SocialNetworkPanelParams> = Vector.<SocialNetworkPanelParams>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.model.payment.shop.category {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.types.ShopCategoryEnum;
public class ShopCategoryAdapt implements ShopCategory {
private var object:IGameObject;
private var impl:ShopCategory;
public function ShopCategoryAdapt(param1:IGameObject, param2:ShopCategory) {
super();
this.object = param1;
this.impl = param2;
}
public function getOrderIndex() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getOrderIndex());
}
finally {
Model.popObject();
}
return result;
}
public function isWithJumpButton() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.isWithJumpButton());
}
finally {
Model.popObject();
}
return result;
}
public function getType() : ShopCategoryEnum {
var result:ShopCategoryEnum = null;
try {
Model.object = this.object;
result = this.impl.getType();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.battlefield.models.continuebattle {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class ContinueBattleModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ContinueBattleModelServer;
private var client:IContinueBattleModelBase = IContinueBattleModelBase(this);
private var modelId:Long = Long.getLong(1750173911,1168019295);
public function ContinueBattleModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ContinueBattleModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.payment.shop.quantityrestriction {
[ModelInterface]
public interface QuantityRestriction {
}
}
|
package alternativa.tanks.model.quest.challenge.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.quest.challenge.gui.TierRenderer_standardPickedClass.png")]
public class TierRenderer_standardPickedClass extends BitmapAsset {
public function TierRenderer_standardPickedClass() {
super();
}
}
}
|
package alternativa.physics.constraints {
import alternativa.physics.PhysicsScene;
public class Constraint {
public var satisfied:Boolean;
public var world:PhysicsScene;
public function Constraint() {
super();
}
public function preProcess(param1:Number) : void {
}
public function apply(param1:Number) : void {
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.effects.activeafterdeath {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.effects.activeafterdeath.ActiveAfterDeathCC;
public class CodecActiveAfterDeathCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_enabled:ICodec;
public function CodecActiveAfterDeathCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_enabled = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ActiveAfterDeathCC = new ActiveAfterDeathCC();
local2.enabled = this.codec_enabled.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ActiveAfterDeathCC = ActiveAfterDeathCC(param2);
this.codec_enabled.encode(param1,local3.enabled);
}
}
}
|
package alternativa.tanks.models.effects.common.bonuscommon
{
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
public class LandingController
{
private static const eulerAngles:Vector3 = new Vector3();
private static const m:Matrix3 = new Matrix3();
private static const ANGULAR_SPEED:Number = 2.5;
private var bonus:ParaBonus;
private var normal:Vector3;
private var pivot:Vector3;
private var r:Vector3;
private var angle:Number;
private var axis:Vector3;
private var oldState:LandingState;
private var newState:LandingState;
private var interpolatedState:LandingState;
public function LandingController(bonus:ParaBonus)
{
super();
this.normal = new Vector3();
this.pivot = new Vector3();
this.r = new Vector3();
this.axis = new Vector3();
this.oldState = new LandingState();
this.newState = new LandingState();
this.interpolatedState = new LandingState();
this.bonus = bonus;
}
public function init(pivot:Vector3, normal:Vector3) : void
{
this.pivot.vCopy(pivot);
this.normal.vCopy(normal);
}
public function start() : void
{
var mesh:BonusMesh = this.bonus.skin;
this.r.reset(mesh.x,mesh.y,mesh.z);
this.r.vSubtract(this.pivot);
this.axis.vCopy(Vector3.Z_AXIS);
this.axis.vCross(this.normal);
this.axis.vNormalize();
this.angle = Math.acos(this.normal.z);
this.newState.position.reset(mesh.x,mesh.y,mesh.z);
this.newState.orientation.setFromEulerAnglesXYZ(mesh.rotationX,mesh.rotationY,mesh.rotationZ);
this.oldState.copy(this.newState);
}
public function runBeforePhysicsUpdate(dt:Number) : void
{
dt *= 0.001;
this.oldState.copy(this.newState);
var deltaAngle:Number = ANGULAR_SPEED * dt;
if(deltaAngle > this.angle)
{
deltaAngle = this.angle;
this.angle = 0;
}
else
{
this.angle -= deltaAngle;
}
m.fromAxisAngle(this.axis,deltaAngle);
this.r.vTransformBy3(m);
this.newState.position.vCopy(this.pivot).vAdd(this.r);
this.newState.orientation.addScaledVector(this.axis,deltaAngle);
this.updateTrigger();
if(this.angle == 0)
{
this.interpolatePhysicsState(1);
this.render();
this.bonus.onLandingComplete();
}
}
private function updateTrigger() : void
{
this.newState.orientation.toMatrix3(m);
this.bonus.trigger.setTransform(this.newState.position,m);
}
public function interpolatePhysicsState(interpolationCoeff:Number) : void
{
this.interpolatedState.interpolate(this.oldState,this.newState,interpolationCoeff);
}
public function render() : void
{
var mesh:BonusMesh = this.bonus.skin;
mesh.x = this.interpolatedState.position.x;
mesh.y = this.interpolatedState.position.y;
mesh.z = this.interpolatedState.position.z;
this.interpolatedState.orientation.getEulerAngles(eulerAngles);
mesh.rotationX = eulerAngles.x;
mesh.rotationY = eulerAngles.y;
mesh.rotationZ = eulerAngles.z;
}
}
}
|
package alternativa.tanks.help {
public class MD5 {
public static const HEX_FORMAT_LOWERCASE:uint = 0;
public static const HEX_FORMAT_UPPERCASE:uint = 1;
public static const BASE64_PAD_CHARACTER_DEFAULT_COMPLIANCE:String = "";
public static const BASE64_PAD_CHARACTER_RFC_COMPLIANCE:String = "=";
public static var hexcase:uint = 0;
public static var b64pad:String = "";
public function MD5() {
super();
}
public static function encrypt(param1:String) : String {
return hex_md5(param1);
}
public static function hex_md5(param1:String) : String {
return rstr2hex(rstr_md5(str2rstr_utf8(param1)));
}
public static function b64_md5(param1:String) : String {
return rstr2b64(rstr_md5(str2rstr_utf8(param1)));
}
public static function any_md5(param1:String, param2:String) : String {
return rstr2any(rstr_md5(str2rstr_utf8(param1)),param2);
}
public static function hex_hmac_md5(param1:String, param2:String) : String {
return rstr2hex(rstr_hmac_md5(str2rstr_utf8(param1),str2rstr_utf8(param2)));
}
public static function b64_hmac_md5(param1:String, param2:String) : String {
return rstr2b64(rstr_hmac_md5(str2rstr_utf8(param1),str2rstr_utf8(param2)));
}
public static function any_hmac_md5(param1:String, param2:String, param3:String) : String {
return rstr2any(rstr_hmac_md5(str2rstr_utf8(param1),str2rstr_utf8(param2)),param3);
}
public static function md5_vm_test() : Boolean {
return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
}
public static function rstr_md5(param1:String) : String {
return binl2rstr(binl_md5(rstr2binl(param1),param1.length * 8));
}
public static function rstr_hmac_md5(param1:String, param2:String) : String {
var local3:Array = rstr2binl(param1);
if(local3.length > 16) {
local3 = binl_md5(local3,param1.length * 8);
}
var local4:Array = new Array(16);
var local5:Array = new Array(16);
var local6:Number = 0;
while(local6 < 16) {
local4[local6] = local3[local6] ^ 0x36363636;
local5[local6] = local3[local6] ^ 0x5C5C5C5C;
local6++;
}
var local7:Array = binl_md5(local4.concat(rstr2binl(param2)),512 + param2.length * 8);
return binl2rstr(binl_md5(local5.concat(local7),512 + 128));
}
public static function rstr2hex(param1:String) : String {
var local4:Number = NaN;
var local2:String = Boolean(hexcase) ? "0123456789ABCDEF" : "0123456789abcdef";
var local3:String = "";
var local5:Number = 0;
while(local5 < param1.length) {
local4 = Number(param1.charCodeAt(local5));
local3 += local2.charAt(local4 >>> 4 & 0x0F) + local2.charAt(local4 & 0x0F);
local5++;
}
return local3;
}
public static function rstr2b64(param1:String) : String {
var local6:Number = NaN;
var local7:Number = NaN;
var local2:String = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var local3:String = "";
var local4:Number = param1.length;
var local5:Number = 0;
while(local5 < local4) {
local6 = param1.charCodeAt(local5) << 16 | (local5 + 1 < local4 ? param1.charCodeAt(local5 + 1) << 8 : 0) | (local5 + 2 < local4 ? param1.charCodeAt(local5 + 2) : 0);
local7 = 0;
while(local7 < 4) {
if(local5 * 8 + local7 * 6 > param1.length * 8) {
local3 += b64pad;
} else {
local3 += local2.charAt(local6 >>> 6 * (3 - local7) & 0x3F);
}
local7++;
}
local5 += 3;
}
return local3;
}
public static function rstr2any(param1:String, param2:String) : String {
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Array = null;
var local3:Number = param2.length;
var local4:Array = [];
var local9:Array = new Array(param1.length / 2);
local5 = 0;
while(local5 < local9.length) {
local9[local5] = param1.charCodeAt(local5 * 2) << 8 | param1.charCodeAt(local5 * 2 + 1);
local5++;
}
while(local9.length > 0) {
local8 = [];
local7 = 0;
local5 = 0;
while(local5 < local9.length) {
local7 = (local7 << 16) + local9[local5];
local6 = Math.floor(local7 / local3);
local7 -= local6 * local3;
if(local8.length > 0 || local6 > 0) {
local8[local8.length] = local6;
}
local5++;
}
local4[local4.length] = local7;
local9 = local8;
}
var local10:String = "";
local5 = local4.length - 1;
while(local5 >= 0) {
local10 += param2.charAt(local4[local5]);
local5--;
}
return local10;
}
public static function str2rstr_utf8(param1:String) : String {
var local4:Number = NaN;
var local5:Number = NaN;
var local2:String = "";
var local3:Number = -1;
while(++local3 < param1.length) {
local4 = Number(param1.charCodeAt(local3));
local5 = local3 + 1 < param1.length ? Number(param1.charCodeAt(local3 + 1)) : 0;
if(55296 <= local4 && local4 <= 56319 && 56320 <= local5 && local5 <= 57343) {
local4 = 65536 + ((local4 & 0x03FF) << 10) + (local5 & 0x03FF);
local3++;
}
if(local4 <= 127) {
local2 += String.fromCharCode(local4);
} else if(local4 <= 2047) {
local2 += String.fromCharCode(0xC0 | local4 >>> 6 & 0x1F,0x80 | local4 & 0x3F);
} else if(local4 <= 65535) {
local2 += String.fromCharCode(0xE0 | local4 >>> 12 & 0x0F,0x80 | local4 >>> 6 & 0x3F,0x80 | local4 & 0x3F);
} else if(local4 <= 2097151) {
local2 += String.fromCharCode(0xF0 | local4 >>> 18 & 7,0x80 | local4 >>> 12 & 0x3F,0x80 | local4 >>> 6 & 0x3F,0x80 | local4 & 0x3F);
}
}
return local2;
}
public static function str2rstr_utf16le(param1:String) : String {
var local2:String = "";
var local3:Number = 0;
while(local3 < param1.length) {
local2 += String.fromCharCode(param1.charCodeAt(local3) & 0xFF,param1.charCodeAt(local3) >>> 8 & 0xFF);
local3++;
}
return local2;
}
public static function str2rstr_utf16be(param1:String) : String {
var local2:String = "";
var local3:Number = 0;
while(local3 < param1.length) {
local2 += String.fromCharCode(param1.charCodeAt(local3) >>> 8 & 0xFF,param1.charCodeAt(local3) & 0xFF);
local3++;
}
return local2;
}
public static function rstr2binl(param1:String) : Array {
var local2:Number = 0;
var local3:Array = new Array(param1.length >> 2);
local2 = 0;
while(local2 < local3.length) {
local3[local2] = 0;
local2++;
}
local2 = 0;
while(local2 < param1.length * 8) {
local3[local2 >> 5] |= (param1.charCodeAt(local2 / 8) & 0xFF) << local2 % 32;
local2 += 8;
}
return local3;
}
public static function binl2rstr(param1:Array) : String {
var local2:String = "";
var local3:Number = 0;
while(local3 < param1.length * 32) {
local2 += String.fromCharCode(param1[local3 >> 5] >>> local3 % 32 & 0xFF);
local3 += 8;
}
return local2;
}
public static function binl_md5(param1:Array, param2:Number) : Array {
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
param1[param2 >> 5] |= 128 << param2 % 32;
param1[(param2 + 64 >>> 9 << 4) + 14] = param2;
var local3:Number = 1732584193;
var local4:Number = -271733879;
var local5:Number = -1732584194;
var local6:Number = 271733878;
var local7:Number = 0;
while(local7 < param1.length) {
local8 = local3;
local9 = local4;
local10 = local5;
local11 = local6;
local3 = md5_ff(local3,local4,local5,local6,param1[local7 + 0],7,-680876936);
local6 = md5_ff(local6,local3,local4,local5,param1[local7 + 1],12,-389564586);
local5 = md5_ff(local5,local6,local3,local4,param1[local7 + 2],17,606105819);
local4 = md5_ff(local4,local5,local6,local3,param1[local7 + 3],22,-1044525330);
local3 = md5_ff(local3,local4,local5,local6,param1[local7 + 4],7,-176418897);
local6 = md5_ff(local6,local3,local4,local5,param1[local7 + 5],12,1200080426);
local5 = md5_ff(local5,local6,local3,local4,param1[local7 + 6],17,-1473231341);
local4 = md5_ff(local4,local5,local6,local3,param1[local7 + 7],22,-45705983);
local3 = md5_ff(local3,local4,local5,local6,param1[local7 + 8],7,1770035416);
local6 = md5_ff(local6,local3,local4,local5,param1[local7 + 9],12,-1958414417);
local5 = md5_ff(local5,local6,local3,local4,param1[local7 + 10],17,-42063);
local4 = md5_ff(local4,local5,local6,local3,param1[local7 + 11],22,-1990404162);
local3 = md5_ff(local3,local4,local5,local6,param1[local7 + 12],7,1804603682);
local6 = md5_ff(local6,local3,local4,local5,param1[local7 + 13],12,-40341101);
local5 = md5_ff(local5,local6,local3,local4,param1[local7 + 14],17,-1502002290);
local4 = md5_ff(local4,local5,local6,local3,param1[local7 + 15],22,1236535329);
local3 = md5_gg(local3,local4,local5,local6,param1[local7 + 1],5,-165796510);
local6 = md5_gg(local6,local3,local4,local5,param1[local7 + 6],9,-1069501632);
local5 = md5_gg(local5,local6,local3,local4,param1[local7 + 11],14,643717713);
local4 = md5_gg(local4,local5,local6,local3,param1[local7 + 0],20,-373897302);
local3 = md5_gg(local3,local4,local5,local6,param1[local7 + 5],5,-701558691);
local6 = md5_gg(local6,local3,local4,local5,param1[local7 + 10],9,38016083);
local5 = md5_gg(local5,local6,local3,local4,param1[local7 + 15],14,-660478335);
local4 = md5_gg(local4,local5,local6,local3,param1[local7 + 4],20,-405537848);
local3 = md5_gg(local3,local4,local5,local6,param1[local7 + 9],5,568446438);
local6 = md5_gg(local6,local3,local4,local5,param1[local7 + 14],9,-1019803690);
local5 = md5_gg(local5,local6,local3,local4,param1[local7 + 3],14,-187363961);
local4 = md5_gg(local4,local5,local6,local3,param1[local7 + 8],20,1163531501);
local3 = md5_gg(local3,local4,local5,local6,param1[local7 + 13],5,-1444681467);
local6 = md5_gg(local6,local3,local4,local5,param1[local7 + 2],9,-51403784);
local5 = md5_gg(local5,local6,local3,local4,param1[local7 + 7],14,1735328473);
local4 = md5_gg(local4,local5,local6,local3,param1[local7 + 12],20,-1926607734);
local3 = md5_hh(local3,local4,local5,local6,param1[local7 + 5],4,-378558);
local6 = md5_hh(local6,local3,local4,local5,param1[local7 + 8],11,-2022574463);
local5 = md5_hh(local5,local6,local3,local4,param1[local7 + 11],16,1839030562);
local4 = md5_hh(local4,local5,local6,local3,param1[local7 + 14],23,-35309556);
local3 = md5_hh(local3,local4,local5,local6,param1[local7 + 1],4,-1530992060);
local6 = md5_hh(local6,local3,local4,local5,param1[local7 + 4],11,1272893353);
local5 = md5_hh(local5,local6,local3,local4,param1[local7 + 7],16,-155497632);
local4 = md5_hh(local4,local5,local6,local3,param1[local7 + 10],23,-1094730640);
local3 = md5_hh(local3,local4,local5,local6,param1[local7 + 13],4,681279174);
local6 = md5_hh(local6,local3,local4,local5,param1[local7 + 0],11,-358537222);
local5 = md5_hh(local5,local6,local3,local4,param1[local7 + 3],16,-722521979);
local4 = md5_hh(local4,local5,local6,local3,param1[local7 + 6],23,76029189);
local3 = md5_hh(local3,local4,local5,local6,param1[local7 + 9],4,-640364487);
local6 = md5_hh(local6,local3,local4,local5,param1[local7 + 12],11,-421815835);
local5 = md5_hh(local5,local6,local3,local4,param1[local7 + 15],16,530742520);
local4 = md5_hh(local4,local5,local6,local3,param1[local7 + 2],23,-995338651);
local3 = md5_ii(local3,local4,local5,local6,param1[local7 + 0],6,-198630844);
local6 = md5_ii(local6,local3,local4,local5,param1[local7 + 7],10,1126891415);
local5 = md5_ii(local5,local6,local3,local4,param1[local7 + 14],15,-1416354905);
local4 = md5_ii(local4,local5,local6,local3,param1[local7 + 5],21,-57434055);
local3 = md5_ii(local3,local4,local5,local6,param1[local7 + 12],6,1700485571);
local6 = md5_ii(local6,local3,local4,local5,param1[local7 + 3],10,-1894986606);
local5 = md5_ii(local5,local6,local3,local4,param1[local7 + 10],15,-1051523);
local4 = md5_ii(local4,local5,local6,local3,param1[local7 + 1],21,-2054922799);
local3 = md5_ii(local3,local4,local5,local6,param1[local7 + 8],6,1873313359);
local6 = md5_ii(local6,local3,local4,local5,param1[local7 + 15],10,-30611744);
local5 = md5_ii(local5,local6,local3,local4,param1[local7 + 6],15,-1560198380);
local4 = md5_ii(local4,local5,local6,local3,param1[local7 + 13],21,1309151649);
local3 = md5_ii(local3,local4,local5,local6,param1[local7 + 4],6,-145523070);
local6 = md5_ii(local6,local3,local4,local5,param1[local7 + 11],10,-1120210379);
local5 = md5_ii(local5,local6,local3,local4,param1[local7 + 2],15,718787259);
local4 = md5_ii(local4,local5,local6,local3,param1[local7 + 9],21,-343485551);
local3 = safe_add(local3,local8);
local4 = safe_add(local4,local9);
local5 = safe_add(local5,local10);
local6 = safe_add(local6,local11);
local7 += 16;
}
return [local3,local4,local5,local6];
}
public static function md5_cmn(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number) : Number {
return safe_add(bit_rol(safe_add(safe_add(param2,param1),safe_add(param4,param6)),param5),param3);
}
public static function md5_ff(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number) : Number {
return md5_cmn(param2 & param3 | ~param2 & param4,param1,param2,param5,param6,param7);
}
public static function md5_gg(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number) : Number {
return md5_cmn(param2 & param4 | param3 & ~param4,param1,param2,param5,param6,param7);
}
public static function md5_hh(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number) : Number {
return md5_cmn(param2 ^ param3 ^ param4,param1,param2,param5,param6,param7);
}
public static function md5_ii(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number) : Number {
return md5_cmn(param3 ^ (param2 | ~param4),param1,param2,param5,param6,param7);
}
public static function safe_add(param1:Number, param2:Number) : Number {
var local3:Number = (param1 & 0xFFFF) + (param2 & 0xFFFF);
var local4:Number = (param1 >> 16) + (param2 >> 16) + (local3 >> 16);
return local4 << 16 | local3 & 0xFFFF;
}
public static function bit_rol(param1:Number, param2:Number) : Number {
return param1 << param2 | param1 >>> 32 - param2;
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory.readytouse {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Shape;
import flash.events.Event;
import flash.geom.ColorTransform;
import flash.geom.Matrix;
import flash.utils.getTimer;
public class LightPillarEffect extends Shape {
public static var barClass:Class = LightPillarEffect_barClass;
public static var barBitmapData:BitmapData = (new barClass() as Bitmap).bitmapData;
public static var topClass:Class = LightPillarEffect_topClass;
public static var topBitmapData:BitmapData = (new topClass() as Bitmap).bitmapData;
private static const DURATION_MS:int = 500;
private static const HEIGHT:int = 500;
private static const matrix:Matrix = new Matrix();
private static const colorTransform:ColorTransform = new ColorTransform();
private var startTime:int;
private var running:Boolean;
public function LightPillarEffect() {
super();
visible = false;
}
public function init(param1:uint) : void {
colorTransform.color = param1;
transform.colorTransform = colorTransform;
}
public function update(param1:int) : void {
var local2:Number = NaN;
if(!this.running) {
return;
}
if(param1 > this.startTime + DURATION_MS) {
this.stop();
return;
}
local2 = (param1 - this.startTime) / DURATION_MS;
this.alpha = -(2 * local2 - 1) * (2 * local2 - 1) + 0.8;
var local3:int = local2 * HEIGHT;
graphics.clear();
matrix.ty = HEIGHT - local3;
graphics.beginBitmapFill(topBitmapData,matrix,true);
graphics.drawRect(0,HEIGHT - local3,topBitmapData.width,Math.min(local3,topBitmapData.height));
graphics.endFill();
if(local3 > topBitmapData.height) {
graphics.beginBitmapFill(barBitmapData,null,false);
graphics.drawRect(0,HEIGHT - local3 + topBitmapData.height,barBitmapData.width,local3 - topBitmapData.height);
graphics.endFill();
}
}
public function start() : void {
this.running = true;
this.startTime = getTimer();
visible = true;
alpha = 0;
}
public function stop() : void {
visible = false;
this.running = false;
dispatchEvent(new Event(Event.COMPLETE));
}
override public function get height() : Number {
return HEIGHT;
}
}
}
|
package {
import controls.panel.BaseButton;
[Embed(source="/_assets/assets.swf", symbol="symbol689")]
public dynamic class MainPanelReferalButton extends BaseButton {
public function MainPanelReferalButton() {
super();
}
}
}
|
package alternativa.tanks.models.battle.ctf {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.ctf.CTFHudIndicators_flagOnBaseBlue.png")]
public class CTFHudIndicators_flagOnBaseBlue extends BitmapAsset {
public function CTFHudIndicators_flagOnBaseBlue() {
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.sfx.shoot.smoky {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.sfx.shoot.smoky.SmokyShootSFXCC;
public class VectorCodecSmokyShootSFXCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecSmokyShootSFXCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(SmokyShootSFXCC,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = int(LengthCodecHelper.decodeLength(param1));
var local3:Vector.<SmokyShootSFXCC> = new Vector.<SmokyShootSFXCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = SmokyShootSFXCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:SmokyShootSFXCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<SmokyShootSFXCC> = Vector.<SmokyShootSFXCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.kits.description.panel {
import flash.display.BitmapData;
import utils.FlipBitmapDataUtils;
public class KitPackageDescriptionPanelBitmaps {
private static const bitmapLeftTopCorner:Class = KitPackageDescriptionPanelBitmaps_bitmapLeftTopCorner;
public static const leftTopCorner:BitmapData = new bitmapLeftTopCorner().bitmapData;
public static const rightTopCorner:BitmapData = FlipBitmapDataUtils.flipH(leftTopCorner);
private static const bitmapLeftBottomCorner:Class = KitPackageDescriptionPanelBitmaps_bitmapLeftBottomCorner;
public static const leftBottomCorner:BitmapData = new bitmapLeftBottomCorner().bitmapData;
public static const rightBottomCorner:BitmapData = FlipBitmapDataUtils.flipH(leftBottomCorner);
private static const bitmapTopLine:Class = KitPackageDescriptionPanelBitmaps_bitmapTopLine;
public static const topLine:BitmapData = new bitmapTopLine().bitmapData;
public static const centerLine:BitmapData = FlipBitmapDataUtils.flipW(topLine);
public static const bottomLine:BitmapData = FlipBitmapDataUtils.flipW(topLine);
private static const bitmapLeftLine:Class = KitPackageDescriptionPanelBitmaps_bitmapLeftLine;
public static const leftLine:BitmapData = new bitmapLeftLine().bitmapData;
public static const rightLine:BitmapData = FlipBitmapDataUtils.flipH(leftLine);
private static const bitmapBackgroundPixel:Class = KitPackageDescriptionPanelBitmaps_bitmapBackgroundPixel;
public static const backgroundPixel:BitmapData = new bitmapBackgroundPixel().bitmapData;
public function KitPackageDescriptionPanelBitmaps() {
super();
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.notifier {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.tanksservices.model.notifier.AbstractNotifier;
public class VectorCodecAbstractNotifierLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecAbstractNotifierLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(AbstractNotifier,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<AbstractNotifier> = new Vector.<AbstractNotifier>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = AbstractNotifier(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:AbstractNotifier = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<AbstractNotifier> = Vector.<AbstractNotifier>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.shoot.twins {
public interface ITwinsShootSFXModelBase {
}
}
|
package projects.tanks.client.partners.impl.fakepartner {
public interface IFakePartnerLoginModelBase {
}
}
|
package forms
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
import assets.IconAlarm;
import controls.Label;
import controls.statassets.BlackRoundRect;
import flash.display.Sprite;
import flash.text.TextFieldAutoSize;
public class FocusWarningWindow extends Sprite
{
private var bg:BlackRoundRect;
private var icon:IconAlarm;
private var label:Label;
public var PADDING:int = 30;
public function FocusWarningWindow()
{
var localeService:ILocaleService = null;
this.bg = new BlackRoundRect();
this.icon = new IconAlarm();
this.label = new Label();
super();
localeService = Main.osgi.getService(ILocaleService) as ILocaleService;
addChild(this.bg);
addChild(this.icon);
addChild(this.label);
this.icon.x = -int(this.icon.width / 2);
this.icon.y = -this.icon.height - 15;
this.label.size = 16;
this.label.text = localeService.getText(TextConst.FOCUS_WARNIG_TEXT);
this.label.autoSize = TextFieldAutoSize.CENTER;
this.label.x = -int(this.label.width / 2);
this.bg.width = width + this.PADDING * 2;
this.bg.height = height + this.PADDING * 2;
this.bg.x = -int(this.bg.width / 2);
this.bg.y = this.icon.y - this.PADDING * 1.1;
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.components.ClanDescriptionInput;
import alternativa.tanks.gui.components.flag.FlagsDropDownList;
import alternativa.tanks.gui.components.rank.RanksDropDownList;
import alternativa.tanks.gui.notinclan.dialogs.ClanDialog;
import alternativa.tanks.models.clan.info.IClanInfoModel;
import alternativa.tanks.models.panel.create.ClanCreateService;
import alternativa.tanks.models.panel.create.CreateClanServiceEvent;
import alternativa.tanks.models.service.ClanInfoUpdateEvent;
import alternativa.tanks.models.service.ClanService;
import controls.base.LabelBase;
import controls.base.TankInputBox;
import controls.base.ThreeLineBigButton;
import controls.dropdownlist.DropDownList;
import flash.events.FocusEvent;
import flash.events.MouseEvent;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class ClanEditProfileDialog extends ClanDialog {
[Inject]
public static var createClanService:ClanCreateService;
[Inject]
public static var clanService:ClanService;
[Inject]
public static var localeService:ILocaleService;
private static const FLAG_FIELD_NAME:String = "country";
private static const GREY_TEXT_COLOR:int = 7829367;
public static const WIDTH:Number = 550;
public static const HEIGHT:Number = 450;
private var clanNameInput:TankInputBox;
private var clanTagInput:TankInputBox;
private var flagsLabel:LabelBase;
private var flagsCombo:FlagsDropDownList;
private var applyRequestsLabel:LabelBase;
private var applyRequests:DropDownList;
private var rankLabel:LabelBase;
private var rankCombo:DropDownList;
private var descriptionInput:ClanDescriptionInput;
private var descriptionLabel:LabelBase;
private var okButton:ThreeLineBigButton;
private var infoModel:IClanInfoModel;
private var lastInfo:ClanInfoUpdateEvent;
private var profileWindow:ClanProfileWindow;
public function ClanEditProfileDialog(param1:IClanInfoModel, param2:ClanInfoUpdateEvent, param3:ClanProfileWindow) {
super();
this.infoModel = param1;
this.lastInfo = param2;
this.profileWindow = param3;
this.init();
this.resize();
}
private function init() : void {
this.clanNameInput = new TankInputBox("",true);
this.clanNameInput.validateFunction = this.updateClanName;
this.clanNameInput.maxChars = 15;
this.clanNameInput.restrict = "0-9.a-zA-z_\\-*";
this.clanNameInput.value = this.getClanName();
this.clanNameInput.enable = false;
this.clanNameInput.textField.textColor = GREY_TEXT_COLOR;
addChild(this.clanNameInput);
this.clanTagInput = new TankInputBox("",true);
this.clanTagInput.validateFunction = this.updateClanTag;
this.clanTagInput.maxChars = 5;
this.clanTagInput.restrict = "0-9.a-zA-z_\\-*";
this.clanTagInput.value = this.getClanTag();
this.clanTagInput.enable = false;
this.clanTagInput.textField.textColor = GREY_TEXT_COLOR;
addChild(this.clanTagInput);
this.descriptionInput = new ClanDescriptionInput(this.getClanDescription(),clanService.maxCharactersDescription);
this.descriptionInput.addEventListener(FocusEvent.FOCUS_IN,this.onFocusInDescriptionInput);
this.descriptionInput.addEventListener(FocusEvent.FOCUS_OUT,this.onFocusOutDescriptionInput);
addChild(this.descriptionInput);
this.descriptionLabel = new LabelBase();
this.descriptionLabel.text = localeService.getText(TanksLocale.TEXT_CLAN_DESCRIPTION_LABEL);
this.descriptionLabel.textColor = GREY_TEXT_COLOR;
this.descriptionLabel.mouseEnabled = false;
this.descriptionLabel.visible = this.descriptionInput.text.length == 0;
this.applyRequestsLabel = new LabelBase();
this.applyRequestsLabel.text = localeService.getText(TanksLocale.TEXT_CLAN_PROFILE_INVATION_CLAN);
this.applyRequestsLabel.mouseEnabled = false;
addChild(this.applyRequestsLabel);
this.applyRequests = new DropDownList();
this.applyRequests.addItem({
"gameName":localeService.getText(TanksLocale.TEXT_CLAN_PROFILE_OPEN),
"id":0,
"rang":0
});
this.applyRequests.addItem({
"gameName":localeService.getText(TanksLocale.TEXT_CLAN_PROFILE_CLOSE),
"id":1,
"rang":0
});
this.applyRequests.selectItemAt(this.requestsEnabled() ? 0 : 1);
this.applyRequests.width = 84;
this.applyRequests.height = 75;
addChild(this.applyRequests);
this.flagsLabel = new LabelBase();
this.flagsLabel.text = localeService.getText(TanksLocale.TEXT_CLAN_FLAG);
addChild(this.flagsLabel);
this.rankLabel = new LabelBase();
this.rankLabel.text = localeService.getText(TanksLocale.TEXT_CLAN_PROFILE_MIN_RANK);
this.rankLabel.mouseEnabled = false;
addChild(this.rankLabel);
this.rankCombo = new RanksDropDownList(clanService.minRankForCreateClan);
this.rankCombo.selectItemByField("rank",this.getMinRankIndex());
this.flagsCombo = new FlagsDropDownList();
this.flagsCombo.selectItemByField(FLAG_FIELD_NAME,this.getClanFlag());
addChild(this.rankCombo);
addChild(this.flagsCombo);
this.okButton = new ThreeLineBigButton();
this.okButton.label = localeService.getText(TanksLocale.TEXT_SETTINGS_BUTTON_SAVE_TEXT);
this.okButton.addEventListener(MouseEvent.CLICK,this.onOkButtonClick);
addChild(this.okButton);
createClanService.addEventListener(CreateClanServiceEvent.CORRECT_NAME,this.onCorrectName);
createClanService.addEventListener(CreateClanServiceEvent.INCORRECT_NAME,this.onIncorrectName);
createClanService.addEventListener(CreateClanServiceEvent.CORRECT_TAG,this.onCorrectTag);
createClanService.addEventListener(CreateClanServiceEvent.INCORRECT_TAG,this.onIncorrectTag);
}
private function onFocusInDescriptionInput(param1:FocusEvent) : void {
this.descriptionLabel.visible = false;
}
private function onFocusOutDescriptionInput(param1:FocusEvent) : void {
if(this.descriptionInput.text.length == 0) {
this.descriptionLabel.visible = true;
}
}
private function getClanDescription() : String {
if(this.lastInfo == null) {
return this.infoModel.getDescription();
}
return this.lastInfo.clanDescription;
}
private function getClanName() : String {
if(this.lastInfo == null) {
return this.infoModel.getClanName();
}
return this.lastInfo.clanName;
}
private function getClanTag() : String {
if(this.lastInfo == null) {
return this.infoModel.getClanTag();
}
return this.lastInfo.clanTag;
}
private function getClanFlag() : ClanFlag {
if(this.lastInfo == null) {
return this.infoModel.getClanFlag();
}
return this.lastInfo.clanFlag;
}
private function requestsEnabled() : Boolean {
if(this.lastInfo == null) {
return this.infoModel.incomingRequestEnabled();
}
return this.lastInfo.clanRequestsEnabled;
}
private function getMinRankIndex() : int {
if(this.lastInfo == null) {
return this.infoModel.getRankIndexForAddClan();
}
return this.lastInfo.clanMinRank;
}
private function resize() : void {
this.clanNameInput.x = MARGIN;
this.clanNameInput.y = MARGIN;
this.clanNameInput.width = WIDTH - 2 * MARGIN;
this.clanTagInput.x = MARGIN;
this.clanTagInput.y = this.clanNameInput.y + this.clanNameInput.height + SMALL_MARGIN;
this.clanTagInput.width = WIDTH - 2 * MARGIN;
this.flagsLabel.x = MARGIN;
this.flagsLabel.y = this.clanTagInput.y + this.clanTagInput.height + SMALL_MARGIN + 6;
this.flagsCombo.x = this.flagsLabel.x + this.flagsLabel.width + SMALL_MARGIN;
this.flagsCombo.y = this.clanTagInput.y + this.clanTagInput.height + SMALL_MARGIN;
this.applyRequestsLabel.x = this.flagsCombo.x + 70 + SMALL_MARGIN;
this.applyRequestsLabel.y = this.flagsLabel.y;
this.applyRequests.x = this.applyRequestsLabel.x + this.applyRequestsLabel.width + SMALL_MARGIN;
this.applyRequests.y = this.flagsCombo.y;
this.rankLabel.x = this.applyRequests.x + 84 + SMALL_MARGIN;
this.rankLabel.y = this.flagsLabel.y;
this.rankCombo.x = this.rankLabel.x + this.rankLabel.width + SMALL_MARGIN;
this.rankCombo.y = this.flagsCombo.y;
this.okButton.x = WIDTH - this.okButton.width >> 1;
this.okButton.y = HEIGHT - this.okButton.height - MARGIN;
this.descriptionLabel.x = SMALL_MARGIN;
this.descriptionLabel.y = SMALL_MARGIN;
this.descriptionInput.x = MARGIN;
this.descriptionInput.y = this.flagsCombo.y + 30 + SMALL_MARGIN;
this.descriptionInput.width = WIDTH - 2 * MARGIN;
this.descriptionInput.height = HEIGHT - this.descriptionInput.y - this.okButton.height - MARGIN - SMALL_MARGIN;
}
override protected function removeEvents() : void {
this.descriptionInput.removeEventListener(FocusEvent.FOCUS_IN,this.onFocusInDescriptionInput);
this.descriptionInput.removeEventListener(FocusEvent.FOCUS_OUT,this.onFocusOutDescriptionInput);
createClanService.removeEventListener(CreateClanServiceEvent.CORRECT_NAME,this.onCorrectName);
createClanService.removeEventListener(CreateClanServiceEvent.INCORRECT_NAME,this.onIncorrectName);
createClanService.removeEventListener(CreateClanServiceEvent.CORRECT_TAG,this.onCorrectTag);
createClanService.removeEventListener(CreateClanServiceEvent.INCORRECT_TAG,this.onIncorrectTag);
}
private function updateOkButtonState() : void {
if((this.clanNameInput.isValid() || !this.clanNameInput.isEnabled()) && (this.clanTagInput.isValid() || !this.clanTagInput.isEnabled()) && !this.clanNameInput.isValidating && !this.clanTagInput.isValidating) {
this.okButton.enabled = true;
} else {
this.okButton.enabled = false;
}
}
private function updateClanName() : void {
createClanService.validateName(this.clanNameInput.value);
}
private function updateClanTag() : void {
createClanService.validateTag(this.clanTagInput.value);
}
private function onCorrectName(param1:CreateClanServiceEvent) : void {
this.clanNameInput.valid();
this.updateOkButtonState();
}
private function onIncorrectName(param1:CreateClanServiceEvent) : void {
this.clanNameInput.invalid();
this.updateOkButtonState();
}
private function onCorrectTag(param1:CreateClanServiceEvent) : void {
this.clanTagInput.valid();
this.updateOkButtonState();
}
private function onIncorrectTag(param1:CreateClanServiceEvent) : void {
this.clanTagInput.invalid();
this.updateOkButtonState();
}
private function onOkButtonClick(param1:MouseEvent) : void {
var local2:ClanInfoUpdateEvent = new ClanInfoUpdateEvent();
var local3:ClanFlag = this.flagsCombo.selectedItem[FLAG_FIELD_NAME];
var local4:int = int(this.rankCombo.selectedItem.rank);
local2.clanName = this.clanNameInput.value;
local2.clanTag = this.clanTagInput.value;
local2.clanFlag = local3;
local2.clanRequestsEnabled = this.applyRequests.selectedItem.id == 0;
local2.clanMinRank = local4;
local2.clanDescription = this.descriptionInput.text;
clanService.updateClanInfo(this.descriptionInput.text,local4,local3,this.applyRequests.selectedItem.id == 0);
this.profileWindow.dispatchUpdate(local2);
destroy();
}
override public function updateActions() : void {
if(!clanUserInfoService.hasAction(ClanAction.EDIT_PROFILE)) {
destroy();
}
}
override public function get height() : Number {
return HEIGHT;
}
override public function get width() : Number {
return WIDTH;
}
override protected function getImageHeaderId() : String {
return TanksLocale.TEXT_HEADER_CLAN_EDIT_PROFILE;
}
}
}
|
package alternativa.tanks.gui.tankpreview {
public class NoTransitionsFoundError extends Error {
public function NoTransitionsFoundError() {
super();
}
}
}
|
package alternativa.tanks.gui.textinputs {
import controls.base.TankInput;
import flash.events.Event;
import flash.events.FocusEvent;
import forms.ColorConstants;
public class PlaceholderInputText extends TankInput {
private var placeholderText:String;
private const placeholderColor:uint = 8421504;
public function PlaceholderInputText(param1:String) {
super();
this.placeholderText = param1;
value = param1;
textField.textColor = this.placeholderColor;
textField.displayAsPassword = false;
addEventListener(FocusEvent.FOCUS_IN,this.focusIn);
addEventListener(FocusEvent.FOCUS_OUT,this.focusOut);
}
public function focusIn(param1:Event) : void {
if(value == this.placeholderText) {
textField.textColor = ColorConstants.WHITE;
value = "";
textField.displayAsPassword = this.hidden;
}
}
public function focusOut(param1:Event) : void {
if(value == "") {
textField.textColor = this.placeholderColor;
value = this.placeholderText;
textField.displayAsPassword = false;
}
}
public function setValue(param1:String) : void {
this.value = param1;
textField.textColor = ColorConstants.WHITE;
}
override public function set hidden(param1:Boolean) : void {
super.hidden = param1;
textField.displayAsPassword = false;
}
}
}
|
package assets.slider {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.slider.slider_TRACK_RIGHT.png")]
public dynamic class slider_TRACK_RIGHT extends BitmapData {
public function slider_TRACK_RIGHT(param1:int = 6, param2:int = 30) {
super(param1,param2);
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapSmallRank04.png")]
public class DefaultRanksBitmaps_bitmapSmallRank04 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapSmallRank04() {
super();
}
}
}
|
package alternativa.tanks.controllers.battlecreate {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.model.map.mapinfo.IMapInfo;
import alternativa.tanks.service.achievement.IAchievementService;
import alternativa.tanks.view.battlecreate.CreateBattleFormLabels;
import alternativa.tanks.view.battlecreate.CreateBattleFormView;
import alternativa.tanks.view.battlelist.modefilter.BattleModeIcons;
import alternativa.types.Long;
import assets.icons.BattleInfoIcons;
import controls.checkbox.CheckBoxEvent;
import flash.display.Bitmap;
import flash.display.DisplayObject;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.TimerEvent;
import flash.net.SharedObject;
import flash.utils.Dictionary;
import flash.utils.Timer;
import mx.utils.StringUtil;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleselect.model.battleselect.create.BattleCreateCC;
import projects.tanks.client.battleservice.BattleCreateParameters;
import projects.tanks.client.battleservice.BattleMode;
import projects.tanks.client.battleservice.Range;
import projects.tanks.client.battleservice.model.createparams.BattleLimits;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.BattleFormatUtil;
public class CreateBattleFormController extends EventDispatcher {
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var achievementService:IAchievementService;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var battleFormatUtil:BattleFormatUtil;
[Inject]
public static var localeService:ILocaleService;
private static const SECONDS_IN_MINUTE:int = 60;
private static const NON_FORMAT_BATTLE_MODE_INDEX:int = 0;
private static const MAX_RANK:int = 31;
private static const MIN_RANK:int = 1;
private static const MIN_RANK_INTERVAL_LENGTH:int = 1;
private static const MIN_PLAYER_FOR_DEATH_MATCH:int = 2;
private static const MIN_PLAYER_FOR_TEAM_BATTLE:int = 1;
private static const SCORE_STEP_COMMON:int = 1;
private static const SCORE_STEP_CP:int = 10;
private static const SCORE_STEP_ASL:int = 10;
private var _battlesLimits:Vector.<BattleLimits>;
private var scoreLimits:Vector.<int>;
private var _timeLimitInSec:int = 1800;
private var _maxPeopleCount:int;
private var _battleMode:BattleMode = BattleMode.DM;
private var _view:CreateBattleFormView;
private var _mapThemes:Dictionary = new Dictionary();
private var _currentRank:int = -1;
private var _mapsParams:Array;
private var _mapParamsForCurrentRank:Array;
private var _themeName:String;
private var _isShowForm:Boolean;
public var battleCreateParams:BattleCreateCC;
private var _checkedBattleNameTimer:Timer;
private var _isAutoName:Boolean;
private var _isCheckedServerBattleName:Boolean;
private var _battleNameBeforeCheck:String;
public function CreateBattleFormController(param1:BattleCreateCC, param2:Vector.<IGameObject>) {
super();
this.battleCreateParams = param1;
this._view = new CreateBattleFormView(this);
this.init(param2);
}
public static function getIcon(param1:int) : DisplayObject {
var local2:BattleInfoIcons = new BattleInfoIcons();
local2.type = param1;
return local2;
}
private function init(param1:Vector.<IGameObject>) : void {
this._battlesLimits = this.battleCreateParams.battlesLimits;
this.scoreLimits = new Vector.<int>(BattleMode.values.length);
this._checkedBattleNameTimer = new Timer(1200);
this._checkedBattleNameTimer.addEventListener(TimerEvent.TIMER,this.onTimer);
this._view.setMaxRankRange(this.battleCreateParams.maxRangeLength - 1);
this._view.setRankIntervalRestriction(MIN_RANK,MAX_RANK,MIN_RANK_INTERVAL_LENGTH);
this._view.resetPrivateBattleCheckBox();
this._view.setBattleFormats(this.createFormatBattleModeDatas());
this.parseMapsParams(param1);
}
private function parseMapsParams(param1:Vector.<IGameObject>) : void {
var local4:IGameObject = null;
var local5:IMapInfo = null;
var local6:CreateBattleMapParams = null;
this._mapsParams = new Array();
var local2:int = int(param1.length);
var local3:int = 0;
while(local3 < local2) {
local4 = param1[local3];
local5 = IMapInfo(local4.adapt(IMapInfo));
local6 = new CreateBattleMapParams();
local6.index = local3;
local6.id = local5.getMapId();
local6.previewResource = local5.getPreviewResource();
local6.gameName = local5.getName();
local6.maxPeople = local5.getMaxPeople();
local6.maxRank = local5.getMaxRank();
local6.minRank = local5.getMinRank();
local6.themeName = local5.getThemeName();
local6.theme = local5.getTheme();
local6.battleModes = local5.getSupportedBattleModes();
local6.enabled = local5.isEnabled();
local6.defaultTheme = local5.getDefaultTheme();
local6.matchmakingMark = local5.hasMatchmakingMark();
this._mapsParams.push(local6);
local3++;
}
}
public function onPlayersNumberChange() : void {
this._maxPeopleCount = this._view.getNumberPlayers();
}
public function onTimeLimitChange() : void {
this._timeLimitInSec = this._view.getTimeLimit() * SECONDS_IN_MINUTE;
this.checkedCorrectBattleParams();
}
public function onScoreLimitChange() : void {
this.scoreLimits[this._battleMode.value] = this._view.getScoreLimit();
this.checkedCorrectBattleParams();
}
public function setBattleMode(param1:BattleMode) : void {
var local3:int = 0;
this._battleMode = param1;
var local2:int = this._battlesLimits[this._battleMode.value].timeLimitInSec;
if(this._timeLimitInSec > local2) {
this._timeLimitInSec = local2;
}
this._view.setTypeBattle(this._battleMode);
if(this._battleMode == BattleMode.DM) {
this._maxPeopleCount = int(this.getSelectedMapParams().maxPeople);
local3 = MIN_PLAYER_FOR_DEATH_MATCH;
} else {
this._maxPeopleCount = int(this.getSelectedMapParams().maxPeople) / 2;
local3 = MIN_PLAYER_FOR_TEAM_BATTLE;
}
this._view.setSettingsPlayersLimit(local3,this._maxPeopleCount);
this._view.setSettingsTimeLimit(0,local2 / SECONDS_IN_MINUTE,this._timeLimitInSec / SECONDS_IN_MINUTE);
var local4:int = this._battlesLimits[this._battleMode.value].scoreLimit;
this.scoreLimits[this._battleMode.value] = this.clamp(this.scoreLimits[this._battleMode.value],0,local4);
var local5:int = this.scoreLimits[this._battleMode.value];
switch(this._battleMode) {
case BattleMode.DM:
this._view.setSettingsScoreLimit(local4,local5,SCORE_STEP_COMMON,CreateBattleFormLabels.stepperKillsLimitLabel,getIcon(BattleInfoIcons.KILL_LIMIT));
this._view.setNameMaxPlayersStepper();
break;
case BattleMode.TDM:
this._view.setSettingsScoreLimit(local4,local5,SCORE_STEP_COMMON,CreateBattleFormLabels.stepperKillsLimitLabel,getIcon(BattleInfoIcons.KILL_LIMIT));
this._view.setNameMaxPlayersTeamStepper();
break;
case BattleMode.CTF:
this._view.setSettingsScoreLimit(local4,local5,SCORE_STEP_COMMON,CreateBattleFormLabels.stepperFlagsLimitLabel,getIcon(BattleInfoIcons.CTF));
this._view.setNameMaxPlayersTeamStepper();
break;
case BattleMode.CP:
this._view.setSettingsScoreLimit(local4,local5,SCORE_STEP_CP,CreateBattleFormLabels.stepperDominationLimitLabel,getIcon(BattleInfoIcons.TEAM_SCORE));
this._view.setNameMaxPlayersTeamStepper();
break;
case BattleMode.AS:
this._view.setSettingsScoreLimit(local4,local5,SCORE_STEP_ASL,CreateBattleFormLabels.stepperDominationLimitLabel,new Bitmap(BattleModeIcons.getIcon(BattleMode.AS)));
this._view.setNameMaxPlayersTeamStepper();
break;
case BattleMode.RUGBY:
this._view.setSettingsScoreLimit(local4,local5,SCORE_STEP_COMMON,CreateBattleFormLabels.stepperDominationLimitLabel,new Bitmap(BattleModeIcons.getIcon(BattleMode.RUGBY)));
this._view.setNameMaxPlayersTeamStepper();
}
this._view.updateOptions();
}
private function clamp(param1:int, param2:int, param3:int) : int {
if(param1 < param2) {
return param2;
}
if(param1 > param3) {
return param3;
}
return param1;
}
public function onMapChange() : void {
this.updateThemes();
this.updateParams();
}
public function onThemeChange() : void {
this._themeName = this._view.getSelectedThemeItem().themeName;
this.updateParams();
}
private function updateParams() : void {
this.updateRangeRank();
this.setAvailableBattleTypes();
this.selectBattleType(this._battleMode);
this.saveMapParamInStorage();
this._view.battleInfo.updatePreview(this.getSelectedMapParams().previewResource);
this._view.battleInfo.setMatchmakingMark(this._view.getSelectMapItem().matchmakingMark);
var local1:Object = this._view.getSelectedFormatItem();
if(local1 == null || local1.index == 0) {
this._view.setBattleName(this._view.getSelectMapItem().gameName);
} else {
this._view.setBattleName(this._view.getSelectMapItem().gameName + " " + local1.gameName);
}
}
public function destroy() : void {
this._view.destroy();
this._view = null;
}
public function showForm() : void {
this._isShowForm = true;
if(this._currentRank != userPropertiesService.rank) {
this._currentRank = userPropertiesService.rank;
if(this._currentRank < MIN_RANK) {
this._currentRank = MIN_RANK;
}
this._view.setCurrentRank(this._currentRank);
this.updateAvailableMaps();
this.selectDefaultMap();
}
achievementService.showStartButtonHelper();
this._view.show();
}
public function hideForm() : void {
this._isShowForm = false;
this._view.hide();
achievementService.hideStartButtonHelper();
}
private function checkedCorrectBattleParams() : void {
if(this.isBattleParamsCorrect()) {
this._view.unBlockedStartButton();
} else {
this._view.blockedStartButton();
}
}
private function isBattleParamsCorrect() : Boolean {
return Boolean(StringUtil.trim(this._view.getBattleName())) && (this._view.getTimeLimit() != 0 || this._view.getScoreLimit() != 0);
}
private function setAvailableBattleTypes() : void {
this._view.setAvailableTypesBattle(this.getSelectedMapParams().battleModes);
}
private function updateRangeRank() : void {
var local1:CreateBattleMapParams = this.getSelectedMapParams();
var local2:Range = this.battleCreateParams.maxRange;
var local3:int = Math.max(local2.min,local1.minRank);
var local4:int = Math.min(local2.max,local1.maxRank);
this._view.setRankIntervalRestriction(local3,local4,MIN_RANK_INTERVAL_LENGTH);
var local5:Range = this.battleCreateParams.defaultRange;
this._view.setMinRang(Math.max(local5.min,this._view.getMinRangValue()));
this._view.setMaxRang(Math.min(local5.max,this._view.getMaxRangValue()));
}
private function updateThemes() : void {
var local3:Array = null;
var local4:String = null;
var local5:String = null;
var local6:SaveMapParams = null;
var local7:CreateBattleMapParams = null;
var local8:CreateBattleMapParams = null;
var local9:Object = null;
var local1:Long = this._view.getSelectMapItem().id;
var local2:Dictionary = this._mapThemes[local1];
if(local2 != null) {
local3 = new Array();
local4 = null;
for(local5 in local2) {
local8 = this._mapThemes[local1][local5];
if(this._currentRank >= local8.minRank && this._currentRank <= local8.maxRank) {
local3.push({
"gameName":local5,
"id":local8.id,
"rang":0,
"theme":local8.theme
});
}
if(local8.defaultTheme != null && local8.defaultTheme.name == local8.theme.name) {
local4 = local5;
}
}
local3.sortOn(["gameName"]);
this._view.setThemeInfo(local3);
local6 = this.getSaveMapParams();
if(local6 != null && local6.selectedThemes != null && local6.selectedThemes[local1] != null) {
this._themeName = local6.selectedThemes[local1];
} else if(local4 != null) {
this._themeName = local4;
}
local7 = this._mapThemes[this._view.getSelectMapItem().id][this._themeName];
if(this._themeName != null && this.isMapAndThemeAvailable(local7)) {
this._view.setSelectMapThemeItemByField("themeName",this._themeName);
} else {
local9 = this._view.getSelectedThemeItem();
this._themeName = local9 != null ? local9.themeName : null;
}
if(local3.length > 1) {
this._view.showThemeForMap();
} else {
this._view.hideThemeForMap();
}
}
}
private function isMapAndThemeAvailable(param1:CreateBattleMapParams) : Boolean {
return param1 != null && param1.enabled && this._currentRank >= param1.minRank && this._currentRank <= param1.maxRank;
}
private function getSelectedMapParams() : CreateBattleMapParams {
return CreateBattleMapParams(this._mapThemes[this._view.getSelectMapItem().id][this._themeName]);
}
private function updateAvailableMaps() : void {
var local1:CreateBattleMapParams = null;
this._mapThemes = new Dictionary();
this._mapParamsForCurrentRank = new Array();
for each(local1 in this._mapsParams) {
if(local1.enabled && this._currentRank <= local1.maxRank) {
if(this._mapThemes[local1.id] == undefined) {
this._mapThemes[local1.id] = new Dictionary();
local1.currentRank = this._currentRank >= local1.minRank ? 0 : local1.minRank;
this._mapParamsForCurrentRank.push(local1);
}
this._mapThemes[local1.id][local1.themeName] = local1;
}
}
if(this._mapParamsForCurrentRank.length != 0) {
this._mapParamsForCurrentRank.sortOn(["currentRank","gameName"],[Array.NUMERIC,null]);
this._view.setMapsInfo(this._mapParamsForCurrentRank);
return;
}
throw new ArgumentError("For your rank is not available maps");
}
private function selectDefaultMap() : void {
var local1:String = null;
var local2:SaveMapParams = this.getSaveMapParams();
var local3:CreateBattleMapParams = this.getMapParams(local2.mapId,local2.themeName);
if(this.isMapAndThemeAvailable(local3)) {
local1 = local3.gameName;
this._themeName = local3.themeName;
} else {
local1 = this._mapParamsForCurrentRank[0].gameName;
this._themeName = this._mapParamsForCurrentRank[0].themeName;
}
this._view.selectMap("gameName",local1);
this.onMapChange();
}
private function getMapParams(param1:Long, param2:String) : CreateBattleMapParams {
var local3:int = int(this._mapsParams.length);
var local4:int = 0;
while(local4 < local3) {
if(this._mapsParams[local4].id == param1 && this._mapsParams[local4].themeName == param2) {
return this._mapsParams[local4];
}
local4++;
}
return null;
}
private function getSaveMapParams() : SaveMapParams {
var local1:SaveMapParams = new SaveMapParams();
var local2:SharedObject = storageService.getStorage();
var local3:Vector.<Object> = local2.data.SelectedMap != null && local2.data.SelectedMap is Vector.<Object> ? local2.data.SelectedMap as Vector.<Object> : new Vector.<Object>();
var local4:int = 0;
while(local4 < local3.length) {
if(local3[local4].userName == userPropertiesService.userName) {
local1.mapId = Long.getLong(int(local3[local4].mapIdHigh),int(local3[local4].mapIdLow));
local1.themeName = local3[local4].mapTheme;
local1.selectedThemes = local3[local4].selectedThemes;
break;
}
local4++;
}
return local1;
}
private function saveMapParamInStorage() : void {
var local6:Object = null;
var local1:SharedObject = storageService.getStorage();
var local2:Vector.<Object> = local1.data.SelectedMap != null && local1.data.SelectedMap is Vector.<Object> ? local1.data.SelectedMap as Vector.<Object> : new Vector.<Object>();
var local3:int = -1;
var local4:int = 0;
while(local4 < local2.length) {
if(local2[local4].userName == userPropertiesService.userName) {
local3 = local4;
break;
}
local4++;
}
var local5:CreateBattleMapParams = this.getSelectedMapParams();
if(local3 != -1) {
local6 = local2[local3];
} else {
local6 = new Object();
local6.userName = userPropertiesService.userName;
local2.push(local6);
}
local6.mapIdLow = local5.id.low;
local6.mapIdHigh = local5.id.high;
local6.mapTheme = local5.themeName;
if(local6.selectedThemes == null) {
local6.selectedThemes = new Object();
}
local6.selectedThemes[local5.id] = local5.themeName;
local1.data.SelectedMap = local2;
}
private function selectBattleType(param1:BattleMode) : void {
if(this.isTypeBattleContainedSelectedMap(param1)) {
this.setBattleMode(param1);
} else {
this.setBattleMode(this.getSelectedMapParams().battleModes[0]);
}
}
private function isTypeBattleContainedSelectedMap(param1:BattleMode) : Boolean {
var local2:Boolean = false;
var local3:Vector.<BattleMode> = this.getSelectedMapParams().battleModes;
var local4:int = 0;
while(local4 < local3.length) {
if(local3[local4] == param1) {
local2 = true;
break;
}
local4++;
}
return local2;
}
public function onCreateBattle() : void {
var local1:BattleCreateParameters = null;
if(this.isBattleParamsCorrect()) {
local1 = new BattleCreateParameters();
local1.battleMode = this._battleMode;
local1.limits = new BattleLimits(this._view.getScoreLimit(),this._view.getTimeLimit() * SECONDS_IN_MINUTE);
local1.mapId = this._view.getSelectedThemeItem().id;
local1.theme = this._view.getSelectedThemeItem().theme;
local1.maxPeopleCount = this._maxPeopleCount;
local1.rankRange = new Range(this._view.getMaxRank(),this._view.getMinRank());
local1.proBattle = true;
local1.privateBattle = this._view.isPrivateBattle;
local1.withoutSupplies = this._view.isNoSuppliesBattle;
local1.withoutUpgrades = this._view.isWithoutUpgrades;
local1.withoutDevices = this._view.isWithoutDevices;
local1.withoutBonuses = this._view.isWithoutBonuses;
local1.goldBoxesEnabled = this._view.isGoldBoxesEnabled;
local1.autoBalance = this._view.isAutoBalance;
local1.friendlyFire = this._view.isFriendlyFire;
local1.withoutDrones = this._view.isWithoutDrones;
local1.reArmorEnabled = this._view.isReArmor;
local1.dependentCooldownEnabled = this._view.isDependentCooldownBattle;
local1.equipmentConstraintsMode = this.getEquipmentConstraintsMode();
local1.parkourMode = this.isParkourFormatItemSelected();
local1.clanBattle = this._view.isClanBattle;
local1.ultimatesEnabled = this._view.isUltimatesEnabled();
local1.name = this._view.getBattleName();
dispatchEvent(new CreateBattleEvent(local1));
this.hideForm();
achievementService.hideAllBubbles(true);
}
}
private function isParkourFormatItemSelected() : Boolean {
return this._view.getSelectedFormatItem().parkour;
}
private function getEquipmentConstraintsMode() : String {
return this._view.getSelectedFormatItem().equipmentConstraintsMode;
}
private function createFormatBattleModeDatas() : Vector.<Object> {
var local3:Object = null;
var local1:Vector.<Object> = new Vector.<Object>();
var local2:int = 0;
local1.push({
"index":local2++,
"gameName":localeService.getText(TanksLocale.TEXT_FORMAT_NAME_NONE),
"equipmentConstraintsMode":null,
"parkour":false,
"rang":0
});
for each(local3 in battleFormatUtil.getEquipmentConstraintsModes()) {
local1.push({
"index":local2++,
"gameName":local3.name,
"equipmentConstraintsMode":local3.mode,
"parkour":false,
"rang":0
});
}
local1.push({
"index":local2,
"gameName":battleFormatUtil.getParkourFormatName(),
"equipmentConstraintsMode":null,
"parkour":true,
"rang":0
});
return local1;
}
public function onFormatChange(param1:Event) : void {
if(this.isParkourFormatItemSelected()) {
this._view.resetDependentCooldownCheckBox();
} else if(this.getEquipmentConstraintsMode() != null) {
this._view.resetReArmorCheckbox();
this._view.resetUpgradesAndDevicesCheckbox();
this._view.resetUltimatesCheckBox();
}
this._view.updateOptions();
this.updateParams();
}
public function onUpgradesOrDevicesChange(param1:Event) : void {
if(!this._view.isWithoutUpgrades || !this._view.isWithoutDevices) {
this.resetEquipConstraintsViewFormat();
}
}
public function onReArmorChanged() : void {
if(this._view.isReArmor) {
this.resetEquipConstraintsViewFormat();
}
}
private function resetEquipConstraintsViewFormat() : void {
if(!this.isParkourFormatItemSelected()) {
this.resetFormatComboBox();
}
}
public function onDependentCooldownChange(param1:CheckBoxEvent) : void {
if(this._view.isDependentCooldownBattle && this.isParkourFormatItemSelected()) {
this.resetFormatComboBox();
}
}
private function resetFormatComboBox() : void {
this._view.selectFormatByIndex(NON_FORMAT_BATTLE_MODE_INDEX);
}
public function onUltimatesChanged(param1:CheckBoxEvent) : void {
if(this._view.isUltimatesEnabled() && this.getEquipmentConstraintsMode() != null) {
this._view.selectFormatByIndex(NON_FORMAT_BATTLE_MODE_INDEX);
}
}
public function onBattleNameChange() : void {
this._view.blockedStartButton();
this._checkedBattleNameTimer.stop();
if(this._view.getBattleNameLength() != 0) {
this._view.hideInvalidRectangleBattleName();
this._isCheckedServerBattleName = false;
this._checkedBattleNameTimer.start();
} else {
this._view.showInvalidRectangleBattleName();
}
}
private function getAutoName() : String {
return this.getSelectedMapParams().gameName + " " + this._battleMode.name;
}
public function onBattleNameInFocus() : void {
if(this._view.getBattleName() == this.getAutoName()) {
this._isAutoName = false;
this._view.setBattleName("");
this._view.showInvalidRectangleBattleName();
this._view.blockedStartButton();
}
}
public function checkedBattleNameResult(param1:String) : void {
this._isCheckedServerBattleName = true;
this._checkedBattleNameTimer.stop();
if(this._view.getBattleName() == this._battleNameBeforeCheck && this._battleNameBeforeCheck != param1) {
this._isAutoName = false;
this._view.setBattleName(param1);
}
this._view.resetProgressBattleNameCheckIcon();
if(this._view.getBattleNameLength() != 0) {
this._view.hideInvalidRectangleBattleName();
}
this.checkedCorrectBattleParams();
}
private function setAutoNameBattle() : void {
this._isAutoName = true;
this._isCheckedServerBattleName = true;
this._view.setBattleName(this.getAutoName());
this._view.hideInvalidRectangleBattleName();
}
public function onBattleNameOutFocus() : void {
if(this._view.getBattleNameLength() == 0) {
this.setAutoNameBattle();
if(this.isBattleParamsCorrect()) {
this._view.unBlockedStartButton();
}
}
}
private function onTimer(param1:TimerEvent) : void {
this._view.setProgressBattleNameCheckIcon();
this._view.blockedStartButton();
this._battleNameBeforeCheck = this._view.getBattleName();
this._checkedBattleNameTimer.stop();
dispatchEvent(new CheckBattleNameEvent(CheckBattleNameEvent.CHECK_NAME,this._battleNameBeforeCheck));
}
}
}
|
package projects.tanks.client.garage.models.item.category {
import projects.tanks.client.commons.types.ItemCategoryEnum;
public class ItemCategoryCC {
private var _category:ItemCategoryEnum;
public function ItemCategoryCC(param1:ItemCategoryEnum = null) {
super();
this._category = param1;
}
public function get category() : ItemCategoryEnum {
return this._category;
}
public function set category(param1:ItemCategoryEnum) : void {
this._category = param1;
}
public function toString() : String {
var local1:String = "ItemCategoryCC [";
local1 += "category = " + this.category + " ";
return local1 + "]";
}
}
}
|
package alternativa.model
{
import alternativa.object.ClientObject;
public interface IObjectLoadListener
{
function objectLoaded(param1:ClientObject) : void;
function objectUnloaded(param1:ClientObject) : void;
}
}
|
package alternativa.tanks.camera
{
public class CameraFovCalculator
{
private static const NARROW_SCREEN:Number = 12;
private static const WIDE_SCREEN:Number = 16;
private static const DIVIDER:Number = 9;
private static const DEFAULT_FOV:Number = Math.PI / 2;
public function CameraFovCalculator()
{
super();
}
public static function getCameraFov(param1:Number, param2:Number) : Number
{
var _loc5_:Number = NaN;
var _loc6_:Number = NaN;
var _loc7_:Number = NaN;
var _loc3_:Number = param2 / DIVIDER;
var _loc4_:Number = param1 / _loc3_;
if(_loc4_ <= NARROW_SCREEN)
{
return DEFAULT_FOV;
}
_loc5_ = _loc4_ - (WIDE_SCREEN - NARROW_SCREEN);
if(_loc5_ < NARROW_SCREEN)
{
_loc5_ = NARROW_SCREEN;
}
_loc6_ = _loc5_ * _loc3_;
_loc7_ = Math.sqrt(_loc6_ * _loc6_ + param2 * param2) * 0.5 / Math.tan(DEFAULT_FOV * 0.5);
return Math.atan(Math.sqrt(param1 * param1 + param2 * param2) * 0.5 / _loc7_) * 2;
}
}
}
|
package alternativa.tanks.models.weapon.gauss.state {
import alternativa.tanks.models.weapon.gauss.GaussEventType;
public class TransitionNotFoundError extends Error {
public function TransitionNotFoundError(param1:IGaussState, param2:GaussEventType) {
super("Transition not found (currentState: " + param1 + ", eventType: " + param2);
}
}
}
|
package assets.windowinner.elemets {
import flash.display.Sprite;
[Embed(source="/_assets/assets.swf", symbol="symbol104")]
public class WindowInnerTopLeftCorner extends Sprite {
public function WindowInnerTopLeftCorner() {
super();
}
}
}
|
package projects.tanks.clients.fp10.models.tankschatmodelflash {
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.chat.CautionExternalLinkWindow;
import alternativa.tanks.gui.communication.CommunicationPanel;
import alternativa.tanks.gui.communication.tabs.chat.ChatTab;
import alternativa.tanks.gui.communication.tabs.chat.IChatTabView;
import alternativa.tanks.gui.communication.tabs.clanchat.ClanChatTab;
import alternativa.tanks.gui.communication.tabs.clanchat.IClanChatView;
import alternativa.tanks.gui.communication.tabs.news.NewsTab;
import alternativa.tanks.gui.news.NewsAlertWindow;
import alternativa.tanks.gui.news.NewsItem;
import alternativa.tanks.model.CommunicationPanelModel;
import alternativa.tanks.model.chat.ChatModel;
import alternativa.tanks.model.chat.ChatSettingsTracker;
import alternativa.tanks.model.clanchat.ClanChatModel;
import alternativa.tanks.model.news.NewsShowingModel;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.services.NewsService;
import alternativa.tanks.services.NewsServiceImpl;
import alternativa.tanks.tracker.ITrackerService;
import alternativa.tanks.utils.Antiflood;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.fp10.libraries.tanksservices.model.serverrestarttime.OnceADayActionService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.activator.IBattleLinkActivatorService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.blockuser.IBlockUserService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.IDialogsService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.rank.RankService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import services.contextmenu.IContextMenuService;
public class Activator implements IBundleActivator {
public static var osgi:OSGi;
public function Activator() {
super();
}
public function start(param1:OSGi) : void {
var modelRegister:ModelRegistry;
var _osgi:OSGi = param1;
osgi = _osgi;
osgi.injectService(ILocaleService,function(param1:Object):void {
CautionExternalLinkWindow.localeService = ILocaleService(param1);
},function():ILocaleService {
return CautionExternalLinkWindow.localeService;
});
osgi.injectService(IChatTabView,function(param1:Object):void {
CommunicationPanel.chatTabView = IChatTabView(param1);
},function():IChatTabView {
return CommunicationPanel.chatTabView;
});
osgi.injectService(IClanChatView,function(param1:Object):void {
CommunicationPanel.clanChatView = IClanChatView(param1);
},function():IClanChatView {
return CommunicationPanel.clanChatView;
});
osgi.injectService(ClanUserInfoService,function(param1:Object):void {
CommunicationPanel.clanUserInfoService = ClanUserInfoService(param1);
},function():ClanUserInfoService {
return CommunicationPanel.clanUserInfoService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
CommunicationPanel.localeService = ILocaleService(param1);
},function():ILocaleService {
return CommunicationPanel.localeService;
});
osgi.injectService(NewsService,function(param1:Object):void {
CommunicationPanel.newsService = NewsService(param1);
},function():NewsService {
return CommunicationPanel.newsService;
});
osgi.injectService(ISettingsService,function(param1:Object):void {
CommunicationPanel.settingsService = ISettingsService(param1);
},function():ISettingsService {
return CommunicationPanel.settingsService;
});
osgi.injectService(IStorageService,function(param1:Object):void {
CommunicationPanel.storageService = IStorageService(param1);
},function():IStorageService {
return CommunicationPanel.storageService;
});
osgi.injectService(IBlockUserService,function(param1:Object):void {
ChatTab.blockUserService = IBlockUserService(param1);
},function():IBlockUserService {
return ChatTab.blockUserService;
});
osgi.injectService(IContextMenuService,function(param1:Object):void {
ChatTab.contextMenuService = IContextMenuService(param1);
},function():IContextMenuService {
return ChatTab.contextMenuService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
ChatTab.localeService = ILocaleService(param1);
},function():ILocaleService {
return ChatTab.localeService;
});
osgi.injectService(IStorageService,function(param1:Object):void {
ChatTab.storageService = IStorageService(param1);
},function():IStorageService {
return ChatTab.storageService;
});
osgi.injectService(IBlockUserService,function(param1:Object):void {
ClanChatTab.blockUserService = IBlockUserService(param1);
},function():IBlockUserService {
return ClanChatTab.blockUserService;
});
osgi.injectService(IContextMenuService,function(param1:Object):void {
ClanChatTab.contextMenuService = IContextMenuService(param1);
},function():IContextMenuService {
return ClanChatTab.contextMenuService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
ClanChatTab.localeService = ILocaleService(param1);
},function():ILocaleService {
return ClanChatTab.localeService;
});
osgi.injectService(NewsService,function(param1:Object):void {
NewsTab.newsService = NewsService(param1);
},function():NewsService {
return NewsTab.newsService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
NewsAlertWindow.localeService = ILocaleService(param1);
},function():ILocaleService {
return NewsAlertWindow.localeService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
NewsItem.localeService = ILocaleService(param1);
},function():ILocaleService {
return NewsItem.localeService;
});
osgi.injectService(NewsService,function(param1:Object):void {
NewsItem.newsService = NewsService(param1);
},function():NewsService {
return NewsItem.newsService;
});
osgi.injectService(PaymentDisplayService,function(param1:Object):void {
NewsItem.paymentDisplayService = PaymentDisplayService(param1);
},function():PaymentDisplayService {
return NewsItem.paymentDisplayService;
});
osgi.injectService(RankService,function(param1:Object):void {
NewsItem.rankService = RankService(param1);
},function():RankService {
return NewsItem.rankService;
});
osgi.injectService(IUserPropertiesService,function(param1:Object):void {
NewsItem.userPropertiesService = IUserPropertiesService(param1);
},function():IUserPropertiesService {
return NewsItem.userPropertiesService;
});
osgi.injectService(IDisplay,function(param1:Object):void {
CommunicationPanelModel.display = IDisplay(param1);
},function():IDisplay {
return CommunicationPanelModel.display;
});
osgi.injectService(IUserPropertiesService,function(param1:Object):void {
CommunicationPanelModel.userPropertiesService = IUserPropertiesService(param1);
},function():IUserPropertiesService {
return CommunicationPanelModel.userPropertiesService;
});
osgi.injectService(IBattleLinkActivatorService,function(param1:Object):void {
ChatModel.battleLinkActivatorService = IBattleLinkActivatorService(param1);
},function():IBattleLinkActivatorService {
return ChatModel.battleLinkActivatorService;
});
osgi.injectService(IClientLog,function(param1:Object):void {
ChatModel.clientLog = IClientLog(param1);
},function():IClientLog {
return ChatModel.clientLog;
});
osgi.injectService(IDisplay,function(param1:Object):void {
ChatModel.display = IDisplay(param1);
},function():IDisplay {
return ChatModel.display;
});
osgi.injectService(IChatTabView,function(param1:Object):void {
ChatModel.lobbyChatView = IChatTabView(param1);
},function():IChatTabView {
return ChatModel.lobbyChatView;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
ChatModel.localeService = ILocaleService(param1);
},function():ILocaleService {
return ChatModel.localeService;
});
osgi.injectService(ITrackerService,function(param1:Object):void {
ChatModel.trackerService = ITrackerService(param1);
},function():ITrackerService {
return ChatModel.trackerService;
});
osgi.injectService(IUserPropertiesService,function(param1:Object):void {
ChatModel.userPropertyService = IUserPropertiesService(param1);
},function():IUserPropertiesService {
return ChatModel.userPropertyService;
});
osgi.injectService(ISettingsService,function(param1:Object):void {
ChatSettingsTracker.settingsService = ISettingsService(param1);
},function():ISettingsService {
return ChatSettingsTracker.settingsService;
});
osgi.injectService(IBattleLinkActivatorService,function(param1:Object):void {
ClanChatModel.battleLinkActivatorService = IBattleLinkActivatorService(param1);
},function():IBattleLinkActivatorService {
return ClanChatModel.battleLinkActivatorService;
});
osgi.injectService(IClanChatView,function(param1:Object):void {
ClanChatModel.clanChatView = IClanChatView(param1);
},function():IClanChatView {
return ClanChatModel.clanChatView;
});
osgi.injectService(IClientLog,function(param1:Object):void {
ClanChatModel.clientLog = IClientLog(param1);
},function():IClientLog {
return ClanChatModel.clientLog;
});
osgi.injectService(IDisplay,function(param1:Object):void {
ClanChatModel.display = IDisplay(param1);
},function():IDisplay {
return ClanChatModel.display;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
ClanChatModel.localeService = ILocaleService(param1);
},function():ILocaleService {
return ClanChatModel.localeService;
});
osgi.injectService(ITrackerService,function(param1:Object):void {
ClanChatModel.trackerService = ITrackerService(param1);
},function():ITrackerService {
return ClanChatModel.trackerService;
});
osgi.injectService(IUserPropertiesService,function(param1:Object):void {
ClanChatModel.userPropertyService = IUserPropertiesService(param1);
},function():IUserPropertiesService {
return ClanChatModel.userPropertyService;
});
osgi.injectService(IDialogsService,function(param1:Object):void {
NewsShowingModel.dialogService = IDialogsService(param1);
},function():IDialogsService {
return NewsShowingModel.dialogService;
});
osgi.injectService(NewsService,function(param1:Object):void {
NewsShowingModel.newsService = NewsService(param1);
},function():NewsService {
return NewsShowingModel.newsService;
});
osgi.injectService(OnceADayActionService,function(param1:Object):void {
NewsShowingModel.onceADayActionService = OnceADayActionService(param1);
},function():OnceADayActionService {
return NewsShowingModel.onceADayActionService;
});
osgi.injectService(IUserPropertiesService,function(param1:Object):void {
NewsShowingModel.userPropertiesService = IUserPropertiesService(param1);
},function():IUserPropertiesService {
return NewsShowingModel.userPropertiesService;
});
osgi.injectService(IStorageService,function(param1:Object):void {
NewsServiceImpl.storageService = IStorageService(param1);
},function():IStorageService {
return NewsServiceImpl.storageService;
});
osgi.injectService(IClientLog,function(param1:Object):void {
Antiflood.clientLog = IClientLog(param1);
},function():IClientLog {
return Antiflood.clientLog;
});
modelRegister = osgi.getService(ModelRegistry) as ModelRegistry;
modelRegister.add(new CommunicationPanelModel());
modelRegister.add(new ChatModel());
modelRegister.add(new ClanChatModel());
modelRegister.add(new NewsShowingModel());
}
public function stop(param1:OSGi) : void {
}
}
}
|
package controls.numeric {
public interface INumericStepper {
function getValue() : Number;
function setValue(param1:Number, param2:Boolean = false) : void;
function getButtonStatus() : int;
}
}
|
package alternativa.tanks.models.tank.killhandlers {
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventListener;
import alternativa.tanks.battle.events.TankRemovedFromBattleEvent;
import alternativa.tanks.battle.events.TankUnloadedEvent;
import alternativa.tanks.battle.events.death.TankDeadEvent;
import flash.utils.getTimer;
import platform.client.fp10.core.type.IGameObject;
public class DeathConfirmationTimeoutTask implements LogicUnit, BattleEventListener {
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var battleService:BattleService;
private static const DEATH_CONFIRMATION_TIMEOUT_MS:int = 2000;
private static const EVENTS:Array = [TankUnloadedEvent,TankDeadEvent,TankRemovedFromBattleEvent];
private var object:IGameObject;
private var triggerTime:int;
private var callback:Function;
public function DeathConfirmationTimeoutTask() {
super();
}
public function start(param1:IGameObject, param2:Function) : void {
var local3:Class = null;
if(this.object != null) {
throw new Error();
}
this.object = param1;
this.callback = param2;
this.triggerTime = getTimer() + DEATH_CONFIRMATION_TIMEOUT_MS;
battleService.getBattleRunner().addLogicUnit(this);
for each(local3 in EVENTS) {
battleEventDispatcher.addBattleEventListener(local3,this);
}
}
public function runLogic(param1:int, param2:int) : void {
if(param1 > this.triggerTime) {
this.stop();
this.callback(this.object);
this.callback = null;
}
}
private function stop() : void {
var local1:Class = null;
battleService.getBattleRunner().removeLogicUnit(this);
for each(local1 in EVENTS) {
battleEventDispatcher.removeBattleEventListener(local1,this);
}
}
public function handleBattleEvent(param1:Object) : void {
if(param1 is TankUnloadedEvent) {
this.handleTankUnloadedEvent(TankUnloadedEvent(param1));
} else if(param1 is TankRemovedFromBattleEvent) {
this.handleTankRemovedFromBattleEvent(TankRemovedFromBattleEvent(param1));
} else if(param1 is TankDeadEvent) {
this.handleTankDeadEvent(TankDeadEvent(param1));
}
}
private function handleTankUnloadedEvent(param1:TankUnloadedEvent) : void {
this.stopIfOurUser(param1.tank.getUser());
}
private function handleTankRemovedFromBattleEvent(param1:TankRemovedFromBattleEvent) : void {
this.stopIfOurUser(param1.tank.getUser());
}
private function handleTankDeadEvent(param1:TankDeadEvent) : void {
this.stopIfOurUser(param1.victim);
}
private function stopIfOurUser(param1:IGameObject) : void {
if(param1 == this.object) {
this.stop();
}
}
}
}
|
package projects.tanks.client.battlefield.models.effects.effectlevel {
public interface IEffectLevelModelBase {
}
}
|
package _codec.projects.tanks.client.battleselect.model.battle.entrance.user {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import projects.tanks.client.battleselect.model.battle.entrance.user.BattleInfoUser;
public class CodecBattleInfoUser implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_clanId:ICodec;
private var codec_score:ICodec;
private var codec_suspicious:ICodec;
private var codec_user:ICodec;
public function CodecBattleInfoUser() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_clanId = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_score = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_suspicious = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_user = param1.getCodec(new TypeCodecInfo(Long,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BattleInfoUser = new BattleInfoUser();
local2.clanId = this.codec_clanId.decode(param1) as Long;
local2.score = this.codec_score.decode(param1) as int;
local2.suspicious = this.codec_suspicious.decode(param1) as Boolean;
local2.user = this.codec_user.decode(param1) as Long;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BattleInfoUser = BattleInfoUser(param2);
this.codec_clanId.encode(param1,local3.clanId);
this.codec_score.encode(param1,local3.score);
this.codec_suspicious.encode(param1,local3.suspicious);
this.codec_user.encode(param1,local3.user);
}
}
}
|
package alternativa.tanks.models.clan.permission {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.clans.clan.permissions.ClanPermission;
public class IClanPermissionsModelAdapt implements IClanPermissionsModel {
private var object:IGameObject;
private var impl:IClanPermissionsModel;
public function IClanPermissionsModelAdapt(param1:IGameObject, param2:IClanPermissionsModel) {
super();
this.object = param1;
this.impl = param2;
}
public function setPosition(param1:Long, param2:ClanPermission) : void {
var id:Long = param1;
var position:ClanPermission = param2;
try {
Model.object = this.object;
this.impl.setPosition(id,position);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.weapon.shaft
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class Indicator_aim_m3 extends BitmapAsset
{
public function Indicator_aim_m3()
{
super();
}
}
}
|
package alternativa.tanks.models.battle.battlefield.event {
import flash.events.Event;
public class ContinueBattleEvent extends Event {
public static const EXIT:String = "BattleStateEvent.EXIT";
public static const CONTINUE:String = "BattleStateEvent.CONTINUE";
public function ContinueBattleEvent(param1:String) {
super(param1);
}
}
}
|
package mx.utils {
import flash.display.DisplayObject;
import flash.utils.getQualifiedClassName;
import mx.core.IRepeaterClient;
import mx.core.mx_internal;
use namespace mx_internal;
public class NameUtil {
mx_internal static const VERSION:String = "4.5.0.19786";
private static var counter:int = 0;
public function NameUtil() {
super();
}
public static function createUniqueName(object:Object) : String {
if(!object) {
return null;
}
var name:String = getQualifiedClassName(object);
var index:int = int(name.indexOf("::"));
if(index != -1) {
name = name.substr(index + 2);
}
var charCode:int = int(name.charCodeAt(name.length - 1));
if(charCode >= 48 && charCode <= 57) {
name += "_";
}
return name + counter++;
}
public static function displayObjectToString(displayObject:DisplayObject) : String {
var result:String = null;
var o:DisplayObject = null;
var s:String = null;
var indices:Array = null;
try {
o = displayObject;
while(o != null) {
if(o.parent && o.stage && o.parent == o.stage) {
break;
}
s = "id" in o && Boolean(o["id"]) ? o["id"] : o.name;
if(o is IRepeaterClient) {
indices = IRepeaterClient(o).instanceIndices;
if(Boolean(indices)) {
s += "[" + indices.join("][") + "]";
}
}
result = result == null ? s : s + "." + result;
o = o.parent;
}
}
catch(e:SecurityError) {
}
return result;
}
public static function getUnqualifiedClassName(object:Object) : String {
var name:String = null;
if(object is String) {
name = object as String;
} else {
name = getQualifiedClassName(object);
}
var index:int = int(name.indexOf("::"));
if(index != -1) {
name = name.substr(index + 2);
}
return name;
}
}
}
|
package projects.tanks.client.battlefield.models.battle.jgr.killstreak {
public class KillStreakCC {
private var _items:Vector.<KillStreakItem>;
public function KillStreakCC(param1:Vector.<KillStreakItem> = null) {
super();
this._items = param1;
}
public function get items() : Vector.<KillStreakItem> {
return this._items;
}
public function set items(param1:Vector.<KillStreakItem>) : void {
this._items = param1;
}
public function toString() : String {
var local1:String = "KillStreakCC [";
local1 += "items = " + this.items + " ";
return local1 + "]";
}
}
}
|
package alternativa.engine3d.objects {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Canvas;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.engine3d.core.VG;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import flash.geom.Matrix3D;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
use namespace alternativa3d;
public class Mesh extends Object3D {
public var clipping:int = 2;
public var sorting:int = 1;
public var threshold:Number = 0.01;
alternativa3d var vertexList:Vertex;
alternativa3d var faceList:Face;
public function Mesh() {
super();
}
public static function calculateVerticesNormalsBySmoothingGroupsForMeshList(param1:Vector.<Object3D>, param2:Number = 0) : void {
}
public function updateUVsBuffer() : void {
}
public function addVertex(param1:Number, param2:Number, param3:Number, param4:Number = 0, param5:Number = 0, param6:Object = null) : Vertex {
var local7:Vertex = null;
var local8:Vertex = null;
local7 = new Vertex();
local7.x = param1;
local7.y = param2;
local7.z = param3;
local7.u = param4;
local7.v = param5;
local7.id = param6;
if(this.alternativa3d::vertexList != null) {
local8 = this.alternativa3d::vertexList;
while(local8.alternativa3d::next != null) {
local8 = local8.alternativa3d::next;
}
local8.alternativa3d::next = local7;
} else {
this.alternativa3d::vertexList = local7;
}
return local7;
}
public function removeVertex(param1:Vertex) : Vertex {
var local3:Vertex = null;
var local5:Face = null;
var local6:Face = null;
var local7:Wrapper = null;
if(param1 == null) {
throw new TypeError("Parameter vertex must be non-null.");
}
var local2:Vertex = this.alternativa3d::vertexList;
while(local2 != null) {
if(local2 == param1) {
if(local3 != null) {
local3.alternativa3d::next = local2.alternativa3d::next;
} else {
this.alternativa3d::vertexList = local2.alternativa3d::next;
}
local2.alternativa3d::next = null;
break;
}
local3 = local2;
local2 = local2.alternativa3d::next;
}
if(local2 == null) {
throw new ArgumentError("Vertex not found.");
}
var local4:Face = this.alternativa3d::faceList;
while(local4 != null) {
local6 = local4.alternativa3d::next;
local7 = local4.alternativa3d::wrapper;
while(local7 != null) {
if(local7.alternativa3d::vertex == local2) {
break;
}
local7 = local7.alternativa3d::next;
}
if(local7 != null) {
if(local5 != null) {
local5.alternativa3d::next = local6;
} else {
this.alternativa3d::faceList = local6;
}
local4.alternativa3d::next = null;
} else {
local5 = local4;
}
local4 = local6;
}
return local2;
}
public function removeVertexById(param1:Object) : Vertex {
var local3:Vertex = null;
var local5:Face = null;
var local6:Face = null;
var local7:Wrapper = null;
if(param1 == null) {
throw new TypeError("Parameter id must be non-null.");
}
var local2:Vertex = this.alternativa3d::vertexList;
while(local2 != null) {
if(local2.id == param1) {
if(local3 != null) {
local3.alternativa3d::next = local2.alternativa3d::next;
} else {
this.alternativa3d::vertexList = local2.alternativa3d::next;
}
local2.alternativa3d::next = null;
break;
}
local3 = local2;
local2 = local2.alternativa3d::next;
}
if(local2 == null) {
throw new ArgumentError("Vertex not found.");
}
var local4:Face = this.alternativa3d::faceList;
while(local4 != null) {
local6 = local4.alternativa3d::next;
local7 = local4.alternativa3d::wrapper;
while(local7 != null) {
if(local7.alternativa3d::vertex == local2) {
break;
}
local7 = local7.alternativa3d::next;
}
if(local7 != null) {
if(local5 != null) {
local5.alternativa3d::next = local6;
} else {
this.alternativa3d::faceList = local6;
}
local4.alternativa3d::next = null;
} else {
local5 = local4;
}
local4 = local6;
}
return local2;
}
public function containsVertex(param1:Vertex) : Boolean {
if(param1 == null) {
throw new TypeError("Parameter vertex must be non-null.");
}
var local2:Vertex = this.alternativa3d::vertexList;
while(local2 != null) {
if(local2 == param1) {
return true;
}
local2 = local2.alternativa3d::next;
}
return false;
}
public function containsVertexWithId(param1:Object) : Boolean {
if(param1 == null) {
throw new TypeError("Parameter id must be non-null.");
}
var local2:Vertex = this.alternativa3d::vertexList;
while(local2 != null) {
if(local2.id == param1) {
return true;
}
local2 = local2.alternativa3d::next;
}
return false;
}
public function getVertexById(param1:Object) : Vertex {
if(param1 == null) {
throw new TypeError("Parameter id must be non-null.");
}
var local2:Vertex = this.alternativa3d::vertexList;
while(local2 != null) {
if(local2.id == param1) {
return local2;
}
local2 = local2.alternativa3d::next;
}
return null;
}
public function addFace(param1:Vector.<Vertex>, param2:Material = null, param3:Object = null) : Face {
var local8:Wrapper = null;
var local9:Vertex = null;
var local10:Face = null;
if(param1 == null) {
throw new TypeError("Parameter vertices must be non-null.");
}
var local4:int = int(param1.length);
if(local4 < 3) {
throw new ArgumentError(local4 + " vertices not enough.");
}
var local5:Face = new Face();
local5.material = param2;
local5.id = param3;
var local6:Wrapper = null;
var local7:int = 0;
while(local7 < local4) {
local8 = new Wrapper();
local9 = param1[local7];
if(local9 == null) {
throw new ArgumentError("Null vertex in vector.");
}
if(!this.containsVertex(local9)) {
throw new ArgumentError("Vertex not found.");
}
local8.alternativa3d::vertex = local9;
if(local6 != null) {
local6.alternativa3d::next = local8;
} else {
local5.alternativa3d::wrapper = local8;
}
local6 = local8;
local7++;
}
if(this.alternativa3d::faceList != null) {
local10 = this.alternativa3d::faceList;
while(local10.alternativa3d::next != null) {
local10 = local10.alternativa3d::next;
}
local10.alternativa3d::next = local5;
} else {
this.alternativa3d::faceList = local5;
}
return local5;
}
public function addFaceByIds(param1:Array, param2:Material = null, param3:Object = null) : Face {
var local8:Wrapper = null;
var local9:Vertex = null;
var local10:Face = null;
if(param1 == null) {
throw new TypeError("Parameter vertices must be non-null.");
}
var local4:int = int(param1.length);
if(local4 < 3) {
throw new ArgumentError(local4 + " vertices not enough.");
}
var local5:Face = new Face();
local5.material = param2;
local5.id = param3;
var local6:Wrapper = null;
var local7:int = 0;
while(local7 < local4) {
local8 = new Wrapper();
local9 = this.getVertexById(param1[local7]);
if(local9 == null) {
throw new ArgumentError("Vertex not found.");
}
local8.alternativa3d::vertex = local9;
if(local6 != null) {
local6.alternativa3d::next = local8;
} else {
local5.alternativa3d::wrapper = local8;
}
local6 = local8;
local7++;
}
if(this.alternativa3d::faceList != null) {
local10 = this.alternativa3d::faceList;
while(local10.alternativa3d::next != null) {
local10 = local10.alternativa3d::next;
}
local10.alternativa3d::next = local5;
} else {
this.alternativa3d::faceList = local5;
}
return local5;
}
public function addTriFace(param1:Vertex, param2:Vertex, param3:Vertex, param4:Material = null, param5:Object = null) : Face {
var local7:Face = null;
if(param1 == null) {
throw new TypeError("Parameter v1 must be non-null.");
}
if(param2 == null) {
throw new TypeError("Parameter v2 must be non-null.");
}
if(param3 == null) {
throw new TypeError("Parameter v3 must be non-null.");
}
if(!this.containsVertex(param1)) {
throw new ArgumentError("Vertex not found.");
}
if(!this.containsVertex(param2)) {
throw new ArgumentError("Vertex not found.");
}
if(!this.containsVertex(param3)) {
throw new ArgumentError("Vertex not found.");
}
var local6:Face = new Face();
local6.material = param4;
local6.id = param5;
local6.alternativa3d::wrapper = new Wrapper();
local6.alternativa3d::wrapper.alternativa3d::vertex = param1;
local6.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local6.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = param2;
local6.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local6.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param3;
if(this.alternativa3d::faceList != null) {
local7 = this.alternativa3d::faceList;
while(local7.alternativa3d::next != null) {
local7 = local7.alternativa3d::next;
}
local7.alternativa3d::next = local6;
} else {
this.alternativa3d::faceList = local6;
}
return local6;
}
public function addQuadFace(param1:Vertex, param2:Vertex, param3:Vertex, param4:Vertex, param5:Material = null, param6:Object = null) : Face {
var local8:Face = null;
if(param1 == null) {
throw new TypeError("Parameter v1 must be non-null.");
}
if(param2 == null) {
throw new TypeError("Parameter v2 must be non-null.");
}
if(param3 == null) {
throw new TypeError("Parameter v3 must be non-null.");
}
if(param4 == null) {
throw new TypeError("Parameter v4 must be non-null.");
}
if(!this.containsVertex(param1)) {
throw new ArgumentError("Vertex not found.");
}
if(!this.containsVertex(param2)) {
throw new ArgumentError("Vertex not found.");
}
if(!this.containsVertex(param3)) {
throw new ArgumentError("Vertex not found.");
}
if(!this.containsVertex(param4)) {
throw new ArgumentError("Vertex not found.");
}
var local7:Face = new Face();
local7.material = param5;
local7.id = param6;
local7.alternativa3d::wrapper = new Wrapper();
local7.alternativa3d::wrapper.alternativa3d::vertex = param1;
local7.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local7.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = param2;
local7.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local7.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param3;
local7.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::next = new Wrapper();
local7.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param4;
if(this.alternativa3d::faceList != null) {
local8 = this.alternativa3d::faceList;
while(local8.alternativa3d::next != null) {
local8 = local8.alternativa3d::next;
}
local8.alternativa3d::next = local7;
} else {
this.alternativa3d::faceList = local7;
}
return local7;
}
public function removeFace(param1:Face) : Face {
var local3:Face = null;
if(param1 == null) {
throw new TypeError("Parameter face must be non-null.");
}
var local2:Face = this.alternativa3d::faceList;
while(local2 != null) {
if(local2 == param1) {
if(local3 != null) {
local3.alternativa3d::next = local2.alternativa3d::next;
} else {
this.alternativa3d::faceList = local2.alternativa3d::next;
}
local2.alternativa3d::next = null;
break;
}
local3 = local2;
local2 = local2.alternativa3d::next;
}
if(local2 == null) {
throw new ArgumentError("Face not found.");
}
return local2;
}
public function removeFaceById(param1:Object) : Face {
var local3:Face = null;
if(param1 == null) {
throw new TypeError("Parameter id must be non-null.");
}
var local2:Face = this.alternativa3d::faceList;
while(local2 != null) {
if(local2.id == param1) {
if(local3 != null) {
local3.alternativa3d::next = local2.alternativa3d::next;
} else {
this.alternativa3d::faceList = local2.alternativa3d::next;
}
local2.alternativa3d::next = null;
break;
}
local3 = local2;
local2 = local2.alternativa3d::next;
}
if(local2 == null) {
throw new ArgumentError("Face not found.");
}
return local2;
}
public function containsFace(param1:Face) : Boolean {
if(param1 == null) {
throw new TypeError("Parameter face must be non-null.");
}
var local2:Face = this.alternativa3d::faceList;
while(local2 != null) {
if(local2 == param1) {
return true;
}
local2 = local2.alternativa3d::next;
}
return false;
}
public function containsFaceWithId(param1:Object) : Boolean {
if(param1 == null) {
throw new TypeError("Parameter id must be non-null.");
}
var local2:Face = this.alternativa3d::faceList;
while(local2 != null) {
if(local2.id == param1) {
return true;
}
local2 = local2.alternativa3d::next;
}
return false;
}
public function getFaceById(param1:Object) : Face {
if(param1 == null) {
throw new TypeError("Parameter id must be non-null.");
}
var local2:Face = this.alternativa3d::faceList;
while(local2 != null) {
if(local2.id == param1) {
return local2;
}
local2 = local2.alternativa3d::next;
}
return null;
}
public function addVerticesAndFaces(param1:Vector.<Number>, param2:Vector.<Number>, param3:Vector.<int>, param4:Boolean = false, param5:Material = null) : void {
var local6:int = 0;
var local7:int = 0;
var local8:int = 0;
var local11:Vertex = null;
var local13:Face = null;
var local14:Face = null;
var local15:Wrapper = null;
var local16:int = 0;
var local17:int = 0;
var local18:Vertex = null;
var local19:Wrapper = null;
if(param1 == null) {
throw new TypeError("Parameter vertices must be non-null.");
}
if(param2 == null) {
throw new TypeError("Parameter uvs must be non-null.");
}
if(param3 == null) {
throw new TypeError("Parameter indices must be non-null.");
}
var local9:int = param1.length / 3;
if(local9 != param2.length / 2) {
throw new ArgumentError("Vertices count and uvs count doesn\'t match.");
}
var local10:int = int(param3.length);
if(!param4 && Boolean(local10 % 3)) {
throw new ArgumentError("Incorrect indices.");
}
local6 = 0;
local8 = 0;
while(local6 < local10) {
if(local6 == local8) {
local17 = param4 ? param3[local6] : 3;
if(local17 < 3) {
throw new ArgumentError(local17 + " vertices not enough.");
}
local8 = param4 ? local17 + ++local6 : local6 + local17;
if(local8 > local10) {
throw new ArgumentError("Incorrect indices.");
}
}
local16 = param3[local6];
if(local16 < 0 || local16 >= local9) {
throw new RangeError("Index is out of bounds.");
}
local6++;
}
if(this.alternativa3d::vertexList != null) {
local11 = this.alternativa3d::vertexList;
while(local11.alternativa3d::next != null) {
local11 = local11.alternativa3d::next;
}
}
var local12:Vector.<Vertex> = new Vector.<Vertex>(local9);
local6 = 0;
local7 = 0;
local8 = 0;
while(local6 < local9) {
local18 = new Vertex();
local18.x = param1[local7];
local7++;
local18.y = param1[local7];
local7++;
local18.z = param1[local7];
local7++;
local18.u = param2[local8];
local8++;
local18.v = param2[local8];
local8++;
local12[local6] = local18;
if(local11 != null) {
local11.alternativa3d::next = local18;
} else {
this.alternativa3d::vertexList = local18;
}
local11 = local18;
local6++;
}
if(this.alternativa3d::faceList != null) {
local13 = this.alternativa3d::faceList;
while(local13.alternativa3d::next != null) {
local13 = local13.alternativa3d::next;
}
}
local6 = 0;
local8 = 0;
while(local6 < local10) {
if(local6 == local8) {
local8 = param4 ? param3[local6] + ++local6 : local6 + 3;
local15 = null;
local14 = new Face();
local14.material = param5;
if(local13 != null) {
local13.alternativa3d::next = local14;
} else {
this.alternativa3d::faceList = local14;
}
local13 = local14;
}
local19 = new Wrapper();
local19.alternativa3d::vertex = local12[param3[local6]];
if(local15 != null) {
local15.alternativa3d::next = local19;
} else {
local14.alternativa3d::wrapper = local19;
}
local15 = local19;
local6++;
}
}
public function get vertices() : Vector.<Vertex> {
var local1:Vector.<Vertex> = new Vector.<Vertex>();
var local2:int = 0;
var local3:Vertex = this.alternativa3d::vertexList;
while(local3 != null) {
local1[local2] = local3;
local2++;
local3 = local3.alternativa3d::next;
}
return local1;
}
public function get faces() : Vector.<Face> {
var local1:Vector.<Face> = new Vector.<Face>();
var local2:int = 0;
var local3:Face = this.alternativa3d::faceList;
while(local3 != null) {
local1[local2] = local3;
local2++;
local3 = local3.alternativa3d::next;
}
return local1;
}
public function weldVertices(param1:Number = 0, param2:Number = 0) : void {
var local3:Vertex = null;
var local4:Vertex = null;
var local9:Wrapper = null;
var local5:Vector.<Vertex> = new Vector.<Vertex>();
var local6:int = 0;
local3 = this.alternativa3d::vertexList;
while(local3 != null) {
local4 = local3.alternativa3d::next;
local3.alternativa3d::next = null;
local5[local6] = local3;
local6++;
local3 = local4;
}
this.alternativa3d::vertexList = null;
this.group(local5,0,local6,0,param1,param2,new Vector.<int>());
var local7:Face = this.alternativa3d::faceList;
while(local7 != null) {
local9 = local7.alternativa3d::wrapper;
while(local9 != null) {
if(local9.alternativa3d::vertex.alternativa3d::value != null) {
local9.alternativa3d::vertex = local9.alternativa3d::vertex.alternativa3d::value;
}
local9 = local9.alternativa3d::next;
}
local7 = local7.alternativa3d::next;
}
var local8:int = 0;
while(local8 < local6) {
local3 = local5[local8];
if(local3.alternativa3d::value == null) {
local3.alternativa3d::next = this.alternativa3d::vertexList;
this.alternativa3d::vertexList = local3;
}
local8++;
}
}
alternativa3d function prepareResources() : void {
}
alternativa3d function addOpaque(param1:Camera3D) : void {
}
alternativa3d function deleteResources() : void {
}
public function weldFaces(param1:Number = 0, param2:Number = 0, param3:Number = 0, param4:Boolean = false) : void {
var local5:int = 0;
var local6:int = 0;
var local7:* = undefined;
var local8:Face = null;
var local9:Face = null;
var local10:Face = null;
var local11:Wrapper = null;
var local12:Wrapper = null;
var local13:Wrapper = null;
var local14:Wrapper = null;
var local15:Wrapper = null;
var local16:Wrapper = null;
var local17:Wrapper = null;
var local18:Wrapper = null;
var local19:Vertex = null;
var local20:Vertex = null;
var local21:Vertex = null;
var local22:Vertex = null;
var local23:Number = NaN;
var local24:Number = NaN;
var local25:Number = NaN;
var local26:Number = NaN;
var local27:Number = NaN;
var local28:Number = NaN;
var local29:Number = NaN;
var local30:Number = NaN;
var local31:Number = NaN;
var local32:Number = NaN;
var local33:Number = NaN;
var local34:Number = NaN;
var local35:Number = NaN;
var local36:Number = NaN;
var local37:Dictionary = null;
var local44:int = 0;
var local45:Number = NaN;
var local46:Number = NaN;
var local47:Number = NaN;
var local48:Number = NaN;
var local49:Number = NaN;
var local50:Number = NaN;
var local51:Number = NaN;
var local52:Number = NaN;
var local53:Number = NaN;
var local54:Number = NaN;
var local55:Number = NaN;
var local56:Number = NaN;
var local57:Number = NaN;
var local58:Number = NaN;
var local59:Number = NaN;
var local60:Number = NaN;
var local61:Number = NaN;
var local62:Number = NaN;
var local63:Number = NaN;
var local64:Boolean = false;
var local65:Face = null;
var local38:Number = 0.001;
param1 = Math.cos(param1) - local38;
param2 += local38;
param3 = Math.cos(Math.PI - param3) - local38;
var local39:Dictionary = new Dictionary();
var local40:Dictionary = new Dictionary();
local9 = this.alternativa3d::faceList;
while(local9 != null) {
local10 = local9.alternativa3d::next;
local9.alternativa3d::next = null;
local20 = local9.alternativa3d::wrapper.alternativa3d::vertex;
local21 = local9.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex;
local22 = local9.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex;
local23 = local21.x - local20.x;
local24 = local21.y - local20.y;
local25 = local21.z - local20.z;
local28 = local22.x - local20.x;
local29 = local22.y - local20.y;
local30 = local22.z - local20.z;
local33 = local30 * local24 - local29 * local25;
local34 = local28 * local25 - local30 * local23;
local35 = local29 * local23 - local28 * local24;
local36 = local33 * local33 + local34 * local34 + local35 * local35;
if(local36 > local38) {
local36 = 1 / Math.sqrt(local36);
local33 *= local36;
local34 *= local36;
local35 *= local36;
local9.alternativa3d::normalX = local33;
local9.alternativa3d::normalY = local34;
local9.alternativa3d::normalZ = local35;
local9.alternativa3d::offset = local20.x * local33 + local20.y * local34 + local20.z * local35;
local39[local9] = true;
local15 = local9.alternativa3d::wrapper;
while(local15 != null) {
local19 = local15.alternativa3d::vertex;
local37 = local40[local19];
if(local37 == null) {
local37 = new Dictionary();
local40[local19] = local37;
}
local37[local9] = true;
local15 = local15.alternativa3d::next;
}
}
local9 = local10;
}
this.alternativa3d::faceList = null;
var local41:Vector.<Face> = new Vector.<Face>();
var local42:Dictionary = new Dictionary();
var local43:Dictionary = new Dictionary();
while(true) {
local9 = null;
var local66:int = 0;
var local67:* = local39;
for(local7 in local67) {
local9 = local7;
delete local39[local7];
}
if(local9 == null) {
break;
}
local44 = 0;
local41[local44] = local9;
local44++;
local20 = local9.alternativa3d::wrapper.alternativa3d::vertex;
local21 = local9.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex;
local22 = local9.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex;
local23 = local21.x - local20.x;
local24 = local21.y - local20.y;
local25 = local21.z - local20.z;
local26 = local21.u - local20.u;
local27 = local21.v - local20.v;
local28 = local22.x - local20.x;
local29 = local22.y - local20.y;
local30 = local22.z - local20.z;
local31 = local22.u - local20.u;
local32 = local22.v - local20.v;
local33 = Number(local9.alternativa3d::normalX);
local34 = Number(local9.alternativa3d::normalY);
local35 = Number(local9.alternativa3d::normalZ);
local45 = -local33 * local29 * local25 + local28 * local34 * local25 + local33 * local24 * local30 - local23 * local34 * local30 - local28 * local24 * local35 + local23 * local29 * local35;
local46 = (-local34 * local30 + local29 * local35) / local45;
local47 = (local33 * local30 - local28 * local35) / local45;
local48 = (-local33 * local29 + local28 * local34) / local45;
local49 = (local20.x * local34 * local30 - local33 * local20.y * local30 - local20.x * local29 * local35 + local28 * local20.y * local35 + local33 * local29 * local20.z - local28 * local34 * local20.z) / local45;
local50 = (local34 * local25 - local24 * local35) / local45;
local51 = (-local33 * local25 + local23 * local35) / local45;
local52 = (local33 * local24 - local23 * local34) / local45;
local53 = (local33 * local20.y * local25 - local20.x * local34 * local25 + local20.x * local24 * local35 - local23 * local20.y * local35 - local33 * local24 * local20.z + local23 * local34 * local20.z) / local45;
local54 = local26 * local46 + local31 * local50;
local55 = local26 * local47 + local31 * local51;
local56 = local26 * local48 + local31 * local52;
local57 = local26 * local49 + local31 * local53 + local20.u;
local58 = local27 * local46 + local32 * local50;
local59 = local27 * local47 + local32 * local51;
local60 = local27 * local48 + local32 * local52;
local61 = local27 * local49 + local32 * local53 + local20.v;
for(local7 in local43) {
delete local43[local7];
}
local5 = 0;
while(local5 < local44) {
local9 = local41[local5];
for(local7 in local42) {
delete local42[local7];
}
local13 = local9.alternativa3d::wrapper;
while(local13 != null) {
for(local7 in local40[local13.alternativa3d::vertex]) {
if(Boolean(local39[local7]) && !local43[local7]) {
local42[local7] = true;
}
}
local13 = local13.alternativa3d::next;
}
for(local7 in local42) {
local8 = local7;
if(local33 * local8.alternativa3d::normalX + local34 * local8.alternativa3d::normalY + local35 * local8.alternativa3d::normalZ >= param1) {
local14 = local8.alternativa3d::wrapper;
while(local14 != null) {
local19 = local14.alternativa3d::vertex;
local62 = local54 * local19.x + local55 * local19.y + local56 * local19.z + local57 - local19.u;
local63 = local58 * local19.x + local59 * local19.y + local60 * local19.z + local61 - local19.v;
if(local62 > param2 || local62 < -param2 || local63 > param2 || local63 < -param2) {
break;
}
local14 = local14.alternativa3d::next;
}
if(local14 == null) {
local13 = local9.alternativa3d::wrapper;
while(local13 != null) {
local15 = local13.alternativa3d::next != null ? local13.alternativa3d::next : local9.alternativa3d::wrapper;
local14 = local8.alternativa3d::wrapper;
while(local14 != null) {
local16 = local14.alternativa3d::next != null ? local14.alternativa3d::next : local8.alternativa3d::wrapper;
if(local13.alternativa3d::vertex == local16.alternativa3d::vertex && local15.alternativa3d::vertex == local14.alternativa3d::vertex) {
break;
}
local14 = local14.alternativa3d::next;
}
if(local14 != null) {
break;
}
local13 = local13.alternativa3d::next;
}
if(local13 != null) {
local41[local44] = local8;
local44++;
delete local39[local8];
}
} else {
local43[local8] = true;
}
} else {
local43[local8] = true;
}
}
local5++;
}
if(local44 == 1) {
local9 = local41[0];
local9.alternativa3d::next = this.alternativa3d::faceList;
this.alternativa3d::faceList = local9;
} else {
while(true) {
local64 = false;
local5 = 0;
while(local5 < local44 - 1) {
local9 = local41[local5];
if(local9 != null) {
local6 = 1;
for(; local6 < local44; local6++) {
local8 = local41[local6];
if(local8 != null) {
local13 = local9.alternativa3d::wrapper;
while(local13 != null) {
local15 = local13.alternativa3d::next != null ? local13.alternativa3d::next : local9.alternativa3d::wrapper;
local14 = local8.alternativa3d::wrapper;
while(local14 != null) {
local16 = local14.alternativa3d::next != null ? local14.alternativa3d::next : local8.alternativa3d::wrapper;
if(local13.alternativa3d::vertex == local16.alternativa3d::vertex && local15.alternativa3d::vertex == local14.alternativa3d::vertex) {
break;
}
local14 = local14.alternativa3d::next;
}
if(local14 != null) {
break;
}
local13 = local13.alternativa3d::next;
}
if(local13 != null) {
while(true) {
local17 = local15.alternativa3d::next != null ? local15.alternativa3d::next : local9.alternativa3d::wrapper;
local12 = local8.alternativa3d::wrapper;
while(local12.alternativa3d::next != local14 && local12.alternativa3d::next != null) {
local12 = local12.alternativa3d::next;
}
if(local17.alternativa3d::vertex != local12.alternativa3d::vertex) {
break;
}
local15 = local17;
local14 = local12;
}
while(true) {
local11 = local9.alternativa3d::wrapper;
while(local11.alternativa3d::next != local13 && local11.alternativa3d::next != null) {
local11 = local11.alternativa3d::next;
}
local18 = local16.alternativa3d::next != null ? local16.alternativa3d::next : local8.alternativa3d::wrapper;
if(local11.alternativa3d::vertex != local18.alternativa3d::vertex) {
break;
}
local13 = local11;
local16 = local18;
}
local20 = local13.alternativa3d::vertex;
local21 = local18.alternativa3d::vertex;
local22 = local11.alternativa3d::vertex;
local23 = local21.x - local20.x;
local24 = local21.y - local20.y;
local25 = local21.z - local20.z;
local28 = local22.x - local20.x;
local29 = local22.y - local20.y;
local30 = local22.z - local20.z;
local33 = local30 * local24 - local29 * local25;
local34 = local28 * local25 - local30 * local23;
local35 = local29 * local23 - local28 * local24;
if(local33 < local38 && local33 > -local38 && local34 < local38 && local34 > -local38 && local35 < local38 && local35 > -local38) {
if(local23 * local28 + local24 * local29 + local25 * local30 > 0) {
continue;
}
} else if(local9.alternativa3d::normalX * local33 + local9.alternativa3d::normalY * local34 + local9.alternativa3d::normalZ * local35 < 0) {
continue;
}
local36 = 1 / Math.sqrt(local23 * local23 + local24 * local24 + local25 * local25);
local23 *= local36;
local24 *= local36;
local25 *= local36;
local36 = 1 / Math.sqrt(local28 * local28 + local29 * local29 + local30 * local30);
local28 *= local36;
local29 *= local36;
local30 *= local36;
if(local23 * local28 + local24 * local29 + local25 * local30 >= param3) {
local20 = local14.alternativa3d::vertex;
local21 = local17.alternativa3d::vertex;
local22 = local12.alternativa3d::vertex;
local23 = local21.x - local20.x;
local24 = local21.y - local20.y;
local25 = local21.z - local20.z;
local28 = local22.x - local20.x;
local29 = local22.y - local20.y;
local30 = local22.z - local20.z;
local33 = local30 * local24 - local29 * local25;
local34 = local28 * local25 - local30 * local23;
local35 = local29 * local23 - local28 * local24;
if(local33 < local38 && local33 > -local38 && local34 < local38 && local34 > -local38 && local35 < local38 && local35 > -local38) {
if(local23 * local28 + local24 * local29 + local25 * local30 > 0) {
continue;
}
} else if(local9.alternativa3d::normalX * local33 + local9.alternativa3d::normalY * local34 + local9.alternativa3d::normalZ * local35 < 0) {
continue;
}
local36 = 1 / Math.sqrt(local23 * local23 + local24 * local24 + local25 * local25);
local23 *= local36;
local24 *= local36;
local25 *= local36;
local36 = 1 / Math.sqrt(local28 * local28 + local29 * local29 + local30 * local30);
local28 *= local36;
local29 *= local36;
local30 *= local36;
if(local23 * local28 + local24 * local29 + local25 * local30 >= param3) {
local64 = true;
local65 = new Face();
local65.material = local9.material;
local65.smoothingGroups = local9.smoothingGroups;
local65.alternativa3d::normalX = local9.alternativa3d::normalX;
local65.alternativa3d::normalY = local9.alternativa3d::normalY;
local65.alternativa3d::normalZ = local9.alternativa3d::normalZ;
local65.alternativa3d::offset = local9.alternativa3d::offset;
local65.id = local9.id;
local17 = null;
while(local15 != local13) {
local18 = new Wrapper();
local18.alternativa3d::vertex = local15.alternativa3d::vertex;
if(local17 != null) {
local17.alternativa3d::next = local18;
} else {
local65.alternativa3d::wrapper = local18;
}
local17 = local18;
local15 = local15.alternativa3d::next != null ? local15.alternativa3d::next : local9.alternativa3d::wrapper;
}
while(local16 != local14) {
local18 = new Wrapper();
local18.alternativa3d::vertex = local16.alternativa3d::vertex;
if(local17 != null) {
local17.alternativa3d::next = local18;
} else {
local65.alternativa3d::wrapper = local18;
}
local17 = local18;
local16 = local16.alternativa3d::next != null ? local16.alternativa3d::next : local8.alternativa3d::wrapper;
}
local41[local5] = local65;
local41[local6] = null;
local9 = local65;
if(param4) {
break;
}
}
}
}
}
}
}
local5++;
}
if(!local64) {
break;
}
}
local5 = 0;
while(local5 < local44) {
local9 = local41[local5];
if(local9 != null) {
local9.alternativa3d::calculateBestSequenceAndNormal();
local9.alternativa3d::next = this.alternativa3d::faceList;
this.alternativa3d::faceList = local9;
}
local5++;
}
}
}
}
private function group(param1:Vector.<Vertex>, param2:int, param3:int, param4:int, param5:Number, param6:Number, param7:Vector.<int>) : void {
var local8:int = 0;
var local9:int = 0;
var local10:Vertex = null;
var local11:Number = NaN;
var local13:Vertex = null;
var local14:int = 0;
var local15:int = 0;
var local16:Number = NaN;
var local17:Vertex = null;
var local18:Vertex = null;
switch(param4) {
case 0:
local8 = param2;
while(local8 < param3) {
local10 = param1[local8];
local10.alternativa3d::offset = local10.x;
local8++;
}
local11 = param5;
break;
case 1:
local8 = param2;
while(local8 < param3) {
local10 = param1[local8];
local10.alternativa3d::offset = local10.y;
local8++;
}
local11 = param5;
break;
case 2:
local8 = param2;
while(local8 < param3) {
local10 = param1[local8];
local10.alternativa3d::offset = local10.z;
local8++;
}
local11 = param5;
break;
case 3:
local8 = param2;
while(local8 < param3) {
local10 = param1[local8];
local10.alternativa3d::offset = local10.u;
local8++;
}
local11 = param6;
break;
case 4:
local8 = param2;
while(local8 < param3) {
local10 = param1[local8];
local10.alternativa3d::offset = local10.v;
local8++;
}
local11 = param6;
}
param7[0] = param2;
param7[1] = param3 - 1;
var local12:int = 2;
while(local12 > 0) {
local12--;
local14 = param7[local12];
local9 = local14;
local12--;
local15 = param7[local12];
local8 = local15;
local10 = param1[local14 + local15 >> 1];
local16 = Number(local10.alternativa3d::offset);
while(local8 <= local9) {
local17 = param1[local8];
while(local17.alternativa3d::offset > local16) {
local8++;
local17 = param1[local8];
}
local18 = param1[local9];
while(local18.alternativa3d::offset < local16) {
local9--;
local18 = param1[local9];
}
if(local8 <= local9) {
param1[local8] = local18;
param1[local9] = local17;
local8++;
local9--;
}
}
if(local15 < local9) {
param7[local12] = local15;
local12++;
param7[local12] = local9;
local12++;
}
if(local8 < local14) {
param7[local12] = local8;
local12++;
param7[local12] = local14;
local12++;
}
}
local8 = param2;
local10 = param1[local8];
local9 = local8 + 1;
while(local9 <= param3) {
if(local9 < param3) {
local13 = param1[local9];
}
if(local9 == param3 || local10.alternativa3d::offset - local13.alternativa3d::offset > local11) {
if(param4 < 4 && local9 - local8 > 1) {
this.group(param1,local8,local9,param4 + 1,param5,param6,param7);
}
if(local9 < param3) {
local8 = local9;
local10 = param1[local8];
}
} else if(param4 == 4) {
local13.alternativa3d::value = local10;
}
local9++;
}
}
public function setMaterialToAllFaces(param1:Material) : void {
var local2:Face = this.alternativa3d::faceList;
while(local2 != null) {
local2.material = param1;
local2 = local2.alternativa3d::next;
}
}
public function calculateFacesNormals(param1:Boolean = true) : void {
var local3:Wrapper = null;
var local4:Vertex = null;
var local5:Vertex = null;
var local6:Vertex = null;
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local2:Face = this.alternativa3d::faceList;
while(local2 != null) {
local3 = local2.alternativa3d::wrapper;
local4 = local3.alternativa3d::vertex;
local3 = local3.alternativa3d::next;
local5 = local3.alternativa3d::vertex;
local3 = local3.alternativa3d::next;
local6 = local3.alternativa3d::vertex;
local7 = local5.x - local4.x;
local8 = local5.y - local4.y;
local9 = local5.z - local4.z;
local10 = local6.x - local4.x;
local11 = local6.y - local4.y;
local12 = local6.z - local4.z;
local13 = local12 * local8 - local11 * local9;
local14 = local10 * local9 - local12 * local7;
local15 = local11 * local7 - local10 * local8;
if(param1) {
local16 = local13 * local13 + local14 * local14 + local15 * local15;
if(local16 > 0.001) {
local16 = 1 / Math.sqrt(local16);
local13 *= local16;
local14 *= local16;
local15 *= local16;
}
}
local2.alternativa3d::normalX = local13;
local2.alternativa3d::normalY = local14;
local2.alternativa3d::normalZ = local15;
local2.alternativa3d::offset = local4.x * local13 + local4.y * local14 + local4.z * local15;
local2 = local2.alternativa3d::next;
}
}
public function calculateVerticesNormals(param1:Boolean = false, param2:Number = 0) : void {
var local3:Vertex = null;
var local4:Number = NaN;
var local6:Wrapper = null;
var local7:Vertex = null;
var local8:Vertex = null;
var local9:Vertex = null;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Vector.<Vertex> = null;
local3 = this.alternativa3d::vertexList;
while(local3 != null) {
local3.normalX = 0;
local3.normalY = 0;
local3.normalZ = 0;
local3 = local3.alternativa3d::next;
}
var local5:Face = this.alternativa3d::faceList;
while(local5 != null) {
local6 = local5.alternativa3d::wrapper;
local7 = local6.alternativa3d::vertex;
local6 = local6.alternativa3d::next;
local8 = local6.alternativa3d::vertex;
local6 = local6.alternativa3d::next;
local9 = local6.alternativa3d::vertex;
local10 = local8.x - local7.x;
local11 = local8.y - local7.y;
local12 = local8.z - local7.z;
local13 = local9.x - local7.x;
local14 = local9.y - local7.y;
local15 = local9.z - local7.z;
local16 = local15 * local11 - local14 * local12;
local17 = local13 * local12 - local15 * local10;
local18 = local14 * local10 - local13 * local11;
local4 = local16 * local16 + local17 * local17 + local18 * local18;
if(local4 > 0.001) {
local4 = 1 / Math.sqrt(local4);
local16 *= local4;
local17 *= local4;
local18 *= local4;
}
local6 = local5.alternativa3d::wrapper;
while(local6 != null) {
local3 = local6.alternativa3d::vertex;
local3.normalX += local16;
local3.normalY += local17;
local3.normalZ += local18;
local6 = local6.alternativa3d::next;
}
local5 = local5.alternativa3d::next;
}
if(param1) {
local19 = this.vertices;
this.alternativa3d::weldNormals(local19,0,local19.length,0,param2,new Vector.<int>());
}
local3 = this.alternativa3d::vertexList;
while(local3 != null) {
local4 = local3.normalX * local3.normalX + local3.normalY * local3.normalY + local3.normalZ * local3.normalZ;
if(local4 > 0.001) {
local4 = 1 / Math.sqrt(local4);
local3.normalX *= local4;
local3.normalY *= local4;
local3.normalZ *= local4;
}
local3 = local3.alternativa3d::next;
}
}
alternativa3d function weldNormals(param1:Vector.<Vertex>, param2:int, param3:int, param4:int, param5:Number, param6:Vector.<int>) : void {
var local7:int = 0;
var local8:int = 0;
var local9:int = 0;
var local10:Vertex = null;
var local12:Vertex = null;
var local13:int = 0;
var local14:int = 0;
var local15:Number = NaN;
var local16:Vertex = null;
var local17:Vertex = null;
switch(param4) {
case 0:
local7 = param2;
while(local7 < param3) {
local10 = param1[local7];
local10.alternativa3d::offset = local10.x;
local7++;
}
break;
case 1:
local7 = param2;
while(local7 < param3) {
local10 = param1[local7];
local10.alternativa3d::offset = local10.y;
local7++;
}
break;
case 2:
local7 = param2;
while(local7 < param3) {
local10 = param1[local7];
local10.alternativa3d::offset = local10.z;
local7++;
}
}
param6[0] = param2;
param6[1] = param3 - 1;
var local11:int = 2;
while(local11 > 0) {
local11--;
local13 = param6[local11];
local8 = local13;
local11--;
local14 = param6[local11];
local7 = local14;
local10 = param1[local13 + local14 >> 1];
local15 = Number(local10.alternativa3d::offset);
while(local7 <= local8) {
local16 = param1[local7];
while(local16.alternativa3d::offset > local15) {
local7++;
local16 = param1[local7];
}
local17 = param1[local8];
while(local17.alternativa3d::offset < local15) {
local8--;
local17 = param1[local8];
}
if(local7 <= local8) {
param1[local7] = local17;
param1[local8] = local16;
local7++;
local8--;
}
}
if(local14 < local8) {
param6[local11] = local14;
local11++;
param6[local11] = local8;
local11++;
}
if(local7 < local13) {
param6[local11] = local7;
local11++;
param6[local11] = local13;
local11++;
}
}
local7 = param2;
local10 = param1[local7];
local8 = local7 + 1;
while(local8 <= param3) {
if(local8 < param3) {
local12 = param1[local8];
}
if(local8 == param3 || local10.alternativa3d::offset - local12.alternativa3d::offset > param5) {
if(local8 - local7 > 1) {
if(param4 < 2) {
this.alternativa3d::weldNormals(param1,local7,local8,param4 + 1,param5,param6);
} else {
local9 = local7 + 1;
while(local9 < local8) {
local12 = param1[local9];
local10.normalX += local12.normalX;
local10.normalY += local12.normalY;
local10.normalZ += local12.normalZ;
local9++;
}
local9 = local7 + 1;
while(local9 < local8) {
local12 = param1[local9];
local12.normalX = local10.normalX;
local12.normalY = local10.normalY;
local12.normalZ = local10.normalZ;
local9++;
}
}
}
if(local8 < param3) {
local7 = local8;
local10 = param1[local7];
}
}
local8++;
}
}
public function calculateVerticesNormalsByAngle(param1:Number, param2:Number = 0) : void {
}
public function calculateVerticesNormalsBySmoothingGroups(param1:Number = 0) : void {
}
public function optimizeForDynamicBSP(param1:int = 1) : void {
var local3:Face = null;
var local5:Face = null;
var local6:Face = null;
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:int = 0;
var local14:Face = null;
var local15:Wrapper = null;
var local16:Vertex = null;
var local17:Vertex = null;
var local18:Vertex = null;
var local19:Number = NaN;
var local20:Number = NaN;
var local21:Number = NaN;
var local22:Boolean = false;
var local23:Boolean = false;
var local24:Vertex = null;
var local25:Number = NaN;
var local2:Face = this.alternativa3d::faceList;
var local4:int = 0;
while(local4 < param1) {
local5 = null;
local6 = local2;
while(local6 != null) {
local7 = Number(local6.alternativa3d::normalX);
local8 = Number(local6.alternativa3d::normalY);
local9 = Number(local6.alternativa3d::normalZ);
local10 = Number(local6.alternativa3d::offset);
local11 = local10 - this.threshold;
local12 = local10 + this.threshold;
local13 = 0;
local14 = local2;
while(local14 != null) {
if(local14 != local6) {
local15 = local14.alternativa3d::wrapper;
local16 = local15.alternativa3d::vertex;
local15 = local15.alternativa3d::next;
local17 = local15.alternativa3d::vertex;
local15 = local15.alternativa3d::next;
local18 = local15.alternativa3d::vertex;
local15 = local15.alternativa3d::next;
local19 = local16.x * local7 + local16.y * local8 + local16.z * local9;
local20 = local17.x * local7 + local17.y * local8 + local17.z * local9;
local21 = local18.x * local7 + local18.y * local8 + local18.z * local9;
local22 = local19 < local11 || local20 < local11 || local21 < local11;
local23 = local19 > local12 || local20 > local12 || local21 > local12;
while(local15 != null) {
local24 = local15.alternativa3d::vertex;
local25 = local24.x * local7 + local24.y * local8 + local24.z * local9;
if(local25 < local11) {
local22 = true;
if(local23) {
break;
}
} else if(local25 > local12) {
local23 = true;
if(local22) {
break;
}
}
local15 = local15.alternativa3d::next;
}
if(local23 && local22) {
local13++;
if(local13 > local4) {
break;
}
}
}
local14 = local14.alternativa3d::next;
}
if(local14 == null) {
if(local5 != null) {
local5.alternativa3d::next = local6.alternativa3d::next;
} else {
local2 = local6.alternativa3d::next;
}
if(local3 != null) {
local3.alternativa3d::next = local6;
} else {
this.alternativa3d::faceList = local6;
}
local3 = local6;
} else {
local5 = local6;
}
local6 = local6.alternativa3d::next;
}
if(local2 == null) {
break;
}
local4++;
}
if(local3 != null) {
local3.alternativa3d::next = local2;
}
}
override public function calculateResolution(param1:int, param2:int, param3:int = 1, param4:Matrix3D = null) : Number {
var local5:Object3D = null;
var local11:Wrapper = null;
var local12:Vertex = null;
var local13:Vertex = null;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local20:Number = NaN;
var local21:Number = NaN;
if(param4 != null) {
local5 = new Object3D();
local5.matrix = param4;
local5.alternativa3d::composeMatrix();
}
var local6:Number = 1e+22;
var local7:Number = 0;
var local8:Number = 0;
var local9:int = 0;
var local10:Face = this.alternativa3d::faceList;
while(local10 != null) {
local11 = local10.alternativa3d::wrapper;
while(local11 != null) {
local12 = local11.alternativa3d::vertex;
local13 = local11.alternativa3d::next != null ? local11.alternativa3d::next.alternativa3d::vertex : local10.alternativa3d::wrapper.alternativa3d::vertex;
local14 = local5 != null ? local5.alternativa3d::ma * (local13.x - local12.x) + local5.alternativa3d::mb * (local13.y - local12.y) + local5.alternativa3d::mc * (local13.z - local12.z) : local13.x - local12.x;
local15 = local5 != null ? local5.alternativa3d::me * (local13.x - local12.x) + local5.alternativa3d::mf * (local13.y - local12.y) + local5.alternativa3d::mg * (local13.z - local12.z) : local13.y - local12.y;
local16 = local5 != null ? local5.alternativa3d::mi * (local13.x - local12.x) + local5.alternativa3d::mj * (local13.y - local12.y) + local5.alternativa3d::mk * (local13.z - local12.z) : local13.z - local12.z;
local17 = (local13.u - local12.u) * param1;
local18 = (local13.v - local12.v) * param2;
local19 = local14 * local14 + local15 * local15 + local16 * local16;
local20 = local17 * local17 + local18 * local18;
if(local19 > 0.001 && local20 > 0.001) {
local21 = Math.sqrt(local19 / local20);
if(local21 < local6) {
local6 = local21;
}
if(local21 > local7) {
local7 = local21;
}
local8 += local21;
local9++;
if(param3 == 0) {
break;
}
}
local11 = local11.alternativa3d::next;
}
local10 = local10.alternativa3d::next;
}
if(local9 == 0) {
return 1;
}
return param3 < 2 ? local8 / local9 : (param3 == 2 ? local6 : local7);
}
override public function intersectRay(param1:Vector3D, param2:Vector3D, param3:Dictionary = null, param4:Camera3D = null) : RayIntersectionData {
var local11:Vector3D = null;
var local12:Face = null;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local20:Number = NaN;
var local21:Number = NaN;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:Wrapper = null;
var local25:Vertex = null;
var local26:Vertex = null;
var local27:Number = NaN;
var local28:Number = NaN;
var local29:Number = NaN;
var local30:Number = NaN;
var local31:Number = NaN;
var local32:Number = NaN;
var local33:RayIntersectionData = null;
if(param3 != null && Boolean(param3[this])) {
return null;
}
if(!alternativa3d::boundIntersectRay(param1,param2,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ)) {
return null;
}
var local5:Number = param1.x;
var local6:Number = param1.y;
var local7:Number = param1.z;
var local8:Number = param2.x;
var local9:Number = param2.y;
var local10:Number = param2.z;
var local13:Number = 1e+22;
var local14:Face = this.alternativa3d::faceList;
while(local14 != null) {
local15 = Number(local14.alternativa3d::normalX);
local16 = Number(local14.alternativa3d::normalY);
local17 = Number(local14.alternativa3d::normalZ);
local18 = local8 * local15 + local9 * local16 + local10 * local17;
if(local18 < 0) {
local19 = local5 * local15 + local6 * local16 + local7 * local17 - local14.alternativa3d::offset;
if(local19 > 0) {
local20 = -local19 / local18;
if(local11 == null || local20 < local13) {
local21 = local5 + local8 * local20;
local22 = local6 + local9 * local20;
local23 = local7 + local10 * local20;
local24 = local14.alternativa3d::wrapper;
while(local24 != null) {
local25 = local24.alternativa3d::vertex;
local26 = local24.alternativa3d::next != null ? local24.alternativa3d::next.alternativa3d::vertex : local14.alternativa3d::wrapper.alternativa3d::vertex;
local27 = local26.x - local25.x;
local28 = local26.y - local25.y;
local29 = local26.z - local25.z;
local30 = local21 - local25.x;
local31 = local22 - local25.y;
local32 = local23 - local25.z;
if((local32 * local28 - local31 * local29) * local15 + (local30 * local29 - local32 * local27) * local16 + (local31 * local27 - local30 * local28) * local17 < 0) {
break;
}
local24 = local24.alternativa3d::next;
}
if(local24 == null) {
if(local20 < local13) {
local13 = local20;
if(local11 == null) {
local11 = new Vector3D();
}
local11.x = local21;
local11.y = local22;
local11.z = local23;
local12 = local14;
}
}
}
}
}
local14 = local14.alternativa3d::next;
}
if(local11 != null) {
local33 = new RayIntersectionData();
local33.object = this;
local33.face = local12;
local33.point = local11;
local33.uv = local12.getUV(local11);
local33.time = local13;
return local33;
}
return null;
}
override alternativa3d function checkIntersection(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Dictionary) : Boolean {
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Wrapper = null;
var local20:Vertex = null;
var local21:Vertex = null;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:Number = NaN;
var local25:Number = NaN;
var local26:Number = NaN;
var local27:Number = NaN;
var local9:Face = this.alternativa3d::faceList;
while(true) {
if(local9 == null) {
return false;
}
local10 = Number(local9.alternativa3d::normalX);
local11 = Number(local9.alternativa3d::normalY);
local12 = Number(local9.alternativa3d::normalZ);
local13 = param4 * local10 + param5 * local11 + param6 * local12;
if(local13 < 0) {
local14 = param1 * local10 + param2 * local11 + param3 * local12 - local9.alternativa3d::offset;
if(local14 > 0) {
local15 = -local14 / local13;
if(local15 < param7) {
local16 = param1 + param4 * local15;
local17 = param2 + param5 * local15;
local18 = param3 + param6 * local15;
local19 = local9.alternativa3d::wrapper;
while(local19 != null) {
local20 = local19.alternativa3d::vertex;
local21 = local19.alternativa3d::next != null ? local19.alternativa3d::next.alternativa3d::vertex : local9.alternativa3d::wrapper.alternativa3d::vertex;
local22 = local21.x - local20.x;
local23 = local21.y - local20.y;
local24 = local21.z - local20.z;
local25 = local16 - local20.x;
local26 = local17 - local20.y;
local27 = local18 - local20.z;
if((local27 * local23 - local26 * local24) * local10 + (local25 * local24 - local27 * local22) * local11 + (local26 * local22 - local25 * local23) * local12 < 0) {
break;
}
local19 = local19.alternativa3d::next;
}
if(local19 == null) {
break;
}
}
}
}
local9 = local9.alternativa3d::next;
}
return true;
}
override alternativa3d function collectPlanes(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Vector3D, param5:Vector3D, param6:Vector.<Face>, param7:Dictionary = null) : void {
var local9:Vertex = null;
var local11:Number = NaN;
var local12:Wrapper = null;
if(param7 != null && Boolean(param7[this])) {
return;
}
var local8:Vector3D = alternativa3d::calculateSphere(param1,param2,param3,param4,param5);
if(!alternativa3d::boundIntersectSphere(local8,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ)) {
return;
}
if(alternativa3d::transformId > 500000000) {
alternativa3d::transformId = 0;
local9 = this.alternativa3d::vertexList;
while(local9 != null) {
local9.alternativa3d::transformId = 0;
local9 = local9.alternativa3d::next;
}
}
++alternativa3d::transformId;
var local10:Face = this.alternativa3d::faceList;
while(local10 != null) {
local11 = local8.x * local10.alternativa3d::normalX + local8.y * local10.alternativa3d::normalY + local8.z * local10.alternativa3d::normalZ - local10.alternativa3d::offset;
if(local11 < local8.w && local11 > -local8.w) {
local12 = local10.alternativa3d::wrapper;
while(local12 != null) {
local9 = local12.alternativa3d::vertex;
if(local9.alternativa3d::transformId != alternativa3d::transformId) {
local9.alternativa3d::cameraX = alternativa3d::ma * local9.x + alternativa3d::mb * local9.y + alternativa3d::mc * local9.z + alternativa3d::md;
local9.alternativa3d::cameraY = alternativa3d::me * local9.x + alternativa3d::mf * local9.y + alternativa3d::mg * local9.z + alternativa3d::mh;
local9.alternativa3d::cameraZ = alternativa3d::mi * local9.x + alternativa3d::mj * local9.y + alternativa3d::mk * local9.z + alternativa3d::ml;
local9.alternativa3d::transformId = alternativa3d::transformId;
}
local12 = local12.alternativa3d::next;
}
param6.push(local10);
}
local10 = local10.alternativa3d::next;
}
}
override public function clone() : Object3D {
var local1:Mesh = new Mesh();
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
var local3:Vertex = null;
var local4:Vertex = null;
var local5:Face = null;
var local7:Vertex = null;
var local8:Face = null;
var local9:Wrapper = null;
var local10:Wrapper = null;
var local11:Wrapper = null;
super.clonePropertiesFrom(param1);
var local2:Mesh = param1 as Mesh;
this.clipping = local2.clipping;
this.sorting = local2.sorting;
this.threshold = local2.threshold;
local3 = local2.alternativa3d::vertexList;
while(local3 != null) {
local7 = new Vertex();
local7.x = local3.x;
local7.y = local3.y;
local7.z = local3.z;
local7.u = local3.u;
local7.v = local3.v;
local7.normalX = local3.normalX;
local7.normalY = local3.normalY;
local7.normalZ = local3.normalZ;
local7.alternativa3d::offset = local3.alternativa3d::offset;
local7.id = local3.id;
local3.alternativa3d::value = local7;
if(local4 != null) {
local4.alternativa3d::next = local7;
} else {
this.alternativa3d::vertexList = local7;
}
local4 = local7;
local3 = local3.alternativa3d::next;
}
var local6:Face = local2.alternativa3d::faceList;
while(local6 != null) {
local8 = new Face();
local8.material = local6.material;
local8.smoothingGroups = local6.smoothingGroups;
local8.id = local6.id;
local8.alternativa3d::normalX = local6.alternativa3d::normalX;
local8.alternativa3d::normalY = local6.alternativa3d::normalY;
local8.alternativa3d::normalZ = local6.alternativa3d::normalZ;
local8.alternativa3d::offset = local6.alternativa3d::offset;
local9 = null;
local10 = local6.alternativa3d::wrapper;
while(local10 != null) {
local11 = new Wrapper();
local11.alternativa3d::vertex = local10.alternativa3d::vertex.alternativa3d::value;
if(local9 != null) {
local9.alternativa3d::next = local11;
} else {
local8.alternativa3d::wrapper = local11;
}
local9 = local11;
local10 = local10.alternativa3d::next;
}
if(local5 != null) {
local5.alternativa3d::next = local8;
} else {
this.alternativa3d::faceList = local8;
}
local5 = local8;
local6 = local6.alternativa3d::next;
}
local3 = local2.alternativa3d::vertexList;
while(local3 != null) {
local3.alternativa3d::value = null;
local3 = local3.alternativa3d::next;
}
}
override alternativa3d function draw(param1:Camera3D, param2:Canvas) : void {
var local4:Vertex = null;
var local5:int = 0;
if(this.alternativa3d::faceList == null) {
return;
}
if(this.clipping == 0) {
if(Boolean(alternativa3d::culling & 1)) {
return;
}
alternativa3d::culling = 0;
}
if(alternativa3d::transformId > 500000000) {
alternativa3d::transformId = 0;
local4 = this.alternativa3d::vertexList;
while(local4 != null) {
local4.alternativa3d::transformId = 0;
local4 = local4.alternativa3d::next;
}
}
++alternativa3d::transformId;
alternativa3d::calculateInverseMatrix();
var local3:Face = this.alternativa3d::prepareFaces(param1);
if(local3 == null) {
return;
}
if(alternativa3d::culling > 0) {
if(this.clipping == 1) {
local3 = param1.alternativa3d::cull(local3,alternativa3d::culling);
} else {
local3 = param1.alternativa3d::clip(local3,alternativa3d::culling);
}
if(local3 == null) {
return;
}
}
if(local3.alternativa3d::processNext != null) {
if(this.sorting == 1) {
local3 = param1.alternativa3d::sortByAverageZ(local3);
} else if(this.sorting == 2) {
local3 = param1.alternativa3d::sortByDynamicBSP(local3,this.threshold);
}
}
if(param1.debug) {
local5 = int(param1.alternativa3d::checkInDebug(this));
if(local5 > 0) {
this.alternativa3d::drawDebug(param1,param2.alternativa3d::getChildCanvas(true,false),local3,local5);
}
}
this.alternativa3d::drawFaces(param1,param2.alternativa3d::getChildCanvas(true,false,this,alpha,blendMode,colorTransform,filters),local3);
}
override alternativa3d function getVG(param1:Camera3D) : VG {
var local3:Vertex = null;
if(this.alternativa3d::faceList == null) {
return null;
}
if(alternativa3d::transformId > 500000000) {
alternativa3d::transformId = 0;
local3 = this.alternativa3d::vertexList;
while(local3 != null) {
local3.alternativa3d::transformId = 0;
local3 = local3.alternativa3d::next;
}
}
++alternativa3d::transformId;
if(this.clipping == 0) {
if(Boolean(alternativa3d::culling & 1)) {
return null;
}
alternativa3d::culling = 0;
}
alternativa3d::calculateInverseMatrix();
var local2:Face = this.alternativa3d::prepareFaces(param1);
if(local2 == null) {
return null;
}
if(alternativa3d::culling > 0) {
if(this.clipping == 1) {
local2 = param1.alternativa3d::cull(local2,alternativa3d::culling);
} else {
local2 = param1.alternativa3d::clip(local2,alternativa3d::culling);
}
if(local2 == null) {
return null;
}
}
return VG.alternativa3d::create(this,local2,this.sorting,param1.debug ? int(param1.alternativa3d::checkInDebug(this)) : 0,false);
}
alternativa3d function prepareFaces(param1:Camera3D) : Face {
var local2:Face = null;
var local3:Face = null;
var local5:Wrapper = null;
var local6:Vertex = null;
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local4:Face = this.alternativa3d::faceList;
while(local4 != null) {
if(local4.alternativa3d::normalX * alternativa3d::imd + local4.alternativa3d::normalY * alternativa3d::imh + local4.alternativa3d::normalZ * alternativa3d::iml > local4.alternativa3d::offset) {
local5 = local4.alternativa3d::wrapper;
while(local5 != null) {
local6 = local5.alternativa3d::vertex;
if(local6.alternativa3d::transformId != alternativa3d::transformId) {
local7 = local6.x;
local8 = local6.y;
local9 = local6.z;
local6.alternativa3d::cameraX = alternativa3d::ma * local7 + alternativa3d::mb * local8 + alternativa3d::mc * local9 + alternativa3d::md;
local6.alternativa3d::cameraY = alternativa3d::me * local7 + alternativa3d::mf * local8 + alternativa3d::mg * local9 + alternativa3d::mh;
local6.alternativa3d::cameraZ = alternativa3d::mi * local7 + alternativa3d::mj * local8 + alternativa3d::mk * local9 + alternativa3d::ml;
local6.alternativa3d::transformId = alternativa3d::transformId;
local6.alternativa3d::drawId = 0;
}
local5 = local5.alternativa3d::next;
}
if(local2 != null) {
local3.alternativa3d::processNext = local4;
} else {
local2 = local4;
}
local3 = local4;
}
local4 = local4.alternativa3d::next;
}
if(local3 != null) {
local3.alternativa3d::processNext = null;
}
return local2;
}
alternativa3d function drawDebug(param1:Camera3D, param2:Canvas, param3:Face, param4:int) : void {
if(Boolean(param4 & Debug.EDGES)) {
Debug.alternativa3d::drawEdges(param1,param2,param3,16777215);
}
if(Boolean(param4 & Debug.BOUNDS)) {
Debug.alternativa3d::drawBounds(param1,param2,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ);
}
}
alternativa3d function drawFaces(param1:Camera3D, param2:Canvas, param3:Face) : void {
var local5:Face = null;
var local4:Face = param3;
while(local4 != null) {
local5 = local4.alternativa3d::processNext;
if(local5 == null || local5.material != param3.material) {
local4.alternativa3d::processNext = null;
if(param3.material != null) {
param3.material.alternativa3d::draw(param1,param2,param3,alternativa3d::ml);
} else {
while(param3 != null) {
local4 = param3.alternativa3d::processNext;
param3.alternativa3d::processNext = null;
param3 = local4;
}
}
param3 = local5;
}
local4 = local5;
}
}
override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void {
var local3:Vertex = this.alternativa3d::vertexList;
while(local3 != null) {
if(param2 != null) {
local3.alternativa3d::cameraX = param2.alternativa3d::ma * local3.x + param2.alternativa3d::mb * local3.y + param2.alternativa3d::mc * local3.z + param2.alternativa3d::md;
local3.alternativa3d::cameraY = param2.alternativa3d::me * local3.x + param2.alternativa3d::mf * local3.y + param2.alternativa3d::mg * local3.z + param2.alternativa3d::mh;
local3.alternativa3d::cameraZ = param2.alternativa3d::mi * local3.x + param2.alternativa3d::mj * local3.y + param2.alternativa3d::mk * local3.z + param2.alternativa3d::ml;
} else {
local3.alternativa3d::cameraX = local3.x;
local3.alternativa3d::cameraY = local3.y;
local3.alternativa3d::cameraZ = local3.z;
}
if(local3.alternativa3d::cameraX < param1.boundMinX) {
param1.boundMinX = local3.alternativa3d::cameraX;
}
if(local3.alternativa3d::cameraX > param1.boundMaxX) {
param1.boundMaxX = local3.alternativa3d::cameraX;
}
if(local3.alternativa3d::cameraY < param1.boundMinY) {
param1.boundMinY = local3.alternativa3d::cameraY;
}
if(local3.alternativa3d::cameraY > param1.boundMaxY) {
param1.boundMaxY = local3.alternativa3d::cameraY;
}
if(local3.alternativa3d::cameraZ < param1.boundMinZ) {
param1.boundMinZ = local3.alternativa3d::cameraZ;
}
if(local3.alternativa3d::cameraZ > param1.boundMaxZ) {
param1.boundMaxZ = local3.alternativa3d::cameraZ;
}
local3 = local3.alternativa3d::next;
}
}
override alternativa3d function split(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Number) : Vector.<Object3D> {
var local9:Vertex = null;
var local10:Vertex = null;
var local14:Face = null;
var local15:Face = null;
var local17:Face = null;
var local18:Wrapper = null;
var local19:Vertex = null;
var local20:Vertex = null;
var local21:Vertex = null;
var local22:Boolean = false;
var local23:Boolean = false;
var local24:Face = null;
var local25:Face = null;
var local26:Wrapper = null;
var local27:Wrapper = null;
var local28:Wrapper = null;
var local29:Number = NaN;
var local30:Vertex = null;
var local5:Vector.<Object3D> = new Vector.<Object3D>(2);
var local6:Vector3D = alternativa3d::calculatePlane(param1,param2,param3);
var local7:Number = local6.w - param4;
var local8:Number = local6.w + param4;
local9 = this.alternativa3d::vertexList;
while(local9 != null) {
local10 = local9.alternativa3d::next;
local9.alternativa3d::next = null;
local9.alternativa3d::offset = local9.x * local6.x + local9.y * local6.y + local9.z * local6.z;
if(local9.alternativa3d::offset >= local7 && local9.alternativa3d::offset <= local8) {
local9.alternativa3d::value = new Vertex();
local9.alternativa3d::value.x = local9.x;
local9.alternativa3d::value.y = local9.y;
local9.alternativa3d::value.z = local9.z;
local9.alternativa3d::value.u = local9.u;
local9.alternativa3d::value.v = local9.v;
local9.alternativa3d::value.normalX = local9.normalX;
local9.alternativa3d::value.normalY = local9.normalY;
local9.alternativa3d::value.normalZ = local9.normalZ;
}
local9.alternativa3d::transformId = 0;
local9 = local10;
}
this.alternativa3d::vertexList = null;
var local11:Face = this.alternativa3d::faceList;
this.alternativa3d::faceList = null;
var local12:Mesh = this.clone() as Mesh;
var local13:Mesh = this.clone() as Mesh;
var local16:Face = local11;
while(local16 != null) {
local17 = local16.alternativa3d::next;
local18 = local16.alternativa3d::wrapper;
local19 = local18.alternativa3d::vertex;
local18 = local18.alternativa3d::next;
local20 = local18.alternativa3d::vertex;
local18 = local18.alternativa3d::next;
local21 = local18.alternativa3d::vertex;
local22 = local19.alternativa3d::offset < local7 || local20.alternativa3d::offset < local7 || local21.alternativa3d::offset < local7;
local23 = local19.alternativa3d::offset > local8 || local20.alternativa3d::offset > local8 || local21.alternativa3d::offset > local8;
local18 = local18.alternativa3d::next;
while(local18 != null) {
local9 = local18.alternativa3d::vertex;
if(local9.alternativa3d::offset < local7) {
local22 = true;
} else if(local9.alternativa3d::offset > local8) {
local23 = true;
}
local18 = local18.alternativa3d::next;
}
if(!local22) {
if(local15 != null) {
local15.alternativa3d::next = local16;
} else {
local13.alternativa3d::faceList = local16;
}
local15 = local16;
} else if(!local23) {
if(local14 != null) {
local14.alternativa3d::next = local16;
} else {
local12.alternativa3d::faceList = local16;
}
local14 = local16;
local18 = local16.alternativa3d::wrapper;
while(local18 != null) {
if(local18.alternativa3d::vertex.alternativa3d::value != null) {
local18.alternativa3d::vertex = local18.alternativa3d::vertex.alternativa3d::value;
}
local18 = local18.alternativa3d::next;
}
} else {
local24 = new Face();
local25 = new Face();
local26 = null;
local27 = null;
local18 = local16.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next;
while(local18.alternativa3d::next != null) {
local18 = local18.alternativa3d::next;
}
local19 = local18.alternativa3d::vertex;
local18 = local16.alternativa3d::wrapper;
while(local18 != null) {
local20 = local18.alternativa3d::vertex;
if(local19.alternativa3d::offset < local7 && local20.alternativa3d::offset > local8 || local19.alternativa3d::offset > local8 && local20.alternativa3d::offset < local7) {
local29 = (local6.w - local19.alternativa3d::offset) / (local20.alternativa3d::offset - local19.alternativa3d::offset);
local9 = new Vertex();
local9.x = local19.x + (local20.x - local19.x) * local29;
local9.y = local19.y + (local20.y - local19.y) * local29;
local9.z = local19.z + (local20.z - local19.z) * local29;
local9.u = local19.u + (local20.u - local19.u) * local29;
local9.v = local19.v + (local20.v - local19.v) * local29;
local9.normalX = local19.normalX + (local20.normalX - local19.normalX) * local29;
local9.normalY = local19.normalY + (local20.normalY - local19.normalY) * local29;
local9.normalZ = local19.normalZ + (local20.normalZ - local19.normalZ) * local29;
local28 = new Wrapper();
local28.alternativa3d::vertex = local9;
if(local26 != null) {
local26.alternativa3d::next = local28;
} else {
local24.alternativa3d::wrapper = local28;
}
local26 = local28;
local30 = new Vertex();
local30.x = local9.x;
local30.y = local9.y;
local30.z = local9.z;
local30.u = local9.u;
local30.v = local9.v;
local30.normalX = local9.normalX;
local30.normalY = local9.normalY;
local30.normalZ = local9.normalZ;
local28 = new Wrapper();
local28.alternativa3d::vertex = local30;
if(local27 != null) {
local27.alternativa3d::next = local28;
} else {
local25.alternativa3d::wrapper = local28;
}
local27 = local28;
}
if(local20.alternativa3d::offset < local7) {
local28 = local18.alternativa3d::create();
local28.alternativa3d::vertex = local20;
if(local26 != null) {
local26.alternativa3d::next = local28;
} else {
local24.alternativa3d::wrapper = local28;
}
local26 = local28;
} else if(local20.alternativa3d::offset > local8) {
local28 = local18.alternativa3d::create();
local28.alternativa3d::vertex = local20;
if(local27 != null) {
local27.alternativa3d::next = local28;
} else {
local25.alternativa3d::wrapper = local28;
}
local27 = local28;
} else {
local28 = local18.alternativa3d::create();
local28.alternativa3d::vertex = local20.alternativa3d::value;
if(local26 != null) {
local26.alternativa3d::next = local28;
} else {
local24.alternativa3d::wrapper = local28;
}
local26 = local28;
local28 = local18.alternativa3d::create();
local28.alternativa3d::vertex = local20;
if(local27 != null) {
local27.alternativa3d::next = local28;
} else {
local25.alternativa3d::wrapper = local28;
}
local27 = local28;
}
local19 = local20;
local18 = local18.alternativa3d::next;
}
local24.material = local16.material;
local24.alternativa3d::calculateBestSequenceAndNormal();
if(local14 != null) {
local14.alternativa3d::next = local24;
} else {
local12.alternativa3d::faceList = local24;
}
local14 = local24;
local25.material = local16.material;
local25.alternativa3d::calculateBestSequenceAndNormal();
if(local15 != null) {
local15.alternativa3d::next = local25;
} else {
local13.alternativa3d::faceList = local25;
}
local15 = local25;
}
local16 = local17;
}
if(local14 != null) {
local14.alternativa3d::next = null;
++local12.alternativa3d::transformId;
local12.collectVertices();
local12.calculateBounds();
local5[0] = local12;
}
if(local15 != null) {
local15.alternativa3d::next = null;
++local13.alternativa3d::transformId;
local13.collectVertices();
local13.calculateBounds();
local5[1] = local13;
}
return local5;
}
private function collectVertices() : void {
var local2:Wrapper = null;
var local3:Vertex = null;
var local1:Face = this.alternativa3d::faceList;
while(local1 != null) {
local2 = local1.alternativa3d::wrapper;
while(local2 != null) {
local3 = local2.alternativa3d::vertex;
if(local3.alternativa3d::transformId != alternativa3d::transformId) {
local3.alternativa3d::next = this.alternativa3d::vertexList;
this.alternativa3d::vertexList = local3;
local3.alternativa3d::transformId = alternativa3d::transformId;
local3.alternativa3d::value = null;
}
local2 = local2.alternativa3d::next;
}
local1 = local1.alternativa3d::next;
}
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _f9fe0ba47b8f509cc1d66a3d8eca940754b1802ff534a5bacc50647ec4973a30_flash_display_Sprite extends Sprite {
public function _f9fe0ba47b8f509cc1d66a3d8eca940754b1802ff534a5bacc50647ec4973a30_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package projects.tanks.client.battlefield.models.user.tank {
public class TankLogicState {
public static const NEW:TankLogicState = new TankLogicState(0,"NEW");
public static const OUT_OF_GAME:TankLogicState = new TankLogicState(1,"OUT_OF_GAME");
public static const ACTIVATING:TankLogicState = new TankLogicState(2,"ACTIVATING");
public static const ACTIVE:TankLogicState = new TankLogicState(3,"ACTIVE");
public static const DEAD:TankLogicState = new TankLogicState(4,"DEAD");
private var _value:int;
private var _name:String;
public function TankLogicState(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<TankLogicState> {
var local1:Vector.<TankLogicState> = new Vector.<TankLogicState>();
local1.push(NEW);
local1.push(OUT_OF_GAME);
local1.push(ACTIVATING);
local1.push(ACTIVE);
local1.push(DEAD);
return local1;
}
public function toString() : String {
return "TankLogicState [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.model.garage.upgrade {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class FlushUpgradesEvents implements FlushUpgrades {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function FlushUpgradesEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function flushToServer(param1:DelayUpgrades, param2:IGameObject) : void {
var i:int = 0;
var m:FlushUpgrades = null;
var delayUpgrades:DelayUpgrades = param1;
var item:IGameObject = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = FlushUpgrades(this.impl[i]);
m.flushToServer(delayUpgrades,item);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.engine3d.loaders.collada {
use namespace collada;
public class DaeImage extends DaeElement {
public function DaeImage(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
public function get init_from() : String {
var local2:XML = null;
var local1:XML = data.init_from[0];
if(local1 != null) {
if(document.versionMajor > 4) {
local2 = local1.ref[0];
return local2 == null ? null : local2.text().toString();
}
return local1.text().toString();
}
return null;
}
}
}
|
package alternativa.tanks.camera
{
import alternativa.console.ConsoleVarFloat;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
public class ProjectileHitCameraModifier implements ICameraStateModifier
{
private static var amplitude:ConsoleVarFloat;
private static var swayAmplitude:ConsoleVarFloat;
private static var time1:ConsoleVarFloat;
private static var time2:ConsoleVarFloat;
private static var m:Matrix3 = new Matrix3();
private static var m1:Matrix3 = new Matrix3();
private var hitDirection:Vector3;
private var swayAxis:Vector3;
private var power:Number;
private var t:Number;
private var state:int;
public function ProjectileHitCameraModifier()
{
this.hitDirection = new Vector3();
this.swayAxis = new Vector3();
super();
}
public static function initVars() : void
{
amplitude = new ConsoleVarFloat("hitcam_ampl",50,-1000,1000);
swayAmplitude = new ConsoleVarFloat("hitcam_sway",-0.05,-10,10);
time1 = new ConsoleVarFloat("hitcam_time1",0.1,0,10);
time2 = new ConsoleVarFloat("hitcam_time2",0.5,0,10);
}
public function init(direction:Vector3, power:Number) : void
{
this.hitDirection.vCopy(direction);
this.power = power;
this.swayAxis.vReset(this.hitDirection.y,-this.hitDirection.x,0).vNormalize();
this.t = 0;
this.state = 0;
}
public function update(time:int, delta:int, position:Vector3, rotation:Vector3) : Boolean
{
var x:Number = NaN;
var omega:Number = NaN;
var alpha:Number = NaN;
this.t += delta * 0.001;
switch(this.state)
{
case 0:
if(this.t > time1.value)
{
this.t = time1.value;
this.state = 1;
}
x = Math.sin(Math.PI / 2 / time1.value * this.t);
break;
case 1:
if(this.t > time2.value)
{
this.t = time2.value;
this.state = 2;
}
omega = Math.PI / (time2.value - time1.value);
alpha = Math.PI * time1.value / (time1.value - time2.value);
x = 0.5 * (1 + Math.cos(omega * this.t + alpha));
break;
case 2:
return false;
}
position.vAddScaled(x * amplitude.value * this.power,this.hitDirection);
m.setRotationMatrix(rotation.x,rotation.y,rotation.z);
m1.fromAxisAngle(this.swayAxis,x * swayAmplitude.value * this.power);
m.append(m1);
m.getEulerAngles(rotation);
return true;
}
public function onAddedToController(controller:IFollowCameraController) : void
{
}
public function destroy() : void
{
}
}
}
|
package _codec.projects.tanks.client.chat.models.chat.chat {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.chat.models.chat.chat.ChatCC;
public class VectorCodecChatCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecChatCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ChatCC,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<ChatCC> = new Vector.<ChatCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ChatCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ChatCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ChatCC> = Vector.<ChatCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.model.item.info {
import flash.display.DisplayObjectContainer;
import flash.events.IEventDispatcher;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ItemActionPanelEvents implements ItemActionPanel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ItemActionPanelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function updateActionElements(param1:DisplayObjectContainer, param2:IEventDispatcher) : void {
var i:int = 0;
var m:ItemActionPanel = null;
var actionContainer:DisplayObjectContainer = param1;
var garageWindowDispatcher:IEventDispatcher = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ItemActionPanel(this.impl[i]);
m.updateActionElements(actionContainer,garageWindowDispatcher);
i++;
}
}
finally {
Model.popObject();
}
}
public function handleDoubleClickOnItemPreview() : void {
var i:int = 0;
var m:ItemActionPanel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ItemActionPanel(this.impl[i]);
m.handleDoubleClickOnItemPreview();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank17.png")]
public class PremiumRankBitmaps_bitmapSmallRank17 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank17() {
super();
}
}
}
|
package alternativa.osgi.service.dump.dumper
{
import alternativa.init.OSGi;
import alternativa.osgi.bundle.Bundle;
public class BundleDumper implements IDumper
{
private var osgi:OSGi;
public function BundleDumper(osgi:OSGi)
{
super();
this.osgi = osgi;
}
public function dump(params:Vector.<String>) : String
{
var result:String = "\n";
var bundles:Vector.<Bundle> = this.osgi.bundleList;
for(var i:int = 0; i < bundles.length; i++)
{
result += " bundle " + (i + 1).toString() + ": " + bundles[i].name + "\n";
}
return result + "\n";
}
public function get dumperName() : String
{
return "bundle";
}
}
}
|
package projects.tanks.client.commons.models.externalauth {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class ExternalAuthApiModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ExternalAuthApiModelServer;
private var client:IExternalAuthApiModelBase = IExternalAuthApiModelBase(this);
private var modelId:Long = Long.getLong(1069448555,141534959);
public function ExternalAuthApiModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ExternalAuthApiModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.weapon.artillery {
import alternativa.tanks.battle.objects.tank.tankskin.turret.ArtilleryTurretSkin;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ArtillerySkinAdapt implements ArtillerySkin {
private var object:IGameObject;
private var impl:ArtillerySkin;
public function ArtillerySkinAdapt(param1:IGameObject, param2:ArtillerySkin) {
super();
this.object = param1;
this.impl = param2;
}
public function getSkin() : ArtilleryTurretSkin {
var result:ArtilleryTurretSkin = null;
try {
Model.object = this.object;
result = this.impl.getSkin();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package platform.loading.codecs {
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.core.general.spaces.loading.modelconstructors.ModelData;
import platform.client.fp10.core.registry.ModelRegistry;
public class ModelDataCodec implements ICodec {
[Inject]
public static var clientLog:IClientLog;
[Inject]
public static var modelRegister:ModelRegistry;
private var longCodec:ICodec;
public function ModelDataCodec() {
super();
}
public function init(param1:IProtocol) : void {
this.longCodec = param1.getCodec(new TypeCodecInfo(Long,false));
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:Object = null;
var local3:Long = Long(this.longCodec.decode(param1));
if(local3.low == 0 && local3.high == 0) {
return new ModelData(this.longCodec.decode(param1),local3);
}
var local4:ICodec = modelRegister.getModelConstructorCodec(local3);
if(local4 == null) {
throw new Error("Constructor codec not found for model " + local3);
}
local2 = local4.decode(param1);
return new ModelData(local2,local3);
}
}
}
|
package alternativa.tanks.model.payment.category {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class PayFullDescriptionEvents implements PayFullDescription {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function PayFullDescriptionEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getFullDescription() : String {
var result:String = null;
var i:int = 0;
var m:PayFullDescription = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayFullDescription(this.impl[i]);
result = m.getFullDescription();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.gui.category {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.category.ItemCategoryButton_discountIconClass.png")]
public class ItemCategoryButton_discountIconClass extends BitmapAsset {
public function ItemCategoryButton_discountIconClass() {
super();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.notifier {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class NotifierEvents implements Notifier {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function NotifierEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function subscribe(param1:Long, param2:UserInfoConsumer) : void {
var i:int = 0;
var m:Notifier = null;
var userId:Long = param1;
var consumer:UserInfoConsumer = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = Notifier(this.impl[i]);
m.subscribe(userId,consumer);
i++;
}
}
finally {
Model.popObject();
}
}
public function unSubscribe(param1:Long) : void {
var i:int = 0;
var m:Notifier = null;
var userId:Long = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = Notifier(this.impl[i]);
m.unSubscribe(userId);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_bitmapArea.png")]
public class ItemInfoPanelBitmaps_bitmapArea extends BitmapAsset {
public function ItemInfoPanelBitmaps_bitmapArea() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.ricochet
{
import alternativa.math.Vector3;
import alternativa.physics.Body;
public interface IRicochetShotListener
{
function shotHit(param1:RicochetShot, param2:Vector3, param3:Vector3, param4:Body) : void;
}
}
|
package _codec.projects.tanks.client.garage.models.item.itempersonaldiscount {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.itempersonaldiscount.DiscountData;
public class CodecDiscountData implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_discountForPercent:ICodec;
private var codec_duration:ICodec;
public function CodecDiscountData() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_discountForPercent = param1.getCodec(new TypeCodecInfo(Number,false));
this.codec_duration = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:DiscountData = new DiscountData();
local2.discountForPercent = this.codec_discountForPercent.decode(param1) as Number;
local2.duration = this.codec_duration.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:DiscountData = DiscountData(param2);
this.codec_discountForPercent.encode(param1,local3.discountForPercent);
this.codec_duration.encode(param1,local3.duration);
}
}
}
|
package _codec.projects.tanks.client.panel.model.quest.daily {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.panel.model.quest.common.specification.QuestLevel;
import projects.tanks.client.panel.model.quest.daily.DailyQuestInfo;
import projects.tanks.client.panel.model.quest.showing.QuestPrizeInfo;
public class CodecDailyQuestInfo implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_canSkipForFree:ICodec;
private var codec_description:ICodec;
private var codec_finishCriteria:ICodec;
private var codec_image:ICodec;
private var codec_level:ICodec;
private var codec_prizes:ICodec;
private var codec_progress:ICodec;
private var codec_questId:ICodec;
private var codec_skipCost:ICodec;
public function CodecDailyQuestInfo() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_canSkipForFree = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_description = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_finishCriteria = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_image = param1.getCodec(new TypeCodecInfo(ImageResource,false));
this.codec_level = param1.getCodec(new EnumCodecInfo(QuestLevel,false));
this.codec_prizes = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(QuestPrizeInfo,false),false,1));
this.codec_progress = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_questId = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_skipCost = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:DailyQuestInfo = new DailyQuestInfo();
local2.canSkipForFree = this.codec_canSkipForFree.decode(param1) as Boolean;
local2.description = this.codec_description.decode(param1) as String;
local2.finishCriteria = this.codec_finishCriteria.decode(param1) as int;
local2.image = this.codec_image.decode(param1) as ImageResource;
local2.level = this.codec_level.decode(param1) as QuestLevel;
local2.prizes = this.codec_prizes.decode(param1) as Vector.<QuestPrizeInfo>;
local2.progress = this.codec_progress.decode(param1) as int;
local2.questId = this.codec_questId.decode(param1) as Long;
local2.skipCost = this.codec_skipCost.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:DailyQuestInfo = DailyQuestInfo(param2);
this.codec_canSkipForFree.encode(param1,local3.canSkipForFree);
this.codec_description.encode(param1,local3.description);
this.codec_finishCriteria.encode(param1,local3.finishCriteria);
this.codec_image.encode(param1,local3.image);
this.codec_level.encode(param1,local3.level);
this.codec_prizes.encode(param1,local3.prizes);
this.codec_progress.encode(param1,local3.progress);
this.codec_questId.encode(param1,local3.questId);
this.codec_skipCost.encode(param1,local3.skipCost);
}
}
}
|
package com.lorentz.SVG.text
{
import com.lorentz.SVG.data.text.SVGDrawnText;
import com.lorentz.SVG.data.text.SVGTextToDraw;
public interface ISVGTextDrawer
{
function start():void;
function drawText(data:SVGTextToDraw):SVGDrawnText;
function end():void;
}
}
|
package projects.tanks.client.battlefield.models.inventory.item {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class InventoryItemModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _activateId:Long = Long.getLong(2114234791,-757663181);
private var model:IModel;
public function InventoryItemModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
public function activate() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._activateId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.view.matchmaking {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.matchmaking.MatchmakingRegistrationDialog_headerImageClass.png")]
public class MatchmakingRegistrationDialog_headerImageClass extends BitmapAsset {
public function MatchmakingRegistrationDialog_headerImageClass() {
super();
}
}
}
|
package alternativa.osgi.service.alert
{
public interface IAlertService
{
function showAlert(param1:String) : void;
}
}
|
package projects.tanks.client.commons.models.layout {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class LobbyLayoutModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _exitFromBattleId:Long = Long.getLong(1387513260,693463006);
private var _exitFromBattle_destinationStateCodec:ICodec;
private var _exitFromBattleToBattleLobbyId:Long = Long.getLong(73829140,-1375051077);
private var _returnToBattleId:Long = Long.getLong(1138854804,134191231);
private var _setBattleLobbyLayoutId:Long = Long.getLong(1012623991,419219676);
private var _setBattleLobbyLayout_showBattleSelectCodec:ICodec;
private var _showBattleSelectId:Long = Long.getLong(1126321820,-1868105487);
private var _showClanId:Long = Long.getLong(1992372558,39777135);
private var _showGarageId:Long = Long.getLong(885385769,533734050);
private var _showMatchmakingId:Long = Long.getLong(1835349208,-421772949);
private var model:IModel;
public function LobbyLayoutModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._exitFromBattle_destinationStateCodec = this.protocol.getCodec(new EnumCodecInfo(LayoutState,false));
this._setBattleLobbyLayout_showBattleSelectCodec = this.protocol.getCodec(new TypeCodecInfo(Boolean,false));
}
public function exitFromBattle(param1:LayoutState) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._exitFromBattle_destinationStateCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._exitFromBattleId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function exitFromBattleToBattleLobby() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._exitFromBattleToBattleLobbyId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
public function returnToBattle() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._returnToBattleId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
public function setBattleLobbyLayout(param1:Boolean) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._setBattleLobbyLayout_showBattleSelectCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._setBattleLobbyLayoutId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function showBattleSelect() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._showBattleSelectId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
public function showClan() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._showClanId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
public function showGarage() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._showGarageId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
public function showMatchmaking() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._showMatchmakingId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.battle.activator {
import alternativa.types.Long;
import flash.events.Event;
public class BattleLinkAliveEvent extends Event {
public static const IS_ALIVE:String = "BattleLinkAliveEvent.IS_ALIVE";
public static const ALIVE:String = "BattleLinkAliveEvent.ALIVE";
public static const DEAD:String = "BattleLinkAliveEvent.DEAD";
public var battleId:Long;
public function BattleLinkAliveEvent(param1:String, param2:Long, param3:Boolean = false, param4:Boolean = false) {
this.battleId = param2;
super(param1,param3,param4);
}
}
}
|
package alternativa.tanks.models.weapons.shell {
import alternativa.math.Vector3;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ShellWeaponListenerEvents implements ShellWeaponListener {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ShellWeaponListenerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function onShot(param1:int, param2:int, param3:Vector3) : void {
var i:int = 0;
var m:ShellWeaponListener = null;
var barrelIndex:int = param1;
var shotId:int = param2;
var direction:Vector3 = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShellWeaponListener(this.impl[i]);
m.onShot(barrelIndex,shotId,direction);
i++;
}
}
finally {
Model.popObject();
}
}
public function onDummyShot(param1:int) : void {
var i:int = 0;
var m:ShellWeaponListener = null;
var barrelIndex:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShellWeaponListener(this.impl[i]);
m.onDummyShot(barrelIndex);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.sfx.colortransform {
import projects.tanks.client.battlefield.models.tankparts.sfx.colortransform.struct.ColorTransformStruct;
public class ColorTransformEntry {
public var t:Number;
public var redMultiplier:Number;
public var greenMultiplier:Number;
public var blueMultiplier:Number;
public var alphaMultiplier:Number;
public var redOffset:int;
public var greenOffset:int;
public var blueOffset:int;
public var alphaOffset:int;
public function ColorTransformEntry(param1:ColorTransformStruct) {
super();
this.t = param1.t;
this.redMultiplier = param1.redMultiplier;
this.greenMultiplier = param1.greenMultiplier;
this.blueMultiplier = param1.blueMultiplier;
this.alphaMultiplier = param1.alphaMultiplier;
this.redOffset = param1.redOffset;
this.greenOffset = param1.greenOffset;
this.blueOffset = param1.blueOffset;
this.alphaOffset = param1.alphaOffset;
}
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased.flag {
public class ClientFlagFlyingData {
private var _currentTime:int;
private var _falling:Boolean;
private var _points:Vector.<FlagFlyPoint>;
public function ClientFlagFlyingData(param1:int = 0, param2:Boolean = false, param3:Vector.<FlagFlyPoint> = null) {
super();
this._currentTime = param1;
this._falling = param2;
this._points = param3;
}
public function get currentTime() : int {
return this._currentTime;
}
public function set currentTime(param1:int) : void {
this._currentTime = param1;
}
public function get falling() : Boolean {
return this._falling;
}
public function set falling(param1:Boolean) : void {
this._falling = param1;
}
public function get points() : Vector.<FlagFlyPoint> {
return this._points;
}
public function set points(param1:Vector.<FlagFlyPoint>) : void {
this._points = param1;
}
public function toString() : String {
var local1:String = "ClientFlagFlyingData [";
local1 += "currentTime = " + this.currentTime + " ";
local1 += "falling = " + this.falling + " ";
local1 += "points = " + this.points + " ";
return local1 + "]";
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.