code
stringlengths 57
237k
|
|---|
package alternativa.tanks.models.battle.battlefield {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.ViewportBorder_bmpClassCorner3.png")]
public class ViewportBorder_bmpClassCorner3 extends BitmapAsset {
public function ViewportBorder_bmpClassCorner3() {
super();
}
}
}
|
package projects.tanks.client.battlefield.bonus.randomgold.notification {
import platform.client.fp10.core.type.IGameObject;
public interface IRandomGoldBonusTakeModelBase {
function showBonusNotification(param1:String, param2:IGameObject, param3:String, param4:String) : void;
}
}
|
package utils.tweener.easing {
public class Elastic {
private static const _2PI:Number = Math.PI * 2;
public function Elastic() {
super();
}
public static function easeIn(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number = 0, param6:Number = 0) : Number {
var local7:Number = NaN;
if(param1 == 0) {
return param2;
}
param1 = param1 / param4;
if(param1 == 1) {
return param2 + param3;
}
if(!param6) {
param6 = param4 * 0.3;
}
if(!param5 || param3 > 0 && param5 < param3 || param3 < 0 && param5 < -param3) {
param5 = param3;
local7 = param6 / 4;
} else {
local7 = param6 / _2PI * Math.asin(param3 / param5);
}
return -(param5 * Math.pow(2,10 * (param1 = param1 - 1)) * Math.sin((param1 * param4 - local7) * _2PI / param6)) + param2;
}
public static function easeOut(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number = 0, param6:Number = 0) : Number {
var local7:Number = NaN;
if(param1 == 0) {
return param2;
}
param1 = param1 / param4;
if(param1 == 1) {
return param2 + param3;
}
if(!param6) {
param6 = param4 * 0.3;
}
if(!param5 || param3 > 0 && param5 < param3 || param3 < 0 && param5 < -param3) {
param5 = param3;
local7 = param6 / 4;
} else {
local7 = param6 / _2PI * Math.asin(param3 / param5);
}
return param5 * Math.pow(2,-10 * param1) * Math.sin((param1 * param4 - local7) * _2PI / param6) + param3 + param2;
}
public static function easeInOut(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number = 0, param6:Number = 0) : Number {
var local7:Number = NaN;
if(param1 == 0) {
return param2;
}
param1 = param1 / (param4 * 0.5);
if(param1 == 2) {
return param2 + param3;
}
if(!param6) {
param6 = param4 * (0.3 * 1.5);
}
if(!param5 || param3 > 0 && param5 < param3 || param3 < 0 && param5 < -param3) {
param5 = param3;
local7 = param6 / 4;
} else {
local7 = param6 / _2PI * Math.asin(param3 / param5);
}
if(param1 < 1) {
return -0.5 * (param5 * Math.pow(2,10 * (param1 = param1 - 1)) * Math.sin((param1 * param4 - local7) * _2PI / param6)) + param2;
}
return param5 * Math.pow(2,-10 * (param1 = param1 - 1)) * Math.sin((param1 * param4 - local7) * _2PI / param6) * 0.5 + param3 + param2;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation {
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.weapons.artillery.rotation.ArtilleryElevatingBarrelCC;
public class VectorCodecArtilleryElevatingBarrelCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecArtilleryElevatingBarrelCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ArtilleryElevatingBarrelCC,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.<ArtilleryElevatingBarrelCC> = new Vector.<ArtilleryElevatingBarrelCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ArtilleryElevatingBarrelCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ArtilleryElevatingBarrelCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ArtilleryElevatingBarrelCC> = Vector.<ArtilleryElevatingBarrelCC>(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.garage.models.item.itemforpartners {
public interface IItemEnabledForPartnerModelBase {
}
}
|
package forms.friends
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
import alternativa.tanks.model.Friend;
import controls.TankWindowInner;
import controls.base.LabelBase;
import controls.base.TankInputBase;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.FocusEvent;
import flash.events.MouseEvent;
import flash.geom.Point;
import flash.net.URLLoader;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import forms.TankWindowWithHeader;
import forms.events.LoginFormEvent;
import forms.friends.list.AcceptedList;
import forms.friends.list.IncomingList;
import forms.friends.list.OutcomingList;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
public class FriendsWindow extends Sprite
{
[Inject]
public static var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
public static const WINDOW_MARGIN:int = 12;
public static const DEFAULT_BUTTON_WIDTH:int = 100;
private static const WINDOW_WIDTH:int = 468 + WINDOW_MARGIN * 2 + 4;
private static const WINDOW_HEIGHT:int = 485;
private static const SEARCH_TIMEOUT:int = 600;
public static var bu:Network;
public static var bup:Sprite = new Sprite();
private var netLoader:URLLoader;
private var _window:TankWindowWithHeader;
private var _windowInner:TankWindowInner;
public var _windowSize:Point;
private var _acceptedButton:FriendsWindowStateBigButton;
private var _outgoingButton:FriendsWindowStateBigButton;
private var _incomingButton:FriendsWindowStateBigButton;
public var _closeButton:FriendWindowButton;
private var _rejectAllIncomingButton:RejectAllIncomingButton;
private var _addFriendButton:RejectAllIncomingButton;
private var _acceptedList:AcceptedList;
private var _outcomingList:OutcomingList;
private var _incomingList:IncomingList;
private var _currentList:IFriendsListState;
private var _searchInListTextInput:TankInputBase;
private var _addFriendtTextInput:TankInputBase;
private var _searchInListLabel:LabelBase;
private var _searchInListTimeOut:uint;
private var _addRequestView:AddRequestView;
private var hh:Boolean = false;
public function FriendsWindow(param1:Network)
{
super();
this.init();
bu = param1;
}
private function init() : void
{
this._window = TankWindowWithHeader.createWindow(localeService.getText(TextConst.FRIENDS_WINDOW_TEXT).toLocaleUpperCase());
addChild(this._window);
this._windowSize = new Point(WINDOW_WIDTH,WINDOW_HEIGHT);
this._windowInner = new TankWindowInner(0,0,TankWindowInner.GREEN);
addChild(this._windowInner);
this._acceptedButton = new FriendsWindowStateBigButton(FriendsWindowState.ACCEPTED);
addChild(this._acceptedButton);
this._acceptedButton.label = localeService.getText(TextConst.FRIENDS_WINDOW_TEXT);
this._acceptedButton.addEventListener(MouseEvent.CLICK,this.onChangeState);
this._outgoingButton = new FriendsWindowStateBigButton(FriendsWindowState.OUTCOMING);
addChild(this._outgoingButton);
this._outgoingButton.label = localeService.getText(TextConst.FRIENDS_WINDOW_OUTCOMING_LIST);
this._outgoingButton.addEventListener(MouseEvent.CLICK,this.onChangeState);
this._incomingButton = new FriendsWindowStateBigButton(FriendsWindowState.INCOMING);
addChild(this._incomingButton);
this._incomingButton.label = localeService.getText(TextConst.FRIENDS_WINDOW_INCOMING_LIST);
this._incomingButton.addEventListener(MouseEvent.CLICK,this.onChangeState);
this._rejectAllIncomingButton = new RejectAllIncomingButton();
addChild(this._rejectAllIncomingButton);
this._rejectAllIncomingButton.label = localeService.getText(TextConst.FRIENDS_WINDOW_REJECT_ALL);
this._rejectAllIncomingButton.addEventListener(MouseEvent.CLICK,this.onClickRejectAllIncoming);
this._addFriendButton = new RejectAllIncomingButton();
addChild(this._addFriendButton);
this._addFriendButton.label = localeService.getText(TextConst.FRIENDS_WINDOW_SEND_INVITE);
this._addFriendButton.addEventListener(MouseEvent.CLICK,this.onClickAddFriend);
this._acceptedList = new AcceptedList();
this._incomingList = new IncomingList(this._rejectAllIncomingButton);
this._outcomingList = new OutcomingList();
this._closeButton = new FriendWindowButton();
addChild(this._closeButton);
this._closeButton.label = localeService.getText(TextConst.FREE_BONUSES_WINDOW_BUTTON_CLOSE_TEXT);
this._searchInListTextInput = new TankInputBase();
this._searchInListTextInput.maxChars = 20;
this._searchInListTextInput.restrict = "0-9.a-zA-z_\\-*";
addChild(this._searchInListTextInput);
this._addFriendtTextInput = new TankInputBase();
this._addFriendtTextInput.maxChars = 20;
this._addFriendtTextInput.restrict = "0-9.a-zA-z_\\-*";
addChild(this._addFriendtTextInput);
this._searchInListTextInput.addEventListener(FocusEvent.FOCUS_IN,this.onFocusInSearchInList);
this._searchInListTextInput.addEventListener(FocusEvent.FOCUS_OUT,this.onFocusOutSearchInList);
this._searchInListTextInput.addEventListener(LoginFormEvent.TEXT_CHANGED,this.onTextChangeSearchInList);
this._searchInListLabel = new LabelBase();
addChild(this._searchInListLabel);
this._searchInListLabel.mouseEnabled = false;
this._searchInListLabel.color = 10987948;
this._searchInListLabel.text = localeService.getText(TextConst.FRIENDS_WINDOW_SEARCH_IN_LIST);
this._addRequestView = new AddRequestView(bu);
addChild(this._addRequestView);
this.resize();
this.show(FriendsWindowState.ACCEPTED);
}
public function removeFriends() : void
{
this._acceptedList.onRemoveFromFriends();
}
public function updateList() : void
{
this._acceptedList.onRemoveFromFriends();
this._outcomingList.onRemoveFromFriends();
this._incomingList.onRemoveFromFriends();
this._currentList.initList();
}
private function onClickRejectAllIncoming(event:MouseEvent) : void
{
var obj:Object = null;
for each(obj in JSON.parse(Friend.friends).incoming)
{
Network(Main.osgi.getService(INetworker)).send("lobby;deny_friend;" + obj.id);
}
}
private function onClickAddFriend(event:MouseEvent) : void
{
Network(Main.osgi.getService(INetworker)).send("lobby;make_friend;" + this._addFriendtTextInput.value);
}
private function onConfirmRejectAllIncoming(event:MouseEvent) : void
{
}
private function onTextChangeSearchInList(event:LoginFormEvent) : void
{
if(this._searchInListTextInput.value.length > 0)
{
this._searchInListLabel.visible = false;
}
clearTimeout(this._searchInListTimeOut);
this._searchInListTimeOut = setTimeout(this._currentList.filter,SEARCH_TIMEOUT,"uid",this._searchInListTextInput.value);
this.updateVisibleSearchInListLabel();
}
private function onFocusInSearchInList(event:FocusEvent) : void
{
this._searchInListLabel.visible = false;
}
private function onFocusOutSearchInList(event:FocusEvent) : void
{
this.updateVisibleSearchInListLabel();
}
private function updateVisibleSearchInListLabel() : void
{
if(this._searchInListTextInput.value.length == 0)
{
this._searchInListLabel.visible = true;
}
}
private function onBattleLinkClick(event:MouseEvent) : void
{
this.hide();
}
private function resize() : void
{
this._window.width = this._windowSize.x;
this._window.height = this._windowSize.y;
this._acceptedButton.width = DEFAULT_BUTTON_WIDTH;
this._acceptedButton.x = WINDOW_MARGIN;
this._acceptedButton.y = WINDOW_MARGIN;
this._incomingButton.width = DEFAULT_BUTTON_WIDTH + 50;
this._incomingButton.x = this._windowSize.x - this._incomingButton.width - WINDOW_MARGIN;
this._incomingButton.y = WINDOW_MARGIN;
this._outgoingButton.width = DEFAULT_BUTTON_WIDTH + 50;
this._outgoingButton.x = this._incomingButton.x - this._outgoingButton.width - 6;
this._outgoingButton.y = WINDOW_MARGIN;
this._closeButton.width = DEFAULT_BUTTON_WIDTH;
this._closeButton.x = this._windowSize.x - this._closeButton.width - WINDOW_MARGIN;
this._closeButton.y = this._windowSize.y - this._closeButton.height - WINDOW_MARGIN;
this._rejectAllIncomingButton.width = DEFAULT_BUTTON_WIDTH;
this._rejectAllIncomingButton.x = this._closeButton.x - this._rejectAllIncomingButton.width - 6;
this._rejectAllIncomingButton.y = this._windowSize.y - this._rejectAllIncomingButton.height - WINDOW_MARGIN;
this._addFriendButton.width = DEFAULT_BUTTON_WIDTH;
this._addFriendButton.x = this._closeButton.x - this._addFriendButton.width - 6;
this._addFriendButton.y = this._windowSize.y - this._addFriendButton.height - WINDOW_MARGIN;
this._windowInner.x = WINDOW_MARGIN;
this._windowInner.y = this._acceptedButton.y + this._acceptedButton.height + 1;
this._windowInner.width = this._windowSize.x - WINDOW_MARGIN * 2;
this._windowInner.height = this._windowSize.y - this._windowInner.y - this._closeButton.height - 18;
var _loc2_:int = this._windowInner.x + 4;
var _loc3_:int = this._windowInner.y + 4;
var _loc4_:int = this._windowInner.width - 4 * 2 + 2;
var _loc5_:int = this._windowInner.height - 4 * 2;
this._acceptedList.resize(_loc4_,_loc5_);
this._acceptedList.x = _loc2_;
this._acceptedList.y = _loc3_;
this._incomingList.resize(_loc4_,_loc5_);
this._incomingList.x = _loc2_;
this._incomingList.y = _loc3_;
this._outcomingList.resize(_loc4_,_loc5_);
this._outcomingList.x = _loc2_;
this._outcomingList.y = _loc3_;
this._searchInListTextInput.width = 235;
this._searchInListTextInput.x = WINDOW_MARGIN;
this._searchInListTextInput.y = this._windowSize.y - this._searchInListTextInput.height - WINDOW_MARGIN;
this._addFriendtTextInput.width = 235;
this._addFriendtTextInput.x = WINDOW_MARGIN;
this._addFriendtTextInput.y = this._windowSize.y - this._addFriendtTextInput.height - WINDOW_MARGIN;
this._searchInListLabel.x = this._searchInListTextInput.x + 3;
this._searchInListLabel.y = this._searchInListTextInput.y + 7;
this._addRequestView.y = this._windowSize.y - this._addRequestView.height - WINDOW_MARGIN;
}
private function onChangeState(event:MouseEvent) : void
{
this.hh = !this.hh;
this.show(FriendsWindowButtonType(event.currentTarget).getType());
}
public function destroy() : void
{
this._acceptedButton.removeEventListener(MouseEvent.CLICK,this.onChangeState);
this._outgoingButton.removeEventListener(MouseEvent.CLICK,this.onChangeState);
this._incomingButton.removeEventListener(MouseEvent.CLICK,this.onChangeState);
this._searchInListTextInput.removeEventListener(FocusEvent.FOCUS_IN,this.onFocusInSearchInList);
this._searchInListTextInput.removeEventListener(FocusEvent.FOCUS_OUT,this.onFocusOutSearchInList);
this._rejectAllIncomingButton.removeEventListener(MouseEvent.CLICK,this.onClickRejectAllIncoming);
this.hide();
}
private function hide() : void
{
if(this._closeButton.hasEventListener(MouseEvent.CLICK))
{
this._closeButton.removeEventListener(MouseEvent.CLICK,this.onCloseButtonClick);
}
if(this._currentList != null)
{
this._currentList.hide();
this._currentList = null;
}
clearTimeout(this._searchInListTimeOut);
this._addRequestView.hide();
}
private function job(param1:Event) : void
{
this.hide();
if(this.hh)
{
FriendsWindowState.INCOMING = new FriendsWindowState(1);
this.show(FriendsWindowState.INCOMING);
}
else
{
FriendsWindowState.ACCEPTED = new FriendsWindowState(0);
this.show(FriendsWindowState.ACCEPTED);
}
}
private function getFriendsListByState(param1:FriendsWindowState) : IFriendsListState
{
switch(param1)
{
case FriendsWindowState.ACCEPTED:
return this._acceptedList;
case FriendsWindowState.INCOMING:
return this._incomingList;
case FriendsWindowState.OUTCOMING:
return this._outcomingList;
default:
return this._acceptedList;
}
}
public function show(param1:FriendsWindowState = null) : void
{
switch(param1)
{
case FriendsWindowState.ACCEPTED:
this.showAccepted();
break;
case FriendsWindowState.INCOMING:
this.showIncoming();
break;
case FriendsWindowState.OUTCOMING:
this.showOutgoing();
}
this._searchInListTextInput.value = "";
this._addFriendtTextInput.value = "";
this._currentList.resetFilter();
}
private function showAccepted() : void
{
this.updateState(FriendsWindowState.ACCEPTED);
this._acceptedList.initList();
addChild(this._acceptedList);
this._currentList = this._acceptedList;
}
private function showIncoming() : void
{
this.updateState(FriendsWindowState.INCOMING);
this._incomingList.initList();
addChild(this._incomingList);
this._currentList = this._incomingList;
}
private function showOutgoing() : void
{
this.updateState(FriendsWindowState.OUTCOMING);
this._outcomingList.initList();
addChild(this._outcomingList);
this._currentList = this._outcomingList;
}
private function updateState(state:FriendsWindowState) : void
{
this.currentState = state;
if(this._currentList != null)
{
this._currentList.hide();
this._currentList = null;
}
if(!this._closeButton.hasEventListener(MouseEvent.CLICK))
{
this._closeButton.addEventListener(MouseEvent.CLICK,this.onCloseButtonClick);
}
}
private function onCloseButtonClick(event:MouseEvent = null) : void
{
this.closeWindow();
}
private function closeWindow() : void
{
this._searchInListTextInput.value = "";
this.updateVisibleSearchInListLabel();
this.hide();
}
public function set currentState(value:FriendsWindowState) : void
{
switch(value)
{
case FriendsWindowState.ACCEPTED:
this._acceptedButton.enable = false;
this._outgoingButton.enable = true;
this._incomingButton.enable = true;
this._rejectAllIncomingButton.visible = false;
this._searchInListTextInput.visible = true;
this._addFriendButton.visible = false;
this._addFriendtTextInput.visible = false;
this.updateVisibleSearchInListLabel();
this._addRequestView.hide();
break;
case FriendsWindowState.INCOMING:
this._acceptedButton.enable = true;
this._outgoingButton.enable = true;
this._incomingButton.enable = false;
this._rejectAllIncomingButton.visible = true;
this._searchInListTextInput.visible = true;
this._addFriendButton.visible = false;
this._addFriendtTextInput.visible = false;
this.updateVisibleSearchInListLabel();
this._addRequestView.hide();
break;
case FriendsWindowState.OUTCOMING:
this._acceptedButton.enable = true;
this._outgoingButton.enable = false;
this._incomingButton.enable = true;
this._rejectAllIncomingButton.visible = false;
this._searchInListTextInput.visible = false;
this._searchInListLabel.visible = false;
this._addFriendButton.visible = true;
this._addFriendtTextInput.visible = true;
this._addRequestView.hide();
}
}
}
}
|
package alternativa.tanks.models.weapon.smoky.sfx {
import alternativa.tanks.models.weapon.smoky.ISmokyEffects;
[ModelInterface]
public interface ISmokySFXModel {
function getEffects() : ISmokyEffects;
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.billboard {
public interface IBillboardsModelBase {
}
}
|
package alternativa.tanks.utils {
public class NotEncryptedNumber implements EncryptedNumber {
private var value:Number;
public function NotEncryptedNumber(param1:Number = 0) {
super();
this.value = param1;
}
public function setNumber(param1:Number) : void {
this.value = param1;
}
public function getNumber() : Number {
return this.value;
}
}
}
|
package alternativa.tanks.models.weapon.terminator
{
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.collision.ICollisionDetector;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.tanks.models.ctf.ICTFModel;
import alternativa.tanks.models.tank.TankData;
import flash.utils.Dictionary;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
public class TerminatorTargetSystem
{
private static const FLAG_CARRIER_BONUS:Number = 10;
private static const DISTANCE_WEIGHT:Number = 0.65;
private static const BASE_DISTANCE:Number = 20000;
private static const MAX_PRIORITY:Number = 1000;
private const COLLISION_GROUP:int = 16;
private const MAX_RAY_LENGTH:Number = 1.0E10;
private var collisionDetector:ICollisionDetector;
private var upAngleStep:Number;
private var upRaysNum:int;
private var downAngleStep:Number;
private var downRaysNum:int;
private var weakeningCoeff:Number;
private var multybodyPredicate:MultybodyCollisionPredicate;
private var intersection:RayIntersection;
private var dir:Vector3;
private var rotationMatrix:Matrix3;
private var origin:Vector3;
private var _v:Vector3;
private var bestDirectionIndex:int;
private var maxDirectionPriority:Number;
private var bestEffectivity:Number;
private var currTargets:Array;
private var currHitPoints:Array;
private var ctfModel:ICTFModel;
private var maxAngle:Number;
public function TerminatorTargetSystem()
{
this.multybodyPredicate = new MultybodyCollisionPredicate();
this.intersection = new RayIntersection();
this.dir = new Vector3();
this.rotationMatrix = new Matrix3();
this.origin = new Vector3();
this._v = new Vector3();
this.currTargets = [];
this.currHitPoints = [];
super();
}
public function setParams(collisionDetector:ICollisionDetector, upAngle:Number, upRaysNum:int, downAngle:Number, downRaysNum:int, weakeningCoeff:Number, ctfModel:ICTFModel) : void
{
this.collisionDetector = collisionDetector;
this.upAngleStep = upAngle / upRaysNum;
this.upRaysNum = upRaysNum;
this.downAngleStep = downAngle / downRaysNum;
this.downRaysNum = downRaysNum;
this.weakeningCoeff = weakeningCoeff;
this.ctfModel = ctfModel;
this.maxAngle = upAngle > downAngle ? Number(upAngle) : Number(downAngle);
}
public function getTargets(shooterData:TankData, barrelOrigin:Vector3, baseDir:Vector3, rotationAxis:Vector3, tanks:Dictionary, shotResult:TerminatorShotResult) : void
{
shotResult.targets.length = 0;
shotResult.hitPoints.length = 0;
this.bestEffectivity = 0;
this.bestDirectionIndex = 10000;
this.maxDirectionPriority = 0;
this.checkAllDirections(shooterData,barrelOrigin,baseDir,rotationAxis,tanks,shotResult);
if(this.bestEffectivity == 0)
{
this.collectTargetsAlongRay(shooterData,barrelOrigin,baseDir,tanks,shotResult);
}
this.multybodyPredicate.bodies = null;
this.currHitPoints.length = 0;
this.currTargets.length = 0;
}
private function checkAllDirections(shooterData:TankData, barrelOrigin:Vector3, baseDir:Vector3, rotationAxis:Vector3, tanks:Dictionary, shotResult:TerminatorShotResult) : void
{
var i:int = 0;
this.checkDirection(barrelOrigin,baseDir,0,0,shooterData,tanks,shotResult);
this.rotationMatrix.fromAxisAngle(rotationAxis,this.upAngleStep);
this.dir.vCopy(baseDir);
var angle:Number = 0;
for(i = 1; i <= this.upRaysNum; i++)
{
angle += this.upAngleStep;
this.dir.vTransformBy3(this.rotationMatrix);
this.checkDirection(barrelOrigin,this.dir,angle,i,shooterData,tanks,shotResult);
}
this.rotationMatrix.fromAxisAngle(rotationAxis,-this.downAngleStep);
this.dir.vCopy(baseDir);
angle = 0;
for(i = 1; i <= this.downRaysNum; i++)
{
angle += this.downAngleStep;
this.dir.vTransformBy3(this.rotationMatrix);
this.checkDirection(barrelOrigin,this.dir,angle,i,shooterData,tanks,shotResult);
}
}
private function checkDirection(barrelOrigin:Vector3, barrelDir:Vector3, angle:Number, dirIndex:int, shooterData:TankData, tanks:Dictionary, shotResult:TerminatorShotResult) : void
{
var distance:Number = NaN;
var directionPriority:Number = NaN;
var len:int = 0;
var i:int = 0;
this.currTargets.length = 0;
this.currHitPoints.length = 0;
var effectivity:Number = this.evaluateDirection(barrelOrigin,barrelDir,shooterData,tanks,this.currTargets,this.currHitPoints);
if(effectivity > 0)
{
distance = this._v.vDiff(this.currHitPoints[0],barrelOrigin).vLength();
directionPriority = this.getDirectionPriority(angle,distance);
if(effectivity > this.bestEffectivity || effectivity == this.bestEffectivity && directionPriority > this.maxDirectionPriority)
{
this.bestEffectivity = effectivity;
this.bestDirectionIndex = dirIndex;
this.maxDirectionPriority = directionPriority;
shotResult.dir.vCopy(barrelDir);
len = this.currTargets.length;
for(i = 0; i < len; i++)
{
shotResult.targets[i] = this.currTargets[i];
shotResult.hitPoints[i] = this.currHitPoints[i];
}
shotResult.targets.length = len;
if(this.currHitPoints.length > len)
{
shotResult.hitPoints[len] = this.currHitPoints[len];
shotResult.hitPoints.length = len + 1;
}
else
{
shotResult.hitPoints.length = len;
}
}
}
}
private function evaluateDirection(barrelOrigin:Vector3, barrelDir:Vector3, shooterData:TankData, tanks:Dictionary, targets:Array, hitPoints:Array) : Number
{
var body:Body = null;
var targetData:TankData = null;
var targetIsEnemy:Boolean = false;
this.multybodyPredicate.bodies = new Dictionary();
this.multybodyPredicate.bodies[shooterData.tank] = true;
this.origin.vCopy(barrelOrigin);
var effectivity:Number = 0;
var effectivityCoeff:Number = 1;
var firstTarget:Boolean = true;
while(this.collisionDetector.intersectRay(this.origin,barrelDir,this.COLLISION_GROUP,this.MAX_RAY_LENGTH,this.multybodyPredicate,this.intersection))
{
body = this.intersection.primitive.body;
if(body == null)
{
hitPoints.push(this.intersection.pos.vClone());
break;
}
targetData = tanks[body];
if(targetData != null)
{
targetIsEnemy = shooterData.teamType == BattleTeamType.NONE || shooterData.teamType != targetData.teamType;
if(firstTarget)
{
if(targetData.health > 0 && !targetIsEnemy)
{
return 0;
}
firstTarget = false;
}
if(targetData.health > 0)
{
if(targetIsEnemy)
{
if(this.ctfModel != null && this.ctfModel.isFlagCarrier(targetData))
{
effectivity += FLAG_CARRIER_BONUS * effectivityCoeff;
}
else
{
effectivity += effectivityCoeff;
}
}
else
{
effectivity -= effectivityCoeff;
}
}
effectivityCoeff *= this.weakeningCoeff;
targets.push(targetData);
hitPoints.push(this.intersection.pos.vClone());
}
this.multybodyPredicate.bodies[body] = true;
this.origin.vCopy(this.intersection.pos);
}
return effectivity;
}
private function collectTargetsAlongRay(shooterData:TankData, barrelOrigin:Vector3, barrelDir:Vector3, tanks:Dictionary, shotResult:TerminatorShotResult) : void
{
var body:Body = null;
var targetData:TankData = null;
shotResult.hitPoints.length = 0;
shotResult.targets.length = 0;
shotResult.dir.vCopy(barrelDir);
this.multybodyPredicate.bodies = new Dictionary();
this.multybodyPredicate.bodies[shooterData.tank] = true;
this.origin.vCopy(barrelOrigin);
while(this.collisionDetector.intersectRay(this.origin,barrelDir,this.COLLISION_GROUP,this.MAX_RAY_LENGTH,this.multybodyPredicate,this.intersection))
{
body = this.intersection.primitive.body;
if(body == null)
{
shotResult.hitPoints.push(this.intersection.pos.vClone());
break;
}
targetData = tanks[body];
if(targetData != null)
{
shotResult.targets.push(targetData);
shotResult.hitPoints.push(this.intersection.pos.vClone());
}
this.multybodyPredicate.bodies[body] = true;
this.origin.vCopy(this.intersection.pos);
}
}
private function getDirectionPriority(angle:Number, distance:Number) : Number
{
return MAX_PRIORITY - (DISTANCE_WEIGHT * distance / BASE_DISTANCE + (1 - DISTANCE_WEIGHT) * angle / this.maxAngle);
}
}
}
import alternativa.physics.Body;
import alternativa.physics.collision.IRayCollisionPredicate;
import flash.utils.Dictionary;
class MultybodyCollisionPredicate implements IRayCollisionPredicate
{
public var bodies:Dictionary;
function MultybodyCollisionPredicate()
{
this.bodies = new Dictionary();
super();
}
public function considerBody(body:Body) : Boolean
{
return this.bodies[body] == null;
}
}
|
package assets.combo {
public class ComboOffButton extends ComboButtonState {
public function ComboOffButton() {
super();
bmpLeft = new combo_OFF_LEFT(1,1);
bmpCenter = new combo_OFF_CENTER(1,1);
bmpRight = new combo_OFF_RIGHT(1,1);
}
}
}
|
package projects.tanks.client.battlefield.models.coloradjust {
public class ColorAdjustParams {
private var _alphaMultiplier:Number;
private var _alphaOffset:Number;
private var _blueMultiplier:Number;
private var _blueOffset:Number;
private var _greenMultiplier:Number;
private var _greenOffset:Number;
private var _redMultiplier:Number;
private var _redOffset:Number;
public function ColorAdjustParams(param1:Number = 0, param2:Number = 0, param3:Number = 0, param4:Number = 0, param5:Number = 0, param6:Number = 0, param7:Number = 0, param8:Number = 0) {
super();
this._alphaMultiplier = param1;
this._alphaOffset = param2;
this._blueMultiplier = param3;
this._blueOffset = param4;
this._greenMultiplier = param5;
this._greenOffset = param6;
this._redMultiplier = param7;
this._redOffset = param8;
}
public function get alphaMultiplier() : Number {
return this._alphaMultiplier;
}
public function set alphaMultiplier(param1:Number) : void {
this._alphaMultiplier = param1;
}
public function get alphaOffset() : Number {
return this._alphaOffset;
}
public function set alphaOffset(param1:Number) : void {
this._alphaOffset = param1;
}
public function get blueMultiplier() : Number {
return this._blueMultiplier;
}
public function set blueMultiplier(param1:Number) : void {
this._blueMultiplier = param1;
}
public function get blueOffset() : Number {
return this._blueOffset;
}
public function set blueOffset(param1:Number) : void {
this._blueOffset = param1;
}
public function get greenMultiplier() : Number {
return this._greenMultiplier;
}
public function set greenMultiplier(param1:Number) : void {
this._greenMultiplier = param1;
}
public function get greenOffset() : Number {
return this._greenOffset;
}
public function set greenOffset(param1:Number) : void {
this._greenOffset = param1;
}
public function get redMultiplier() : Number {
return this._redMultiplier;
}
public function set redMultiplier(param1:Number) : void {
this._redMultiplier = param1;
}
public function get redOffset() : Number {
return this._redOffset;
}
public function set redOffset(param1:Number) : void {
this._redOffset = param1;
}
public function toString() : String {
var local1:String = "ColorAdjustParams [";
local1 += "alphaMultiplier = " + this.alphaMultiplier + " ";
local1 += "alphaOffset = " + this.alphaOffset + " ";
local1 += "blueMultiplier = " + this.blueMultiplier + " ";
local1 += "blueOffset = " + this.blueOffset + " ";
local1 += "greenMultiplier = " + this.greenMultiplier + " ";
local1 += "greenOffset = " + this.greenOffset + " ";
local1 += "redMultiplier = " + this.redMultiplier + " ";
local1 += "redOffset = " + this.redOffset + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.matchmaking.notify {
import alternativa.tanks.loader.ILoaderWindowService;
import alternativa.tanks.model.matchmaking.MatchmakingQueue;
import alternativa.tanks.service.matchmaking.MatchmakingFormService;
import projects.tanks.client.battleselect.model.matchmaking.notify.IMatchmakingNotifyModelBase;
import projects.tanks.client.battleselect.model.matchmaking.notify.MatchmakingNotifyModelBase;
import projects.tanks.client.battleselect.model.matchmaking.queue.MatchmakingMode;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.flash.commons.services.notification.INotificationService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
[ModelInfo]
public class MatchmakingNotifyModel extends MatchmakingNotifyModelBase implements IMatchmakingNotifyModelBase {
[Inject]
public static var matchmakingFormService:MatchmakingFormService;
[Inject]
public static var loaderService:ILoaderWindowService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var notificationService:INotificationService;
public function MatchmakingNotifyModel() {
super();
}
public function userRegistrationSuccessful(param1:int, param2:MatchmakingMode) : void {
MatchmakingQueue(object.adapt(MatchmakingQueue)).registrationSuccessful();
matchmakingFormService.showRegistrationWindow(param1,param2);
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.BEGIN_LAYOUT_SWITCH,this.onBeginLayoutSwitch);
}
private function onBeginLayoutSwitch(param1:LobbyLayoutServiceEvent) : void {
if(param1.state == LayoutState.BATTLE) {
matchmakingFormService.hideRegistrationWindow();
}
}
public function registrationCancelled() : void {
MatchmakingQueue(object.adapt(MatchmakingQueue)).registrationCancelled();
matchmakingFormService.hideRegistrationWindow();
}
public function registrationTimeout() : void {
matchmakingFormService.hideRegistrationWindow();
notificationService.addNotification(new MatchmakingTimeoutNotification());
}
}
}
|
package _codec.projects.tanks.client.garage.models.garage {
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.Float;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.commons.types.ItemCategoryEnum;
import projects.tanks.client.garage.models.garage.GarageModelCC;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class CodecGarageModelCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_cameraAltitude:ICodec;
private var codec_cameraDistance:ICodec;
private var codec_cameraFov:ICodec;
private var codec_cameraPitch:ICodec;
private var codec_garageBox:ICodec;
private var codec_hideLinks:ICodec;
private var codec_mountableCategories:ICodec;
private var codec_skyboxBackSide:ICodec;
private var codec_skyboxBottomSide:ICodec;
private var codec_skyboxFrontSide:ICodec;
private var codec_skyboxLeftSide:ICodec;
private var codec_skyboxRightSide:ICodec;
private var codec_skyboxTopSide:ICodec;
public function CodecGarageModelCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_cameraAltitude = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_cameraDistance = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_cameraFov = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_cameraPitch = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_garageBox = param1.getCodec(new TypeCodecInfo(Tanks3DSResource,false));
this.codec_hideLinks = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_mountableCategories = param1.getCodec(new CollectionCodecInfo(new EnumCodecInfo(ItemCategoryEnum,false),false,1));
this.codec_skyboxBackSide = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_skyboxBottomSide = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_skyboxFrontSide = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_skyboxLeftSide = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_skyboxRightSide = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_skyboxTopSide = param1.getCodec(new TypeCodecInfo(TextureResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:GarageModelCC = new GarageModelCC();
local2.cameraAltitude = this.codec_cameraAltitude.decode(param1) as Number;
local2.cameraDistance = this.codec_cameraDistance.decode(param1) as Number;
local2.cameraFov = this.codec_cameraFov.decode(param1) as Number;
local2.cameraPitch = this.codec_cameraPitch.decode(param1) as Number;
local2.garageBox = this.codec_garageBox.decode(param1) as Tanks3DSResource;
local2.hideLinks = this.codec_hideLinks.decode(param1) as Boolean;
local2.mountableCategories = this.codec_mountableCategories.decode(param1) as Vector.<ItemCategoryEnum>;
local2.skyboxBackSide = this.codec_skyboxBackSide.decode(param1) as TextureResource;
local2.skyboxBottomSide = this.codec_skyboxBottomSide.decode(param1) as TextureResource;
local2.skyboxFrontSide = this.codec_skyboxFrontSide.decode(param1) as TextureResource;
local2.skyboxLeftSide = this.codec_skyboxLeftSide.decode(param1) as TextureResource;
local2.skyboxRightSide = this.codec_skyboxRightSide.decode(param1) as TextureResource;
local2.skyboxTopSide = this.codec_skyboxTopSide.decode(param1) as TextureResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:GarageModelCC = GarageModelCC(param2);
this.codec_cameraAltitude.encode(param1,local3.cameraAltitude);
this.codec_cameraDistance.encode(param1,local3.cameraDistance);
this.codec_cameraFov.encode(param1,local3.cameraFov);
this.codec_cameraPitch.encode(param1,local3.cameraPitch);
this.codec_garageBox.encode(param1,local3.garageBox);
this.codec_hideLinks.encode(param1,local3.hideLinks);
this.codec_mountableCategories.encode(param1,local3.mountableCategories);
this.codec_skyboxBackSide.encode(param1,local3.skyboxBackSide);
this.codec_skyboxBottomSide.encode(param1,local3.skyboxBottomSide);
this.codec_skyboxFrontSide.encode(param1,local3.skyboxFrontSide);
this.codec_skyboxLeftSide.encode(param1,local3.skyboxLeftSide);
this.codec_skyboxRightSide.encode(param1,local3.skyboxRightSide);
this.codec_skyboxTopSide.encode(param1,local3.skyboxTopSide);
}
}
}
|
package alternativa.utils.textureutils
{
import flash.utils.ByteArray;
public class TextureByteData
{
public var diffuseData:ByteArray;
public var opacityData:ByteArray;
public function TextureByteData(diffuseData:ByteArray = null, opacityData:ByteArray = null)
{
super();
this.diffuseData = diffuseData;
this.opacityData = opacityData;
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_bitmapThunderResistance.png")]
public class ResistancesIcons_bitmapThunderResistance extends BitmapAsset {
public function ResistancesIcons_bitmapThunderResistance() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.smoke {
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 HullSmokeModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function HullSmokeModelServer(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 alternativa.tanks.battle.objects.tank.tankskin.materialfactory {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.skintexturesregistry.TankSkinTextureRegistry;
import alternativa.tanks.battle.objects.tank.tankskin.SkinMaterials;
import alternativa.tanks.battle.objects.tank.tankskin.TankHullSkinCacheItem;
import alternativa.tanks.battle.objects.tank.tankskin.TankSkin;
import alternativa.tanks.battle.objects.tank.tankskin.turret.TurretSkinCacheItem;
import alternativa.tanks.materials.TrackMaterial;
import alternativa.types.Long;
import alternativa.utils.TextureMaterialRegistry;
import flash.display.BitmapData;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.clients.flash.commons.models.coloring.IColoring;
public class DefaultTankSkinMaterialsFactory implements TankSkinMaterialsFactory {
[Inject]
public static var textureMaterialRegistry:TextureMaterialRegistry;
[Inject]
public static var skinTextureRegistry:TankSkinTextureRegistry;
[Inject]
public static var battleService:BattleService;
public function DefaultTankSkinMaterialsFactory() {
super();
}
public function createSkinMaterials(param1:TankSkin, param2:IColoring) : SkinMaterials {
var local13:MultiframeTextureResource = null;
var local14:TextureMaterial = null;
var local15:TextureMaterial = null;
var local16:TextureResource = null;
var local3:TankHullSkinCacheItem = param1.getHullDescriptor();
var local4:TurretSkinCacheItem = param1.getTurretDescriptor();
var local5:Long = local3.partId;
var local6:BitmapData = local3.lightmap;
var local7:BitmapData = local3.details;
var local8:Long = local4.partId;
var local9:BitmapData = local4.lightmap;
var local10:BitmapData = local4.details;
if(param2.isAnimated()) {
local13 = param2.getAnimatedColoring();
local14 = textureMaterialRegistry.getAnimatedPaint(local13,local6,local7,local5);
local15 = textureMaterialRegistry.getAnimatedPaint(local13,local9,local10,local8);
} else {
local16 = param2.getColoring();
local14 = textureMaterialRegistry.getPaint(local16,local6,local7,local5);
local15 = textureMaterialRegistry.getPaint(local16,local9,local10,local8);
}
var local11:TrackMaterial = new TrackMaterial(local7);
var local12:TrackMaterial = new TrackMaterial(local7);
textureMaterialRegistry.addMaterial(local11);
textureMaterialRegistry.addMaterial(local12);
return new SkinMaterials(local14,local15,local11,local12);
}
public function createDeadSkinMaterials(param1:TankSkin, param2:TextureResource) : SkinMaterials {
var local3:TankHullSkinCacheItem = param1.getHullDescriptor();
var local4:TurretSkinCacheItem = param1.getTurretDescriptor();
var local5:Long = local3.partId;
var local6:BitmapData = local3.lightmap;
var local7:BitmapData = local3.details;
var local8:Long = local4.partId;
var local9:BitmapData = local4.lightmap;
var local10:BitmapData = local4.details;
var local11:TextureMaterial = textureMaterialRegistry.getPaint(param2,local6,local7,local5);
var local12:TextureMaterial = textureMaterialRegistry.getPaint(param2,local9,local10,local8);
return new SkinMaterials(local11,local12);
}
}
}
|
package alternativa.tanks.model {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.gui.communication.CommunicationPanel;
import flash.display.DisplayObjectContainer;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.chat.models.CommunicationPanelModelBase;
import projects.tanks.client.chat.models.ICommunicationPanelModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.UserPropertiesServiceEvent;
[ModelInfo]
public class CommunicationPanelModel extends CommunicationPanelModelBase implements ICommunicationPanelModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var display:IDisplay;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
private var panel:CommunicationPanel;
public function CommunicationPanelModel() {
super();
}
private static function get layer() : DisplayObjectContainer {
return display.systemLayer;
}
public function objectLoaded() : void {
if(userPropertiesService.isInited()) {
this.addCommunicationPanel();
} else {
userPropertiesService.addEventListener(UserPropertiesServiceEvent.ON_INIT_USER_PROPERTIES,this.onInitUserPropertiesService);
}
}
private function onInitUserPropertiesService(param1:UserPropertiesServiceEvent) : void {
userPropertiesService.removeEventListener(UserPropertiesServiceEvent.ON_INIT_USER_PROPERTIES,this.onInitUserPropertiesService);
this.addCommunicationPanel();
}
private function addCommunicationPanel() : void {
this.panel = new CommunicationPanel();
layer.addChild(this.panel);
}
public function objectUnloaded() : void {
userPropertiesService.removeEventListener(UserPropertiesServiceEvent.ON_INIT_USER_PROPERTIES,this.onInitUserPropertiesService);
layer.removeChild(this.panel);
}
}
}
|
package _codec.projects.tanks.client.clans.clan.clanfriends {
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.TypeCodecInfo;
import alternativa.types.Long;
import projects.tanks.client.clans.clan.clanfriends.ClanFriendsCC;
public class CodecClanFriendsCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_users:ICodec;
public function CodecClanFriendsCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_users = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Long,false),true,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ClanFriendsCC = new ClanFriendsCC();
local2.users = this.codec_users.decode(param1) as Vector.<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:ClanFriendsCC = ClanFriendsCC(param2);
this.codec_users.encode(param1,local3.users);
}
}
}
|
package controls.cellrenderer
{
import flash.display.Bitmap;
import flash.display.BitmapData;
public class CellUnavailable extends CellRendererDefault
{
[Embed(source="1004.png")]
private static const normalLeft:Class;
private static const normalLeftData:BitmapData = Bitmap(new normalLeft()).bitmapData;
[Embed(source="828.png")]
private static const normalCenter:Class;
private static const normalCenterData:BitmapData = Bitmap(new normalCenter()).bitmapData;
[Embed(source="1079.png")]
private static const normalRight:Class;
private static const normalRightData:BitmapData = Bitmap(new normalRight()).bitmapData;
public function CellUnavailable()
{
super();
bmpLeft = normalLeftData;
bmpCenter = normalCenterData;
bmpRight = normalRightData;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.shot {
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 ShotgunShotModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ShotgunShotModelServer(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 alternativa.tanks.help {
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.flash.commons.services.datetime.DateFormatter;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class DateTimeHelper {
[Inject]
public static var localeService:ILocaleService;
private static const MILLISECONDS_IN_SECOND:int = 1000;
private static const DAY_IN_MILLISECONDS:int = 24 * 60 * 60 * MILLISECONDS_IN_SECOND;
public function DateTimeHelper() {
super();
}
public static function formatDateTimeWithExpiredLabel(param1:Date) : String {
var local3:Number = NaN;
var local2:String = " ";
if(!isNaN(param1.date)) {
local3 = param1.getTime() - new Date().getTime();
if(local3 < DAY_IN_MILLISECONDS) {
local2 = localeService.getText(TanksLocale.TEXT_PREMIUM_COMPLETION_IN) + DateFormatter.formatTime(param1);
} else {
local2 = localeService.getText(TanksLocale.TEXT_PREMIUM_COMPLETION) + DateFormatter.formatDateToLocalized(param1);
}
}
return local2;
}
public static function convertSecondsToMilliseconds(param1:int) : Number {
return Number(param1) * MILLISECONDS_IN_SECOND;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.shaft {
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.Float;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.tankparts.weapon.shaft.ShaftCC;
public class CodecShaftCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_afterShotPause:ICodec;
private var codec_aimingImpact:ICodec;
private var codec_chargeRate:ICodec;
private var codec_dischargeRate:ICodec;
private var codec_fastShotEnergy:ICodec;
private var codec_horizontalTargetingSpeed:ICodec;
private var codec_initialFOV:ICodec;
private var codec_maxEnergy:ICodec;
private var codec_minAimedShotEnergy:ICodec;
private var codec_minimumFOV:ICodec;
private var codec_reticleImage:ICodec;
private var codec_rotationCoeffKmin:ICodec;
private var codec_rotationCoeffT1:ICodec;
private var codec_rotationCoeffT2:ICodec;
private var codec_shrubsHidingRadiusMax:ICodec;
private var codec_shrubsHidingRadiusMin:ICodec;
private var codec_targetingAcceleration:ICodec;
private var codec_targetingTransitionTime:ICodec;
private var codec_verticalTargetingSpeed:ICodec;
public function CodecShaftCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_afterShotPause = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_aimingImpact = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_chargeRate = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_dischargeRate = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_fastShotEnergy = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_horizontalTargetingSpeed = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_initialFOV = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_maxEnergy = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_minAimedShotEnergy = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_minimumFOV = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_reticleImage = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_rotationCoeffKmin = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_rotationCoeffT1 = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_rotationCoeffT2 = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_shrubsHidingRadiusMax = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_shrubsHidingRadiusMin = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_targetingAcceleration = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_targetingTransitionTime = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_verticalTargetingSpeed = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ShaftCC = new ShaftCC();
local2.afterShotPause = this.codec_afterShotPause.decode(param1) as int;
local2.aimingImpact = this.codec_aimingImpact.decode(param1) as Number;
local2.chargeRate = this.codec_chargeRate.decode(param1) as Number;
local2.dischargeRate = this.codec_dischargeRate.decode(param1) as Number;
local2.fastShotEnergy = this.codec_fastShotEnergy.decode(param1) as Number;
local2.horizontalTargetingSpeed = this.codec_horizontalTargetingSpeed.decode(param1) as Number;
local2.initialFOV = this.codec_initialFOV.decode(param1) as Number;
local2.maxEnergy = this.codec_maxEnergy.decode(param1) as Number;
local2.minAimedShotEnergy = this.codec_minAimedShotEnergy.decode(param1) as Number;
local2.minimumFOV = this.codec_minimumFOV.decode(param1) as Number;
local2.reticleImage = this.codec_reticleImage.decode(param1) as TextureResource;
local2.rotationCoeffKmin = this.codec_rotationCoeffKmin.decode(param1) as Number;
local2.rotationCoeffT1 = this.codec_rotationCoeffT1.decode(param1) as Number;
local2.rotationCoeffT2 = this.codec_rotationCoeffT2.decode(param1) as Number;
local2.shrubsHidingRadiusMax = this.codec_shrubsHidingRadiusMax.decode(param1) as Number;
local2.shrubsHidingRadiusMin = this.codec_shrubsHidingRadiusMin.decode(param1) as Number;
local2.targetingAcceleration = this.codec_targetingAcceleration.decode(param1) as Number;
local2.targetingTransitionTime = this.codec_targetingTransitionTime.decode(param1) as int;
local2.verticalTargetingSpeed = this.codec_verticalTargetingSpeed.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ShaftCC = ShaftCC(param2);
this.codec_afterShotPause.encode(param1,local3.afterShotPause);
this.codec_aimingImpact.encode(param1,local3.aimingImpact);
this.codec_chargeRate.encode(param1,local3.chargeRate);
this.codec_dischargeRate.encode(param1,local3.dischargeRate);
this.codec_fastShotEnergy.encode(param1,local3.fastShotEnergy);
this.codec_horizontalTargetingSpeed.encode(param1,local3.horizontalTargetingSpeed);
this.codec_initialFOV.encode(param1,local3.initialFOV);
this.codec_maxEnergy.encode(param1,local3.maxEnergy);
this.codec_minAimedShotEnergy.encode(param1,local3.minAimedShotEnergy);
this.codec_minimumFOV.encode(param1,local3.minimumFOV);
this.codec_reticleImage.encode(param1,local3.reticleImage);
this.codec_rotationCoeffKmin.encode(param1,local3.rotationCoeffKmin);
this.codec_rotationCoeffT1.encode(param1,local3.rotationCoeffT1);
this.codec_rotationCoeffT2.encode(param1,local3.rotationCoeffT2);
this.codec_shrubsHidingRadiusMax.encode(param1,local3.shrubsHidingRadiusMax);
this.codec_shrubsHidingRadiusMin.encode(param1,local3.shrubsHidingRadiusMin);
this.codec_targetingAcceleration.encode(param1,local3.targetingAcceleration);
this.codec_targetingTransitionTime.encode(param1,local3.targetingTransitionTime);
this.codec_verticalTargetingSpeed.encode(param1,local3.verticalTargetingSpeed);
}
}
}
|
package projects.tanks.client.garage.models.item.rarity {
public class ItemRarityCC {
private var _rarity:Rarity;
public function ItemRarityCC(param1:Rarity = null) {
super();
this._rarity = param1;
}
public function get rarity() : Rarity {
return this._rarity;
}
public function set rarity(param1:Rarity) : void {
this._rarity = param1;
}
public function toString() : String {
var local1:String = "ItemRarityCC [";
local1 += "rarity = " + this.rarity + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.battlefield.mine
{
import alternativa.console.ConsoleVarFloat;
import alternativa.console.ConsoleVarInt;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.tanks.camera.ICameraStateModifier;
import alternativa.tanks.camera.IFollowCameraController;
import alternativa.tanks.vehicles.tanks.Tank;
import flash.utils.getTimer;
public class MineExplosionCameraEffect implements ICameraStateModifier
{
private static var amplitude:ConsoleVarFloat;
private static var yawAmplitude:ConsoleVarFloat;
private static var rollAmplitude:ConsoleVarFloat;
private static var duration:ConsoleVarInt;
private static var m1:Matrix3 = new Matrix3();
private static var m2:Matrix3 = new Matrix3();
private static var axis:Vector3 = new Vector3();
private var sign:int;
private var time:int;
private var tank:Tank;
public function MineExplosionCameraEffect()
{
super();
}
public static function initVars() : void
{
amplitude = new ConsoleVarFloat("minecam_ampl",0,-10000,10000);
yawAmplitude = new ConsoleVarFloat("minecam_yaw",-0.02,-10,10);
rollAmplitude = new ConsoleVarFloat("minecam_roll",0.03,-10,10);
duration = new ConsoleVarInt("minecam_time",800,0,10000);
}
public function update(time:int, delta:int, position:Vector3, rotation:Vector3) : Boolean
{
if(time - this.time > duration.value)
{
return false;
}
this.sign = -this.sign;
var f:Number = 0.5 * (1 + Math.cos((time - this.time) * Math.PI / duration.value));
position.z += amplitude.value * this.sign * f;
m1.setRotationMatrix(rotation.x,rotation.y,rotation.z);
axis.vDiff(this.tank.state.pos,position).vNormalize();
m2.fromAxisAngle(axis,rollAmplitude.value * this.sign * f);
m1.append(m2);
m2.fromAxisAngle(Vector3.Z_AXIS,yawAmplitude.value * this.sign * f);
m1.append(m2);
m1.getEulerAngles(rotation);
return true;
}
public function onAddedToController(controller:IFollowCameraController) : void
{
this.time = getTimer();
this.sign = 1;
this.tank = controller.tank;
}
public function destroy() : void
{
axis = null;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IFriendsEvents implements IFriends {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IFriendsEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function isLocal() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:IFriends = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IFriends(this.impl[i]);
result = Boolean(m.isLocal());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.servermodels.loginbyhash {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ILoginByHashEvents implements ILoginByHash {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ILoginByHashEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function loginByHash(param1:String) : void {
var i:int = 0;
var m:ILoginByHash = null;
var hash:String = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ILoginByHash(this.impl[i]);
m.loginByHash(hash);
i++;
}
}
finally {
Model.popObject();
}
}
public function loginBySingleUseHash(param1:String) : void {
var i:int = 0;
var m:ILoginByHash = null;
var hash:String = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ILoginByHash(this.impl[i]);
m.loginBySingleUseHash(hash);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.battle.commonflag {
import alternativa.math.Quaternion;
import alternativa.math.Vector3;
public class FlagStatus {
public var position:Vector3 = new Vector3();
public var rotation:Quaternion = new Quaternion();
public function FlagStatus() {
super();
}
public function apply(param1:Vector3, param2:Quaternion) : void {
this.position.copy(param1);
this.rotation.copy(param2);
}
public function applyPos(param1:Vector3) : * {
this.position.copy(param1);
}
public function copy(param1:FlagStatus) : * {
this.apply(param1.position,param1.rotation);
}
public function copyTo(param1:FlagStatus) : * {
param1.apply(this.position,this.rotation);
}
public function interpolate(param1:FlagStatus, param2:FlagStatus, param3:Number) : * {
this.position.x = param1.position.x + param3 * (param2.position.x - param1.position.x);
this.position.y = param1.position.y + param3 * (param2.position.y - param1.position.y);
this.position.z = param1.position.z + param3 * (param2.position.z - param1.position.z);
this.rotation.slerp(param1.rotation,param2.rotation,param3);
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.sfx.freeze {
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.freeze.FreezeSFXCC;
public class VectorCodecFreezeSFXCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecFreezeSFXCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(FreezeSFXCC,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.<FreezeSFXCC> = new Vector.<FreezeSFXCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = FreezeSFXCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:FreezeSFXCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<FreezeSFXCC> = Vector.<FreezeSFXCC>(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 assets {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol215")]
public dynamic class Diamond extends MovieClip {
public function Diamond() {
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapSmallRank31.png")]
public class DefaultRanksBitmaps_bitmapSmallRank31 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapSmallRank31() {
super();
}
}
}
|
package alternativa.tanks.service.delaymountcategory {
import alternativa.osgi.service.logging.LogService;
import alternativa.tanks.service.item.ItemService;
import controls.timer.CountDownTimer;
import flash.utils.Dictionary;
import flash.utils.getTimer;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.types.ItemCategoryEnum;
import projects.tanks.client.garage.models.item.delaymount.DelayMountCategoryCC;
public class DelayMountCategoryServiceImpl implements IDelayMountCategoryService {
[Inject]
public static var itemService:ItemService;
[Inject]
public static var logService:LogService;
private var timers:Dictionary = new Dictionary();
public function DelayMountCategoryServiceImpl() {
super();
}
public function getDownTimer(param1:IGameObject) : CountDownTimer {
var local2:ItemCategoryEnum = itemService.getCategory(param1);
return this.timers[local2];
}
public function createTimers(param1:DelayMountCategoryCC) : void {
this.createTimer(ItemCategoryEnum.ARMOR,param1.delayMountArmorInSec);
this.createTimer(ItemCategoryEnum.WEAPON,param1.delayMountWeaponInSec);
this.createTimer(ItemCategoryEnum.RESISTANCE_MODULE,param1.delayMountResistanceInSec);
this.createTimer(ItemCategoryEnum.DRONE,param1.delayMountDroneInSec);
}
private function createTimer(param1:ItemCategoryEnum, param2:int) : void {
var local3:CountDownTimer = new CountDownTimer();
local3.start(param2 * 1000 + getTimer());
this.timers[param1] = local3;
}
public function destroyTimers() : void {
var local1:CountDownTimer = null;
for each(local1 in this.timers) {
if(local1 != null) {
local1.destroy();
}
}
delete this.timers[ItemCategoryEnum.ARMOR];
delete this.timers[ItemCategoryEnum.RESISTANCE_MODULE];
delete this.timers[ItemCategoryEnum.WEAPON];
delete this.timers[ItemCategoryEnum.DRONE];
}
public function resetTimers() : void {
var local1:CountDownTimer = null;
for each(local1 in this.timers) {
if(local1 != null) {
local1.stop();
}
}
}
}
}
|
package projects.tanks.client.battleselect.model.battle.param {
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 BattleParamInfoModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BattleParamInfoModelServer(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 _codec.projects.tanks.client.clans.panel.notification {
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.clans.panel.notification.ClanPanelNotificationCC;
public class CodecClanPanelNotificationCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_numberNotifications:ICodec;
private var codec_restrictionTimeJoinClanInSec:ICodec;
public function CodecClanPanelNotificationCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_numberNotifications = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_restrictionTimeJoinClanInSec = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ClanPanelNotificationCC = new ClanPanelNotificationCC();
local2.numberNotifications = this.codec_numberNotifications.decode(param1) as int;
local2.restrictionTimeJoinClanInSec = this.codec_restrictionTimeJoinClanInSec.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:ClanPanelNotificationCC = ClanPanelNotificationCC(param2);
this.codec_numberNotifications.encode(param1,local3.numberNotifications);
this.codec_restrictionTimeJoinClanInSec.encode(param1,local3.restrictionTimeJoinClanInSec);
}
}
}
|
package alternativa.tanks.servermodels.registartion.password {
import alternativa.osgi.service.launcherparams.ILauncherParams;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.newbieservice.NewbieUserService;
import alternativa.tanks.service.IEntranceClientFacade;
import alternativa.tanks.service.IPasswordParamsService;
import alternativa.tanks.tracker.ITrackerService;
import alternativa.tanks.ymservice.YandexMetricaService;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.entrance.model.entrance.registration.IRegistrationModelBase;
import projects.tanks.client.entrance.model.entrance.registration.RegistrationModelBase;
import projects.tanks.clients.flash.commons.models.layout.LobbyLayoutModel;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
import services.alertservice.AlertAnswer;
import utils.preview.IImageResource;
import utils.preview.ImageResourceLoadingWrapper;
[ModelInfo]
public class PasswordRegistrationModel extends RegistrationModelBase implements IRegistrationModelBase, IPasswordRegistration, ObjectLoadListener, IImageResource {
[Inject]
public static var facade:IEntranceClientFacade;
[Inject]
public static var passwordParamsService:IPasswordParamsService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var trackerService:ITrackerService;
[Inject]
public static var launcherParams:ILauncherParams;
[Inject]
public static var ymService:YandexMetricaService;
[Inject]
public static var newbieUserService:NewbieUserService;
[Inject]
public static var storageService:IStorageService;
private static const USER_IS_REGISTERED:String = "registered";
public function PasswordRegistrationModel() {
super();
}
public function objectLoaded() : void {
this.checkFormerUser();
passwordParamsService.minPasswordLength = getInitParam().minPasswordLength;
passwordParamsService.maxPasswordLength = getInitParam().maxPasswordLength;
facade.registrationThroughEmail = getInitParam().enableRequiredEmail;
var local1:ImageResource = getInitParam().bgResource;
if(local1.isLazy && !local1.isLoaded) {
local1.loadLazyResource(new ImageResourceLoadingWrapper(this));
} else {
this.setPreviewResource(local1);
}
}
private function checkFormerUser() : void {
var local1:Object = storageService.getStorage().data.uniqueUserIdHighDWord;
var local2:Object = storageService.getStorage().data.uniqueUserIdLowDWord;
if(Boolean(local1) && Boolean(local2)) {
server.setFormerUserId(Long.getLong(int(local1),int(local2)));
}
}
public function enteredUidIsFree() : void {
facade.callsignIsFree();
}
public function anchorRegistration() : void {
if(launcherParams.getParameter("partner") != null) {
trackerService.trackPageView("registered/" + launcherParams.getParameter("partner"));
} else {
trackerService.trackPageView("registered");
}
ymService.reachGoalIfPlayerWasInTutorial(USER_IS_REGISTERED);
newbieUserService.isNewbieUser = true;
storageService.getStorage().data[LobbyLayoutModel.USE_BATTLE_LIST_KEY] = false;
}
public function enteredUidIsBusy(param1:Vector.<String>) : void {
facade.callsignIsBusy(param1);
}
public function enteredUidIsIncorrect() : void {
facade.callsignIsIncorrect();
}
public function passwordIsIncorrect() : void {
facade.registrationPasswordIsIncorrect();
}
public function registrationFailed() : void {
alertService.showAlert("Registration failed. Try again.",Vector.<String>([localeService.getText(AlertAnswer.OK)]));
}
public function register(param1:String, param2:String, param3:String, param4:Boolean, param5:String, param6:String, param7:String) : void {
this.resetUniqueUser();
server.register(param1,param2,param3,param4,param5,param6,param7);
}
private function resetUniqueUser() : void {
var local1:Object = storageService.getStorage().data;
local1.uniqueUserIdLowDWord = null;
local1.uniqueUserIdHighDWord = null;
}
public function checkCallsign(param1:String) : void {
server.checkUid(param1);
}
public function setPreviewResource(param1:ImageResource) : void {
if(facade != null) {
facade.registrationFormBackgroundRGB = param1.data;
}
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ItemInfoPanel_bitmapMechResistance extends BitmapAsset
{
public function ItemInfoPanel_bitmapMechResistance()
{
super();
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_impactForceClass.png")]
public class ItemInfoPanelBitmaps_impactForceClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_impactForceClass() {
super();
}
}
}
|
package projects.tanks.clients.flash.commons.services.timeunit {
import alternativa.osgi.service.locale.ILocaleService;
public class TimeUnitService implements ITimeUnitService {
[Inject]
public static var localeService:ILocaleService;
public function TimeUnitService() {
super();
}
private static function getRuTimeUnitNames(param1:int, param2:int, param3:int) : TimeUnitNames {
var local4:TimeUnitNames = new TimeUnitNames();
param3 %= 100;
if(param3 >= 11 && param3 <= 19) {
local4.dayName = "дней";
} else {
param3 %= 10;
if(param3 == 1) {
local4.dayName = "день";
} else if(param3 >= 2 && param3 <= 4) {
local4.dayName = "дня";
} else {
local4.dayName = "дней";
}
}
if(param2 == 1 || param2 == 21) {
local4.hourName = "час";
} else if(param2 >= 2 && param2 <= 4 || param2 >= 22 && param2 <= 24) {
local4.hourName = "часа";
} else if(param2 >= 5 && param2 <= 20) {
local4.hourName = "часов";
}
if(param1 == 0 || param1 == 1 || param1 == 21 || param1 == 31 || param1 == 41 || param1 == 51) {
local4.minuteName = "минуту";
} else if(param1 >= 2 && param1 <= 4 || param1 >= 22 && param1 <= 24 || param1 >= 32 && param1 <= 34 || param1 >= 42 && param1 <= 44 || param1 >= 52 && param1 <= 54) {
local4.minuteName = "минуты";
} else if(param1 >= 5 && param1 <= 20 || param1 >= 25 && param1 <= 30 || param1 >= 35 && param1 <= 40 || param1 >= 45 && param1 <= 50 || param1 >= 55 && param1 <= 60) {
local4.minuteName = "минут";
}
return local4;
}
private static function getEnTimeUnitNames(param1:int, param2:int, param3:int) : TimeUnitNames {
var local4:TimeUnitNames = new TimeUnitNames();
if(param3 == 1) {
local4.dayName = "day";
} else {
local4.dayName = "days";
}
if(param2 == 1) {
local4.hourName = "hour";
} else {
local4.hourName = "hours";
}
if(param1 == 1 || param1 == 0) {
local4.minuteName = "minute";
} else {
local4.minuteName = "minutes";
}
return local4;
}
private static function getDeTimeUnitNames(param1:int, param2:int, param3:int) : TimeUnitNames {
var local4:TimeUnitNames = new TimeUnitNames();
if(param3 == 1) {
local4.dayName = "Tag";
} else {
local4.dayName = "Tage";
}
if(param2 == 1) {
local4.hourName = "Stunde";
} else {
local4.hourName = "Stunden";
}
if(param1 == 1 || param1 == 0) {
local4.minuteName = "Minute";
} else {
local4.minuteName = "Minuten";
}
return local4;
}
private static function getBrTimeUnitNames(param1:int, param2:int, param3:int) : TimeUnitNames {
var local4:TimeUnitNames = new TimeUnitNames();
if(param3 == 1) {
local4.dayName = "dia";
} else {
local4.dayName = "dias";
}
if(param2 == 1) {
local4.hourName = "hora";
} else {
local4.hourName = "horas";
}
if(param1 == 1 || param1 == 0) {
local4.minuteName = "minuto";
} else {
local4.minuteName = "minutos";
}
return local4;
}
private static function getEsTimeUnitNames(param1:int, param2:int, param3:int) : TimeUnitNames {
var local4:TimeUnitNames = new TimeUnitNames();
if(param3 == 1) {
local4.dayName = "día";
} else {
local4.dayName = "días";
}
if(param2 == 1) {
local4.hourName = "hora";
} else {
local4.hourName = "horas";
}
if(param1 == 1 || param1 == 0) {
local4.minuteName = "minuto";
} else {
local4.minuteName = "minutos";
}
return local4;
}
private static function getCnTimeUnitNames() : TimeUnitNames {
var local1:TimeUnitNames = new TimeUnitNames();
local1.dayName = "天";
local1.hourName = "小时";
local1.minuteName = "分鐘";
return local1;
}
private static function getFaTimeUnitNames() : TimeUnitNames {
var local1:TimeUnitNames = new TimeUnitNames();
local1.dayName = "روز";
local1.hourName = "ساعت";
local1.minuteName = "دقیقه";
return local1;
}
private static function getPlTimeUnitNames(param1:int, param2:int, param3:int) : TimeUnitNames {
var local4:TimeUnitNames = new TimeUnitNames();
if(param3 == 1) {
local4.dayName = "dzień";
} else {
local4.dayName = "dni";
}
if(param2 == 1) {
local4.hourName = "godzina";
} else {
local4.hourName = "godzin";
}
if(param1 == 0) {
local4.minuteName = "minut";
} else if(param1 == 1) {
local4.minuteName = "minuta";
} else if(param1 >= 2 && param1 <= 4 || param1 >= 22 && param1 <= 24 || param1 >= 32 && param1 <= 34 || param1 >= 42 && param1 <= 44 || param1 >= 52 && param1 <= 54) {
local4.minuteName = "minuty";
} else {
local4.minuteName = "minut";
}
return local4;
}
public function getLocalizedTimeString(param1:int, param2:int, param3:int) : String {
var local4:String = "";
var local5:TimeUnitNames = this.getTimeUnitNames(param1,param2,param3);
if(param3 == 0 && param2 == 0 && param1 == 0) {
return "1 " + local5.minuteName;
}
if(param3 != 0) {
local4 = param3 + " " + local5.dayName;
}
if(param2 != 0) {
local4 = local4 + " " + param2 + " " + local5.hourName;
}
if(param1 != 0) {
local4 = local4 + " " + param1 + " " + local5.minuteName;
}
return local4;
}
public function getLocalizedDaysString(param1:int) : String {
return param1 + " " + this.getLocalizedDaysName(param1);
}
public function getLocalizedDaysName(param1:int) : String {
return this.getTimeUnitNames(0,0,param1).dayName;
}
public function getLocalizedShortDaysName(param1:int) : String {
switch(localeService.language) {
case "cn":
case "fa":
return this.getLocalizedDaysName(param1);
default:
return this.getLocalizedDaysName(param1).charAt(0);
}
}
public function getTimeUnitNames(param1:int, param2:int, param3:int) : TimeUnitNames {
switch(localeService.language) {
case "ru":
return getRuTimeUnitNames(param1,param2,param3);
case "de":
return getDeTimeUnitNames(param1,param2,param3);
case "pt_BR":
return getBrTimeUnitNames(param1,param2,param3);
case "pl":
return getPlTimeUnitNames(param1,param2,param3);
case "es":
return getEsTimeUnitNames(param1,param2,param3);
case "cn":
return getCnTimeUnitNames();
case "fa":
return getFaTimeUnitNames();
case "en":
}
return getEnTimeUnitNames(param1,param2,param3);
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_mineActivationDelayClass.png")]
public class ItemInfoPanelBitmaps_mineActivationDelayClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_mineActivationDelayClass() {
super();
}
}
}
|
package alternativa.tanks.model.payment.modes.sms {
import projects.tanks.client.panel.model.payment.modes.sms.types.Country;
[ModelInterface]
public interface SMSPayMode {
function getCountries() : Vector.<Country>;
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.shoot.smoky {
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity.LightingSFXEntity;
public class SmokyShootSFXCC {
private var _criticalHitSize:int;
private var _criticalHitTexture:MultiframeTextureResource;
private var _explosionMarkTexture:TextureResource;
private var _explosionSize:int;
private var _explosionSound:SoundResource;
private var _explosionTexture:MultiframeTextureResource;
private var _lightingSFXEntity:LightingSFXEntity;
private var _shotSound:SoundResource;
private var _shotTexture:TextureResource;
public function SmokyShootSFXCC(param1:int = 0, param2:MultiframeTextureResource = null, param3:TextureResource = null, param4:int = 0, param5:SoundResource = null, param6:MultiframeTextureResource = null, param7:LightingSFXEntity = null, param8:SoundResource = null, param9:TextureResource = null) {
super();
this._criticalHitSize = param1;
this._criticalHitTexture = param2;
this._explosionMarkTexture = param3;
this._explosionSize = param4;
this._explosionSound = param5;
this._explosionTexture = param6;
this._lightingSFXEntity = param7;
this._shotSound = param8;
this._shotTexture = param9;
}
public function get criticalHitSize() : int {
return this._criticalHitSize;
}
public function set criticalHitSize(param1:int) : void {
this._criticalHitSize = param1;
}
public function get criticalHitTexture() : MultiframeTextureResource {
return this._criticalHitTexture;
}
public function set criticalHitTexture(param1:MultiframeTextureResource) : void {
this._criticalHitTexture = param1;
}
public function get explosionMarkTexture() : TextureResource {
return this._explosionMarkTexture;
}
public function set explosionMarkTexture(param1:TextureResource) : void {
this._explosionMarkTexture = param1;
}
public function get explosionSize() : int {
return this._explosionSize;
}
public function set explosionSize(param1:int) : void {
this._explosionSize = param1;
}
public function get explosionSound() : SoundResource {
return this._explosionSound;
}
public function set explosionSound(param1:SoundResource) : void {
this._explosionSound = param1;
}
public function get explosionTexture() : MultiframeTextureResource {
return this._explosionTexture;
}
public function set explosionTexture(param1:MultiframeTextureResource) : void {
this._explosionTexture = param1;
}
public function get lightingSFXEntity() : LightingSFXEntity {
return this._lightingSFXEntity;
}
public function set lightingSFXEntity(param1:LightingSFXEntity) : void {
this._lightingSFXEntity = param1;
}
public function get shotSound() : SoundResource {
return this._shotSound;
}
public function set shotSound(param1:SoundResource) : void {
this._shotSound = param1;
}
public function get shotTexture() : TextureResource {
return this._shotTexture;
}
public function set shotTexture(param1:TextureResource) : void {
this._shotTexture = param1;
}
public function toString() : String {
var local1:String = "SmokyShootSFXCC [";
local1 += "criticalHitSize = " + this.criticalHitSize + " ";
local1 += "criticalHitTexture = " + this.criticalHitTexture + " ";
local1 += "explosionMarkTexture = " + this.explosionMarkTexture + " ";
local1 += "explosionSize = " + this.explosionSize + " ";
local1 += "explosionSound = " + this.explosionSound + " ";
local1 += "explosionTexture = " + this.explosionTexture + " ";
local1 += "lightingSFXEntity = " + this.lightingSFXEntity + " ";
local1 += "shotSound = " + this.shotSound + " ";
local1 += "shotTexture = " + this.shotTexture + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_unstableplazmaIconClass.png")]
public class DeviceIcons_unstableplazmaIconClass extends BitmapAsset {
public function DeviceIcons_unstableplazmaIconClass() {
super();
}
}
}
|
package alternativa.math {
import flash.geom.Vector3D;
import flash.utils.getQualifiedClassName;
public class Quaternion {
private static const _q:Quaternion = new Quaternion();
public var w:Number;
public var x:Number;
public var y:Number;
public var z:Number;
public function Quaternion(param1:Number = 1, param2:Number = 0, param3:Number = 0, param4:Number = 0) {
super();
this.w = param1;
this.x = param2;
this.y = param3;
this.z = param4;
}
public static function multiply(param1:Quaternion, param2:Quaternion, param3:Quaternion) : void {
param3.w = param1.w * param2.w - param1.x * param2.x - param1.y * param2.y - param1.z * param2.z;
param3.x = param1.w * param2.x + param1.x * param2.w + param1.y * param2.z - param1.z * param2.y;
param3.y = param1.w * param2.y + param1.y * param2.w + param1.z * param2.x - param1.x * param2.z;
param3.z = param1.w * param2.z + param1.z * param2.w + param1.x * param2.y - param1.y * param2.x;
}
public static function createFromAxisAngle(param1:Vector3, param2:Number) : Quaternion {
var local3:Quaternion = new Quaternion();
local3.setFromAxisAngle(param1,param2);
return local3;
}
public static function createFromAxisAngleComponents(param1:Number, param2:Number, param3:Number, param4:Number) : Quaternion {
var local5:Quaternion = new Quaternion();
local5.setFromAxisAngleComponents(param1,param2,param3,param4);
return local5;
}
public function reset(param1:Number = 1, param2:Number = 0, param3:Number = 0, param4:Number = 0) : Quaternion {
this.w = param1;
this.x = param2;
this.y = param3;
this.z = param4;
return this;
}
public function normalize() : Quaternion {
var local1:Number = this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z;
if(local1 == 0) {
this.w = 1;
} else {
local1 = 1 / Math.sqrt(local1);
this.w *= local1;
this.x *= local1;
this.y *= local1;
this.z *= local1;
}
return this;
}
public function prepend(param1:Quaternion) : Quaternion {
var local2:Number = this.w * param1.w - this.x * param1.x - this.y * param1.y - this.z * param1.z;
var local3:Number = this.w * param1.x + this.x * param1.w + this.y * param1.z - this.z * param1.y;
var local4:Number = this.w * param1.y + this.y * param1.w + this.z * param1.x - this.x * param1.z;
var local5:Number = this.w * param1.z + this.z * param1.w + this.x * param1.y - this.y * param1.x;
this.w = local2;
this.x = local3;
this.y = local4;
this.z = local5;
return this;
}
public function append(param1:Quaternion) : Quaternion {
var local2:Number = param1.w * this.w - param1.x * this.x - param1.y * this.y - param1.z * this.z;
var local3:Number = param1.w * this.x + param1.x * this.w + param1.y * this.z - param1.z * this.y;
var local4:Number = param1.w * this.y + param1.y * this.w + param1.z * this.x - param1.x * this.z;
var local5:Number = param1.w * this.z + param1.z * this.w + param1.x * this.y - param1.y * this.x;
this.w = local2;
this.x = local3;
this.y = local4;
this.z = local5;
return this;
}
public function rotateByVector(param1:Vector3) : Quaternion {
var local2:Number = -param1.x * this.x - param1.y * this.y - param1.z * this.z;
var local3:Number = param1.x * this.w + param1.y * this.z - param1.z * this.y;
var local4:Number = param1.y * this.w + param1.z * this.x - param1.x * this.z;
var local5:Number = param1.z * this.w + param1.x * this.y - param1.y * this.x;
this.w = local2;
this.x = local3;
this.y = local4;
this.z = local5;
return this;
}
public function addScaledVector(param1:Vector3, param2:Number) : Quaternion {
var local3:Number = param1.x * param2;
var local4:Number = param1.y * param2;
var local5:Number = param1.z * param2;
var local6:Number = -this.x * local3 - this.y * local4 - this.z * local5;
var local7:Number = local3 * this.w + local4 * this.z - local5 * this.y;
var local8:Number = local4 * this.w + local5 * this.x - local3 * this.z;
var local9:Number = local5 * this.w + local3 * this.y - local4 * this.x;
this.w += 0.5 * local6;
this.x += 0.5 * local7;
this.y += 0.5 * local8;
this.z += 0.5 * local9;
var local10:Number = this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z;
if(local10 == 0) {
this.w = 1;
} else {
local10 = 1 / Math.sqrt(local10);
this.w *= local10;
this.x *= local10;
this.y *= local10;
this.z *= local10;
}
return this;
}
public function toMatrix3(param1:Matrix3) : Quaternion {
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local2:Number = 2 * this.x * this.x;
var local3:Number = 2 * this.y * this.y;
var local4:Number = 2 * this.z * this.z;
var local5:Number = 2 * this.x * this.y;
var local6:Number = 2 * this.y * this.z;
local7 = 2 * this.z * this.x;
local8 = 2 * this.w * this.x;
local9 = 2 * this.w * this.y;
var local10:Number = 2 * this.w * this.z;
param1.m00 = 1 - local3 - local4;
param1.m01 = local5 - local10;
param1.m02 = local7 + local9;
param1.m10 = local5 + local10;
param1.m11 = 1 - local2 - local4;
param1.m12 = local6 - local8;
param1.m20 = local7 - local9;
param1.m21 = local6 + local8;
param1.m22 = 1 - local2 - local3;
return this;
}
public function getYAxis(param1:Vector3) : Vector3 {
var local3:Number = NaN;
var local2:Number = 2 * this.x * this.x;
local3 = 2 * this.z * this.z;
var local4:Number = 2 * this.x * this.y;
var local5:Number = 2 * this.y * this.z;
var local6:Number = 2 * this.w * this.x;
var local7:Number = 2 * this.w * this.z;
param1.x = local4 - local7;
param1.y = 1 - local2 - local3;
param1.z = local5 + local6;
return param1;
}
public function getZAxis(param1:Vector3) : Vector3 {
var local6:Number = NaN;
var local2:Number = 2 * this.x * this.x;
var local3:Number = 2 * this.y * this.y;
var local4:Number = 2 * this.y * this.z;
var local5:Number = 2 * this.z * this.x;
local6 = 2 * this.w * this.x;
var local7:Number = 2 * this.w * this.y;
param1.x = local5 + local7;
param1.y = local4 - local6;
param1.z = 1 - local2 - local3;
return param1;
}
public function toMatrix4(param1:Matrix4) : Quaternion {
var local2:Number = NaN;
var local4:Number = NaN;
var local6:Number = NaN;
var local8:Number = NaN;
local2 = 2 * this.x * this.x;
var local3:Number = 2 * this.y * this.y;
local4 = 2 * this.z * this.z;
var local5:Number = 2 * this.x * this.y;
local6 = 2 * this.y * this.z;
var local7:Number = 2 * this.z * this.x;
local8 = 2 * this.w * this.x;
var local9:Number = 2 * this.w * this.y;
var local10:Number = 2 * this.w * this.z;
param1.m00 = 1 - local3 - local4;
param1.m01 = local5 - local10;
param1.m02 = local7 + local9;
param1.m10 = local5 + local10;
param1.m11 = 1 - local2 - local4;
param1.m12 = local6 - local8;
param1.m20 = local7 - local9;
param1.m21 = local6 + local8;
param1.m22 = 1 - local2 - local3;
return this;
}
public function length() : Number {
return Math.sqrt(this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z);
}
public function lengthSqr() : Number {
return this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z;
}
public function setFromAxisAngle(param1:Vector3, param2:Number) : Quaternion {
this.w = Math.cos(0.5 * param2);
var local3:Number = Math.sin(0.5 * param2) / Math.sqrt(param1.x * param1.x + param1.y * param1.y + param1.z * param1.z);
this.x = param1.x * local3;
this.y = param1.y * local3;
this.z = param1.z * local3;
return this;
}
public function setFromAxisAngleComponents(param1:Number, param2:Number, param3:Number, param4:Number) : Quaternion {
this.w = Math.cos(0.5 * param4);
var local5:Number = Math.sin(0.5 * param4) / Math.sqrt(param1 * param1 + param2 * param2 + param3 * param3);
this.x = param1 * local5;
this.y = param2 * local5;
this.z = param3 * local5;
return this;
}
public function toAxisVector(param1:Vector3 = null) : Vector3 {
var local2:Number = NaN;
var local3:Number = NaN;
if(this.w < -1 || this.w > 1) {
this.normalize();
}
if(param1 == null) {
param1 = new Vector3();
}
if(this.w > -1 && this.w < 1) {
if(this.w == 0) {
param1.x = this.x;
param1.y = this.y;
param1.z = this.z;
} else {
local2 = 2 * Math.acos(this.w);
local3 = 1 / Math.sqrt(1 - this.w * this.w);
param1.x = this.x * local3 * local2;
param1.y = this.y * local3 * local2;
param1.z = this.z * local3 * local2;
}
} else {
param1.x = 0;
param1.y = 0;
param1.z = 0;
}
return param1;
}
public function getEulerAngles(param1:Vector3) : Vector3 {
var local2:Number = 2 * this.x * this.x;
var local3:Number = 2 * this.y * this.y;
var local4:Number = 2 * this.z * this.z;
var local5:Number = 2 * this.x * this.y;
var local6:Number = 2 * this.y * this.z;
var local7:Number = 2 * this.z * this.x;
var local8:Number = 2 * this.w * this.x;
var local9:Number = 2 * this.w * this.y;
var local10:Number = 2 * this.w * this.z;
var local11:Number = 1 - local3 - local4;
var local12:Number = local5 - local10;
var local13:Number = local5 + local10;
var local14:Number = 1 - local2 - local4;
var local15:Number = local7 - local9;
var local16:Number = local6 + local8;
var local17:Number = 1 - local2 - local3;
if(-1 < local15 && local15 < 1) {
if(param1 == null) {
param1 = new Vector3(Math.atan2(local16,local17),-Math.asin(local15),Math.atan2(local13,local11));
} else {
param1.x = Math.atan2(local16,local17);
param1.y = -Math.asin(local15);
param1.z = Math.atan2(local13,local11);
}
} else if(param1 == null) {
param1 = new Vector3(0,0.5 * (local15 <= -1 ? Math.PI : -Math.PI),Math.atan2(-local12,local14));
} else {
param1.x = 0;
param1.y = local15 <= -1 ? Math.PI : -Math.PI;
param1.y *= 0.5;
param1.z = Math.atan2(-local12,local14);
}
return param1;
}
public function setFromEulerAnglesXYZ(param1:Number, param2:Number, param3:Number) : void {
this.setFromAxisAngleComponents(1,0,0,param1);
_q.setFromAxisAngleComponents(0,1,0,param2);
this.append(_q);
this.normalize();
_q.setFromAxisAngleComponents(0,0,1,param3);
this.append(_q);
this.normalize();
}
public function setFromEulerAngles(param1:Vector3) : void {
this.setFromEulerAnglesXYZ(param1.x,param1.y,param1.z);
}
public function conjugate() : void {
this.x = -this.x;
this.y = -this.y;
this.z = -this.z;
}
public function nlerp(param1:Quaternion, param2:Quaternion, param3:Number) : Quaternion {
var local4:Number = 1 - param3;
this.w = param1.w * local4 + param2.w * param3;
this.x = param1.x * local4 + param2.x * param3;
this.y = param1.y * local4 + param2.y * param3;
this.z = param1.z * local4 + param2.z * param3;
local4 = this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z;
if(local4 == 0) {
this.w = 1;
} else {
local4 = 1 / Math.sqrt(local4);
this.w *= local4;
this.x *= local4;
this.y *= local4;
this.z *= local4;
}
return this;
}
public function subtract(param1:Quaternion) : Quaternion {
this.w -= param1.w;
this.x -= param1.x;
this.y -= param1.y;
this.z -= param1.z;
return this;
}
public function diff(param1:Quaternion, param2:Quaternion) : Quaternion {
this.w = param2.w - param1.w;
this.x = param2.x - param1.x;
this.y = param2.y - param1.y;
this.z = param2.z - param1.z;
return this;
}
public function copy(param1:Quaternion) : Quaternion {
this.w = param1.w;
this.x = param1.x;
this.y = param1.y;
this.z = param1.z;
return this;
}
public function toVector3D(param1:Vector3D) : Vector3D {
param1.x = this.x;
param1.y = this.y;
param1.z = this.z;
param1.w = this.w;
return param1;
}
public function clone() : Quaternion {
return new Quaternion(this.w,this.x,this.y,this.z);
}
public function toString() : String {
return getQualifiedClassName(this) + "(" + this.w + ", " + this.x + ", " + this.y + ", " + this.z + ")";
}
public function slerp(param1:Quaternion, param2:Quaternion, param3:Number) : Quaternion {
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local4:Number = 1;
var local5:Number = param1.w * param2.w + param1.x * param2.x + param1.y * param2.y + param1.z * param2.z;
if(local5 < 0) {
local5 = -local5;
local4 = -1;
}
if(1 - local5 < 0.001) {
local6 = 1 - param3;
local7 = param3 * local4;
this.w = param1.w * local6 + param2.w * local7;
this.x = param1.x * local6 + param2.x * local7;
this.y = param1.y * local6 + param2.y * local7;
this.z = param1.z * local6 + param2.z * local7;
this.normalize();
} else {
local8 = Math.acos(local5);
local9 = Math.sin(local8);
local10 = Math.sin((1 - param3) * local8) / local9;
local11 = Math.sin(param3 * local8) / local9 * local4;
this.w = param1.w * local10 + param2.w * local11;
this.x = param1.x * local10 + param2.x * local11;
this.y = param1.y * local10 + param2.y * local11;
this.z = param1.z * local10 + param2.z * local11;
}
return this;
}
public function isFiniteQuaternion() : Boolean {
return isFinite(this.w) && isFinite(this.x) && isFinite(this.y) && isFinite(this.z);
}
}
}
|
package alternativa.tanks.models.weapon.ricochet {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.WeaponObject;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapon.ricochet.RicochetCC;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class RemoteRicochetWeapon implements IRicochetWeapon {
private static const _gunParams:AllGlobalGunParams = new AllGlobalGunParams();
private var recoilForce:Number;
private var ammunition:RicochetAmmunition;
private var effects:RicochetEffects;
private var weaponPlatform:WeaponPlatform;
public function RemoteRicochetWeapon(param1:IGameObject, param2:RicochetCC) {
super();
var local3:IRicochetSFXModel = IRicochetSFXModel(param1.adapt(IRicochetSFXModel));
var local4:WeaponObject = new WeaponObject(param1);
var local5:RicochetAmmunition = new RicochetAmmunition(local4,param2,local3.getSfxData());
this.recoilForce = local4.commonData().getRecoilForce();
this.ammunition = local5;
this.effects = local3.getRicochetEffects();
}
public function init(param1:WeaponPlatform) : void {
this.weaponPlatform = param1;
}
public function shoot(param1:Vector3) : void {
this.weaponPlatform.getAllGunParams(_gunParams);
this.createShotEffects(_gunParams);
var local2:RicochetShot = this.ammunition.getShot();
local2.addToGame(_gunParams,param1,this.weaponPlatform.getBody(),true,-1);
}
public function shootDummy() : void {
this.weaponPlatform.getAllGunParams(_gunParams);
this.createShotEffects(_gunParams);
}
private function createShotEffects(param1:AllGlobalGunParams) : void {
this.weaponPlatform.getBody().addWorldForceScaled(param1.muzzlePosition,param1.direction,-this.recoilForce);
this.weaponPlatform.addDust();
this.effects.createShotEffects(this.weaponPlatform.getTurret3D(),this.weaponPlatform.getLocalMuzzlePosition(),param1.muzzlePosition);
this.effects.createLightEffect(this.weaponPlatform.getTurret3D(),this.weaponPlatform.getLocalMuzzlePosition());
}
public function destroy() : void {
}
public function activate() : void {
}
public function deactivate() : void {
}
public function enable() : void {
}
public function disable(param1:Boolean) : void {
}
public function reset() : void {
}
public function getStatus() : Number {
return 0;
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.RICOCHET_RESISTANCE;
}
public function updateRecoilForce(param1:Number) : void {
this.recoilForce = param1;
}
public function fullyRecharge() : void {
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
}
public function setBuffedMode(param1:Boolean) : void {
}
public function stun() : void {
}
public function calm(param1:int) : void {
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank25.png")]
public class PremiumRankBitmaps_bitmapSmallRank25 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank25() {
super();
}
}
}
|
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.TypeCodecInfo;
import platform.client.models.commons.types.Timestamp;
public class VectorCodecTimestampLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTimestampLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(Timestamp,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.<Timestamp> = new Vector.<Timestamp>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = Timestamp(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:Timestamp = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<Timestamp> = Vector.<Timestamp>(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.chat {
import controls.TankWindowInner;
import controls.base.LabelBase;
import controls.statassets.StatLineBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import forms.ColorConstants;
import forms.userlabel.ChatUpdateEvent;
import projects.tanks.client.chat.models.chat.chat.ChatAddressMode;
import projects.tanks.client.chat.types.MessageType;
import projects.tanks.client.chat.types.UserStatus;
public class ChatOutputLine extends Sprite {
private static const SYSTEM_MESSAGE_COLOR:uint = 8454016;
private static const WARNING_MESSAGE_COLOR:uint = 16776960;
private static const DEFAULT_MESSAGE_COLOR:uint = ColorConstants.WHITE;
private static const UID_COLOR_WITHOUT_LIGHT:uint = 1244928;
private static const UID_COLOR_WITH_LIGHT:uint = 5898034;
private static const PRIVATE_MESSAGE_MARK:String = "→";
private static const PUBLIC_MESSAGE_MARK:String = "—";
private var data:ChatOutputData;
private var _output:LabelBase;
private var _userName:String;
private var _userNameTo:String;
private var _sourceUserLabel:LobbyChatUserLabel;
private var _targetUserLabel:LobbyChatUserLabel;
private var _arrowLabel:LabelBase;
private var _light:Boolean = false;
private var _self:Boolean = false;
private var _namesWidth:int = 0;
private var _messageType:MessageType;
private var _showIP:Boolean;
private var _sourceUserIP:String;
private var _width:int;
private var _background:Bitmap;
public var addressMode:ChatAddressMode;
public function ChatOutputLine(param1:ChatOutputData, param2:int, param3:Boolean, param4:Boolean, param5:String) {
var local8:String = null;
super();
this.data = param1;
var local6:UserStatus = param1.getSender();
var local7:UserStatus = param1.getReceiver();
local8 = param1.getText();
this._width = param2;
this._sourceUserIP = local6.ip;
this._messageType = param1.getMessageType();
this.addressMode = param1.getAddressMode();
mouseEnabled = false;
this._background = new Bitmap();
addChild(this._background);
if(local6.userId != null) {
this._userName = local6.uid;
this._sourceUserLabel = new LobbyChatUserLabel(local6,param3,param5);
addChild(this._sourceUserLabel);
this._sourceUserLabel.setUidColor(UID_COLOR_WITHOUT_LIGHT);
this.updateSourceUserLabel(local7.userId == null);
}
if(local7.userId != null) {
this._userNameTo = local7.uid;
this._targetUserLabel = new LobbyChatUserLabel(local7,param3,param5);
addChild(this._targetUserLabel);
this._targetUserLabel.setUidColor(UID_COLOR_WITHOUT_LIGHT);
this._arrowLabel = new LabelBase();
addChild(this._arrowLabel);
this._arrowLabel.text = this.addressMode == ChatAddressMode.PRIVATE ? PRIVATE_MESSAGE_MARK : PUBLIC_MESSAGE_MARK;
this._arrowLabel.color = this.addressMode == ChatAddressMode.PRIVATE ? DEFAULT_MESSAGE_COLOR : UID_COLOR_WITHOUT_LIGHT;
this.updateTargetUserLabel();
}
this._output = new LabelBase();
this._output.color = this.getMessageColor(this._messageType);
this._output.multiline = true;
this._output.wordWrap = true;
this._output.correctCursorBehaviour = false;
this._output.selectable = true;
addChild(this._output);
if(this._namesWidth > this._width / 2) {
this._output.y = 15;
this._output.x = 0;
this._output.width = this._width - 5;
} else {
this._output.x = this._namesWidth + 3;
this._output.y = 0;
this._output.width = this._width - this._namesWidth - 8;
}
if(param1.isHtml()) {
this._output.htmlText = local8;
} else {
this._output.text = local8;
}
this.showIP = param4;
this.self = param5 == this._userNameTo;
}
public function getData() : ChatOutputData {
return this.data;
}
private function onUpdateTargetUserLabel(param1:ChatUpdateEvent) : void {
this.updateTargetUserLabel();
}
private function onUpdateSourceUserLabel(param1:ChatUpdateEvent) : void {
this.updateSourceUserLabel(this._targetUserLabel == null);
}
private function updateSourceUserLabel(param1:Boolean) : void {
var local2:String = "";
if(this._sourceUserIP != "" && this._messageType == MessageType.USER && this._showIP) {
local2 += " (" + this._sourceUserIP + ")";
}
if(param1) {
local2 += ":";
}
this._sourceUserLabel.setAdditionalText(local2);
if(param1) {
this._namesWidth = this._sourceUserLabel.width + 2;
} else {
this._namesWidth = this._sourceUserLabel.width + 6;
}
}
private function updateTargetUserLabel() : void {
this._targetUserLabel.setAdditionalText(":");
this._targetUserLabel.x = this._sourceUserLabel.x + this._sourceUserLabel.width + 14;
this._namesWidth += this._targetUserLabel.width + 11;
this._arrowLabel.x = this._sourceUserLabel.x + this._sourceUserLabel.width - 1;
}
override public function set width(param1:Number) : void {
var local2:BitmapData = null;
var local4:StatLineBase = null;
var local3:int = 0;
this._width = int(param1);
if(this._namesWidth > this._width / 2 && this._output.text.length * 8 > this._width - this._namesWidth) {
this._output.y = 19;
this._output.x = 0;
this._output.width = this._width - 5;
local3 = 21;
} else {
this._output.x = this._namesWidth;
this._output.y = 0;
this._output.width = this._width - this._namesWidth - 5;
this._output.height = 20;
}
this._background.bitmapData = new BitmapData(1,Math.max(int(this._output.textHeight + 7.5 + local3),19),true,0);
if(this._light || this._self) {
local4 = this._self ? new ChatLineHighlightPrivate() : new ChatLineHighlightNormal();
local4.width = this._width;
local4.height = Math.max(int(this._output.textHeight + 5.5 + local3),19);
local4.y = 2;
local4.graphics.beginFill(0,0);
local4.graphics.drawRect(0,0,2,2);
local4.graphics.endFill();
local2 = new BitmapData(local4.width,local4.height + 2,true,0);
local2.draw(local4);
this._background.bitmapData = local2;
}
}
public function set light(param1:Boolean) : void {
var local2:uint = 0;
if(this._messageType != MessageType.USER) {
return;
}
this._light = param1;
if(this._light) {
local2 = UID_COLOR_WITH_LIGHT;
} else {
local2 = UID_COLOR_WITHOUT_LIGHT;
}
if(this._sourceUserLabel != null) {
this._sourceUserLabel.setUidColor(local2);
}
if(this._targetUserLabel != null) {
this._targetUserLabel.setUidColor(local2);
}
this.width = this._width;
}
public function set self(param1:Boolean) : void {
var local2:uint = 0;
var local3:uint = 0;
if(this._messageType != MessageType.USER) {
return;
}
this._self = param1;
if(this._self) {
local3 = TankWindowInner.GREEN;
local2 = TankWindowInner.GREEN;
} else {
local2 = UID_COLOR_WITHOUT_LIGHT;
local3 = DEFAULT_MESSAGE_COLOR;
}
if(this._sourceUserLabel != null) {
this._sourceUserLabel.setUidColor(local2,this._self);
}
if(this._targetUserLabel != null) {
this._targetUserLabel.setUidColor(local2);
}
this._output.color = local3;
this.width = this._width;
}
public function set showIP(param1:Boolean) : void {
this._showIP = param1;
if(this._sourceUserLabel != null) {
this.updateSourceUserLabel(this._targetUserLabel == null);
}
if(this._targetUserLabel != null) {
this.updateTargetUserLabel();
}
this.width = this._width;
}
public function get userName() : String {
return this._userName;
}
public function get userNameTo() : String {
return this._userNameTo;
}
private function getMessageColor(param1:MessageType) : uint {
switch(param1) {
case MessageType.SYSTEM:
return SYSTEM_MESSAGE_COLOR;
case MessageType.WARNING:
return WARNING_MESSAGE_COLOR;
default:
return DEFAULT_MESSAGE_COLOR;
}
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p22 extends BitmapAsset
{
public function RangIconNormal_p22()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.turret {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class TurretStateSenderAdapt implements TurretStateSender {
private var object:IGameObject;
private var impl:TurretStateSender;
public function TurretStateSenderAdapt(param1:IGameObject, param2:TurretStateSender) {
super();
this.object = param1;
this.impl = param2;
}
public function sendTurretState() : void {
try {
Model.object = this.object;
this.impl.sendTurretState();
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.clan.clanfriends {
import alternativa.tanks.models.user.IClanUserModel;
import alternativa.tanks.service.clan.ClanFriendsService;
import alternativa.tanks.service.clan.ClanMembersListEvent;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.clans.clan.clanfriends.ClanFriendsModelBase;
import projects.tanks.client.clans.clan.clanfriends.IClanFriendsModelBase;
[ModelInfo]
public class ClanFriendsModel extends ClanFriendsModelBase implements IClanFriendsModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var clanFriendsService:ClanFriendsService;
public function ClanFriendsModel() {
super();
}
public function objectLoaded() : void {
if(!this.isServiceSpace()) {
return;
}
clanFriendsService.clanMembers = getInitParam().users.concat();
}
public function onUserAdd(param1:Long) : void {
if(!this.isServiceSpace()) {
return;
}
clanFriendsService.clanMembers.push(param1);
clanFriendsService.dispatchEvent(new ClanMembersListEvent(ClanMembersListEvent.ACCEPTED_USER,param1));
}
public function onUserRemove(param1:Long) : void {
if(!this.isServiceSpace()) {
return;
}
var local2:int = int(clanFriendsService.clanMembers.indexOf(param1));
if(local2 >= 0) {
clanFriendsService.clanMembers.splice(local2,1);
clanFriendsService.dispatchEvent(new ClanMembersListEvent(ClanMembersListEvent.REMOVE_USER,param1));
}
}
public function userJoinClan(param1:Vector.<Long>) : void {
if(!this.isServiceSpace()) {
return;
}
clanFriendsService.clanMembers = param1.concat();
}
public function objectUnloaded() : void {
if(!this.isServiceSpace()) {
return;
}
clanFriendsService.clanMembers = null;
}
private function isServiceSpace() : Boolean {
return IClanUserModel(object.adapt(IClanUserModel)).loadingInServiceSpace();
}
}
}
|
package alternativa.tanks.battle.events {
import alternativa.tanks.battle.objects.tank.Tank;
public class TankUnloadedEvent {
public var tank:Tank;
public var isLocal:Boolean;
public function TankUnloadedEvent(param1:Tank, param2:Boolean) {
super();
this.tank = param1;
this.isLocal = param2;
}
}
}
|
package scpacker.server.models.mines
{
import alternativa.init.Main;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import alternativa.tanks.models.battlefield.mine.BattleMinesModel;
import com.alternativaplatform.projects.tanks.client.models.battlefield.mine.BattleMine;
import com.alternativaplatform.projects.tanks.client.models.battlefield.mine.IBattleMinesModelBase;
public class ServerBattleMinesModel
{
private static const __object:ClientObject = new ClientObject("ServerBattleMinesModel_obj",null,"ServerBattleMinesModel_obj",null);
private var model:BattleMinesModel;
private var modelsService:IModelService;
public function ServerBattleMinesModel()
{
super();
}
public function init() : void
{
this.modelsService = IModelService(Main.osgi.getService(IModelService));
this.model = BattleMinesModel(this.modelsService.getModelsByInterface(IBattleMinesModelBase)[0]);
}
public function initModel(data:String) : void
{
var json:Object = JSON.parse(data);
this.model.initObject(__object,"activationSound_mine",json.activationTimeMsec,"blueMineTexture","deactivationSound_mine","enemyMineTexture","explosionSound_mine",json.farVisibilityRadius,"friendlyMineTexture_mine","idleExplosionTexture_mine",json.impactForce,"mainExplosionTextureId_mine",json.minDistanceFromBase,"modelId_mine",json.nearVisibilityRadius,json.radius,"redMineTexture_mine");
this.model.objectLoaded(__object);
}
public function initMines(data:String) : void
{
var obj:Object = null;
var mine:BattleMine = null;
var json:Object = JSON.parse(data);
var _mines:Array = new Array();
for each(obj in json.mines)
{
mine = new BattleMine(true,obj.mineId,obj.ownerId,obj.x,obj.y,obj.z);
_mines.push(mine);
}
this.model.initMines(null,_mines);
}
public function removeMines(ownerId:String) : void
{
this.model.removeMines(null,ownerId);
}
public function putMine(ownerObject:ClientObject, data:Object) : void
{
var json:Object = data;
this.model.putMine(ownerObject,json.mineId,json.x,json.y,json.z,json.userId);
}
public function activateMine(ownerId:String) : void
{
this.model.activateMine(null,ownerId);
}
public function hitMine(ownerObject:ClientObject, mineId:String) : void
{
this.model.explodeMine(ownerObject,mineId,ownerObject.id);
}
}
}
|
package controls.base {
import controls.TankInput;
import flash.events.MouseEvent;
import flash.text.TextFieldType;
import flash.ui.Mouse;
import flash.ui.MouseCursor;
import utils.FontParamsUtil;
public class TankInputBase extends controls.TankInput {
public function TankInputBase() {
super();
_label.sharpness = FontParamsUtil.SHARPNESS_LABEL_BASE;
_label.thickness = FontParamsUtil.THICKNESS_LABEL_BASE;
textField.sharpness = FontParamsUtil.SHARPNESS_TANK_INPUT_BASE;
textField.thickness = FontParamsUtil.THICKNESS_TANK_INPUT_BASE;
textField.addEventListener(MouseEvent.MOUSE_OVER,this.onMouseOver);
textField.addEventListener(MouseEvent.MOUSE_OUT,this.onMouseOut);
}
private function onMouseOver(param1:MouseEvent) : void {
Mouse.cursor = MouseCursor.IBEAM;
}
private function onMouseOut(param1:MouseEvent) : void {
Mouse.cursor = MouseCursor.AUTO;
}
public function set enable(param1:Boolean) : void {
textField.type = param1 ? TextFieldType.INPUT : TextFieldType.DYNAMIC;
textField.selectable = param1;
textField.mouseEnabled = param1;
textField.mouseWheelEnabled = param1;
textField.tabEnabled = param1;
}
override public function set x(param1:Number) : void {
super.x = int(param1);
}
override public function set y(param1:Number) : void {
super.y = int(param1);
}
override public function set width(param1:Number) : void {
super.width = Math.ceil(param1);
}
override public function set height(param1:Number) : void {
super.height = Math.ceil(param1);
}
}
}
|
package alternativa.engine3d.core
{
import alternativa.engine3d.alternativa3d;
use namespace alternativa3d;
public class Light3D extends Object3D
{
public var color:uint;
public var intensity:Number = 1;
alternativa3d var localWeight:Number;
alternativa3d var localRed:Number;
alternativa3d var localGreen:Number;
alternativa3d var localBlue:Number;
alternativa3d var cma:Number;
alternativa3d var cmb:Number;
alternativa3d var cmc:Number;
alternativa3d var cmd:Number;
alternativa3d var cme:Number;
alternativa3d var cmf:Number;
alternativa3d var cmg:Number;
alternativa3d var cmh:Number;
alternativa3d var cmi:Number;
alternativa3d var cmj:Number;
alternativa3d var cmk:Number;
alternativa3d var cml:Number;
alternativa3d var oma:Number;
alternativa3d var omb:Number;
alternativa3d var omc:Number;
alternativa3d var omd:Number;
alternativa3d var ome:Number;
alternativa3d var omf:Number;
alternativa3d var omg:Number;
alternativa3d var omh:Number;
alternativa3d var omi:Number;
alternativa3d var omj:Number;
alternativa3d var omk:Number;
alternativa3d var oml:Number;
alternativa3d var nextLight:Light3D;
public function Light3D()
{
super();
}
override public function clone() : Object3D
{
var _loc1_:Light3D = new Light3D();
_loc1_.clonePropertiesFrom(this);
return _loc1_;
}
override protected function clonePropertiesFrom(param1:Object3D) : void
{
super.clonePropertiesFrom(param1);
var _loc2_:Light3D = param1 as Light3D;
this.color = _loc2_.color;
this.intensity = _loc2_.intensity;
}
alternativa3d function calculateCameraMatrix(param1:Camera3D) : void
{
composeMatrix();
var _loc2_:Object3D = this;
while(_loc2_._parent != null)
{
_loc2_ = _loc2_._parent;
_loc2_.composeMatrix();
appendMatrix(_loc2_);
}
appendMatrix(param1);
this.cma = ma;
this.cmb = mb;
this.cmc = mc;
this.cmd = md;
this.cme = me;
this.cmf = mf;
this.cmg = mg;
this.cmh = mh;
this.cmi = mi;
this.cmj = mj;
this.cmk = mk;
this.cml = ml;
}
alternativa3d function calculateObjectMatrix(param1:Object3D) : void
{
this.oma = param1.ima * this.cma + param1.imb * this.cme + param1.imc * this.cmi;
this.omb = param1.ima * this.cmb + param1.imb * this.cmf + param1.imc * this.cmj;
this.omc = param1.ima * this.cmc + param1.imb * this.cmg + param1.imc * this.cmk;
this.omd = param1.ima * this.cmd + param1.imb * this.cmh + param1.imc * this.cml + param1.imd;
this.ome = param1.ime * this.cma + param1.imf * this.cme + param1.img * this.cmi;
this.omf = param1.ime * this.cmb + param1.imf * this.cmf + param1.img * this.cmj;
this.omg = param1.ime * this.cmc + param1.imf * this.cmg + param1.img * this.cmk;
this.omh = param1.ime * this.cmd + param1.imf * this.cmh + param1.img * this.cml + param1.imh;
this.omi = param1.imi * this.cma + param1.imj * this.cme + param1.imk * this.cmi;
this.omj = param1.imi * this.cmb + param1.imj * this.cmf + param1.imk * this.cmj;
this.omk = param1.imi * this.cmc + param1.imj * this.cmg + param1.imk * this.cmk;
this.oml = param1.imi * this.cmd + param1.imj * this.cmh + param1.imk * this.cml + param1.iml;
}
override alternativa3d function setParent(param1:Object3DContainer) : void
{
var _loc2_:Object3DContainer = null;
var _loc3_:Light3D = null;
var _loc4_:Light3D = null;
if(param1 == null)
{
_loc2_ = _parent;
while(_loc2_._parent != null)
{
_loc2_ = _loc2_._parent;
}
_loc4_ = _loc2_.lightList;
while(_loc4_ != null)
{
if(_loc4_ == this)
{
if(_loc3_ != null)
{
_loc3_.nextLight = this.nextLight;
}
else
{
_loc2_.lightList = this.nextLight;
}
this.nextLight = null;
break;
}
_loc3_ = _loc4_;
_loc4_ = _loc4_.nextLight;
}
}
else
{
_loc2_ = param1;
while(_loc2_._parent != null)
{
_loc2_ = _loc2_._parent;
}
this.nextLight = _loc2_.lightList;
_loc2_.lightList = this;
}
_parent = param1;
}
alternativa3d function drawDebug(param1:Camera3D) : void
{
}
override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void
{
param1.boundMinX = -1e+22;
param1.boundMinY = -1e+22;
param1.boundMinZ = -1e+22;
param1.boundMaxX = 1e+22;
param1.boundMaxY = 1e+22;
param1.boundMaxZ = 1e+22;
}
override alternativa3d function cullingInCamera(param1:Camera3D, param2:int) : int
{
return -1;
}
alternativa3d function checkFrustumCulling(param1:Camera3D) : Boolean
{
var _loc2_:Vertex = boundVertexList;
_loc2_.x = boundMinX;
_loc2_.y = boundMinY;
_loc2_.z = boundMinZ;
_loc2_ = _loc2_.next;
_loc2_.x = boundMaxX;
_loc2_.y = boundMinY;
_loc2_.z = boundMinZ;
_loc2_ = _loc2_.next;
_loc2_.x = boundMinX;
_loc2_.y = boundMaxY;
_loc2_.z = boundMinZ;
_loc2_ = _loc2_.next;
_loc2_.x = boundMaxX;
_loc2_.y = boundMaxY;
_loc2_.z = boundMinZ;
_loc2_ = _loc2_.next;
_loc2_.x = boundMinX;
_loc2_.y = boundMinY;
_loc2_.z = boundMaxZ;
_loc2_ = _loc2_.next;
_loc2_.x = boundMaxX;
_loc2_.y = boundMinY;
_loc2_.z = boundMaxZ;
_loc2_ = _loc2_.next;
_loc2_.x = boundMinX;
_loc2_.y = boundMaxY;
_loc2_.z = boundMaxZ;
_loc2_ = _loc2_.next;
_loc2_.x = boundMaxX;
_loc2_.y = boundMaxY;
_loc2_.z = boundMaxZ;
_loc2_ = boundVertexList;
while(_loc2_ != null)
{
_loc2_.cameraX = ma * _loc2_.x + mb * _loc2_.y + mc * _loc2_.z + md;
_loc2_.cameraY = me * _loc2_.x + mf * _loc2_.y + mg * _loc2_.z + mh;
_loc2_.cameraZ = mi * _loc2_.x + mj * _loc2_.y + mk * _loc2_.z + ml;
_loc2_ = _loc2_.next;
}
_loc2_ = boundVertexList;
while(_loc2_ != null)
{
if(_loc2_.cameraZ > param1.nearClipping)
{
break;
}
_loc2_ = _loc2_.next;
}
if(_loc2_ == null)
{
return false;
}
_loc2_ = boundVertexList;
while(_loc2_ != null)
{
if(_loc2_.cameraZ < param1.farClipping)
{
break;
}
_loc2_ = _loc2_.next;
}
if(_loc2_ == null)
{
return false;
}
_loc2_ = boundVertexList;
while(_loc2_ != null)
{
if(-_loc2_.cameraX < _loc2_.cameraZ)
{
break;
}
_loc2_ = _loc2_.next;
}
if(_loc2_ == null)
{
return false;
}
_loc2_ = boundVertexList;
while(_loc2_ != null)
{
if(_loc2_.cameraX < _loc2_.cameraZ)
{
break;
}
_loc2_ = _loc2_.next;
}
if(_loc2_ == null)
{
return false;
}
_loc2_ = boundVertexList;
while(_loc2_ != null)
{
if(-_loc2_.cameraY < _loc2_.cameraZ)
{
break;
}
_loc2_ = _loc2_.next;
}
if(_loc2_ == null)
{
return false;
}
_loc2_ = boundVertexList;
while(_loc2_ != null)
{
if(_loc2_.cameraY < _loc2_.cameraZ)
{
break;
}
_loc2_ = _loc2_.next;
}
if(_loc2_ == null)
{
return false;
}
return true;
}
alternativa3d function checkBoundsIntersection(param1:Object3D) : Boolean
{
var _loc2_:Number = NaN;
var _loc3_:Number = NaN;
var _loc4_:Number = (boundMaxX - boundMinX) * 0.5;
var _loc5_:Number = (boundMaxY - boundMinY) * 0.5;
var _loc6_:Number = (boundMaxZ - boundMinZ) * 0.5;
var _loc7_:Number = this.oma * _loc4_;
var _loc8_:Number = this.ome * _loc4_;
var _loc9_:Number = this.omi * _loc4_;
var _loc10_:Number = this.omb * _loc5_;
var _loc11_:Number = this.omf * _loc5_;
var _loc12_:Number = this.omj * _loc5_;
var _loc13_:Number = this.omc * _loc6_;
var _loc14_:Number = this.omg * _loc6_;
var _loc15_:Number = this.omk * _loc6_;
var _loc16_:Number = (param1.boundMaxX - param1.boundMinX) * 0.5;
var _loc17_:Number = (param1.boundMaxY - param1.boundMinY) * 0.5;
var _loc18_:Number = (param1.boundMaxZ - param1.boundMinZ) * 0.5;
var _loc19_:Number = this.oma * (boundMinX + _loc4_) + this.omb * (boundMinY + _loc5_) + this.omc * (boundMinZ + _loc6_) + this.omd - param1.boundMinX - _loc16_;
var _loc20_:Number = this.ome * (boundMinX + _loc4_) + this.omf * (boundMinY + _loc5_) + this.omg * (boundMinZ + _loc6_) + this.omh - param1.boundMinY - _loc17_;
var _loc21_:Number = this.omi * (boundMinX + _loc4_) + this.omj * (boundMinY + _loc5_) + this.omk * (boundMinZ + _loc6_) + this.oml - param1.boundMinZ - _loc18_;
_loc2_ = 0;
_loc3_ = _loc7_ >= 0 ? Number(Number(_loc7_)) : Number(Number(-_loc7_));
_loc2_ += _loc3_;
_loc3_ = _loc10_ >= 0 ? Number(Number(_loc10_)) : Number(Number(-_loc10_));
_loc2_ += _loc3_;
_loc3_ = _loc13_ >= 0 ? Number(Number(_loc13_)) : Number(Number(-_loc13_));
_loc2_ += _loc3_;
_loc2_ += _loc16_;
_loc3_ = _loc19_ >= 0 ? Number(Number(_loc19_)) : Number(Number(-_loc19_));
_loc2_ -= _loc3_;
if(_loc2_ <= 0)
{
return false;
}
_loc2_ = 0;
_loc3_ = _loc8_ >= 0 ? Number(Number(_loc8_)) : Number(Number(-_loc8_));
_loc2_ += _loc3_;
_loc3_ = _loc11_ >= 0 ? Number(Number(_loc11_)) : Number(Number(-_loc11_));
_loc2_ += _loc3_;
_loc3_ = _loc14_ >= 0 ? Number(Number(_loc14_)) : Number(Number(-_loc14_));
_loc2_ += _loc3_;
_loc2_ += _loc17_;
_loc3_ = _loc20_ >= 0 ? Number(Number(_loc20_)) : Number(Number(-_loc20_));
_loc2_ -= _loc3_;
if(_loc2_ <= 0)
{
return false;
}
_loc2_ = 0;
_loc3_ = _loc9_ >= 0 ? Number(Number(_loc9_)) : Number(Number(-_loc9_));
_loc2_ += _loc3_;
_loc3_ = _loc12_ >= 0 ? Number(Number(_loc12_)) : Number(Number(-_loc12_));
_loc2_ += _loc3_;
_loc3_ = _loc15_ >= 0 ? Number(Number(_loc15_)) : Number(Number(-_loc15_));
_loc2_ += _loc3_;
_loc2_ += _loc17_;
_loc3_ = _loc21_ >= 0 ? Number(Number(_loc21_)) : Number(Number(-_loc21_));
_loc2_ -= _loc3_;
if(_loc2_ <= 0)
{
return false;
}
_loc2_ = 0;
_loc3_ = this.oma * _loc7_ + this.ome * _loc8_ + this.omi * _loc9_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ += _loc3_;
_loc3_ = this.oma * _loc10_ + this.ome * _loc11_ + this.omi * _loc12_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ += _loc3_;
_loc3_ = this.oma * _loc13_ + this.ome * _loc14_ + this.omi * _loc15_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ += _loc3_;
_loc3_ = this.oma >= 0 ? Number(Number(this.oma * _loc16_)) : Number(Number(-this.oma * _loc16_));
_loc2_ += _loc3_;
_loc3_ = this.ome >= 0 ? Number(Number(this.ome * _loc17_)) : Number(Number(-this.ome * _loc17_));
_loc2_ += _loc3_;
_loc3_ = this.omi >= 0 ? Number(Number(this.omi * _loc18_)) : Number(Number(-this.omi * _loc18_));
_loc2_ += _loc3_;
_loc3_ = this.oma * _loc19_ + this.ome * _loc20_ + this.omi * _loc21_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ -= _loc3_;
if(_loc2_ <= 0)
{
return false;
}
_loc2_ = 0;
_loc3_ = this.omb * _loc7_ + this.omf * _loc8_ + this.omj * _loc9_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ += _loc3_;
_loc3_ = this.omb * _loc10_ + this.omf * _loc11_ + this.omj * _loc12_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ += _loc3_;
_loc3_ = this.omb * _loc13_ + this.omf * _loc14_ + this.omj * _loc15_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ += _loc3_;
_loc3_ = this.omb >= 0 ? Number(Number(this.omb * _loc16_)) : Number(Number(-this.omb * _loc16_));
_loc2_ += _loc3_;
_loc3_ = this.omf >= 0 ? Number(Number(this.omf * _loc17_)) : Number(Number(-this.omf * _loc17_));
_loc2_ += _loc3_;
_loc3_ = this.omj >= 0 ? Number(Number(this.omj * _loc18_)) : Number(Number(-this.omj * _loc18_));
_loc2_ += _loc3_;
_loc3_ = this.omb * _loc19_ + this.omf * _loc20_ + this.omj * _loc21_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ -= _loc3_;
if(_loc2_ <= 0)
{
return false;
}
_loc2_ = 0;
_loc3_ = this.omc * _loc7_ + this.omg * _loc8_ + this.omk * _loc9_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ += _loc3_;
_loc3_ = this.omc * _loc10_ + this.omg * _loc11_ + this.omk * _loc12_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ += _loc3_;
_loc3_ = this.omc * _loc13_ + this.omg * _loc14_ + this.omk * _loc15_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ += _loc3_;
_loc3_ = this.omc >= 0 ? Number(Number(this.omc * _loc16_)) : Number(Number(-this.omc * _loc16_));
_loc2_ += _loc3_;
_loc3_ = this.omg >= 0 ? Number(Number(this.omg * _loc17_)) : Number(Number(-this.omg * _loc17_));
_loc2_ += _loc3_;
_loc3_ = this.omk >= 0 ? Number(Number(this.omk * _loc18_)) : Number(Number(-this.omk * _loc18_));
_loc2_ += _loc3_;
_loc3_ = this.omc * _loc19_ + this.omg * _loc20_ + this.omk * _loc21_;
_loc3_ = _loc3_ >= 0 ? Number(Number(_loc3_)) : Number(Number(-_loc3_));
_loc2_ -= _loc3_;
if(_loc2_ <= 0)
{
return false;
}
return true;
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_bitmapmachinegunResistance_x2.png")]
public class ResistancesIcons_bitmapmachinegunResistance_x2 extends BitmapAsset {
public function ResistancesIcons_bitmapmachinegunResistance_x2() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon {
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.laser.LaserPointer;
import alternativa.tanks.models.weapon.rocketlauncher.Rocket;
import alternativa.tanks.models.weapon.rocketlauncher.RocketLauncherObject;
import alternativa.tanks.models.weapon.rocketlauncher.radio.RocketExplodeEvent;
import alternativa.tanks.models.weapon.rocketlauncher.sfx.RocketLauncherEffects;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.RocketTargetPoint;
import projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher.RocketLauncherCC;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class RemoteRocketLauncherWeapon implements Weapon {
[Inject]
public static var battleService:BattleService;
private static const allGunParams:AllGlobalGunParams = new AllGlobalGunParams();
private var weaponObject:RocketLauncherObject;
private var rocketLauncherParams:RocketLauncherCC;
private var weaponPlatform:WeaponPlatform;
private var effects:RocketLauncherEffects;
private var target:RocketTargetPoint = new RocketTargetPoint();
private var recoilForce:Number;
public function RemoteRocketLauncherWeapon(param1:RocketLauncherObject, param2:RocketLauncherCC) {
super();
this.weaponObject = param1;
this.rocketLauncherParams = param2;
}
public function init(param1:WeaponPlatform) : void {
this.weaponPlatform = param1;
this.effects = new RocketLauncherEffects(this.weaponObject.getSfxData(),param1.getTurret3D());
this.recoilForce = this.weaponObject.commonData().getRecoilForce();
}
public function destroy() : void {
this.weaponObject = null;
this.rocketLauncherParams = null;
this.weaponPlatform = null;
this.target.resetTarget();
this.target = null;
}
public function activate() : void {
}
public function enable() : void {
}
public function deactivate() : void {
this.stopEffects();
}
public function disable(param1:Boolean) : void {
this.stopEffects();
}
public function reset() : void {
this.stopEffects();
}
private function stopEffects() : void {
LaserPointer(this.weaponObject.getObject().adapt(LaserPointer)).hideLaser();
}
public function getStatus() : Number {
return 0;
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.ROCKET_LAUNCHER_RESISTANCE;
}
public function dummyShoot(param1:int) : void {
this.weaponPlatform.getAllGunParams(allGunParams,param1);
this.createShotEffects(param1);
}
public function simpleShoot(param1:int, param2:Vector3, param3:int) : void {
this.target.resetTarget();
this.shoot(param3,param1,param2);
}
public function salvoShoot(param1:int, param2:Vector3, param3:int, param4:Tank, param5:Vector3) : void {
this.target.setTank(param4);
this.target.setLocalPoint(param5);
this.shoot(param3,param1,param2);
}
private function shoot(param1:int, param2:int, param3:Vector3) : void {
this.weaponPlatform.getAllGunParams(allGunParams,param2);
this.createShotEffects(param2);
var local4:Rocket = Rocket(battleService.getObjectPool().getObject(Rocket));
local4.init(this.rocketLauncherParams,this.weaponObject,this.target,param2,this.effects,RocketExplodeEvent.SINGLE);
local4.addToGame(allGunParams,param3,this.weaponPlatform.getBody(),true,param1);
}
private function createShotEffects(param1:int) : void {
this.weaponPlatform.getBody().addWorldForceScaled(allGunParams.muzzlePosition,allGunParams.direction,-this.recoilForce);
this.weaponPlatform.addDust();
this.effects.playShotEffect(allGunParams.muzzlePosition,param1);
}
public function explodeRocket(param1:int) : void {
this.weaponObject.dispatchEvent(new RocketExplodeEvent(RocketExplodeEvent.SINGLE,param1));
}
public function updateRecoilForce(param1:Number) : void {
this.recoilForce = param1;
}
public function fullyRecharge() : void {
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
}
public function stun() : void {
}
public function calm(param1:int) : void {
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.ricochet {
import platform.client.fp10.core.type.IGameObject;
public interface IRicochetModelBase {
function addEnergy(param1:int) : void;
function fire(param1:IGameObject, param2:int, param3:int, param4:int) : void;
function fireDummy(param1:IGameObject) : void;
function reconfigureWeapon(param1:Number, param2:Number) : void;
}
}
|
package alternativa.tanks.model.donationalert {
import alternativa.osgi.OSGi;
import alternativa.tanks.gui.EmailBlockRequestEvent;
import alternativa.tanks.gui.ThanksForPurchaseWindow;
import alternativa.tanks.service.paymentcomplete.PaymentCompleteService;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.types.Long;
import flash.display.BitmapData;
import flash.events.Event;
import flash.utils.setTimeout;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.client.panel.model.donationalert.DonationAlertModelBase;
import projects.tanks.client.panel.model.donationalert.IDonationAlertModelBase;
import projects.tanks.client.panel.model.donationalert.types.DonationData;
import projects.tanks.client.panel.model.donationalert.types.GoodInfoData;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
[ModelInfo]
public class DonationAlertModel extends DonationAlertModelBase implements IDonationAlertModelBase, ObjectLoadListener, ObjectUnloadListener, ThanksForDonationFormService {
[Inject]
public static var settingsService:ISettingsService;
[Inject]
public static var paymentCompleteService:PaymentCompleteService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
private var window:ThanksForPurchaseWindow = null;
private var time:Long = null;
private var confirmTime:Long;
private var goods:Vector.<GoodInfoData> = new Vector.<GoodInfoData>();
private var showEmailBlock:Boolean = false;
private var currentObject:IGameObject;
public function DonationAlertModel() {
super();
}
public function objectLoaded() : void {
this.currentObject = object;
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,getFunctionWrapper(this.onEndLayoutSwitch));
OSGi.getInstance().registerService(ThanksForDonationFormService,this);
}
private function onEndLayoutSwitch(param1:LobbyLayoutServiceEvent) : void {
if(param1.state != LayoutState.BATTLE) {
this.showAlertIfPossible();
}
}
public function objectUnloaded() : void {
OSGi.getInstance().unregisterService(ThanksForDonationFormService);
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,getFunctionWrapper(this.onEndLayoutSwitch));
this.currentObject = null;
}
private function showAlertIfPossible() : void {
if(this.window == null && this.goods.length > 0 && lobbyLayoutService.getCurrentState() != LayoutState.BATTLE && !lobbyLayoutService.isSwitchInProgress()) {
this.window = this.createForm(this.goods,this.showEmailBlock);
this.confirmTime = this.time;
this.goods.length = 0;
this.show();
}
paymentCompleteService.paymentCompleted();
}
public function showDonationAlert(param1:DonationData) : void {
this.updateData(param1);
this.showAlertIfPossible();
}
public function showDonationAlertWithEmailBlock(param1:DonationData) : void {
this.showEmailBlock = true;
this.updateData(param1);
this.showAlertIfPossible();
}
public function getThanksForPurchaseForm(param1:Vector.<GoodInfoData>, param2:Boolean) : ThanksForPurchaseWindow {
var form:ThanksForPurchaseWindow = null;
var items:Vector.<GoodInfoData> = param1;
var requiredEmail:Boolean = param2;
try {
object = this.currentObject;
form = this.createForm(items,requiredEmail);
}
finally {
popObject();
}
return form;
}
private function createForm(param1:Vector.<GoodInfoData>, param2:Boolean) : ThanksForPurchaseWindow {
var local3:BitmapData = null;
if(param2) {
local3 = getInitParam().imageWithEmail.data;
} else {
local3 = getInitParam().imageWithoutEmail.data;
}
return new ThanksForPurchaseWindow(local3,param1,param2);
}
private function updateData(param1:DonationData) : void {
var local2:GoodInfoData = null;
var local3:GoodInfoData = null;
this.time = param1.time;
for each(local2 in param1.goods) {
local3 = this.findGood(local2.name);
if(local3 == null) {
this.goods.push(local2);
} else {
local3.count += local2.count;
}
}
}
private function findGood(param1:String) : GoodInfoData {
var local2:GoodInfoData = null;
for each(local2 in this.goods) {
if(param1 == local2.name) {
return local2;
}
}
return null;
}
public function showEmailIsBusy(param1:String) : void {
this.window.showEmailIsBusy(param1);
}
public function showEmailIsForbidden(param1:String) : void {
this.window.showEmailIsForbidden(param1);
}
public function showEmailIsFree(param1:String) : void {
this.window.showEmailIsFree(param1);
}
private function onClose(param1:Event) : void {
this.window.removeEventListener(Event.CANCEL,getFunctionWrapper(this.onClose));
this.window.removeEventListener(EmailBlockRequestEvent.SEND_VALIDATE_EMAIL_REQUEST_EVENT,getFunctionWrapper(this.onValidateEmail));
if(this.window.hasEmailBlock) {
server.confirmWithEmail(this.confirmTime,this.window.email);
settingsService.setEmail(this.window.email,false);
} else {
server.confirm(this.confirmTime);
}
this.window.destroy();
this.window = null;
this.showEmailBlock = false;
if(this.goods.length > 0) {
setTimeout(getFunctionWrapper(this.showAlertIfPossible),1000);
}
}
private function show() : void {
this.window.addInDialogLayer();
this.window.addEventListener(Event.CANCEL,getFunctionWrapper(this.onClose));
this.window.addEventListener(EmailBlockRequestEvent.SEND_VALIDATE_EMAIL_REQUEST_EVENT,getFunctionWrapper(this.onValidateEmail));
}
private function onValidateEmail(param1:EmailBlockRequestEvent) : void {
server.validateEmail(param1.email);
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.terminator.sfx {
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.weapon.terminator.sfx.TerminatorSFXCC;
public class VectorCodecTerminatorSFXCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTerminatorSFXCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TerminatorSFXCC,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.<TerminatorSFXCC> = new Vector.<TerminatorSFXCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TerminatorSFXCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TerminatorSFXCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TerminatorSFXCC> = Vector.<TerminatorSFXCC>(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.math
{
import flash.geom.Vector3D;
public class Vector3 extends Vector3D
{
public static const ZERO:Vector3 = new Vector3(0,0,0);
public static const X_AXIS:Vector3 = new Vector3(1,0,0);
public static const Y_AXIS:Vector3 = new Vector3(0,1,0);
public static const Z_AXIS:Vector3 = new Vector3(0,0,1);
public static const DOWN:Vector3 = new Vector3(0,0,-1);
private var x_:Number;
private var y_:Number;
private var z_:Number;
public function Vector3(x:Number = 0, y:Number = 0, z:Number = 0)
{
super();
this.x = x;
this.y = y;
this.z = z;
}
public static function interpolate(param1:Number, param2:Vector3, param3:Vector3, param4:Vector3) : void
{
param4.x = param2.x + param1 * (param3.x - param2.x);
param4.y = param2.y + param1 * (param3.y - param2.y);
param4.z = param2.z + param1 * (param3.z - param2.z);
}
public static function distanceBetween(param1:Vector3, param2:Vector3) : Number
{
var _loc3_:Number = param1.x - param2.x;
var _loc4_:Number = param1.y - param2.y;
var _loc5_:Number = param1.z - param2.z;
return Math.sqrt(_loc3_ * _loc3_ + _loc4_ * _loc4_ + _loc5_ * _loc5_);
}
public function vLength() : Number
{
return Math.sqrt(x * x + y * y + z * z);
}
public function vLengthSqr() : Number
{
return x * x + y * y + z * z;
}
public function vSetLength(length:Number) : Vector3
{
var k:Number = NaN;
var d:Number = x * x + y * y + z * z;
if(d == 0)
{
x = length;
}
else
{
k = length / Math.sqrt(x * x + y * y + z * z);
x *= k;
y *= k;
z *= k;
}
return this;
}
public function vNormalize() : Vector3
{
var d:Number = x * x + y * y + z * z;
if(d == 0)
{
x = 1;
}
else
{
d = Math.sqrt(d);
x /= d;
y /= d;
z /= d;
}
return this;
}
public function vAdd(v:Vector3) : Vector3
{
x += v.x;
y += v.y;
z += v.z;
return this;
}
public function vRemove(v:Vector3) : Vector3
{
x -= v.x;
y -= v.y;
z -= v.z;
return this;
}
public function vAddScaled(k:Number, v:Vector3) : Vector3
{
x += k * v.x;
y += k * v.y;
z += k * v.z;
return this;
}
public function vSubtract(v:Vector3) : Vector3
{
x -= v.x;
y -= v.y;
z -= v.z;
return this;
}
public function vSum(a:Vector3, b:Vector3) : Vector3
{
x = a.x + b.x;
y = a.y + b.y;
z = a.z + b.z;
return this;
}
public function vDiff(a:Vector3, b:Vector3) : Vector3
{
x = a.x - b.x;
y = a.y - b.y;
z = a.z - b.z;
return this;
}
public function vCosAngle(v:Vector3) : Number
{
return (x * v.x + y * v.y + z * v.z) / (Math.sqrt(x * x + y * y + z * z) * Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z));
}
public function vScale(k:Number) : Vector3
{
x *= k;
y *= k;
z *= k;
return this;
}
public function vReverse() : Vector3
{
x = -x;
y = -y;
z = -z;
return this;
}
public function distanceToSquared(param1:Vector3) : Number
{
var _loc2_:Number = this.x - param1.x;
var _loc3_:Number = this.y - param1.y;
var _loc4_:Number = this.z - param1.z;
return _loc2_ * _loc2_ + _loc3_ * _loc3_ + _loc4_ * _loc4_;
}
public function vDot(v:Vector3) : Number
{
return x * v.x + y * v.y + z * v.z;
}
public function vCross(v:Vector3) : Vector3
{
var xx:Number = y * v.z - z * v.y;
var yy:Number = z * v.x - x * v.z;
var zz:Number = x * v.y - y * v.x;
x = xx;
y = yy;
z = zz;
return this;
}
public function vCross2(a:Vector3, b:Vector3) : Vector3
{
x = a.y * b.z - a.z * b.y;
y = a.z * b.x - a.x * b.z;
z = a.x * b.y - a.y * b.x;
return this;
}
public function vTransformBy3(m:Matrix3) : Vector3
{
var xx:Number = x;
var yy:Number = y;
var zz:Number = z;
x = m.a * xx + m.b * yy + m.c * zz;
y = m.e * xx + m.f * yy + m.g * zz;
z = m.i * xx + m.j * yy + m.k * zz;
return this;
}
public function vTransformBy3Tr(m:Matrix3) : Vector3
{
var xx:Number = x;
var yy:Number = y;
var zz:Number = z;
x = m.a * xx + m.e * yy + m.i * zz;
y = m.b * xx + m.f * yy + m.j * zz;
z = m.c * xx + m.g * yy + m.k * zz;
return this;
}
public function vTransformBy4(m:Matrix4) : Vector3
{
var xx:Number = x;
var yy:Number = y;
var zz:Number = z;
x = m.a * xx + m.b * yy + m.c * zz + m.d;
y = m.e * xx + m.f * yy + m.g * zz + m.h;
z = m.i * xx + m.j * yy + m.k * zz + m.l;
return this;
}
public function vTransformInverseBy4(m:Matrix4) : Vector3
{
var xx:Number = x - m.d;
var yy:Number = y - m.h;
var zz:Number = z - m.l;
x = m.a * xx + m.e * yy + m.i * zz;
y = m.b * xx + m.f * yy + m.j * zz;
z = m.c * xx + m.g * yy + m.k * zz;
return this;
}
public function vDeltaTransformBy4(m:Matrix4) : Vector3
{
var xx:Number = x;
var yy:Number = y;
var zz:Number = z;
x = m.a * xx + m.b * yy + m.c * zz;
y = m.e * xx + m.f * yy + m.g * zz;
z = m.i * xx + m.j * yy + m.k * zz;
return this;
}
public function vReset(x:Number = 0, y:Number = 0, z:Number = 0) : Vector3
{
this.x = x;
this.y = y;
this.z = z;
return this;
}
public function vCopy(v:Vector3) : Vector3
{
x = v.x;
y = v.y;
z = v.z;
return this;
}
public function vClone() : Vector3
{
return new Vector3(x,y,z);
}
public function toVector3D(result:Vector3D) : Vector3D
{
result.x = x;
result.y = y;
result.z = z;
return result;
}
public function interpolate(param1:Number, param2:Vector3, param3:Vector3) : void
{
this.x = param2.x + param1 * (param3.x - param2.x);
this.y = param2.y + param1 * (param3.y - param2.y);
this.z = param2.z + param1 * (param3.z - param2.z);
}
public function copyFromVector3D(source:Vector3D) : Vector3
{
x = source.x;
y = source.y;
z = source.z;
return this;
}
override public function copyFrom(source:Vector3D) : void
{
x = source.x;
y = source.y;
z = source.z;
}
public function lengthSqr() : Number
{
return this.x * this.x + this.y * this.y + this.z * this.z;
}
public function scale(param1:Number) : Vector3
{
this.x *= param1;
this.y *= param1;
this.z *= param1;
return this;
}
public function reset(param1:Number = 0, param2:Number = 0, param3:Number = 0) : Vector3
{
this.x = param1;
this.y = param2;
this.z = param3;
return this;
}
public function distanceTo(param1:Vector3) : Number
{
var _loc2_:Number = this.x - param1.x;
var _loc3_:Number = this.y - param1.y;
var _loc4_:Number = this.z - param1.z;
return Math.sqrt(_loc2_ * _loc2_ + _loc3_ * _loc3_ + _loc4_ * _loc4_);
}
override public function toString() : String
{
return "Vector3(" + x + ", " + y + ", " + z + ")";
}
}
}
|
package com.alternativaplatform.client.models.core.users.model.entrance
{
import scpacker.Base;
public class EntranceModelBase extends Base
{
public function EntranceModelBase()
{
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_overdriveBg2xClass.png")]
public class HudInventoryIcon_overdriveBg2xClass extends BitmapAsset {
public function HudInventoryIcon_overdriveBg2xClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.crystalpackage {
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.panel.model.shop.crystalpackage.CrystalPackageCC;
public class CodecCrystalPackageCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_bonusCrystals:ICodec;
private var codec_crystals:ICodec;
private var codec_premiumDurationInDays:ICodec;
public function CodecCrystalPackageCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_bonusCrystals = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_crystals = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_premiumDurationInDays = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:CrystalPackageCC = new CrystalPackageCC();
local2.bonusCrystals = this.codec_bonusCrystals.decode(param1) as int;
local2.crystals = this.codec_crystals.decode(param1) as int;
local2.premiumDurationInDays = this.codec_premiumDurationInDays.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:CrystalPackageCC = CrystalPackageCC(param2);
this.codec_bonusCrystals.encode(param1,local3.bonusCrystals);
this.codec_crystals.encode(param1,local3.crystals);
this.codec_premiumDurationInDays.encode(param1,local3.premiumDurationInDays);
}
}
}
|
package alternativa.tanks.model.item.properties {
import projects.tanks.client.commons.types.ItemGarageProperty;
public interface ItemPropertyValue {
function getValue(param1:int = 0) : String;
function getProperty() : ItemGarageProperty;
}
}
|
package _codec.projects.tanks.client.commons.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.commons.types.ItemGarageProperty;
public class CodecItemGarageProperty implements ICodec {
public function CodecItemGarageProperty() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ItemGarageProperty = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = ItemGarageProperty.HULL_ARMOR;
break;
case 1:
local2 = ItemGarageProperty.HULL_SPEED;
break;
case 2:
local2 = ItemGarageProperty.HULL_TURN_SPEED;
break;
case 3:
local2 = ItemGarageProperty.HULL_POWER;
break;
case 4:
local2 = ItemGarageProperty.HULL_MASS;
break;
case 5:
local2 = ItemGarageProperty.ALL_RESISTANCE;
break;
case 6:
local2 = ItemGarageProperty.FIREBIRD_RESISTANCE;
break;
case 7:
local2 = ItemGarageProperty.SMOKY_RESISTANCE;
break;
case 8:
local2 = ItemGarageProperty.TWINS_RESISTANCE;
break;
case 9:
local2 = ItemGarageProperty.RAILGUN_RESISTANCE;
break;
case 10:
local2 = ItemGarageProperty.ISIS_RESISTANCE;
break;
case 11:
local2 = ItemGarageProperty.MINE_RESISTANCE;
break;
case 12:
local2 = ItemGarageProperty.THUNDER_RESISTANCE;
break;
case 13:
local2 = ItemGarageProperty.FREEZE_RESISTANCE;
break;
case 14:
local2 = ItemGarageProperty.RICOCHET_RESISTANCE;
break;
case 15:
local2 = ItemGarageProperty.SHAFT_RESISTANCE;
break;
case 16:
local2 = ItemGarageProperty.SHOTGUN_RESISTANCE;
break;
case 17:
local2 = ItemGarageProperty.MACHINE_GUN_RESISTANCE;
break;
case 18:
local2 = ItemGarageProperty.ROCKET_LAUNCHER_RESISTANCE;
break;
case 19:
local2 = ItemGarageProperty.ARTILLERY_RESISTANCE;
break;
case 20:
local2 = ItemGarageProperty.GAUSS_RESISTANCE;
break;
case 21:
local2 = ItemGarageProperty.DAMAGE;
break;
case 22:
local2 = ItemGarageProperty.DAMAGE_PER_SECOND;
break;
case 23:
local2 = ItemGarageProperty.WEAPON_COOLDOWN_TIME;
break;
case 24:
local2 = ItemGarageProperty.AIMING_MODE_COOLDOWN_TIME;
break;
case 25:
local2 = ItemGarageProperty.CRITICAL_HIT_CHANCE;
break;
case 26:
local2 = ItemGarageProperty.CRITICAL_HIT_DAMAGE;
break;
case 27:
local2 = ItemGarageProperty.SHOT_RANGE;
break;
case 28:
local2 = ItemGarageProperty.TURRET_TURN_SPEED;
break;
case 29:
local2 = ItemGarageProperty.AIMING_ERROR;
break;
case 30:
local2 = ItemGarageProperty.SHOT_AREA;
break;
case 31:
local2 = ItemGarageProperty.CONE_ANGLE;
break;
case 32:
local2 = ItemGarageProperty.CHARGING_TIME;
break;
case 33:
local2 = ItemGarageProperty.FIRE_DAMAGE;
break;
case 34:
local2 = ItemGarageProperty.WEAPON_WEAKENING_COEFF;
break;
case 35:
local2 = ItemGarageProperty.ISIS_DAMAGE;
break;
case 36:
local2 = ItemGarageProperty.ISIS_HEALING_PER_SECOND;
break;
case 37:
local2 = ItemGarageProperty.AIMING_MODE_DAMAGE;
break;
case 38:
local2 = ItemGarageProperty.AIMING_WEAPON_DISCHARGE_RATE;
break;
case 39:
local2 = ItemGarageProperty.SHAFT_AIMED_SHOT_IMPACT;
break;
case 40:
local2 = ItemGarageProperty.SHAFT_TARGETING_SPEED;
break;
case 41:
local2 = ItemGarageProperty.SHAFT_ARCADE_DAMAGE;
break;
case 42:
local2 = ItemGarageProperty.GAUSS_AIMING_MODE_DAMAGE;
break;
case 43:
local2 = ItemGarageProperty.WEAPON_IMPACT_FORCE;
break;
case 44:
local2 = ItemGarageProperty.WEAPON_KICKBACK;
break;
case 45:
local2 = ItemGarageProperty.SHELL_SPEED;
break;
case 46:
local2 = ItemGarageProperty.WEAPON_CHARGE_RATE;
break;
case 47:
local2 = ItemGarageProperty.WEAPON_MIN_DAMAGE_PERCENT;
break;
case 48:
local2 = ItemGarageProperty.THUNDER_MIN_SPLASH_DAMAGE_PERCENT;
break;
case 49:
local2 = ItemGarageProperty.DEPENDENCY_FIRST_AID_SEC;
break;
case 50:
local2 = ItemGarageProperty.DEPENDENCY_DOUBLE_ARMOR_SEC;
break;
case 51:
local2 = ItemGarageProperty.DEPENDENCY_DOUBLE_DAMAGE_SEC;
break;
case 52:
local2 = ItemGarageProperty.DEPENDENCY_NITRO_SEC;
break;
case 53:
local2 = ItemGarageProperty.DEPENDENCY_MINE_SEC;
break;
case 54:
local2 = ItemGarageProperty.DEPENDENCY_DROPPABLE_GOLD_SEC;
break;
case 55:
local2 = ItemGarageProperty.COOLDOWN_FIRST_AID_SEC;
break;
case 56:
local2 = ItemGarageProperty.COOLDOWN_DOUBLE_ARMOR_SEC;
break;
case 57:
local2 = ItemGarageProperty.COOLDOWN_DOUBLE_DAMAGE_SEC;
break;
case 58:
local2 = ItemGarageProperty.COOLDOWN_NITRO_SEC;
break;
case 59:
local2 = ItemGarageProperty.COOLDOWN_MINE_SEC;
break;
case 60:
local2 = ItemGarageProperty.COOLDOWN_DROPPABLE_GOLD_SEC;
break;
case 61:
local2 = ItemGarageProperty.DURATION_FIRST_AID_SEC;
break;
case 62:
local2 = ItemGarageProperty.DURATION_DOUBLE_ARMOR_SEC;
break;
case 63:
local2 = ItemGarageProperty.DURATION_DOUBLE_DAMAGE_SEC;
break;
case 64:
local2 = ItemGarageProperty.DURATION_NITRO_SEC;
break;
case 65:
local2 = ItemGarageProperty.ATTACK_EFFECT;
break;
case 66:
local2 = ItemGarageProperty.FIRST_AID_EFFECT_INSTANT;
break;
case 67:
local2 = ItemGarageProperty.FIRST_AID_EFFECT;
break;
case 68:
local2 = ItemGarageProperty.PROTECTION_EFFECT;
break;
case 69:
local2 = ItemGarageProperty.SPEED_EFFECT;
break;
case 70:
local2 = ItemGarageProperty.SHOTGUN_IMPACT_FORCE;
break;
case 71:
local2 = ItemGarageProperty.DISCHARGE_SPEED;
break;
case 72:
local2 = ItemGarageProperty.FREEZE_PER_TICK;
break;
case 73:
local2 = ItemGarageProperty.VERTICAL_ANGLES;
break;
case 74:
local2 = ItemGarageProperty.DRONE_RELOAD;
break;
case 75:
local2 = ItemGarageProperty.DRONE_REPAIR_HEALTH;
break;
case 76:
local2 = ItemGarageProperty.DRONE_INVENTORY;
break;
case 77:
local2 = ItemGarageProperty.DRONE_INVENTORY_ADD;
break;
case 78:
local2 = ItemGarageProperty.DRONE_BONUS_ADD;
break;
case 79:
local2 = ItemGarageProperty.DRONE_FIRST_AID_BONUS_ADD;
break;
case 80:
local2 = ItemGarageProperty.DRONE_OVERDRIVE_BOOST;
break;
case 81:
local2 = ItemGarageProperty.DRONE_DEFEND;
break;
case 82:
local2 = ItemGarageProperty.DRONE_ARMOR_BOOST;
break;
case 83:
local2 = ItemGarageProperty.DRONE_MINE;
break;
case 84:
local2 = ItemGarageProperty.DRONE_ADDITIONAL_MINES;
break;
case 85:
local2 = ItemGarageProperty.DRONE_MINES_ACTIVATION_DELAY;
break;
case 86:
local2 = ItemGarageProperty.DRONE_MINES_PLACEMENT_RADIUS;
break;
case 87:
local2 = ItemGarageProperty.DRONE_INVENTORY_COOLDOWN_BOOST;
break;
case 88:
local2 = ItemGarageProperty.DRONE_POWER_BOOST;
break;
case 89:
local2 = ItemGarageProperty.DRONE_POWER_DURATION;
break;
case 90:
local2 = ItemGarageProperty.DRONE_CRITICAL_HEALTH;
break;
case 91:
local2 = ItemGarageProperty.DRONE_REPAIR_RADIUS;
break;
case 92:
local2 = ItemGarageProperty.DRONE_INVENTORY_RADIUS;
break;
case 93:
local2 = ItemGarageProperty.DRONE_COOLDOWN_RADIUS;
break;
case 94:
local2 = ItemGarageProperty.DRONE_CONSTANT_ARMOR_PERCENT;
break;
case 95:
local2 = ItemGarageProperty.DRONE_CONSTANT_POWER_PERCENT;
break;
case 96:
local2 = ItemGarageProperty.ULTIMATE_HEAL_HP;
break;
case 97:
local2 = ItemGarageProperty.ULTIMATE_CHARGE_PER_SEC;
break;
case 98:
local2 = ItemGarageProperty.ULTIMATE_CHARGE_PER_SCORE_POINT;
break;
case 99:
local2 = ItemGarageProperty.ULTIMATE_SCORE_COOLDOWN_SEC;
break;
case 100:
local2 = ItemGarageProperty.ULTIMATE_ACTIVATION_DISCHARGE_PER_SEC;
}
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 alternativa.engine3d.loaders.collada {
public namespace daeAlternativa3DInstance = "http://alternativaplatform.com/a3d/Instance";
}
|
package alternativa.tanks.battle.objects.tank.tankskin {
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Shadow;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.tankskin.materialfactory.DefaultTankSkinMaterialsFactory;
import alternativa.tanks.battle.objects.tank.tankskin.materialfactory.TankSkinMaterialsFactory;
import alternativa.tanks.battle.objects.tank.tankskin.turret.CustomTurretSkin;
import alternativa.tanks.battle.objects.tank.tankskin.turret.TurretGeometryItem;
import alternativa.tanks.battle.objects.tank.tankskin.turret.TurretSkin;
import alternativa.tanks.battle.objects.tank.tankskin.turret.TurretSkinCacheItem;
import alternativa.tanks.battle.scene3d.BattleScene3D;
import alternativa.tanks.battle.scene3d.Object3DNames;
import alternativa.tanks.models.tank.TankPartsRegistry;
import alternativa.tanks.models.tank.hullcommon.HullCommon;
import alternativa.tanks.services.colortransform.ColorTransformService;
import alternativa.utils.TextureMaterialRegistry;
import flash.geom.ColorTransform;
import flash.geom.Vector3D;
import platform.client.fp10.core.resource.types.TextureResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.flash.commons.models.coloring.IColoring;
import projects.tanks.clients.flash.resources.object3ds.IObject3DS;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class TankSkin {
[Inject]
public static var textureMaterialRegistry:TextureMaterialRegistry;
[Inject]
public static var colorTransformService:ColorTransformService;
[Inject]
public static var battleService:BattleService;
private static const BASE_COLOR_TRANSFORM:ColorTransform = new ColorTransform();
private static const hullMatrix:Matrix4 = new Matrix4();
private static const tankPartsRegistry:TankPartsRegistry = new TankPartsRegistry();
public var targetColorTransformOffset:Number = 0;
private var normalMaterials:SkinMaterials;
private var deadMaterials:SkinMaterials;
private var hullDescriptor:TankHullSkinCacheItem;
private var hullMesh:Mesh;
private var turretDescriptor:TurretSkinCacheItem;
private var turretSkin:TurretSkin;
private var colorTransform1:ColorTransform = new ColorTransform();
private var targetColorTransform:ColorTransform = new ColorTransform();
private var leftTrackSkin:TrackSkin;
private var rightTrackSkin:TrackSkin;
private var ambientShadow:Shadow;
private var desiredColorTransform:ColorTransform = new ColorTransform();
private var tankSkinMaterialFactory:TankSkinMaterialsFactory = new DefaultTankSkinMaterialsFactory();
private var heatColorTransform:ColorTransform;
private var frostColorTransform:ColorTransform;
public function TankSkin(param1:IGameObject, param2:IGameObject, param3:IGameObject) {
super();
var local4:HullCommon = HullCommon(param1.adapt(HullCommon));
var local5:TextureResource = local4.getDeadColoring();
var local6:Tanks3DSResource = IObject3DS(param1.adapt(IObject3DS)).getResource3DS();
this.hullDescriptor = tankPartsRegistry.getHullDescriptor(local6);
var local7:Tanks3DSResource = IObject3DS(param2.adapt(IObject3DS)).getResource3DS();
this.turretDescriptor = tankPartsRegistry.getTurretDescriptor(local7);
this.hullMesh = this.cloneMesh(this.hullDescriptor.mesh);
if(param2.hasModel(CustomTurretSkin)) {
this.turretSkin = CustomTurretSkin(param2.adapt(CustomTurretSkin)).createSkin(local7);
} else {
this.turretSkin = new TurretSkin(local7);
}
this.turretSkin.setColorTransform(this.targetColorTransform);
this.createTrackSkins(this.hullMesh);
var local8:IColoring = IColoring(param3.adapt(IColoring));
this.normalMaterials = this.tankSkinMaterialFactory.createSkinMaterials(this,local8);
this.deadMaterials = this.tankSkinMaterialFactory.createDeadSkinMaterials(this,local5);
this.heatColorTransform = colorTransformService.getHeatColorAdjust();
this.frostColorTransform = colorTransformService.getFrostColorAdjust();
this.createAmbientShadow();
}
private static function setIntermediateValue(param1:ColorTransform, param2:String, param3:ColorTransform, param4:ColorTransform, param5:Number) : void {
var local6:Number = param4[param2] - param3[param2];
param1[param2] = param3[param2] + Math.abs(param5) * local6;
}
private static function copyColorTransform(param1:ColorTransform, param2:ColorTransform) : void {
param2.redMultiplier = param1.redMultiplier;
param2.greenMultiplier = param1.greenMultiplier;
param2.blueMultiplier = param1.blueMultiplier;
param2.alphaMultiplier = param1.alphaMultiplier;
param2.redOffset = param1.redOffset;
param2.greenOffset = param1.greenOffset;
param2.blueOffset = param1.blueOffset;
param2.alphaOffset = param1.alphaOffset;
}
private function createAmbientShadow() : void {
this.ambientShadow = new Shadow(128,8,100,1,1,1118498,0.6);
this.ambientShadow.direction = new Vector3D(0,0,-1);
this.ambientShadow.offset = 90;
this.ambientShadow.backFadeRange = 90;
this.ambientShadow.addCaster(this.hullMesh);
this.turretSkin.initShadow(this.ambientShadow);
}
public function setAlpha(param1:Number) : void {
this.hullMesh.alpha = param1;
this.turretSkin.alpha = param1;
this.ambientShadow.alpha = param1 * 0.6;
}
public function getHullAlpha() : Number {
return this.hullMesh.alpha;
}
public function dispose() : void {
this.hullMesh.setMaterialToAllFaces(null);
this.turretSkin.destroy();
this.setTracksMaterial(null,null);
this.releaseMaterials(this.normalMaterials);
this.releaseMaterials(this.deadMaterials);
this.normalMaterials = null;
this.deadMaterials = null;
this.hullMesh = null;
this.turretSkin = null;
this.leftTrackSkin = null;
this.rightTrackSkin = null;
}
private function releaseMaterials(param1:SkinMaterials) : void {
textureMaterialRegistry.releaseMaterial(param1.hullMaterial);
textureMaterialRegistry.releaseMaterial(param1.turretMaterial);
textureMaterialRegistry.releaseMaterial(param1.leftTrackMaterial);
textureMaterialRegistry.releaseMaterial(param1.rightTrackMaterial);
}
public function setNormalState() : void {
this.hullMesh.setMaterialToAllFaces(this.normalMaterials.hullMaterial);
this.turretSkin.setMaterials(this.normalMaterials.turretMaterial);
this.setTracksMaterial(this.normalMaterials.leftTrackMaterial,this.normalMaterials.rightTrackMaterial);
}
public function setDeadState() : void {
this.hullMesh.setMaterialToAllFaces(this.deadMaterials.hullMaterial);
this.turretSkin.setMaterials(this.deadMaterials.turretMaterial);
this.setTracksMaterial(this.deadMaterials.hullMaterial,this.deadMaterials.hullMaterial);
this.resetColorTransform();
}
private function setTracksMaterial(param1:Material, param2:Material) : void {
this.leftTrackSkin.setMaterial(param1);
this.rightTrackSkin.setMaterial(param2);
}
public function resetColorTransform() : void {
this.targetColorTransformOffset = 0;
this.colorTransform1.redMultiplier = 1;
this.colorTransform1.greenMultiplier = 1;
this.colorTransform1.blueMultiplier = 1;
this.colorTransform1.redOffset = 0;
this.colorTransform1.greenOffset = 0;
this.colorTransform1.blueOffset = 0;
copyColorTransform(this.colorTransform1,this.targetColorTransform);
}
public function setColorTransformByTemperature(param1:Number) : void {
var local2:ColorTransform = null;
if(param1 == 0) {
local2 = BASE_COLOR_TRANSFORM;
} else if(param1 < 0) {
local2 = this.frostColorTransform;
} else {
local2 = this.heatColorTransform;
}
setIntermediateValue(this.desiredColorTransform,"redMultiplier",BASE_COLOR_TRANSFORM,local2,param1);
setIntermediateValue(this.desiredColorTransform,"blueMultiplier",BASE_COLOR_TRANSFORM,local2,param1);
setIntermediateValue(this.desiredColorTransform,"greenMultiplier",BASE_COLOR_TRANSFORM,local2,param1);
setIntermediateValue(this.desiredColorTransform,"redOffset",BASE_COLOR_TRANSFORM,local2,param1);
setIntermediateValue(this.desiredColorTransform,"blueOffset",BASE_COLOR_TRANSFORM,local2,param1);
setIntermediateValue(this.desiredColorTransform,"greenOffset",BASE_COLOR_TRANSFORM,local2,param1);
setIntermediateValue(this.targetColorTransform,"redMultiplier",this.targetColorTransform,this.desiredColorTransform,0.03);
setIntermediateValue(this.targetColorTransform,"blueMultiplier",this.targetColorTransform,this.desiredColorTransform,0.03);
setIntermediateValue(this.targetColorTransform,"greenMultiplier",this.targetColorTransform,this.desiredColorTransform,0.03);
setIntermediateValue(this.targetColorTransform,"redOffset",this.targetColorTransform,this.desiredColorTransform,0.03);
setIntermediateValue(this.targetColorTransform,"blueOffset",this.targetColorTransform,this.desiredColorTransform,0.03);
setIntermediateValue(this.targetColorTransform,"greenOffset",this.targetColorTransform,this.desiredColorTransform,0.03);
}
public function addToScene() : void {
var local1:BattleScene3D = battleService.getBattleScene3D();
local1.addObject(this.hullMesh);
local1.addTurret(this.turretSkin);
local1.addAmbientShadow(this.ambientShadow);
}
public function removeFromScene() : void {
var local1:BattleScene3D = battleService.getBattleScene3D();
local1.removeObject(this.hullMesh);
local1.removeTurret(this.turretSkin);
local1.removeAmbientShadow(this.ambientShadow);
}
public function getHullMesh() : Mesh {
return this.hullMesh;
}
public function getTurret3D() : Object3D {
return this.turretSkin.getTurret3D();
}
public function getBarrel3D() : Object3D {
return this.turretSkin.getBarrel3D();
}
public function getTurretSkin() : TurretSkin {
return this.turretSkin;
}
public function getHullDescriptor() : TankHullSkinCacheItem {
return this.hullDescriptor;
}
public function getTurretDescriptor() : TurretSkinCacheItem {
return this.turretDescriptor;
}
public function getTurretGeometry() : Vector.<TurretGeometryItem> {
return this.turretDescriptor.getGeometry();
}
public function updateHullTransform(param1:Vector3, param2:Vector3) : void {
if(this.hullDescriptor != null) {
this.hullMesh.x = param1.x;
this.hullMesh.y = param1.y;
this.hullMesh.z = param1.z;
this.hullMesh.rotationX = param2.x;
this.hullMesh.rotationY = param2.y;
this.hullMesh.rotationZ = param2.z;
}
}
public function updateTurretTransform(param1:Number, param2:Number) : void {
if(this.hullDescriptor != null && this.turretDescriptor != null) {
hullMatrix.setMatrix(this.hullMesh.x,this.hullMesh.y,this.hullMesh.z,this.hullMesh.rotationX,this.hullMesh.rotationY,this.hullMesh.rotationZ);
this.turretSkin.updateTurretTransform(hullMatrix,this.hullDescriptor,param1,param2);
}
}
public function updateTracks(param1:Number, param2:Number) : void {
this.leftTrackSkin.move(param1);
this.rightTrackSkin.move(param2);
}
private function createTrackSkins(param1:Mesh) : void {
var local2:Face = null;
this.leftTrackSkin = new TrackSkin();
this.rightTrackSkin = new TrackSkin();
for each(local2 in param1.faces) {
if(local2.material.name == "tracks") {
this.addFaceToTrackSkin(local2);
}
}
this.leftTrackSkin.init();
this.rightTrackSkin.init();
}
private function addFaceToTrackSkin(param1:Face) : void {
var local2:Vertex = param1.vertices[0];
if(local2.x < 0) {
this.leftTrackSkin.addFace(param1);
} else {
this.rightTrackSkin.addFace(param1);
}
}
private function cloneMesh(param1:Mesh) : Mesh {
var local2:Mesh = Mesh(param1.clone());
local2.name = Object3DNames.TANK_PART;
local2.colorTransform = this.targetColorTransform;
local2.shadowMapAlphaThreshold = 0.1;
local2.calculateVerticesNormalsBySmoothingGroups(0.01);
return local2;
}
public function readGlobalFlagMountPoint(param1:Vector3, param2:Vector3) : void {
var local4:Object3D = null;
var local3:Matrix4 = TurretSkin.turretMatrix;
local4 = this.turretSkin.getTurret3D();
local3.setMatrix(local4.x,local4.y,local4.z,local4.rotationX,local4.rotationY,local4.rotationZ);
local3.transformVector(this.turretDescriptor.flagMountPoint,param1);
param2.x = local4.rotationX;
param2.y = local4.rotationY;
param2.z = local4.rotationZ;
}
}
}
|
package swfaddress {
import flash.events.Event;
public class SWFAddressEvent extends Event {
public static const INIT:String = "init";
public static const CHANGE:String = "change";
private var _value:String;
private var _path:String;
private var _pathNames:Array;
private var _parameters:Object;
private var _parametersNames:Array;
public function SWFAddressEvent(param1:String) {
super(param1,false,false);
}
override public function get currentTarget() : Object {
return SWFAddress;
}
override public function get type() : String {
return super.type;
}
override public function get target() : Object {
return SWFAddress;
}
public function get value() : String {
if(this._value == null) {
this._value = SWFAddress.getValue();
}
return this._value;
}
public function get path() : String {
if(this._path == null) {
this._path = SWFAddress.getPath();
}
return this._path;
}
public function get pathNames() : Array {
if(this._pathNames == null) {
this._pathNames = SWFAddress.getPathNames();
}
return this._pathNames;
}
public function get parameters() : Object {
var local1:int = 0;
if(this._parameters == null) {
this._parameters = new Object();
local1 = 0;
while(local1 < this.parametersNames.length) {
this._parameters[this.parametersNames[local1]] = SWFAddress.getParameter(this.parametersNames[local1]);
local1++;
}
}
return this._parameters;
}
public function get parametersNames() : Array {
if(this._parametersNames == null) {
this._parametersNames = SWFAddress.getParameterNames();
}
return this._parametersNames;
}
override public function clone() : Event {
return new SWFAddressEvent(this.type);
}
override public function toString() : String {
return formatToString("SWFAddressEvent","type","bubbles","cancelable","eventPhase","value","path","pathNames","parameters","parametersNames");
}
}
}
|
package alternativa.tanks.model.item.shopabonement {
import projects.tanks.client.commons.types.ShopCategoryEnum;
[ModelInterface]
public interface ShopAbonement {
function getShopCategory() : ShopCategoryEnum;
}
}
|
package projects.tanks.client.panel.model.androidapprating {
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 AndroidAppRatingModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:AndroidAppRatingModelServer;
private var client:IAndroidAppRatingModelBase = IAndroidAppRatingModelBase(this);
private var modelId:Long = Long.getLong(1012815736,604595236);
private var _showDialogAppRatingId:Long = Long.getLong(384306161,1146565800);
public function AndroidAppRatingModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new AndroidAppRatingModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._showDialogAppRatingId:
this.client.showDialogAppRating();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package controls {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.events.MouseEvent;
public class DefaultIconButton extends DefaultButton {
protected var _icon:Bitmap;
private var _releaseIcon:BitmapData;
private var _hoveredIcon:BitmapData;
private var _pressedIcon:BitmapData;
public function DefaultIconButton(param1:BitmapData, param2:BitmapData, param3:BitmapData) {
super();
this.icon = param1;
this._releaseIcon = param1;
this._hoveredIcon = param2;
this._pressedIcon = param3;
this.width = 70;
removeChild(stateUP);
removeChild(stateDOWN);
removeChild(stateOFF);
removeChild(stateOVER);
}
public function set icon(param1:BitmapData) : void {
this._icon = new Bitmap(param1);
addChild(this._icon);
this._icon.x = 3;
this._icon.y = 3;
this.width = _width;
}
override public function set width(param1:Number) : void {
_width = int(param1);
stateDOWN.width = stateOFF.width = stateOVER.width = stateUP.width = _width;
if(this._icon != null) {
_label.x = 20;
_label.width = _width - 22;
} else {
_label.x = 2;
_label.width = _width - 4;
}
}
override protected function onMouseEvent(param1:MouseEvent) : void {
if(enable) {
switch(param1.type) {
case MouseEvent.MOUSE_OVER:
setState(2);
this.icon = this._hoveredIcon;
break;
case MouseEvent.MOUSE_OUT:
setState(1);
this.icon = this._releaseIcon;
break;
case MouseEvent.MOUSE_DOWN:
setState(3);
this.icon = this._pressedIcon;
break;
case MouseEvent.MOUSE_UP:
setState(1);
this.icon = this._releaseIcon;
}
}
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p25 extends BitmapAsset
{
public function RangIconNormal_p25()
{
super();
}
}
}
|
package alternativa.init
{
import alternativa.osgi.CommonBundleActivator;
import alternativa.tanks.models.effects.common.bonuscommon.BonusCommonModel;
import alternativa.tanks.models.effects.crystal.CrystalBonusModel;
import alternativa.tanks.models.effects.firstaid.FirstAidModel;
import alternativa.tanks.models.longterm.LongTermBonusModel;
import alternativa.tanks.models.sfx.colortransform.ColorTransformModel;
import alternativa.tanks.models.sfx.flame.FlamethrowerSFXModel;
import alternativa.tanks.models.sfx.healing.HealingGunSFXModel;
import alternativa.tanks.models.sfx.shoot.gun.SmokySFXModel;
import alternativa.tanks.models.sfx.shoot.plasma.PlasmaSFXModel;
import alternativa.tanks.models.sfx.shoot.pumpkingun.PumpkingunSFXModel;
import alternativa.tanks.models.sfx.shoot.railgun.RailgunSFXModel;
import alternativa.tanks.models.sfx.shoot.ricochet.RicochetSFXModel;
import alternativa.tanks.models.sfx.shoot.thunder.ThunderSFXModel;
import alternativa.tanks.models.weapon.common.WeaponCommonModel;
import alternativa.tanks.models.weapon.flamethrower.FlamethrowerModel;
import alternativa.tanks.models.weapon.freeze.FreezeModel;
import alternativa.tanks.models.weapon.freeze.FreezeSFXModel;
import alternativa.tanks.models.weapon.gun.SmokyModel;
import alternativa.tanks.models.weapon.healing.HealingGunModel;
import alternativa.tanks.models.weapon.plasma.PlasmaModel;
import alternativa.tanks.models.weapon.pumpkingun.PumpkinModel;
import alternativa.tanks.models.weapon.railgun.RailgunModel;
import alternativa.tanks.models.weapon.ricochet.RicochetModel;
import alternativa.tanks.models.weapon.shared.shot.ShotModel;
import alternativa.tanks.models.weapon.terminator.TerminatorModel;
import alternativa.tanks.models.weapon.thunder.ThunderModel;
import alternativa.tanks.models.weapon.weakening.WeaponWeakeningModel;
public class TanksWarfareActivator extends CommonBundleActivator
{
public function TanksWarfareActivator()
{
super();
}
override public function start(osgi:OSGi) : void
{
registerModel(new FirstAidModel(),osgi);
registerModel(new BonusCommonModel(),osgi);
registerModel(new LongTermBonusModel(),osgi);
registerModel(new CrystalBonusModel(),osgi);
registerModel(new WeaponCommonModel(),osgi);
registerModel(new WeaponWeakeningModel(),osgi);
registerModel(new ShotModel(),osgi);
registerModel(new SmokyModel(),osgi);
registerModel(new SmokySFXModel(),osgi);
registerModel(new PlasmaModel(),osgi);
registerModel(new PlasmaSFXModel(),osgi);
registerModel(new FlamethrowerModel(),osgi);
registerModel(new FlamethrowerSFXModel(),osgi);
registerModel(new RailgunModel(),osgi);
registerModel(new RailgunSFXModel(),osgi);
registerModel(new TerminatorModel(),osgi);
registerModel(new HealingGunModel(),osgi);
registerModel(new HealingGunSFXModel(),osgi);
registerModel(new ThunderModel(),osgi);
registerModel(new ThunderSFXModel(),osgi);
registerModel(new RicochetModel(),osgi);
registerModel(new RicochetSFXModel(),osgi);
registerModel(new PumpkinModel(),osgi);
registerModel(new PumpkingunSFXModel(),osgi);
registerModel(new FreezeModel(),osgi);
registerModel(new FreezeSFXModel(),osgi);
registerModel(new ColorTransformModel(),osgi);
}
}
}
|
package projects.tanks.client.battleselect.model.battle {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.client.battleservice.model.types.BattleSuspicionLevel;
public class BattleInfoModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BattleInfoModelServer;
private var client:IBattleInfoModelBase = IBattleInfoModelBase(this);
private var modelId:Long = Long.getLong(678248814,-1039722970);
private var _resetBattleNameId:Long = Long.getLong(1723702817,-1559950205);
private var _roundFinishedId:Long = Long.getLong(2079393446,1872275759);
private var _roundStartedId:Long = Long.getLong(1595490780,1527833154);
private var _roundStarted_timeLeftInSecCodec:ICodec;
private var _setBattleNameId:Long = Long.getLong(1955622129,800057322);
private var _setBattleName_nameCodec:ICodec;
private var _updateSuspicionId:Long = Long.getLong(1794766139,-788021385);
private var _updateSuspicion_suspicionLevelCodec:ICodec;
private var _updateUserSuspiciousStateId:Long = Long.getLong(571437576,1704127087);
private var _updateUserSuspiciousState_userIdCodec:ICodec;
private var _updateUserSuspiciousState_suspiciousCodec:ICodec;
public function BattleInfoModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BattleInfoModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(BattleInfoCC,false)));
this._roundStarted_timeLeftInSecCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._setBattleName_nameCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._updateSuspicion_suspicionLevelCodec = this._protocol.getCodec(new EnumCodecInfo(BattleSuspicionLevel,false));
this._updateUserSuspiciousState_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._updateUserSuspiciousState_suspiciousCodec = this._protocol.getCodec(new TypeCodecInfo(Boolean,false));
}
protected function getInitParam() : BattleInfoCC {
return BattleInfoCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._resetBattleNameId:
this.client.resetBattleName();
break;
case this._roundFinishedId:
this.client.roundFinished();
break;
case this._roundStartedId:
this.client.roundStarted(int(this._roundStarted_timeLeftInSecCodec.decode(param2)));
break;
case this._setBattleNameId:
this.client.setBattleName(String(this._setBattleName_nameCodec.decode(param2)));
break;
case this._updateSuspicionId:
this.client.updateSuspicion(BattleSuspicionLevel(this._updateSuspicion_suspicionLevelCodec.decode(param2)));
break;
case this._updateUserSuspiciousStateId:
this.client.updateUserSuspiciousState(Long(this._updateUserSuspiciousState_userIdCodec.decode(param2)),Boolean(this._updateUserSuspiciousState_suspiciousCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.gui.foreignclan {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.foreignclan.ForeignClanWindow_bitmapPlayersIcon.png")]
public class ForeignClanWindow_bitmapPlayersIcon extends BitmapAsset {
public function ForeignClanWindow_bitmapPlayersIcon() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.facilities.facillity {
public interface IFacilitySphericalZoneModelBase {
}
}
|
package projects.tanks.client.partners.impl.china.china3rdplatform.auth {
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 China3rdPlatformLoginModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function China3rdPlatformLoginModelServer(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 alternativa.tanks.model.item.buyable {
[ModelInterface]
public interface IBuyable {
function getPriceWithoutDiscount() : int;
function getPrice() : int;
function isBuyable() : Boolean;
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.twins {
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.Float;
import projects.tanks.client.battlefield.models.tankparts.weapon.twins.TwinsCC;
public class CodecTwinsCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_shellRadius:ICodec;
private var codec_speed:ICodec;
public function CodecTwinsCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_shellRadius = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_speed = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:TwinsCC = new TwinsCC();
local2.shellRadius = this.codec_shellRadius.decode(param1) as Number;
local2.speed = this.codec_speed.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:TwinsCC = TwinsCC(param2);
this.codec_shellRadius.encode(param1,local3.shellRadius);
this.codec_speed.encode(param1,local3.speed);
}
}
}
|
package alternativa.engine3d.core {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.lights.DirectionalLight;
import alternativa.engine3d.lights.OmniLight;
import alternativa.engine3d.lights.SpotLight;
import alternativa.engine3d.lights.TubeLight;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Decal;
import alternativa.engine3d.objects.Sprite3D;
import alternativa.gfx.core.Device;
import alternativa.gfx.core.IndexBufferResource;
import alternativa.gfx.core.TextureResource;
import alternativa.gfx.core.VertexBufferResource;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.display.StageAlign;
import flash.display3D.Context3DBlendFactor;
import flash.display3D.Context3DClearMask;
import flash.display3D.Context3DCompareMode;
import flash.display3D.Context3DProgramType;
import flash.display3D.Context3DStencilAction;
import flash.display3D.Context3DTriangleFace;
import flash.events.Event;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.geom.Vector3D;
import flash.system.System;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.utils.Dictionary;
import flash.utils.getDefinitionByName;
import flash.utils.getQualifiedClassName;
import flash.utils.getQualifiedSuperclassName;
import flash.utils.getTimer;
use namespace alternativa3d;
public class Camera3D extends Object3D {
alternativa3d static var renderId:int = 0;
private static const constantsAttributesCount:int = 8;
private static const constantsOffset:int = 16;
private static const constantsMaxTriangles:int = 18;
private static const constants:Vector.<Number> = new Vector.<Number>(constantsMaxTriangles * 3 * constantsAttributesCount);
private static const constantsVertexBuffer:VertexBufferResource = createConstantsVertexBuffer(constantsMaxTriangles * 3);
private static const constantsIndexBuffer:IndexBufferResource = createConstantsIndexBuffer(constantsMaxTriangles * 3);
public var view:View;
public var fov:Number = 1.5707963267948966;
public var nearClipping:Number = 1;
public var farClipping:Number = 1000000;
public var onRender:Function;
alternativa3d var viewSizeX:Number;
alternativa3d var viewSizeY:Number;
alternativa3d var focalLength:Number;
alternativa3d var correctionX:Number;
alternativa3d var correctionY:Number;
alternativa3d var lights:Vector.<Light3D> = new Vector.<Light3D>();
alternativa3d var lightsLength:int = 0;
alternativa3d var occluders:Vector.<Vertex> = new Vector.<Vertex>();
alternativa3d var numOccluders:int;
alternativa3d var occludedAll:Boolean;
alternativa3d var numDraws:int;
alternativa3d var numShadows:int;
alternativa3d var numTriangles:int;
alternativa3d var device:Device;
alternativa3d var projection:Vector.<Number> = new Vector.<Number>(4);
alternativa3d var correction:Vector.<Number> = new Vector.<Number>(4);
alternativa3d var transform:Vector.<Number> = new Vector.<Number>(12);
private var opaqueMaterials:Vector.<Material> = new Vector.<Material>();
private var opaqueVertexBuffers:Vector.<VertexBufferResource> = new Vector.<VertexBufferResource>();
private var opaqueIndexBuffers:Vector.<IndexBufferResource> = new Vector.<IndexBufferResource>();
private var opaqueFirstIndexes:Vector.<int> = new Vector.<int>();
private var opaqueNumsTriangles:Vector.<int> = new Vector.<int>();
private var opaqueObjects:Vector.<Object3D> = new Vector.<Object3D>();
private var opaqueCount:int = 0;
private var skyMaterials:Vector.<Material> = new Vector.<Material>();
private var skyVertexBuffers:Vector.<VertexBufferResource> = new Vector.<VertexBufferResource>();
private var skyIndexBuffers:Vector.<IndexBufferResource> = new Vector.<IndexBufferResource>();
private var skyFirstIndexes:Vector.<int> = new Vector.<int>();
private var skyNumsTriangles:Vector.<int> = new Vector.<int>();
private var skyObjects:Vector.<Object3D> = new Vector.<Object3D>();
private var skyCount:int = 0;
private var transparentFaceLists:Vector.<Face> = new Vector.<Face>();
private var transparentObjects:Vector.<Object3D> = new Vector.<Object3D>();
private var transparentCount:int = 0;
private var transparentOpaqueFaceLists:Vector.<Face> = new Vector.<Face>();
private var transparentOpaqueObjects:Vector.<Object3D> = new Vector.<Object3D>();
private var transparentOpaqueCount:int = 0;
private var transparentBatchObjects:Vector.<Object3D> = new Vector.<Object3D>();
private var decals:Vector.<Decal> = new Vector.<Decal>();
private var decalsCount:int = 0;
alternativa3d var depthObjects:Vector.<Object3D> = new Vector.<Object3D>();
alternativa3d var depthCount:int = 0;
alternativa3d var casterObjects:Vector.<Object3D> = new Vector.<Object3D>();
alternativa3d var casterCount:int = 0;
alternativa3d var shadowAtlases:Array = new Array();
alternativa3d var receiversVertexBuffers:Vector.<VertexBufferResource>;
alternativa3d var receiversIndexBuffers:Vector.<IndexBufferResource>;
alternativa3d var gma:Number;
alternativa3d var gmb:Number;
alternativa3d var gmc:Number;
alternativa3d var gmd:Number;
alternativa3d var gme:Number;
alternativa3d var gmf:Number;
alternativa3d var gmg:Number;
alternativa3d var gmh:Number;
alternativa3d var gmi:Number;
alternativa3d var gmj:Number;
alternativa3d var gmk:Number;
alternativa3d var gml:Number;
alternativa3d var fogParams:Vector.<Number> = Vector.<Number>([1,1,0,1]);
alternativa3d var fogFragment:Vector.<Number> = Vector.<Number>([0,0,0,1]);
private var fragmentConst:Vector.<Number> = Vector.<Number>([0,0,0,1,0.5,0.5,0,1 / 4096]);
private var shadows:Dictionary = new Dictionary();
private var shadowList:Vector.<Shadow> = new Vector.<Shadow>();
private var depthRenderer:DepthRenderer = new DepthRenderer();
alternativa3d var depthMap:TextureResource;
alternativa3d var lightMap:TextureResource;
private var depthParams:Vector.<Number> = Vector.<Number>([0,0,0,1]);
private var ssaoParams:Vector.<Number> = Vector.<Number>([0,0,0,1]);
private var lightTransform:Vector.<Number> = Vector.<Number>([0,0,0,1]);
private var lightParams:Vector.<Number> = Vector.<Number>([0,0,0,1,0,0,0,1]);
alternativa3d var omnies:Vector.<OmniLight> = new Vector.<OmniLight>();
alternativa3d var omniesCount:int = 0;
alternativa3d var spots:Vector.<SpotLight> = new Vector.<SpotLight>();
alternativa3d var spotsCount:int = 0;
alternativa3d var tubes:Vector.<TubeLight> = new Vector.<TubeLight>();
alternativa3d var tubesCount:int = 0;
public var fogNear:Number = 0;
public var fogFar:Number = 1000000;
public var fogAlpha:Number = 0;
public var fogColor:int = 8355711;
public var softTransparency:Boolean = false;
public var depthBufferScale:Number = 1;
public var ssao:Boolean = false;
public var ssaoRadius:Number = 100;
public var ssaoRange:Number = 1000;
public var ssaoColor:int = 0;
public var ssaoAlpha:Number = 1;
public var directionalLight:DirectionalLight;
public var shadowMap:ShadowMap;
public var ambientColor:int = 0;
public var deferredLighting:Boolean = false;
public var fogStrength:Number = 1;
public var softTransparencyStrength:Number = 1;
public var ssaoStrength:Number = 1;
public var directionalLightStrength:Number = 1;
public var shadowMapStrength:Number = 1;
public var shadowsStrength:Number = 1;
public var shadowsDistanceMultiplier:Number = 1;
public var deferredLightingStrength:Number = 1;
public var debug:Boolean = false;
private var debugSet:Object = new Object();
private var _diagram:Sprite = this.createDiagram();
public var fpsUpdatePeriod:int = 10;
public var timerUpdatePeriod:int = 10;
private var fpsTextField:TextField;
private var memoryTextField:TextField;
private var drawsTextField:TextField;
private var shadowsTextField:TextField;
private var trianglesTextField:TextField;
private var timerTextField:TextField;
private var graph:Bitmap;
private var rect:Rectangle;
private var _diagramAlign:String = "TR";
private var _diagramHorizontalMargin:Number = 2;
private var _diagramVerticalMargin:Number = 2;
private var fpsUpdateCounter:int;
private var previousFrameTime:int;
private var previousPeriodTime:int;
private var maxMemory:int;
private var timerUpdateCounter:int;
private var timeSum:int;
private var timeCount:int;
private var timer:int;
private var firstVertex:Vertex = new Vertex();
private var firstFace:Face = new Face();
private var firstWrapper:Wrapper = new Wrapper();
alternativa3d var lastWrapper:Wrapper = this.firstWrapper;
alternativa3d var lastVertex:Vertex = this.firstVertex;
alternativa3d var lastFace:Face = this.firstFace;
public function Camera3D() {
super();
}
private static function createConstantsVertexBuffer(param1:int) : VertexBufferResource {
var local5:int = 0;
var local2:Vector.<Number> = new Vector.<Number>();
var local3:int = 0;
while(local3 < param1) {
local2.push((local3 << 1) + constantsOffset);
local3++;
}
var local4:int = 0;
while(local4 < param1 << 1) {
local5 = local4 * 4 + 3;
constants[local5] = 1;
local4++;
}
return new VertexBufferResource(local2,1);
}
private static function createConstantsIndexBuffer(param1:int) : IndexBufferResource {
var local2:Vector.<uint> = new Vector.<uint>();
var local3:int = 0;
while(local3 < param1) {
local2.push(local3);
local3++;
}
return new IndexBufferResource(local2);
}
public function addShadow(param1:Shadow) : void {
this.shadows[param1] = true;
}
public function removeShadow(param1:Shadow) : void {
delete this.shadows[param1];
}
public function removeAllShadows() : void {
this.shadows = new Dictionary();
}
public function render() : void {
var local1:int = 0;
var local2:int = 0;
var local3:int = 0;
var local4:Shadow = null;
var local5:Object3D = null;
var local6:Light3D = null;
var local7:ShadowAtlas = null;
var local8:Boolean = false;
var local9:Material = null;
var local10:* = undefined;
var local11:Decal = null;
var local12:int = 0;
var local13:int = 0;
var local14:int = 0;
var local15:TextureResource = null;
var local16:Face = null;
var local17:Object3D = null;
var local18:Boolean = false;
var local19:Boolean = false;
var local20:int = 0;
var local21:Sprite3D = null;
var local22:Face = null;
var local23:Face = null;
var local24:Object3D = null;
var local25:Sprite3D = null;
this.alternativa3d::numDraws = 0;
this.alternativa3d::numShadows = 0;
this.alternativa3d::numTriangles = 0;
if(this.view != null && this.view.alternativa3d::device != null && Boolean(this.view.alternativa3d::device.ready)) {
++alternativa3d::renderId;
this.alternativa3d::device = this.view.alternativa3d::device;
this.view.alternativa3d::configure();
if(this.nearClipping < 1) {
this.nearClipping = 1;
}
if(this.farClipping > 1000000) {
this.farClipping = 1000000;
}
this.alternativa3d::viewSizeX = this.view.alternativa3d::_width * 0.5;
this.alternativa3d::viewSizeY = this.view.alternativa3d::_height * 0.5;
this.alternativa3d::focalLength = Math.sqrt(this.alternativa3d::viewSizeX * this.alternativa3d::viewSizeX + this.alternativa3d::viewSizeY * this.alternativa3d::viewSizeY) / Math.tan(this.fov * 0.5);
this.alternativa3d::correctionX = this.alternativa3d::viewSizeX / this.alternativa3d::focalLength;
this.alternativa3d::correctionY = this.alternativa3d::viewSizeY / this.alternativa3d::focalLength;
this.alternativa3d::projection[0] = 1 << this.view.zBufferPrecision;
this.alternativa3d::projection[1] = 1;
this.alternativa3d::projection[2] = this.farClipping / (this.farClipping - this.nearClipping);
this.alternativa3d::projection[3] = this.nearClipping * this.farClipping / (this.nearClipping - this.farClipping);
this.alternativa3d::composeCameraMatrix();
local5 = this;
while(local5.alternativa3d::_parent != null) {
local5 = local5.alternativa3d::_parent;
local5.alternativa3d::composeMatrix();
alternativa3d::appendMatrix(local5);
}
this.alternativa3d::gma = alternativa3d::ma;
this.alternativa3d::gmb = alternativa3d::mb;
this.alternativa3d::gmc = alternativa3d::mc;
this.alternativa3d::gmd = alternativa3d::md;
this.alternativa3d::gme = alternativa3d::me;
this.alternativa3d::gmf = alternativa3d::mf;
this.alternativa3d::gmg = alternativa3d::mg;
this.alternativa3d::gmh = alternativa3d::mh;
this.alternativa3d::gmi = alternativa3d::mi;
this.alternativa3d::gmj = alternativa3d::mj;
this.alternativa3d::gmk = alternativa3d::mk;
this.alternativa3d::gml = alternativa3d::ml;
alternativa3d::invertMatrix();
this.alternativa3d::transform[0] = alternativa3d::ma;
this.alternativa3d::transform[1] = alternativa3d::mb;
this.alternativa3d::transform[2] = alternativa3d::mc;
this.alternativa3d::transform[3] = alternativa3d::md;
this.alternativa3d::transform[4] = alternativa3d::me;
this.alternativa3d::transform[5] = alternativa3d::mf;
this.alternativa3d::transform[6] = alternativa3d::mg;
this.alternativa3d::transform[7] = alternativa3d::mh;
this.alternativa3d::transform[8] = alternativa3d::mi;
this.alternativa3d::transform[9] = alternativa3d::mj;
this.alternativa3d::transform[10] = alternativa3d::mk;
this.alternativa3d::transform[11] = alternativa3d::ml;
this.alternativa3d::numOccluders = 0;
this.alternativa3d::occludedAll = false;
if(local5 != this && local5.visible) {
this.alternativa3d::lightsLength = 0;
local6 = (local5 as Object3DContainer).alternativa3d::lightList;
while(local6 != null) {
if(local6.visible) {
local6.alternativa3d::calculateCameraMatrix(this);
if(local6.alternativa3d::checkFrustumCulling(this)) {
this.alternativa3d::lights[this.alternativa3d::lightsLength] = local6;
++this.alternativa3d::lightsLength;
if(!this.view.alternativa3d::constrained && this.deferredLighting && this.deferredLightingStrength > 0) {
if(local6 is OmniLight) {
this.alternativa3d::omnies[this.alternativa3d::omniesCount] = local6 as OmniLight;
++this.alternativa3d::omniesCount;
} else if(local6 is SpotLight) {
this.alternativa3d::spots[this.alternativa3d::spotsCount] = local6 as SpotLight;
++this.alternativa3d::spotsCount;
} else if(local6 is TubeLight) {
this.alternativa3d::tubes[this.alternativa3d::tubesCount] = local6 as TubeLight;
++this.alternativa3d::tubesCount;
}
}
}
}
local6 = local6.alternativa3d::nextLight;
}
local5.alternativa3d::appendMatrix(this);
local5.alternativa3d::cullingInCamera(this,63);
if(this.debug) {
local1 = 0;
while(local1 < this.alternativa3d::lightsLength) {
(this.alternativa3d::lights[local1] as Light3D).alternativa3d::drawDebug(this);
local1++;
}
}
local8 = false;
if(!this.view.alternativa3d::constrained && this.shadowsStrength > 0) {
for(local10 in this.shadows) {
local4 = local10;
if(local4.alternativa3d::checkVisibility(this)) {
local2 = local4.mapSize + local4.blur;
local7 = this.alternativa3d::shadowAtlases[local2];
if(local7 == null) {
local7 = new ShadowAtlas(local4.mapSize,local4.blur);
this.alternativa3d::shadowAtlases[local2] = local7;
}
local7.alternativa3d::shadows[local7.alternativa3d::shadowsCount] = local4;
++local7.alternativa3d::shadowsCount;
local8 = true;
}
}
}
this.alternativa3d::device.setCulling(Context3DTriangleFace.FRONT);
this.alternativa3d::device.setBlendFactors(Context3DBlendFactor.ONE,Context3DBlendFactor.ZERO);
this.alternativa3d::device.setStencilActions(Context3DTriangleFace.NONE);
this.alternativa3d::device.setStencilReferenceValue(0);
if(local8) {
this.alternativa3d::device.setCulling(Context3DTriangleFace.BACK);
this.alternativa3d::device.setDepthTest(true,Context3DCompareMode.GREATER_EQUAL);
this.alternativa3d::device.setProgram(Shadow.alternativa3d::getCasterProgram());
for each(local7 in this.alternativa3d::shadowAtlases) {
if(local7.alternativa3d::shadowsCount > 0) {
local7.alternativa3d::renderCasters(this);
}
}
this.alternativa3d::device.setCulling(Context3DTriangleFace.FRONT);
this.alternativa3d::device.setDepthTest(false,Context3DCompareMode.ALWAYS);
for each(local7 in this.alternativa3d::shadowAtlases) {
if(local7.alternativa3d::shadowsCount > 0) {
local7.alternativa3d::renderBlur(this);
}
}
this.alternativa3d::device.setTextureAt(0,null);
this.alternativa3d::device.setVertexBufferAt(1,null);
}
if(this.directionalLight != null) {
this.directionalLight.alternativa3d::composeAndAppend(this);
this.directionalLight.alternativa3d::calculateInverseMatrix();
}
local5.alternativa3d::concatenatedAlpha = local5.alpha;
local5.alternativa3d::concatenatedBlendMode = local5.blendMode;
local5.alternativa3d::concatenatedColorTransform = local5.colorTransform;
local5.alternativa3d::draw(this);
this.alternativa3d::device.setDepthTest(true,Context3DCompareMode.LESS);
if(!this.view.alternativa3d::constrained && this.shadowMap != null && this.shadowMapStrength > 0) {
this.shadowMap.alternativa3d::calculateBounds(this);
this.shadowMap.alternativa3d::render(this,this.alternativa3d::casterObjects,this.alternativa3d::casterCount);
}
this.alternativa3d::depthMap = null;
this.alternativa3d::lightMap = null;
if(!this.view.alternativa3d::constrained && (this.softTransparency && this.softTransparencyStrength > 0 || this.ssao && this.ssaoStrength > 0 || this.deferredLighting && this.deferredLightingStrength > 0)) {
this.depthRenderer.alternativa3d::render(this,this.view.alternativa3d::_width,this.view.alternativa3d::_height,this.depthBufferScale,this.ssao && this.ssaoStrength > 0,this.deferredLighting && this.deferredLightingStrength > 0,this.directionalLight != null && this.directionalLightStrength > 0 || this.shadowMap != null && this.shadowMapStrength > 0 ? 0 : 0.5,this.alternativa3d::depthObjects,this.alternativa3d::depthCount);
if(this.softTransparency && this.softTransparencyStrength > 0 || this.ssao && this.ssaoStrength > 0) {
this.alternativa3d::depthMap = this.depthRenderer.alternativa3d::depthBuffer;
}
if(this.deferredLighting && this.deferredLightingStrength > 0) {
this.alternativa3d::lightMap = this.depthRenderer.alternativa3d::lightBuffer;
}
} else {
this.depthRenderer.alternativa3d::resetResources();
}
if(local8 || !this.view.alternativa3d::constrained && (this.softTransparency && this.softTransparencyStrength > 0 || this.ssao && this.ssaoStrength > 0 || this.deferredLighting && this.deferredLightingStrength > 0) || !this.view.alternativa3d::constrained && this.shadowMap != null && this.shadowMapStrength > 0) {
this.alternativa3d::device.setRenderToBackBuffer();
}
this.view.alternativa3d::clearArea();
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,3,this.alternativa3d::projection,1);
this.fragmentConst[0] = this.farClipping;
this.fragmentConst[1] = this.farClipping / 255;
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,17,this.fragmentConst,2);
this.alternativa3d::correction[0] = this.view.alternativa3d::rect.width / this.alternativa3d::device.width;
this.alternativa3d::correction[1] = this.view.alternativa3d::rect.height / this.alternativa3d::device.height;
this.alternativa3d::correction[2] = (this.view.alternativa3d::rect.x * 2 + this.view.alternativa3d::rect.width - this.alternativa3d::device.width) / this.alternativa3d::device.width;
this.alternativa3d::correction[3] = (this.view.alternativa3d::rect.y * 2 + this.view.alternativa3d::rect.height - this.alternativa3d::device.height) / this.alternativa3d::device.height;
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,13,this.alternativa3d::correction,1);
if(!this.view.alternativa3d::constrained && (this.softTransparency && this.softTransparencyStrength > 0 || this.ssao && this.ssaoStrength > 0 || this.deferredLighting && this.deferredLightingStrength > 0 || this.shadowMap != null && this.shadowMapStrength > 0)) {
this.depthParams[0] = this.depthRenderer.alternativa3d::correctionX;
this.depthParams[1] = this.depthRenderer.alternativa3d::correctionY;
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,4,this.depthParams,1);
if(this.ssao && this.ssaoStrength > 0) {
this.ssaoParams[0] = (1 - 2 * (this.ssaoColor >> 16 & 0xFF) / 255) * this.ssaoAlpha * this.ssaoStrength;
this.ssaoParams[1] = (1 - 2 * (this.ssaoColor >> 8 & 0xFF) / 255) * this.ssaoAlpha * this.ssaoStrength;
this.ssaoParams[2] = (1 - 2 * (this.ssaoColor & 0xFF) / 255) * this.ssaoAlpha * this.ssaoStrength;
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,12,this.ssaoParams,1);
}
}
if(!this.view.alternativa3d::constrained && this.shadowMap != null && this.shadowMapStrength > 0) {
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,6,this.shadowMap.alternativa3d::transform,4);
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,5,this.shadowMap.alternativa3d::params,5);
}
if(this.fogAlpha > 0 && this.fogStrength > 0) {
this.alternativa3d::fogParams[2] = this.fogNear;
this.alternativa3d::fogParams[3] = this.fogFar - this.fogNear;
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,5,this.alternativa3d::fogParams,1);
this.alternativa3d::fogFragment[0] = (this.fogColor >> 16 & 0xFF) / 255;
this.alternativa3d::fogFragment[1] = (this.fogColor >> 8 & 0xFF) / 255;
this.alternativa3d::fogFragment[2] = (this.fogColor & 0xFF) / 255;
this.alternativa3d::fogFragment[3] = this.fogAlpha * this.fogStrength;
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,2,this.alternativa3d::fogFragment,1);
}
if(!this.view.alternativa3d::constrained && this.directionalLight != null && this.directionalLightStrength > 0) {
this.lightTransform[0] = -this.directionalLight.alternativa3d::imi;
this.lightTransform[1] = -this.directionalLight.alternativa3d::imj;
this.lightTransform[2] = -this.directionalLight.alternativa3d::imk;
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,10,this.lightTransform,1);
this.lightParams[0] = this.directionalLight.intensity * (this.directionalLight.color >> 16 & 0xFF) * 2 * this.directionalLightStrength / 255;
this.lightParams[1] = this.directionalLight.intensity * (this.directionalLight.color >> 8 & 0xFF) * 2 * this.directionalLightStrength / 255;
this.lightParams[2] = this.directionalLight.intensity * (this.directionalLight.color & 0xFF) * 2 * this.directionalLightStrength / 255;
this.lightParams[4] = 1 + ((this.ambientColor >> 16 & 0xFF) * 2 / 255 - 1) * this.directionalLightStrength;
this.lightParams[5] = 1 + ((this.ambientColor >> 8 & 0xFF) * 2 / 255 - 1) * this.directionalLightStrength;
this.lightParams[6] = 1 + ((this.ambientColor & 0xFF) * 2 / 255 - 1) * this.directionalLightStrength;
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,10,this.lightParams,2);
} else if(!this.view.alternativa3d::constrained && this.shadowMap != null && this.shadowMapStrength > 0) {
this.lightParams[0] = 0;
this.lightParams[1] = 0;
this.lightParams[2] = 0;
this.lightParams[4] = 1;
this.lightParams[5] = 1;
this.lightParams[6] = 1;
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,10,this.lightParams,2);
}
local1 = 0;
while(local1 < this.opaqueCount) {
local9 = this.opaqueMaterials[local1];
local9.alternativa3d::drawOpaque(this,this.opaqueVertexBuffers[local1],this.opaqueIndexBuffers[local1],this.opaqueFirstIndexes[local1],this.opaqueNumsTriangles[local1],this.opaqueObjects[local1]);
local1++;
}
this.alternativa3d::device.setDepthTest(false,Context3DCompareMode.LESS_EQUAL);
local1 = 0;
while(local1 < this.skyCount) {
local9 = this.skyMaterials[local1];
local9.alternativa3d::drawOpaque(this,this.skyVertexBuffers[local1],this.skyIndexBuffers[local1],this.skyFirstIndexes[local1],this.skyNumsTriangles[local1],this.skyObjects[local1]);
local1++;
}
this.alternativa3d::device.setDepthTest(false,Context3DCompareMode.LESS);
local1 = this.decalsCount - 1;
while(local1 >= 0) {
local11 = this.decals[local1];
if(local11.alternativa3d::concatenatedBlendMode != "normal") {
this.alternativa3d::device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA,Context3DBlendFactor.ONE);
} else {
this.alternativa3d::device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA,Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA);
}
local11.alternativa3d::faceList.material.alternativa3d::drawOpaque(this,local11.alternativa3d::vertexBuffer,local11.alternativa3d::indexBuffer,0,local11.alternativa3d::numTriangles,local11);
local1--;
}
if(local8) {
this.alternativa3d::device.setTextureAt(0,null);
this.alternativa3d::device.setTextureAt(1,null);
this.alternativa3d::device.setTextureAt(2,null);
this.alternativa3d::device.setTextureAt(3,null);
this.alternativa3d::device.setTextureAt(5,null);
this.alternativa3d::device.setVertexBufferAt(1,null);
this.alternativa3d::device.setVertexBufferAt(2,null);
local12 = 0;
for each(local7 in this.alternativa3d::shadowAtlases) {
local1 = 0;
while(local1 < local7.alternativa3d::shadowsCount) {
this.shadowList[local12] = local7.alternativa3d::shadows[local1];
local12++;
local1++;
}
}
this.alternativa3d::device.setDepthTest(false,Context3DCompareMode.LESS);
local15 = null;
local1 = 0;
while(local1 < local12) {
if(local1 > 0) {
this.alternativa3d::device.clear(0,0,0,0,1,0,Context3DClearMask.STENCIL);
}
this.alternativa3d::device.setBlendFactors(Context3DBlendFactor.ZERO,Context3DBlendFactor.ONE);
this.alternativa3d::device.setCulling(Context3DTriangleFace.NONE);
this.alternativa3d::device.setStencilActions(Context3DTriangleFace.FRONT_AND_BACK,Context3DCompareMode.ALWAYS,Context3DStencilAction.INVERT);
local13 = local1;
local14 = 1;
while(local13 < local1 + 8 && local13 < local12) {
local4 = this.shadowList[local13];
if(!local4.alternativa3d::cameraInside) {
this.alternativa3d::device.setStencilReferenceValue(local14,local14,local14);
local4.alternativa3d::renderVolume(this);
}
local13++;
local14 <<= 1;
}
this.alternativa3d::device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA,Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA);
this.alternativa3d::device.setCulling(Context3DTriangleFace.FRONT);
this.alternativa3d::device.setStencilActions(Context3DTriangleFace.BACK,Context3DCompareMode.EQUAL);
local13 = local1;
local14 = 1;
while(local13 < local1 + 8 && local13 < local12) {
local4 = this.shadowList[local13];
if(local4.alternativa3d::texture != local15) {
this.alternativa3d::device.setTextureAt(0,local4.alternativa3d::texture);
local15 = local4.alternativa3d::texture;
}
if(!local4.alternativa3d::cameraInside) {
this.alternativa3d::device.setStencilReferenceValue(local14,local14,local14);
local4.alternativa3d::renderReceivers(this);
} else {
this.alternativa3d::device.setStencilActions(Context3DTriangleFace.BACK,Context3DCompareMode.ALWAYS);
local4.alternativa3d::renderReceivers(this);
this.alternativa3d::device.setStencilActions(Context3DTriangleFace.BACK,Context3DCompareMode.EQUAL);
}
local13++;
local14 <<= 1;
}
this.alternativa3d::device.setTextureAt(0,null);
local15 = null;
local1 += 8;
}
this.alternativa3d::device.setStencilActions();
this.alternativa3d::device.setStencilReferenceValue(0);
}
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,13,this.alternativa3d::correction,1);
this.alternativa3d::device.setCulling(Context3DTriangleFace.FRONT);
local1 = 0;
while(local1 < this.transparentOpaqueCount) {
if(local1 < this.transparentOpaqueFaceLists.length && local1 < this.transparentOpaqueObjects.length) {
this.transparentFaceLists[this.transparentCount] = this.transparentOpaqueFaceLists[local1];
this.transparentObjects[this.transparentCount] = this.transparentOpaqueObjects[local1];
++this.transparentCount;
}
local1++;
}
this.transparentOpaqueCount = this.transparentCount - this.transparentOpaqueCount;
this.alternativa3d::device.setDepthTest(true,Context3DCompareMode.LESS);
local1 = this.transparentCount - 1;
while(local1 >= 0) {
if(local1 + 1 == this.transparentOpaqueCount) {
this.alternativa3d::device.setDepthTest(false,Context3DCompareMode.LESS);
}
local16 = this.transparentFaceLists[local1];
local17 = this.transparentObjects[local1];
if(local17.alternativa3d::concatenatedBlendMode != "normal") {
this.alternativa3d::device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA,Context3DBlendFactor.ONE);
} else {
this.alternativa3d::device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA,Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA);
}
local18 = local17 is Sprite3D;
if(local18) {
local20 = 0;
local21 = Sprite3D(local17);
local22 = local16;
while(local22.alternativa3d::processNext != null) {
local22.alternativa3d::distance = local20;
local22 = local22.alternativa3d::processNext;
}
local22.alternativa3d::distance = local20;
this.transparentBatchObjects[local20] = local17;
local20++;
local13 = local1 - 1;
while(local13 >= 0) {
local23 = this.transparentFaceLists[local13];
if(local16.material != local23.material) {
break;
}
local24 = this.transparentObjects[local13];
if(!(local24 is Sprite3D)) {
break;
}
local25 = Sprite3D(local24);
if(local21.useLight != local25.useLight || local21.useShadowMap != local25.useShadowMap || Boolean(local21.alternativa3d::lighted) || Boolean(local25.alternativa3d::lighted) || local21.softAttenuation != local25.softAttenuation || local21.alternativa3d::concatenatedAlpha != local25.alternativa3d::concatenatedAlpha || local21.alternativa3d::concatenatedColorTransform != null || local25.alternativa3d::concatenatedColorTransform != null || local21.alternativa3d::concatenatedBlendMode != local25.alternativa3d::concatenatedBlendMode) {
break;
}
local22.alternativa3d::processNext = local23;
local22 = local23;
while(local22.alternativa3d::processNext != null) {
local22.alternativa3d::distance = local20;
local22 = local22.alternativa3d::processNext;
}
local22.alternativa3d::distance = local20;
this.transparentBatchObjects[local20] = local24;
local20++;
local1--;
local13--;
}
}
local19 = local18 && !Sprite3D(local17).depthTest;
if(local19) {
this.alternativa3d::device.setDepthTest(false,Context3DCompareMode.ALWAYS);
}
this.drawTransparentList(local16,local17,local18);
if(local19) {
this.alternativa3d::device.setDepthTest(false,Context3DCompareMode.LESS);
}
local1--;
}
this.alternativa3d::device.setTextureAt(0,null);
this.alternativa3d::device.setTextureAt(1,null);
this.alternativa3d::device.setTextureAt(2,null);
this.alternativa3d::device.setTextureAt(3,null);
this.alternativa3d::device.setTextureAt(5,null);
this.alternativa3d::device.setTextureAt(6,null);
this.alternativa3d::device.setTextureAt(7,null);
this.alternativa3d::device.setVertexBufferAt(1,null);
this.alternativa3d::device.setVertexBufferAt(2,null);
this.alternativa3d::device.setVertexBufferAt(3,null);
this.alternativa3d::device.setVertexBufferAt(4,null);
this.alternativa3d::device.setVertexBufferAt(5,null);
this.alternativa3d::device.setVertexBufferAt(6,null);
this.alternativa3d::device.setVertexBufferAt(7,null);
this.opaqueMaterials.length = 0;
this.opaqueVertexBuffers.length = 0;
this.opaqueIndexBuffers.length = 0;
this.opaqueFirstIndexes.length = 0;
this.opaqueNumsTriangles.length = 0;
this.opaqueObjects.length = 0;
this.opaqueCount = 0;
this.skyMaterials.length = 0;
this.skyVertexBuffers.length = 0;
this.skyIndexBuffers.length = 0;
this.skyFirstIndexes.length = 0;
this.skyNumsTriangles.length = 0;
this.skyObjects.length = 0;
this.skyCount = 0;
this.transparentFaceLists.length = 0;
this.transparentObjects.length = 0;
this.transparentCount = 0;
this.transparentOpaqueFaceLists.length = 0;
this.transparentOpaqueObjects.length = 0;
this.transparentOpaqueCount = 0;
this.transparentBatchObjects.length = 0;
this.decals.length = 0;
this.decalsCount = 0;
this.alternativa3d::depthObjects.length = 0;
this.alternativa3d::depthCount = 0;
this.alternativa3d::casterObjects.length = 0;
this.alternativa3d::casterCount = 0;
this.alternativa3d::omnies.length = 0;
this.alternativa3d::omniesCount = 0;
this.alternativa3d::spots.length = 0;
this.alternativa3d::spotsCount = 0;
this.alternativa3d::tubes.length = 0;
this.alternativa3d::tubesCount = 0;
for each(local7 in this.alternativa3d::shadowAtlases) {
if(local7.alternativa3d::shadowsCount > 0) {
local7.alternativa3d::clear();
}
}
this.alternativa3d::receiversVertexBuffers = null;
this.alternativa3d::receiversIndexBuffers = null;
this.alternativa3d::deferredDestroy();
this.alternativa3d::clearOccluders();
this.view.alternativa3d::onRender(this);
if(this.onRender != null) {
this.onRender();
}
this.view.alternativa3d::present();
} else {
this.view.alternativa3d::clearArea();
if(this.onRender != null) {
this.onRender();
}
this.view.alternativa3d::present();
}
this.alternativa3d::device = null;
}
}
private function drawTransparentList(param1:Face, param2:Object3D, param3:Boolean) : void {
var local4:Vertex = null;
var local5:Vertex = null;
var local6:Vertex = null;
var local7:Wrapper = null;
var local8:Face = null;
var local12:int = 0;
var local13:Object3D = null;
var local9:int = 0;
var local10:int = 0;
var local11:Material = param1.material;
while(param1 != null) {
local8 = param1.alternativa3d::processNext;
param1.alternativa3d::processNext = null;
local7 = param1.alternativa3d::wrapper;
local4 = local7.alternativa3d::vertex;
local7 = local7.alternativa3d::next;
local5 = local7.alternativa3d::vertex;
if(param3) {
local12 = int(param1.alternativa3d::distance);
local13 = this.transparentBatchObjects[local12];
local7 = local7.alternativa3d::next;
while(local7 != null) {
if(local10 == constantsMaxTriangles) {
if(local11 != null) {
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,constantsOffset,constants,local10 * 6,false);
local11.alternativa3d::drawTransparent(this,constantsVertexBuffer,constantsIndexBuffer,0,local10,param2,true);
}
local10 = 0;
local9 = 0;
}
local6 = local7.alternativa3d::vertex;
constants[local9] = local4.alternativa3d::cameraX;
local9++;
constants[local9] = local4.alternativa3d::cameraY;
local9++;
constants[local9] = local4.alternativa3d::cameraZ;
local9++;
constants[local9] = -local13.alternativa3d::md;
local9++;
constants[local9] = local4.u;
local9++;
constants[local9] = local4.v;
local9++;
constants[local9] = -local13.alternativa3d::mh;
local9++;
constants[local9] = -local13.alternativa3d::ml;
local9++;
constants[local9] = local5.alternativa3d::cameraX;
local9++;
constants[local9] = local5.alternativa3d::cameraY;
local9++;
constants[local9] = local5.alternativa3d::cameraZ;
local9++;
constants[local9] = -local13.alternativa3d::md;
local9++;
constants[local9] = local5.u;
local9++;
constants[local9] = local5.v;
local9++;
constants[local9] = -local13.alternativa3d::mh;
local9++;
constants[local9] = -local13.alternativa3d::ml;
local9++;
constants[local9] = local6.alternativa3d::cameraX;
local9++;
constants[local9] = local6.alternativa3d::cameraY;
local9++;
constants[local9] = local6.alternativa3d::cameraZ;
local9++;
constants[local9] = -local13.alternativa3d::md;
local9++;
constants[local9] = local6.u;
local9++;
constants[local9] = local6.v;
local9++;
constants[local9] = -local13.alternativa3d::mh;
local9++;
constants[local9] = -local13.alternativa3d::ml;
local9++;
local10++;
local5 = local6;
local7 = local7.alternativa3d::next;
}
} else {
local7 = local7.alternativa3d::next;
while(local7 != null) {
if(local10 == constantsMaxTriangles) {
if(local11 != null) {
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,constantsOffset,constants,local10 * 6,false);
local11.alternativa3d::drawTransparent(this,constantsVertexBuffer,constantsIndexBuffer,0,local10,param2,true);
}
local10 = 0;
local9 = 0;
}
local6 = local7.alternativa3d::vertex;
constants[local9] = local4.alternativa3d::cameraX;
local9++;
constants[local9] = local4.alternativa3d::cameraY;
local9++;
constants[local9] = local4.alternativa3d::cameraZ;
local9++;
constants[local9] = local4.normalX;
local9++;
constants[local9] = local4.u;
local9++;
constants[local9] = local4.v;
local9++;
constants[local9] = local4.normalY;
local9++;
constants[local9] = local4.normalZ;
local9++;
constants[local9] = local5.alternativa3d::cameraX;
local9++;
constants[local9] = local5.alternativa3d::cameraY;
local9++;
constants[local9] = local5.alternativa3d::cameraZ;
local9++;
constants[local9] = local5.normalX;
local9++;
constants[local9] = local5.u;
local9++;
constants[local9] = local5.v;
local9++;
constants[local9] = local5.normalY;
local9++;
constants[local9] = local5.normalZ;
local9++;
constants[local9] = local6.alternativa3d::cameraX;
local9++;
constants[local9] = local6.alternativa3d::cameraY;
local9++;
constants[local9] = local6.alternativa3d::cameraZ;
local9++;
constants[local9] = local6.normalX;
local9++;
constants[local9] = local6.u;
local9++;
constants[local9] = local6.v;
local9++;
constants[local9] = local6.normalY;
local9++;
constants[local9] = local6.normalZ;
local9++;
local10++;
local5 = local6;
local7 = local7.alternativa3d::next;
}
}
param1 = local8;
}
if(local10 > 0 && local11 != null) {
this.alternativa3d::device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,constantsOffset,constants,local10 * 6,false);
local11.alternativa3d::drawTransparent(this,constantsVertexBuffer,constantsIndexBuffer,0,local10,param2,true);
}
}
public function lookAt(param1:Number, param2:Number, param3:Number) : void {
var local4:Number = param1 - this.x;
var local5:Number = param2 - this.y;
var local6:Number = param3 - this.z;
rotationX = Math.atan2(local6,Math.sqrt(local4 * local4 + local5 * local5)) - Math.PI / 2;
rotationY = 0;
rotationZ = -Math.atan2(local4,local5);
}
public function projectGlobal(param1:Vector3D) : Vector3D {
if(this.view == null) {
throw new Error("It is necessary to have view set.");
}
this.alternativa3d::viewSizeX = this.view.alternativa3d::_width * 0.5;
this.alternativa3d::viewSizeY = this.view.alternativa3d::_height * 0.5;
this.alternativa3d::focalLength = Math.sqrt(this.alternativa3d::viewSizeX * this.alternativa3d::viewSizeX + this.alternativa3d::viewSizeY * this.alternativa3d::viewSizeY) / Math.tan(this.fov * 0.5);
this.alternativa3d::composeCameraMatrix();
var local2:Object3D = this;
while(local2.alternativa3d::_parent != null) {
local2 = local2.alternativa3d::_parent;
alternativa3d::tA.alternativa3d::composeMatrixFromSource(local2);
alternativa3d::appendMatrix(alternativa3d::tA);
}
alternativa3d::invertMatrix();
var local3:Vector3D = new Vector3D();
local3.x = alternativa3d::ma * param1.x + alternativa3d::mb * param1.y + alternativa3d::mc * param1.z + alternativa3d::md;
local3.y = alternativa3d::me * param1.x + alternativa3d::mf * param1.y + alternativa3d::mg * param1.z + alternativa3d::mh;
local3.z = alternativa3d::mi * param1.x + alternativa3d::mj * param1.y + alternativa3d::mk * param1.z + alternativa3d::ml;
local3.x = local3.x * this.alternativa3d::viewSizeX / local3.z + this.alternativa3d::viewSizeX;
local3.y = local3.y * this.alternativa3d::viewSizeY / local3.z + this.alternativa3d::viewSizeY;
return local3;
}
public function calculateRay(param1:Vector3D, param2:Vector3D, param3:Number, param4:Number) : void {
if(this.view == null) {
throw new Error("It is necessary to have view set.");
}
this.alternativa3d::viewSizeX = this.view.alternativa3d::_width * 0.5;
this.alternativa3d::viewSizeY = this.view.alternativa3d::_height * 0.5;
this.alternativa3d::focalLength = Math.sqrt(this.alternativa3d::viewSizeX * this.alternativa3d::viewSizeX + this.alternativa3d::viewSizeY * this.alternativa3d::viewSizeY) / Math.tan(this.fov * 0.5);
param3 -= this.alternativa3d::viewSizeX;
param4 -= this.alternativa3d::viewSizeY;
var local5:Number = param3 * this.alternativa3d::focalLength / this.alternativa3d::viewSizeX;
var local6:Number = param4 * this.alternativa3d::focalLength / this.alternativa3d::viewSizeY;
var local7:Number = this.alternativa3d::focalLength;
var local8:Number = local5 * this.nearClipping / this.alternativa3d::focalLength;
var local9:Number = local6 * this.nearClipping / this.alternativa3d::focalLength;
var local10:Number = this.nearClipping;
this.alternativa3d::composeCameraMatrix();
var local11:Object3D = this;
while(local11.alternativa3d::_parent != null) {
local11 = local11.alternativa3d::_parent;
alternativa3d::tA.alternativa3d::composeMatrixFromSource(local11);
alternativa3d::appendMatrix(alternativa3d::tA);
}
param1.x = alternativa3d::ma * local8 + alternativa3d::mb * local9 + alternativa3d::mc * local10 + alternativa3d::md;
param1.y = alternativa3d::me * local8 + alternativa3d::mf * local9 + alternativa3d::mg * local10 + alternativa3d::mh;
param1.z = alternativa3d::mi * local8 + alternativa3d::mj * local9 + alternativa3d::mk * local10 + alternativa3d::ml;
param2.x = alternativa3d::ma * local5 + alternativa3d::mb * local6 + alternativa3d::mc * local7;
param2.y = alternativa3d::me * local5 + alternativa3d::mf * local6 + alternativa3d::mg * local7;
param2.z = alternativa3d::mi * local5 + alternativa3d::mj * local6 + alternativa3d::mk * local7;
var local12:Number = 1 / Math.sqrt(param2.x * param2.x + param2.y * param2.y + param2.z * param2.z);
param2.x *= local12;
param2.y *= local12;
param2.z *= local12;
}
override public function clone() : Object3D {
var local1:Camera3D = new Camera3D();
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
var local3:* = undefined;
super.clonePropertiesFrom(param1);
var local2:Camera3D = param1 as Camera3D;
this.fov = local2.fov;
this.nearClipping = local2.nearClipping;
this.farClipping = local2.farClipping;
this.debug = local2.debug;
this.fogNear = local2.fogNear;
this.fogFar = local2.fogFar;
this.fogAlpha = local2.fogAlpha;
this.fogColor = local2.fogColor;
this.softTransparency = local2.softTransparency;
this.depthBufferScale = local2.depthBufferScale;
this.ssao = local2.ssao;
this.ssaoRadius = local2.ssaoRadius;
this.ssaoRange = local2.ssaoRange;
this.ssaoColor = local2.ssaoColor;
this.ssaoAlpha = local2.ssaoAlpha;
this.directionalLight = local2.directionalLight;
this.shadowMap = local2.shadowMap;
this.ambientColor = local2.ambientColor;
this.deferredLighting = local2.deferredLighting;
this.fogStrength = local2.fogStrength;
this.softTransparencyStrength = local2.softTransparencyStrength;
this.ssaoStrength = local2.ssaoStrength;
this.directionalLightStrength = local2.directionalLightStrength;
this.shadowMapStrength = local2.shadowMapStrength;
this.shadowsStrength = local2.shadowsStrength;
this.shadowsDistanceMultiplier = local2.shadowsDistanceMultiplier;
this.deferredLightingStrength = local2.deferredLightingStrength;
for(local3 in local2.shadows) {
this.shadows[local3] = true;
}
}
alternativa3d function addOpaque(param1:Material, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D) : void {
this.opaqueMaterials[this.opaqueCount] = param1;
this.opaqueVertexBuffers[this.opaqueCount] = param2;
this.opaqueIndexBuffers[this.opaqueCount] = param3;
this.opaqueFirstIndexes[this.opaqueCount] = param4;
this.opaqueNumsTriangles[this.opaqueCount] = param5;
this.opaqueObjects[this.opaqueCount] = param6;
++this.opaqueCount;
}
alternativa3d function addSky(param1:Material, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D) : void {
this.skyMaterials[this.skyCount] = param1;
this.skyVertexBuffers[this.skyCount] = param2;
this.skyIndexBuffers[this.skyCount] = param3;
this.skyFirstIndexes[this.skyCount] = param4;
this.skyNumsTriangles[this.skyCount] = param5;
this.skyObjects[this.skyCount] = param6;
++this.skyCount;
}
alternativa3d function addTransparent(param1:Face, param2:Object3D) : void {
this.transparentFaceLists[this.transparentCount] = param1;
this.transparentObjects[this.transparentCount] = param2;
++this.transparentCount;
}
alternativa3d function addTransparentOpaque(param1:Face, param2:Object3D) : void {
this.transparentOpaqueFaceLists[this.transparentOpaqueCount] = param1;
this.transparentOpaqueObjects[this.transparentOpaqueCount] = param2;
++this.transparentOpaqueCount;
}
alternativa3d function addDecal(param1:Decal) : void {
this.decals[this.decalsCount] = param1;
++this.decalsCount;
}
alternativa3d function composeCameraMatrix() : void {
var local1:Number = this.alternativa3d::viewSizeX / this.alternativa3d::focalLength;
var local2:Number = this.alternativa3d::viewSizeY / this.alternativa3d::focalLength;
var local3:Number = Math.cos(rotationX);
var local4:Number = Math.sin(rotationX);
var local5:Number = Math.cos(rotationY);
var local6:Number = Math.sin(rotationY);
var local7:Number = Math.cos(rotationZ);
var local8:Number = Math.sin(rotationZ);
var local9:Number = local7 * local6;
var local10:Number = local8 * local6;
var local11:Number = local5 * scaleX;
var local12:Number = local4 * scaleY;
var local13:Number = local3 * scaleY;
var local14:Number = local3 * scaleZ;
var local15:Number = local4 * scaleZ;
alternativa3d::ma = local7 * local11 * local1;
alternativa3d::mb = (local9 * local12 - local8 * local13) * local2;
alternativa3d::mc = local9 * local14 + local8 * local15;
alternativa3d::md = x;
alternativa3d::me = local8 * local11 * local1;
alternativa3d::mf = (local10 * local12 + local7 * local13) * local2;
alternativa3d::mg = local10 * local14 - local7 * local15;
alternativa3d::mh = y;
alternativa3d::mi = -local6 * scaleX * local1;
alternativa3d::mj = local5 * local12 * local2;
alternativa3d::mk = local5 * local14;
alternativa3d::ml = z;
var local16:Number = this.view.offsetX / this.alternativa3d::viewSizeX;
var local17:Number = this.view.offsetY / this.alternativa3d::viewSizeY;
alternativa3d::mc -= alternativa3d::ma * local16 + alternativa3d::mb * local17;
alternativa3d::mg -= alternativa3d::me * local16 + alternativa3d::mf * local17;
alternativa3d::mk -= alternativa3d::mi * local16 + alternativa3d::mj * local17;
}
public function addToDebug(param1:int, param2:*) : void {
if(!this.debugSet[param1]) {
this.debugSet[param1] = new Dictionary();
}
this.debugSet[param1][param2] = true;
}
public function removeFromDebug(param1:int, param2:*) : void {
var local3:* = undefined;
if(Boolean(this.debugSet[param1])) {
delete this.debugSet[param1][param2];
var local4:int = 0;
var local5:* = this.debugSet[param1];
for(local3 in local5) {
}
if(!local3) {
delete this.debugSet[param1];
}
}
}
alternativa3d function checkInDebug(param1:Object3D) : int {
var local4:Class = null;
var local2:int = 0;
var local3:int = 1;
while(local3 <= 512) {
if(Boolean(this.debugSet[local3])) {
if(Boolean(this.debugSet[local3][Object3D]) || Boolean(this.debugSet[local3][param1])) {
local2 |= local3;
} else {
local4 = getDefinitionByName(getQualifiedClassName(param1)) as Class;
while(local4 != Object3D) {
if(Boolean(this.debugSet[local3][local4])) {
local2 |= local3;
break;
}
local4 = Class(getDefinitionByName(getQualifiedSuperclassName(local4)));
}
}
}
local3 <<= 1;
}
return local2;
}
public function startTimer() : void {
this.timer = getTimer();
}
public function stopTimer() : void {
this.timeSum += getTimer() - this.timer;
++this.timeCount;
}
public function get diagram() : DisplayObject {
return this._diagram;
}
public function get diagramAlign() : String {
return this._diagramAlign;
}
public function set diagramAlign(param1:String) : void {
this._diagramAlign = param1;
this.resizeDiagram();
}
public function get diagramHorizontalMargin() : Number {
return this._diagramHorizontalMargin;
}
public function set diagramHorizontalMargin(param1:Number) : void {
this._diagramHorizontalMargin = param1;
this.resizeDiagram();
}
public function get diagramVerticalMargin() : Number {
return this._diagramVerticalMargin;
}
public function set diagramVerticalMargin(param1:Number) : void {
this._diagramVerticalMargin = param1;
this.resizeDiagram();
}
private function createDiagram() : Sprite {
var diagram:Sprite = null;
diagram = new Sprite();
diagram.mouseEnabled = false;
diagram.mouseChildren = false;
diagram.addEventListener(Event.ADDED_TO_STAGE,function():void {
while(diagram.numChildren > 0) {
diagram.removeChildAt(0);
}
fpsTextField = new TextField();
fpsTextField.defaultTextFormat = new TextFormat("Tahoma",10,13421772);
fpsTextField.autoSize = TextFieldAutoSize.LEFT;
fpsTextField.text = "FPS:";
fpsTextField.selectable = false;
fpsTextField.x = -3;
fpsTextField.y = -5;
diagram.addChild(fpsTextField);
fpsTextField = new TextField();
fpsTextField.defaultTextFormat = new TextFormat("Tahoma",10,13421772);
fpsTextField.autoSize = TextFieldAutoSize.RIGHT;
fpsTextField.text = Number(diagram.stage.frameRate).toFixed(2);
fpsTextField.selectable = false;
fpsTextField.x = -3;
fpsTextField.y = -5;
fpsTextField.width = 65;
diagram.addChild(fpsTextField);
timerTextField = new TextField();
timerTextField.defaultTextFormat = new TextFormat("Tahoma",10,26367);
timerTextField.autoSize = TextFieldAutoSize.LEFT;
timerTextField.text = "MS:";
timerTextField.selectable = false;
timerTextField.x = -3;
timerTextField.y = 4;
diagram.addChild(timerTextField);
timerTextField = new TextField();
timerTextField.defaultTextFormat = new TextFormat("Tahoma",10,26367);
timerTextField.autoSize = TextFieldAutoSize.RIGHT;
timerTextField.text = "";
timerTextField.selectable = false;
timerTextField.x = -3;
timerTextField.y = 4;
timerTextField.width = 65;
diagram.addChild(timerTextField);
memoryTextField = new TextField();
memoryTextField.defaultTextFormat = new TextFormat("Tahoma",10,13421568);
memoryTextField.autoSize = TextFieldAutoSize.LEFT;
memoryTextField.text = "MEM:";
memoryTextField.selectable = false;
memoryTextField.x = -3;
memoryTextField.y = 13;
diagram.addChild(memoryTextField);
memoryTextField = new TextField();
memoryTextField.defaultTextFormat = new TextFormat("Tahoma",10,13421568);
memoryTextField.autoSize = TextFieldAutoSize.RIGHT;
memoryTextField.text = bytesToString(System.totalMemory);
memoryTextField.selectable = false;
memoryTextField.x = -3;
memoryTextField.y = 13;
memoryTextField.width = 65;
diagram.addChild(memoryTextField);
drawsTextField = new TextField();
drawsTextField.defaultTextFormat = new TextFormat("Tahoma",10,52224);
drawsTextField.autoSize = TextFieldAutoSize.LEFT;
drawsTextField.text = "DRW:";
drawsTextField.selectable = false;
drawsTextField.x = -3;
drawsTextField.y = 22;
diagram.addChild(drawsTextField);
drawsTextField = new TextField();
drawsTextField.defaultTextFormat = new TextFormat("Tahoma",10,52224);
drawsTextField.autoSize = TextFieldAutoSize.RIGHT;
drawsTextField.text = "0";
drawsTextField.selectable = false;
drawsTextField.x = -3;
drawsTextField.y = 22;
drawsTextField.width = 52;
diagram.addChild(drawsTextField);
shadowsTextField = new TextField();
shadowsTextField.defaultTextFormat = new TextFormat("Tahoma",10,16711731);
shadowsTextField.autoSize = TextFieldAutoSize.LEFT;
shadowsTextField.text = "SHD:";
shadowsTextField.selectable = false;
shadowsTextField.x = -3;
shadowsTextField.y = 31;
diagram.addChild(shadowsTextField);
shadowsTextField = new TextField();
shadowsTextField.defaultTextFormat = new TextFormat("Tahoma",10,16711731);
shadowsTextField.autoSize = TextFieldAutoSize.RIGHT;
shadowsTextField.text = "0";
shadowsTextField.selectable = false;
shadowsTextField.x = -3;
shadowsTextField.y = 31;
shadowsTextField.width = 52;
diagram.addChild(shadowsTextField);
trianglesTextField = new TextField();
trianglesTextField.defaultTextFormat = new TextFormat("Tahoma",10,16737792);
trianglesTextField.autoSize = TextFieldAutoSize.LEFT;
trianglesTextField.text = "TRI:";
trianglesTextField.selectable = false;
trianglesTextField.x = -3;
trianglesTextField.y = 40;
diagram.addChild(trianglesTextField);
trianglesTextField = new TextField();
trianglesTextField.defaultTextFormat = new TextFormat("Tahoma",10,16737792);
trianglesTextField.autoSize = TextFieldAutoSize.RIGHT;
trianglesTextField.text = "0";
trianglesTextField.selectable = false;
trianglesTextField.x = -3;
trianglesTextField.y = 40;
trianglesTextField.width = 52;
diagram.addChild(trianglesTextField);
graph = new Bitmap(new BitmapData(60,40,true,553648127));
rect = new Rectangle(0,0,1,40);
graph.x = 0;
graph.y = 54;
diagram.addChild(graph);
previousPeriodTime = getTimer();
previousFrameTime = previousPeriodTime;
fpsUpdateCounter = 0;
maxMemory = 0;
timerUpdateCounter = 0;
timeSum = 0;
timeCount = 0;
diagram.stage.addEventListener(Event.ENTER_FRAME,updateDiagram,false,-1000);
diagram.stage.addEventListener(Event.RESIZE,resizeDiagram,false,-1000);
resizeDiagram();
});
diagram.addEventListener(Event.REMOVED_FROM_STAGE,function():void {
while(diagram.numChildren > 0) {
diagram.removeChildAt(0);
}
fpsTextField = null;
memoryTextField = null;
drawsTextField = null;
shadowsTextField = null;
trianglesTextField = null;
timerTextField = null;
graph.bitmapData.dispose();
graph = null;
rect = null;
diagram.stage.removeEventListener(Event.ENTER_FRAME,updateDiagram);
diagram.stage.removeEventListener(Event.RESIZE,resizeDiagram);
});
return diagram;
}
private function resizeDiagram(param1:Event = null) : void {
var local2:Point = null;
if(this._diagram.stage != null) {
local2 = this._diagram.parent.globalToLocal(new Point());
if(this._diagramAlign == StageAlign.TOP_LEFT || this._diagramAlign == StageAlign.LEFT || this._diagramAlign == StageAlign.BOTTOM_LEFT) {
this._diagram.x = Math.round(local2.x + this._diagramHorizontalMargin);
}
if(this._diagramAlign == StageAlign.TOP || this._diagramAlign == StageAlign.BOTTOM) {
this._diagram.x = Math.round(local2.x + this._diagram.stage.stageWidth / 2 - this.graph.width / 2);
}
if(this._diagramAlign == StageAlign.TOP_RIGHT || this._diagramAlign == StageAlign.RIGHT || this._diagramAlign == StageAlign.BOTTOM_RIGHT) {
this._diagram.x = Math.round(local2.x + this._diagram.stage.stageWidth - this._diagramHorizontalMargin - this.graph.width);
}
if(this._diagramAlign == StageAlign.TOP_LEFT || this._diagramAlign == StageAlign.TOP || this._diagramAlign == StageAlign.TOP_RIGHT) {
this._diagram.y = Math.round(local2.y + this._diagramVerticalMargin);
}
if(this._diagramAlign == StageAlign.LEFT || this._diagramAlign == StageAlign.RIGHT) {
this._diagram.y = Math.round(local2.y + this._diagram.stage.stageHeight / 2 - (this.graph.y + this.graph.height) / 2);
}
if(this._diagramAlign == StageAlign.BOTTOM_LEFT || this._diagramAlign == StageAlign.BOTTOM || this._diagramAlign == StageAlign.BOTTOM_RIGHT) {
this._diagram.y = Math.round(local2.y + this._diagram.stage.stageHeight - this._diagramVerticalMargin - this.graph.y - this.graph.height);
}
}
}
private function updateDiagram(param1:Event) : void {
var local2:Number = NaN;
var local3:int = 0;
var local4:String = null;
var local5:int = getTimer();
var local6:int = this._diagram.stage.frameRate;
if(++this.fpsUpdateCounter == this.fpsUpdatePeriod) {
local2 = 1000 * this.fpsUpdatePeriod / (local5 - this.previousPeriodTime);
if(local2 > local6) {
local2 = local6;
}
local3 = local2 * 100 % 100;
local4 = local3 >= 10 ? String(local3) : (local3 > 0 ? "0" + String(local3) : "00");
this.fpsTextField.text = int(local2) + "." + local4;
this.previousPeriodTime = local5;
this.fpsUpdateCounter = 0;
}
local2 = 1000 / (local5 - this.previousFrameTime);
if(local2 > local6) {
local2 = local6;
}
this.graph.bitmapData.scroll(1,0);
this.graph.bitmapData.fillRect(this.rect,553648127);
this.graph.bitmapData.setPixel32(0,40 * (1 - local2 / local6),4291611852);
this.previousFrameTime = local5;
if(++this.timerUpdateCounter == this.timerUpdatePeriod) {
if(this.timeCount > 0) {
local2 = this.timeSum / this.timeCount;
local3 = local2 * 100 % 100;
local4 = local3 >= 10 ? String(local3) : (local3 > 0 ? "0" + String(local3) : "00");
this.timerTextField.text = int(local2) + "." + local4;
} else {
this.timerTextField.text = "";
}
this.timerUpdateCounter = 0;
this.timeSum = 0;
this.timeCount = 0;
}
var local7:int = int(System.totalMemory);
local2 = local7 / 1048576;
local3 = local2 * 100 % 100;
local4 = local3 >= 10 ? String(local3) : (local3 > 0 ? "0" + String(local3) : "00");
this.memoryTextField.text = int(local2) + "." + local4;
if(local7 > this.maxMemory) {
this.maxMemory = local7;
}
this.graph.bitmapData.setPixel32(0,40 * (1 - local7 / this.maxMemory),4291611648);
this.drawsTextField.text = String(this.alternativa3d::numDraws);
this.shadowsTextField.text = String(this.alternativa3d::numShadows);
this.trianglesTextField.text = String(this.alternativa3d::numTriangles);
}
private function bytesToString(param1:int) : String {
if(param1 < 1024) {
return param1 + "b";
}
if(param1 < 10240) {
return (param1 / 1024).toFixed(2) + "kb";
}
if(param1 < 102400) {
return (param1 / 1024).toFixed(1) + "kb";
}
if(param1 < 1048576) {
return (param1 >> 10) + "kb";
}
if(param1 < 10485760) {
return (param1 / 1048576).toFixed(2);
}
if(param1 < 104857600) {
return (param1 / 1048576).toFixed(1);
}
return String(param1 >> 20);
}
alternativa3d function deferredDestroy() : void {
var local2:Wrapper = null;
var local3:Wrapper = null;
var local1:Face = this.firstFace.alternativa3d::next;
while(local1 != null) {
local2 = local1.alternativa3d::wrapper;
if(local2 != null) {
local3 = null;
while(local2 != null) {
local2.alternativa3d::vertex = null;
local3 = local2;
local2 = local2.alternativa3d::next;
}
this.alternativa3d::lastWrapper.alternativa3d::next = local1.alternativa3d::wrapper;
this.alternativa3d::lastWrapper = local3;
}
local1.material = null;
local1.alternativa3d::wrapper = null;
local1 = local1.alternativa3d::next;
}
if(this.firstFace != this.alternativa3d::lastFace) {
this.alternativa3d::lastFace.alternativa3d::next = Face.alternativa3d::collector;
Face.alternativa3d::collector = this.firstFace.alternativa3d::next;
this.firstFace.alternativa3d::next = null;
this.alternativa3d::lastFace = this.firstFace;
}
if(this.firstWrapper != this.alternativa3d::lastWrapper) {
this.alternativa3d::lastWrapper.alternativa3d::next = Wrapper.alternativa3d::collector;
Wrapper.alternativa3d::collector = this.firstWrapper.alternativa3d::next;
this.firstWrapper.alternativa3d::next = null;
this.alternativa3d::lastWrapper = this.firstWrapper;
}
if(this.firstVertex != this.alternativa3d::lastVertex) {
this.alternativa3d::lastVertex.alternativa3d::next = Vertex.alternativa3d::collector;
Vertex.alternativa3d::collector = this.firstVertex.alternativa3d::next;
this.firstVertex.alternativa3d::next = null;
this.alternativa3d::lastVertex = this.firstVertex;
}
}
alternativa3d function clearOccluders() : void {
var local2:Vertex = null;
var local3:Vertex = null;
var local1:int = 0;
while(local1 < this.alternativa3d::numOccluders) {
local2 = this.alternativa3d::occluders[local1];
local3 = local2;
while(local3.alternativa3d::next != null) {
local3 = local3.alternativa3d::next;
}
local3.alternativa3d::next = Vertex.alternativa3d::collector;
Vertex.alternativa3d::collector = local2;
this.alternativa3d::occluders[local1] = null;
local1++;
}
this.alternativa3d::numOccluders = 0;
}
alternativa3d function sortByAverageZ(param1:Face) : Face {
var local2:int = 0;
var local3:Number = NaN;
var local4:Wrapper = null;
var local5:Face = param1;
var local6:Face = param1.alternativa3d::processNext;
while(local6 != null && local6.alternativa3d::processNext != null) {
param1 = param1.alternativa3d::processNext;
local6 = local6.alternativa3d::processNext.alternativa3d::processNext;
}
local6 = param1.alternativa3d::processNext;
param1.alternativa3d::processNext = null;
if(local5.alternativa3d::processNext != null) {
local5 = this.alternativa3d::sortByAverageZ(local5);
} else {
local2 = 0;
local3 = 0;
local4 = local5.alternativa3d::wrapper;
while(local4 != null) {
local2++;
local3 += local4.alternativa3d::vertex.alternativa3d::cameraZ;
local4 = local4.alternativa3d::next;
}
local5.alternativa3d::distance = local3 / local2;
}
if(local6.alternativa3d::processNext != null) {
local6 = this.alternativa3d::sortByAverageZ(local6);
} else {
local2 = 0;
local3 = 0;
local4 = local6.alternativa3d::wrapper;
while(local4 != null) {
local2++;
local3 += local4.alternativa3d::vertex.alternativa3d::cameraZ;
local4 = local4.alternativa3d::next;
}
local6.alternativa3d::distance = local3 / local2;
}
var local7:Boolean = local5.alternativa3d::distance > local6.alternativa3d::distance;
if(local7) {
param1 = local5;
local5 = local5.alternativa3d::processNext;
} else {
param1 = local6;
local6 = local6.alternativa3d::processNext;
}
var local8:Face = param1;
while(true) {
if(local5 == null) {
local8.alternativa3d::processNext = local6;
return param1;
}
if(local6 == null) {
local8.alternativa3d::processNext = local5;
return param1;
}
if(local7) {
if(local5.alternativa3d::distance > local6.alternativa3d::distance) {
local8 = local5;
local5 = local5.alternativa3d::processNext;
} else {
local8.alternativa3d::processNext = local6;
local8 = local6;
local6 = local6.alternativa3d::processNext;
local7 = false;
}
} else if(local6.alternativa3d::distance > local5.alternativa3d::distance) {
local8 = local6;
local6 = local6.alternativa3d::processNext;
} else {
local8.alternativa3d::processNext = local5;
local8 = local5;
local5 = local5.alternativa3d::processNext;
local7 = true;
}
}
return null;
}
alternativa3d function sortByDynamicBSP(param1:Face, param2:Number, param3:Face = null) : Face {
var local4:Wrapper = null;
var local5:Vertex = null;
var local6:Vertex = null;
var local7:Vertex = null;
var local8:Vertex = null;
var local23:Face = null;
var local24:Face = null;
var local26:Face = null;
var local27:Face = null;
var local28:Face = null;
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:Number = NaN;
var local38:Number = NaN;
var local39:Number = NaN;
var local40:Boolean = false;
var local41:Boolean = false;
var local42:Number = NaN;
var local43:Face = null;
var local44:Face = null;
var local45:Wrapper = null;
var local46:Wrapper = null;
var local47:Wrapper = null;
var local48:Boolean = false;
var local49:Number = NaN;
var local9:Face = param1;
param1 = local9.alternativa3d::processNext;
local4 = local9.alternativa3d::wrapper;
local5 = local4.alternativa3d::vertex;
local4 = local4.alternativa3d::next;
local6 = local4.alternativa3d::vertex;
var local10:Number = Number(local5.alternativa3d::cameraX);
var local11:Number = Number(local5.alternativa3d::cameraY);
var local12:Number = Number(local5.alternativa3d::cameraZ);
var local13:Number = local6.alternativa3d::cameraX - local10;
var local14:Number = local6.alternativa3d::cameraY - local11;
var local15:Number = local6.alternativa3d::cameraZ - local12;
var local16:Number = 0;
var local17:Number = 0;
var local18:Number = 1;
var local19:Number = local12;
var local20:Number = 0;
local4 = local4.alternativa3d::next;
while(local4 != null) {
local8 = local4.alternativa3d::vertex;
local30 = local8.alternativa3d::cameraX - local10;
local31 = local8.alternativa3d::cameraY - local11;
local32 = local8.alternativa3d::cameraZ - local12;
local33 = local32 * local14 - local31 * local15;
local34 = local30 * local15 - local32 * local13;
local35 = local31 * local13 - local30 * local14;
local36 = local33 * local33 + local34 * local34 + local35 * local35;
if(local36 > param2) {
local36 = 1 / Math.sqrt(local36);
local16 = local33 * local36;
local17 = local34 * local36;
local18 = local35 * local36;
local19 = local10 * local16 + local11 * local17 + local12 * local18;
break;
}
if(local36 > local20) {
local36 = 1 / Math.sqrt(local36);
local16 = local33 * local36;
local17 = local34 * local36;
local18 = local35 * local36;
local19 = local10 * local16 + local11 * local17 + local12 * local18;
local20 = local36;
}
local4 = local4.alternativa3d::next;
}
var local21:Number = local19 - param2;
var local22:Number = local19 + param2;
var local25:Face = local9;
var local29:Face = param1;
while(local29 != null) {
local28 = local29.alternativa3d::processNext;
local4 = local29.alternativa3d::wrapper;
local5 = local4.alternativa3d::vertex;
local4 = local4.alternativa3d::next;
local6 = local4.alternativa3d::vertex;
local4 = local4.alternativa3d::next;
local7 = local4.alternativa3d::vertex;
local4 = local4.alternativa3d::next;
local37 = local5.alternativa3d::cameraX * local16 + local5.alternativa3d::cameraY * local17 + local5.alternativa3d::cameraZ * local18;
local38 = local6.alternativa3d::cameraX * local16 + local6.alternativa3d::cameraY * local17 + local6.alternativa3d::cameraZ * local18;
local39 = local7.alternativa3d::cameraX * local16 + local7.alternativa3d::cameraY * local17 + local7.alternativa3d::cameraZ * local18;
local40 = local37 < local21 || local38 < local21 || local39 < local21;
local41 = local37 > local22 || local38 > local22 || local39 > local22;
while(local4 != null) {
local8 = local4.alternativa3d::vertex;
local42 = local8.alternativa3d::cameraX * local16 + local8.alternativa3d::cameraY * local17 + local8.alternativa3d::cameraZ * local18;
if(local42 < local21) {
local40 = true;
} else if(local42 > local22) {
local41 = true;
}
local8.alternativa3d::offset = local42;
local4 = local4.alternativa3d::next;
}
if(!local40) {
if(!local41) {
local25.alternativa3d::processNext = local29;
local25 = local29;
} else {
if(local26 != null) {
local27.alternativa3d::processNext = local29;
} else {
local26 = local29;
}
local27 = local29;
}
} else if(!local41) {
if(local23 != null) {
local24.alternativa3d::processNext = local29;
} else {
local23 = local29;
}
local24 = local29;
} else {
local5.alternativa3d::offset = local37;
local6.alternativa3d::offset = local38;
local7.alternativa3d::offset = local39;
local43 = local29.alternativa3d::create();
local43.material = local29.material;
this.alternativa3d::lastFace.alternativa3d::next = local43;
this.alternativa3d::lastFace = local43;
local44 = local29.alternativa3d::create();
local44.material = local29.material;
this.alternativa3d::lastFace.alternativa3d::next = local44;
this.alternativa3d::lastFace = local44;
local45 = null;
local46 = null;
local4 = local29.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next;
while(local4.alternativa3d::next != null) {
local4 = local4.alternativa3d::next;
}
local5 = local4.alternativa3d::vertex;
local37 = Number(local5.alternativa3d::offset);
local48 = local29.material != null && Boolean(local29.material.alternativa3d::useVerticesNormals);
local4 = local29.alternativa3d::wrapper;
while(local4 != null) {
local6 = local4.alternativa3d::vertex;
local38 = Number(local6.alternativa3d::offset);
if(local37 < local21 && local38 > local22 || local37 > local22 && local38 < local21) {
local49 = (local19 - local37) / (local38 - local37);
local8 = local6.alternativa3d::create();
this.alternativa3d::lastVertex.alternativa3d::next = local8;
this.alternativa3d::lastVertex = local8;
local8.alternativa3d::cameraX = local5.alternativa3d::cameraX + (local6.alternativa3d::cameraX - local5.alternativa3d::cameraX) * local49;
local8.alternativa3d::cameraY = local5.alternativa3d::cameraY + (local6.alternativa3d::cameraY - local5.alternativa3d::cameraY) * local49;
local8.alternativa3d::cameraZ = local5.alternativa3d::cameraZ + (local6.alternativa3d::cameraZ - local5.alternativa3d::cameraZ) * local49;
local8.u = local5.u + (local6.u - local5.u) * local49;
local8.v = local5.v + (local6.v - local5.v) * local49;
if(local48) {
local8.x = local5.x + (local6.x - local5.x) * local49;
local8.y = local5.y + (local6.y - local5.y) * local49;
local8.z = local5.z + (local6.z - local5.z) * local49;
local8.normalX = local5.normalX + (local6.normalX - local5.normalX) * local49;
local8.normalY = local5.normalY + (local6.normalY - local5.normalY) * local49;
local8.normalZ = local5.normalZ + (local6.normalZ - local5.normalZ) * local49;
}
local47 = local4.alternativa3d::create();
local47.alternativa3d::vertex = local8;
if(local45 != null) {
local45.alternativa3d::next = local47;
} else {
local43.alternativa3d::wrapper = local47;
}
local45 = local47;
local47 = local4.alternativa3d::create();
local47.alternativa3d::vertex = local8;
if(local46 != null) {
local46.alternativa3d::next = local47;
} else {
local44.alternativa3d::wrapper = local47;
}
local46 = local47;
}
if(local38 <= local22) {
local47 = local4.alternativa3d::create();
local47.alternativa3d::vertex = local6;
if(local45 != null) {
local45.alternativa3d::next = local47;
} else {
local43.alternativa3d::wrapper = local47;
}
local45 = local47;
}
if(local38 >= local21) {
local47 = local4.alternativa3d::create();
local47.alternativa3d::vertex = local6;
if(local46 != null) {
local46.alternativa3d::next = local47;
} else {
local44.alternativa3d::wrapper = local47;
}
local46 = local47;
}
local5 = local6;
local37 = local38;
local4 = local4.alternativa3d::next;
}
if(local23 != null) {
local24.alternativa3d::processNext = local43;
} else {
local23 = local43;
}
local24 = local43;
if(local26 != null) {
local27.alternativa3d::processNext = local44;
} else {
local26 = local44;
}
local27 = local44;
local29.alternativa3d::processNext = null;
}
local29 = local28;
}
if(local26 != null) {
local27.alternativa3d::processNext = null;
if(local26.alternativa3d::processNext != null) {
param3 = this.alternativa3d::sortByDynamicBSP(local26,param2,param3);
} else {
local26.alternativa3d::processNext = param3;
param3 = local26;
}
}
local25.alternativa3d::processNext = param3;
param3 = local9;
if(local23 != null) {
local24.alternativa3d::processNext = null;
if(local23.alternativa3d::processNext != null) {
param3 = this.alternativa3d::sortByDynamicBSP(local23,param2,param3);
} else {
local23.alternativa3d::processNext = param3;
param3 = local23;
}
}
return param3;
}
alternativa3d function cull(param1:Face, param2:int) : Face {
var local3:Face = null;
var local4:Face = null;
var local5:Face = null;
var local6:Vertex = null;
var local7:Vertex = null;
var local8:Vertex = null;
var local9:Wrapper = null;
var local10:Vertex = null;
var local11:Wrapper = null;
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:Number = NaN;
var local20:Number = NaN;
var local21:Boolean = (param2 & 1) > 0;
var local22:Boolean = (param2 & 2) > 0;
var local23:Boolean = (param2 & 4) > 0;
var local24:Boolean = (param2 & 8) > 0;
var local25:Boolean = (param2 & 0x10) > 0;
var local26:Boolean = (param2 & 0x20) > 0;
var local27:Number = this.nearClipping;
var local28:Number = this.farClipping;
var local29:Boolean = local23 || local24;
var local30:Boolean = local25 || local26;
var local31:Face = param1;
for(; local31 != null; local31 = local5) {
local5 = local31.alternativa3d::processNext;
local9 = local31.alternativa3d::wrapper;
local6 = local9.alternativa3d::vertex;
local9 = local9.alternativa3d::next;
local7 = local9.alternativa3d::vertex;
local9 = local9.alternativa3d::next;
local8 = local9.alternativa3d::vertex;
local9 = local9.alternativa3d::next;
if(local29) {
local12 = Number(local6.alternativa3d::cameraX);
local15 = Number(local7.alternativa3d::cameraX);
local18 = Number(local8.alternativa3d::cameraX);
}
if(local30) {
local13 = Number(local6.alternativa3d::cameraY);
local16 = Number(local7.alternativa3d::cameraY);
local19 = Number(local8.alternativa3d::cameraY);
}
local14 = Number(local6.alternativa3d::cameraZ);
local17 = Number(local7.alternativa3d::cameraZ);
local20 = Number(local8.alternativa3d::cameraZ);
if(local21) {
if(local14 <= local27 || local17 <= local27 || local20 <= local27) {
local31.alternativa3d::processNext = null;
continue;
}
local11 = local9;
while(local11 != null) {
if(local11.alternativa3d::vertex.alternativa3d::cameraZ <= local27) {
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 != null) {
local31.alternativa3d::processNext = null;
continue;
}
}
if(local22 && local14 >= local28 && local17 >= local28 && local20 >= local28) {
local11 = local9;
while(local11 != null) {
if(local11.alternativa3d::vertex.alternativa3d::cameraZ < local28) {
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local31.alternativa3d::processNext = null;
continue;
}
}
if(local23 && local14 <= -local12 && local17 <= -local15 && local20 <= -local18) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(-local10.alternativa3d::cameraX < local10.alternativa3d::cameraZ) {
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local31.alternativa3d::processNext = null;
continue;
}
}
if(local24 && local14 <= local12 && local17 <= local15 && local20 <= local18) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(local10.alternativa3d::cameraX < local10.alternativa3d::cameraZ) {
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local31.alternativa3d::processNext = null;
continue;
}
}
if(local25 && local14 <= -local13 && local17 <= -local16 && local20 <= -local19) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(-local10.alternativa3d::cameraY < local10.alternativa3d::cameraZ) {
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local31.alternativa3d::processNext = null;
continue;
}
}
if(local26 && local14 <= local13 && local17 <= local16 && local20 <= local19) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(local10.alternativa3d::cameraY < local10.alternativa3d::cameraZ) {
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local31.alternativa3d::processNext = null;
continue;
}
}
if(local3 != null) {
local4.alternativa3d::processNext = local31;
} else {
local3 = local31;
}
local4 = local31;
}
if(local4 != null) {
local4.alternativa3d::processNext = null;
}
return local3;
}
alternativa3d function clip(param1:Face, param2:int) : Face {
var local3:Face = null;
var local4:Face = null;
var local5:Face = null;
var local6:Vertex = null;
var local7:Vertex = null;
var local8:Vertex = null;
var local9:Wrapper = null;
var local10:Vertex = null;
var local11:Wrapper = null;
var local12:Wrapper = null;
var local13:Wrapper = null;
var local14:Wrapper = null;
var local15:Wrapper = null;
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:Number = NaN;
var local25:Boolean = false;
var local26:Boolean = false;
var local27:Boolean = false;
var local28:Boolean = false;
var local29:Boolean = false;
var local30:Boolean = false;
var local31:Number = NaN;
var local32:Number = NaN;
var local33:Boolean = false;
var local34:Boolean = false;
var local35:int = 0;
var local36:Number = NaN;
var local37:Face = null;
var local38:Boolean = false;
var local39:Face = null;
local25 = (param2 & 1) > 0;
local26 = (param2 & 2) > 0;
local27 = (param2 & 4) > 0;
local28 = (param2 & 8) > 0;
local29 = (param2 & 0x10) > 0;
local30 = (param2 & 0x20) > 0;
local31 = this.nearClipping;
local32 = this.farClipping;
local33 = local27 || local28;
local34 = local29 || local30;
local37 = param1;
for(; local37 != null; local37 = local5) {
local5 = local37.alternativa3d::processNext;
local9 = local37.alternativa3d::wrapper;
local6 = local9.alternativa3d::vertex;
local9 = local9.alternativa3d::next;
local7 = local9.alternativa3d::vertex;
local9 = local9.alternativa3d::next;
local8 = local9.alternativa3d::vertex;
local9 = local9.alternativa3d::next;
if(local33) {
local16 = Number(local6.alternativa3d::cameraX);
local19 = Number(local7.alternativa3d::cameraX);
local22 = Number(local8.alternativa3d::cameraX);
}
if(local34) {
local17 = Number(local6.alternativa3d::cameraY);
local20 = Number(local7.alternativa3d::cameraY);
local23 = Number(local8.alternativa3d::cameraY);
}
local18 = Number(local6.alternativa3d::cameraZ);
local21 = Number(local7.alternativa3d::cameraZ);
local24 = Number(local8.alternativa3d::cameraZ);
local35 = 0;
if(local25) {
if(local18 <= local31 && local21 <= local31 && local24 <= local31) {
local11 = local9;
while(local11 != null) {
if(local11.alternativa3d::vertex.alternativa3d::cameraZ > local31) {
local35 |= 1;
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local37.alternativa3d::processNext = null;
continue;
}
} else if(local18 > local31 && local21 > local31 && local24 > local31) {
local11 = local9;
while(local11 != null) {
if(local11.alternativa3d::vertex.alternativa3d::cameraZ <= local31) {
local35 |= 1;
break;
}
local11 = local11.alternativa3d::next;
}
} else {
local35 |= 1;
}
}
if(local26) {
if(local18 >= local32 && local21 >= local32 && local24 >= local32) {
local11 = local9;
while(local11 != null) {
if(local11.alternativa3d::vertex.alternativa3d::cameraZ < local32) {
local35 |= 2;
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local37.alternativa3d::processNext = null;
continue;
}
} else if(local18 < local32 && local21 < local32 && local24 < local32) {
local11 = local9;
while(local11 != null) {
if(local11.alternativa3d::vertex.alternativa3d::cameraZ >= local32) {
local35 |= 2;
break;
}
local11 = local11.alternativa3d::next;
}
} else {
local35 |= 2;
}
}
if(local27) {
if(local18 <= -local16 && local21 <= -local19 && local24 <= -local22) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(-local10.alternativa3d::cameraX < local10.alternativa3d::cameraZ) {
local35 |= 4;
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local37.alternativa3d::processNext = null;
continue;
}
} else if(local18 > -local16 && local21 > -local19 && local24 > -local22) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(-local10.alternativa3d::cameraX >= local10.alternativa3d::cameraZ) {
local35 |= 4;
break;
}
local11 = local11.alternativa3d::next;
}
} else {
local35 |= 4;
}
}
if(local28) {
if(local18 <= local16 && local21 <= local19 && local24 <= local22) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(local10.alternativa3d::cameraX < local10.alternativa3d::cameraZ) {
local35 |= 8;
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local37.alternativa3d::processNext = null;
continue;
}
} else if(local18 > local16 && local21 > local19 && local24 > local22) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(local10.alternativa3d::cameraX >= local10.alternativa3d::cameraZ) {
local35 |= 8;
break;
}
local11 = local11.alternativa3d::next;
}
} else {
local35 |= 8;
}
}
if(local29) {
if(local18 <= -local17 && local21 <= -local20 && local24 <= -local23) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(-local10.alternativa3d::cameraY < local10.alternativa3d::cameraZ) {
local35 |= 16;
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local37.alternativa3d::processNext = null;
continue;
}
} else if(local18 > -local17 && local21 > -local20 && local24 > -local23) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(-local10.alternativa3d::cameraY >= local10.alternativa3d::cameraZ) {
local35 |= 16;
break;
}
local11 = local11.alternativa3d::next;
}
} else {
local35 |= 16;
}
}
if(local30) {
if(local18 <= local17 && local21 <= local20 && local24 <= local23) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(local10.alternativa3d::cameraY < local10.alternativa3d::cameraZ) {
local35 |= 32;
break;
}
local11 = local11.alternativa3d::next;
}
if(local11 == null) {
local37.alternativa3d::processNext = null;
continue;
}
} else if(local18 > local17 && local21 > local20 && local24 > local23) {
local11 = local9;
while(local11 != null) {
local10 = local11.alternativa3d::vertex;
if(local10.alternativa3d::cameraY >= local10.alternativa3d::cameraZ) {
local35 |= 32;
break;
}
local11 = local11.alternativa3d::next;
}
} else {
local35 |= 32;
}
}
if(local35 > 0) {
local38 = local37.material != null && Boolean(local37.material.alternativa3d::useVerticesNormals);
local12 = null;
local13 = null;
local11 = local37.alternativa3d::wrapper;
while(local11 != null) {
local15 = local11.alternativa3d::create();
local15.alternativa3d::vertex = local11.alternativa3d::vertex;
if(local12 != null) {
local13.alternativa3d::next = local15;
} else {
local12 = local15;
}
local13 = local15;
local11 = local11.alternativa3d::next;
}
if(Boolean(local35 & 1)) {
local6 = local13.alternativa3d::vertex;
local18 = Number(local6.alternativa3d::cameraZ);
local11 = local12;
local12 = null;
local13 = null;
while(local11 != null) {
local14 = local11.alternativa3d::next;
local7 = local11.alternativa3d::vertex;
local21 = Number(local7.alternativa3d::cameraZ);
if(local21 > local31 && local18 <= local31 || local21 <= local31 && local18 > local31) {
local36 = (local31 - local18) / (local21 - local18);
local10 = local7.alternativa3d::create();
this.alternativa3d::lastVertex.alternativa3d::next = local10;
this.alternativa3d::lastVertex = local10;
local10.alternativa3d::cameraX = local6.alternativa3d::cameraX + (local7.alternativa3d::cameraX - local6.alternativa3d::cameraX) * local36;
local10.alternativa3d::cameraY = local6.alternativa3d::cameraY + (local7.alternativa3d::cameraY - local6.alternativa3d::cameraY) * local36;
local10.alternativa3d::cameraZ = local18 + (local21 - local18) * local36;
local10.x = local6.x + (local7.x - local6.x) * local36;
local10.y = local6.y + (local7.y - local6.y) * local36;
local10.z = local6.z + (local7.z - local6.z) * local36;
local10.u = local6.u + (local7.u - local6.u) * local36;
local10.v = local6.v + (local7.v - local6.v) * local36;
if(local38) {
local10.normalX = local6.normalX + (local7.normalX - local6.normalX) * local36;
local10.normalY = local6.normalY + (local7.normalY - local6.normalY) * local36;
local10.normalZ = local6.normalZ + (local7.normalZ - local6.normalZ) * local36;
}
local15 = local11.alternativa3d::create();
local15.alternativa3d::vertex = local10;
if(local12 != null) {
local13.alternativa3d::next = local15;
} else {
local12 = local15;
}
local13 = local15;
}
if(local21 > local31) {
if(local12 != null) {
local13.alternativa3d::next = local11;
} else {
local12 = local11;
}
local13 = local11;
local11.alternativa3d::next = null;
} else {
local11.alternativa3d::vertex = null;
local11.alternativa3d::next = Wrapper.alternativa3d::collector;
Wrapper.alternativa3d::collector = local11;
}
local6 = local7;
local18 = local21;
local11 = local14;
}
if(local12 == null) {
local37.alternativa3d::processNext = null;
continue;
}
}
if(Boolean(local35 & 2)) {
local6 = local13.alternativa3d::vertex;
local18 = Number(local6.alternativa3d::cameraZ);
local11 = local12;
local12 = null;
local13 = null;
while(local11 != null) {
local14 = local11.alternativa3d::next;
local7 = local11.alternativa3d::vertex;
local21 = Number(local7.alternativa3d::cameraZ);
if(local21 < local32 && local18 >= local32 || local21 >= local32 && local18 < local32) {
local36 = (local32 - local18) / (local21 - local18);
local10 = local7.alternativa3d::create();
this.alternativa3d::lastVertex.alternativa3d::next = local10;
this.alternativa3d::lastVertex = local10;
local10.alternativa3d::cameraX = local6.alternativa3d::cameraX + (local7.alternativa3d::cameraX - local6.alternativa3d::cameraX) * local36;
local10.alternativa3d::cameraY = local6.alternativa3d::cameraY + (local7.alternativa3d::cameraY - local6.alternativa3d::cameraY) * local36;
local10.alternativa3d::cameraZ = local18 + (local21 - local18) * local36;
local10.x = local6.x + (local7.x - local6.x) * local36;
local10.y = local6.y + (local7.y - local6.y) * local36;
local10.z = local6.z + (local7.z - local6.z) * local36;
local10.u = local6.u + (local7.u - local6.u) * local36;
local10.v = local6.v + (local7.v - local6.v) * local36;
if(local38) {
local10.normalX = local6.normalX + (local7.normalX - local6.normalX) * local36;
local10.normalY = local6.normalY + (local7.normalY - local6.normalY) * local36;
local10.normalZ = local6.normalZ + (local7.normalZ - local6.normalZ) * local36;
}
local15 = local11.alternativa3d::create();
local15.alternativa3d::vertex = local10;
if(local12 != null) {
local13.alternativa3d::next = local15;
} else {
local12 = local15;
}
local13 = local15;
}
if(local21 < local32) {
if(local12 != null) {
local13.alternativa3d::next = local11;
} else {
local12 = local11;
}
local13 = local11;
local11.alternativa3d::next = null;
} else {
local11.alternativa3d::vertex = null;
local11.alternativa3d::next = Wrapper.alternativa3d::collector;
Wrapper.alternativa3d::collector = local11;
}
local6 = local7;
local18 = local21;
local11 = local14;
}
if(local12 == null) {
local37.alternativa3d::processNext = null;
continue;
}
}
if(Boolean(local35 & 4)) {
local6 = local13.alternativa3d::vertex;
local16 = Number(local6.alternativa3d::cameraX);
local18 = Number(local6.alternativa3d::cameraZ);
local11 = local12;
local12 = null;
local13 = null;
while(local11 != null) {
local14 = local11.alternativa3d::next;
local7 = local11.alternativa3d::vertex;
local19 = Number(local7.alternativa3d::cameraX);
local21 = Number(local7.alternativa3d::cameraZ);
if(local21 > -local19 && local18 <= -local16 || local21 <= -local19 && local18 > -local16) {
local36 = (local16 + local18) / (local16 + local18 - local19 - local21);
local10 = local7.alternativa3d::create();
this.alternativa3d::lastVertex.alternativa3d::next = local10;
this.alternativa3d::lastVertex = local10;
local10.alternativa3d::cameraX = local16 + (local19 - local16) * local36;
local10.alternativa3d::cameraY = local6.alternativa3d::cameraY + (local7.alternativa3d::cameraY - local6.alternativa3d::cameraY) * local36;
local10.alternativa3d::cameraZ = local18 + (local21 - local18) * local36;
local10.x = local6.x + (local7.x - local6.x) * local36;
local10.y = local6.y + (local7.y - local6.y) * local36;
local10.z = local6.z + (local7.z - local6.z) * local36;
local10.u = local6.u + (local7.u - local6.u) * local36;
local10.v = local6.v + (local7.v - local6.v) * local36;
if(local38) {
local10.normalX = local6.normalX + (local7.normalX - local6.normalX) * local36;
local10.normalY = local6.normalY + (local7.normalY - local6.normalY) * local36;
local10.normalZ = local6.normalZ + (local7.normalZ - local6.normalZ) * local36;
}
local15 = local11.alternativa3d::create();
local15.alternativa3d::vertex = local10;
if(local12 != null) {
local13.alternativa3d::next = local15;
} else {
local12 = local15;
}
local13 = local15;
}
if(local21 > -local19) {
if(local12 != null) {
local13.alternativa3d::next = local11;
} else {
local12 = local11;
}
local13 = local11;
local11.alternativa3d::next = null;
} else {
local11.alternativa3d::vertex = null;
local11.alternativa3d::next = Wrapper.alternativa3d::collector;
Wrapper.alternativa3d::collector = local11;
}
local6 = local7;
local16 = local19;
local18 = local21;
local11 = local14;
}
if(local12 == null) {
local37.alternativa3d::processNext = null;
continue;
}
}
if(Boolean(local35 & 8)) {
local6 = local13.alternativa3d::vertex;
local16 = Number(local6.alternativa3d::cameraX);
local18 = Number(local6.alternativa3d::cameraZ);
local11 = local12;
local12 = null;
local13 = null;
while(local11 != null) {
local14 = local11.alternativa3d::next;
local7 = local11.alternativa3d::vertex;
local19 = Number(local7.alternativa3d::cameraX);
local21 = Number(local7.alternativa3d::cameraZ);
if(local21 > local19 && local18 <= local16 || local21 <= local19 && local18 > local16) {
local36 = (local18 - local16) / (local18 - local16 + local19 - local21);
local10 = local7.alternativa3d::create();
this.alternativa3d::lastVertex.alternativa3d::next = local10;
this.alternativa3d::lastVertex = local10;
local10.alternativa3d::cameraX = local16 + (local19 - local16) * local36;
local10.alternativa3d::cameraY = local6.alternativa3d::cameraY + (local7.alternativa3d::cameraY - local6.alternativa3d::cameraY) * local36;
local10.alternativa3d::cameraZ = local18 + (local21 - local18) * local36;
local10.x = local6.x + (local7.x - local6.x) * local36;
local10.y = local6.y + (local7.y - local6.y) * local36;
local10.z = local6.z + (local7.z - local6.z) * local36;
local10.u = local6.u + (local7.u - local6.u) * local36;
local10.v = local6.v + (local7.v - local6.v) * local36;
if(local38) {
local10.normalX = local6.normalX + (local7.normalX - local6.normalX) * local36;
local10.normalY = local6.normalY + (local7.normalY - local6.normalY) * local36;
local10.normalZ = local6.normalZ + (local7.normalZ - local6.normalZ) * local36;
}
local15 = local11.alternativa3d::create();
local15.alternativa3d::vertex = local10;
if(local12 != null) {
local13.alternativa3d::next = local15;
} else {
local12 = local15;
}
local13 = local15;
}
if(local21 > local19) {
if(local12 != null) {
local13.alternativa3d::next = local11;
} else {
local12 = local11;
}
local13 = local11;
local11.alternativa3d::next = null;
} else {
local11.alternativa3d::vertex = null;
local11.alternativa3d::next = Wrapper.alternativa3d::collector;
Wrapper.alternativa3d::collector = local11;
}
local6 = local7;
local16 = local19;
local18 = local21;
local11 = local14;
}
if(local12 == null) {
local37.alternativa3d::processNext = null;
continue;
}
}
if(Boolean(local35 & 0x10)) {
local6 = local13.alternativa3d::vertex;
local17 = Number(local6.alternativa3d::cameraY);
local18 = Number(local6.alternativa3d::cameraZ);
local11 = local12;
local12 = null;
local13 = null;
while(local11 != null) {
local14 = local11.alternativa3d::next;
local7 = local11.alternativa3d::vertex;
local20 = Number(local7.alternativa3d::cameraY);
local21 = Number(local7.alternativa3d::cameraZ);
if(local21 > -local20 && local18 <= -local17 || local21 <= -local20 && local18 > -local17) {
local36 = (local17 + local18) / (local17 + local18 - local20 - local21);
local10 = local7.alternativa3d::create();
this.alternativa3d::lastVertex.alternativa3d::next = local10;
this.alternativa3d::lastVertex = local10;
local10.alternativa3d::cameraX = local6.alternativa3d::cameraX + (local7.alternativa3d::cameraX - local6.alternativa3d::cameraX) * local36;
local10.alternativa3d::cameraY = local17 + (local20 - local17) * local36;
local10.alternativa3d::cameraZ = local18 + (local21 - local18) * local36;
local10.x = local6.x + (local7.x - local6.x) * local36;
local10.y = local6.y + (local7.y - local6.y) * local36;
local10.z = local6.z + (local7.z - local6.z) * local36;
local10.u = local6.u + (local7.u - local6.u) * local36;
local10.v = local6.v + (local7.v - local6.v) * local36;
if(local38) {
local10.normalX = local6.normalX + (local7.normalX - local6.normalX) * local36;
local10.normalY = local6.normalY + (local7.normalY - local6.normalY) * local36;
local10.normalZ = local6.normalZ + (local7.normalZ - local6.normalZ) * local36;
}
local15 = local11.alternativa3d::create();
local15.alternativa3d::vertex = local10;
if(local12 != null) {
local13.alternativa3d::next = local15;
} else {
local12 = local15;
}
local13 = local15;
}
if(local21 > -local20) {
if(local12 != null) {
local13.alternativa3d::next = local11;
} else {
local12 = local11;
}
local13 = local11;
local11.alternativa3d::next = null;
} else {
local11.alternativa3d::vertex = null;
local11.alternativa3d::next = Wrapper.alternativa3d::collector;
Wrapper.alternativa3d::collector = local11;
}
local6 = local7;
local17 = local20;
local18 = local21;
local11 = local14;
}
if(local12 == null) {
local37.alternativa3d::processNext = null;
continue;
}
}
if(Boolean(local35 & 0x20)) {
local6 = local13.alternativa3d::vertex;
local17 = Number(local6.alternativa3d::cameraY);
local18 = Number(local6.alternativa3d::cameraZ);
local11 = local12;
local12 = null;
local13 = null;
while(local11 != null) {
local14 = local11.alternativa3d::next;
local7 = local11.alternativa3d::vertex;
local20 = Number(local7.alternativa3d::cameraY);
local21 = Number(local7.alternativa3d::cameraZ);
if(local21 > local20 && local18 <= local17 || local21 <= local20 && local18 > local17) {
local36 = (local18 - local17) / (local18 - local17 + local20 - local21);
local10 = local7.alternativa3d::create();
this.alternativa3d::lastVertex.alternativa3d::next = local10;
this.alternativa3d::lastVertex = local10;
local10.alternativa3d::cameraX = local6.alternativa3d::cameraX + (local7.alternativa3d::cameraX - local6.alternativa3d::cameraX) * local36;
local10.alternativa3d::cameraY = local17 + (local20 - local17) * local36;
local10.alternativa3d::cameraZ = local18 + (local21 - local18) * local36;
local10.x = local6.x + (local7.x - local6.x) * local36;
local10.y = local6.y + (local7.y - local6.y) * local36;
local10.z = local6.z + (local7.z - local6.z) * local36;
local10.u = local6.u + (local7.u - local6.u) * local36;
local10.v = local6.v + (local7.v - local6.v) * local36;
if(local38) {
local10.normalX = local6.normalX + (local7.normalX - local6.normalX) * local36;
local10.normalY = local6.normalY + (local7.normalY - local6.normalY) * local36;
local10.normalZ = local6.normalZ + (local7.normalZ - local6.normalZ) * local36;
}
local15 = local11.alternativa3d::create();
local15.alternativa3d::vertex = local10;
if(local12 != null) {
local13.alternativa3d::next = local15;
} else {
local12 = local15;
}
local13 = local15;
}
if(local21 > local20) {
if(local12 != null) {
local13.alternativa3d::next = local11;
} else {
local12 = local11;
}
local13 = local11;
local11.alternativa3d::next = null;
} else {
local11.alternativa3d::vertex = null;
local11.alternativa3d::next = Wrapper.alternativa3d::collector;
Wrapper.alternativa3d::collector = local11;
}
local6 = local7;
local17 = local20;
local18 = local21;
local11 = local14;
}
if(local12 == null) {
local37.alternativa3d::processNext = null;
continue;
}
}
local37.alternativa3d::processNext = null;
local39 = local37.alternativa3d::create();
local39.material = local37.material;
this.alternativa3d::lastFace.alternativa3d::next = local39;
this.alternativa3d::lastFace = local39;
local39.alternativa3d::wrapper = local12;
local37 = local39;
}
if(local3 != null) {
local4.alternativa3d::processNext = local37;
} else {
local3 = local37;
}
local4 = local37;
}
if(local4 != null) {
local4.alternativa3d::processNext = null;
}
return local3;
}
}
}
|
package alternativa.tanks.bonuses
{
import alternativa.math.Vector3;
import alternativa.physics.PhysicsScene;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
public interface IBonus
{
function get bonusId() : String;
function attach(param1:Vector3, param2:PhysicsScene, param3:Scene3DContainer, param4:IBonusListener) : void;
function update(param1:int, param2:int, param3:Number) : Boolean;
function isFalling() : Boolean;
function setRestingState(param1:Number, param2:Number, param3:Number) : void;
function setTakenState() : void;
function setRemovedState() : void;
function destroy() : void;
function readBonusPosition(param1:Vector3) : void;
}
}
|
package alternativa.osgi.service.loader
{
public class LoadingProgressData
{
public var status:String;
public var progress:Number;
public function LoadingProgressData(status:String, progress:Number)
{
super();
this.status = status;
this.progress = progress;
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank27.png")]
public class PremiumRankBitmaps_bitmapSmallRank27 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank27() {
super();
}
}
}
|
package projects.tanks.client.garage.models.garage.upgrade {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
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 UpgradeGarageItemModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _instantUpgradeId:Long = Long.getLong(352299153,1189456555);
private var _instantUpgrade_itemCodec:ICodec;
private var _instantUpgrade_numLevelsCodec:ICodec;
private var _instantUpgrade_expectedPriceCodec:ICodec;
private var _speedUpId:Long = Long.getLong(691265024,-2084377048);
private var _speedUp_itemCodec:ICodec;
private var _speedUp_expectedPriceCodec:ICodec;
private var _upgradeItemId:Long = Long.getLong(1876823160,-33493301);
private var _upgradeItem_itemCodec:ICodec;
private var _upgradeItem_expectedPriceCodec:ICodec;
private var _upgradeItem_expectedTimeInSecondsCodec:ICodec;
private var model:IModel;
public function UpgradeGarageItemModelServer(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._instantUpgrade_itemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._instantUpgrade_numLevelsCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._instantUpgrade_expectedPriceCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._speedUp_itemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._speedUp_expectedPriceCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._upgradeItem_itemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._upgradeItem_expectedPriceCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._upgradeItem_expectedTimeInSecondsCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
}
public function instantUpgrade(param1:IGameObject, param2:int, param3:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._instantUpgrade_itemCodec.encode(this.protocolBuffer,param1);
this._instantUpgrade_numLevelsCodec.encode(this.protocolBuffer,param2);
this._instantUpgrade_expectedPriceCodec.encode(this.protocolBuffer,param3);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local4:SpaceCommand = new SpaceCommand(Model.object.id,this._instantUpgradeId,this.protocolBuffer);
var local5:IGameObject = Model.object;
var local6:ISpace = local5.space;
local6.commandSender.sendCommand(local4);
this.protocolBuffer.optionalMap.clear();
}
public function speedUp(param1:IGameObject, param2:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._speedUp_itemCodec.encode(this.protocolBuffer,param1);
this._speedUp_expectedPriceCodec.encode(this.protocolBuffer,param2);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local3:SpaceCommand = new SpaceCommand(Model.object.id,this._speedUpId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function upgradeItem(param1:IGameObject, param2:int, param3:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._upgradeItem_itemCodec.encode(this.protocolBuffer,param1);
this._upgradeItem_expectedPriceCodec.encode(this.protocolBuffer,param2);
this._upgradeItem_expectedTimeInSecondsCodec.encode(this.protocolBuffer,param3);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local4:SpaceCommand = new SpaceCommand(Model.object.id,this._upgradeItemId,this.protocolBuffer);
var local5:IGameObject = Model.object;
var local6:ISpace = local5.space;
local6.commandSender.sendCommand(local4);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_red_DOWN_RIGHT.png")]
public dynamic class button_red_DOWN_RIGHT extends BitmapData {
public function button_red_DOWN_RIGHT(param1:int = 7, param2:int = 30) {
super(param1,param2);
}
}
}
|
package projects.tanks.client.entrance.model.entrance.emailconfirm {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
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 EmailConfirmModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _confirmEmailId:Long = Long.getLong(1066290430,-1857025759);
private var _confirmEmail_emailCodec:ICodec;
private var _confirmEmail_emailConfirmHashCodec:ICodec;
private var model:IModel;
public function EmailConfirmModelServer(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._confirmEmail_emailCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._confirmEmail_emailConfirmHashCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function confirmEmail(param1:String, param2:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._confirmEmail_emailCodec.encode(this.protocolBuffer,param1);
this._confirmEmail_emailConfirmHashCodec.encode(this.protocolBuffer,param2);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local3:SpaceCommand = new SpaceCommand(Model.object.id,this._confirmEmailId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.models.weapon.shaft.modes
{
import alternativa.engine3d.core.Object3D;
import alternativa.init.Main;
import alternativa.math.Matrix4;
import alternativa.math.Quaternion;
import alternativa.math.Vector3;
import alternativa.tanks.camera.CameraFovCalculator;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.tank.ITank;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.tank.TankModel;
import alternativa.tanks.models.tank.turret.default.DefaultTurretController;
import alternativa.tanks.models.tank.turret.shaft.ShaftTurretController;
import alternativa.tanks.models.weapon.shaft.LinearInterpolator;
import alternativa.tanks.models.weapon.shaft.ShaftData;
import alternativa.tanks.models.weapon.shaft.ShaftDeactivationTask;
import alternativa.tanks.models.weapon.shaft.ShaftEnergyMode;
import alternativa.tanks.models.weapon.shaft.ShaftModel;
import alternativa.tanks.models.weapon.shaft.cameracontrollers.TargetingCameraController;
import alternativa.tanks.models.weapon.shaft.sfx.ShaftSFXModel;
import alternativa.tanks.models.weapon.shaft.states.ShaftModes;
import alternativa.tanks.utils.MathUtils;
import alternativa.tanks.vehicles.tanks.TankSkin;
import scpacker.tanks.WeaponsManager;
public class TargetingController
{
private static var aimDirection:Vector3 = new Vector3();
private static var cameraPosition:Vector3 = new Vector3();
private var up:Boolean;
private var down:Boolean;
public var cameraController:TargetingCameraController;
private var fovInterpolator:LinearInterpolator;
private var rangeInterpolator:LinearInterpolator;
private var exitTime:int;
private var fired:Boolean;
private var chargingEffectActive:Boolean;
public var shaftMode:ShaftModes;
private var timeLeft:int = 0;
private var alphaInterpolator:LinearInterpolator;
private var reticleAlphaInterpolator:LinearInterpolator;
private var stateDuration:int = 500;
public var camera:GameCamera;
public var skin:TankSkin;
private var targetFOV:Number = 0.698132;
private var targetCameraPosition:Vector3;
private var initialCameraOrientation:Quaternion;
private var targetCameraOrientation:Quaternion;
private var cameraOrientation:Quaternion;
private var initialCameraPosition:Vector3;
private var cameraPosition:Vector3;
private var cameraMatrix:Matrix4;
private var turretMatrix:Matrix4;
private var cameraAngles:Vector3;
private var battlefieldModel:BattlefieldModel;
public var deactivationTask:ShaftDeactivationTask;
public var shaftModel:ShaftModel;
private var initalEnegry:Number;
private var lastEnergy:Number;
private var savedTurnAcceleration:Number;
private var savedTurnSpred:Number;
private var tankModel:TankModel;
private var sfxModel:ShaftSFXModel;
public function TargetingController(shaftModel:ShaftModel)
{
this.fovInterpolator = new LinearInterpolator();
this.rangeInterpolator = new LinearInterpolator();
this.shaftMode = ShaftModes.TARGET_ACTIVATION;
super();
var shaftData:ShaftData = shaftModel.shaftData;
this.targetFOV = shaftData.minimumFOV;
this.fovInterpolator.setInterval(shaftData.initialFOV,shaftData.minimumFOV);
this.rangeInterpolator.setInterval(shaftData.shrubsHidingRadiusMin,shaftData.shrubsHidingRadiusMax);
this.cameraController = new TargetingCameraController(shaftData.elevationAngleUp,shaftData.elevationAngleDown,shaftData.verticalTargetingSpeed,shaftData.horizontalTargetingSpeed);
this.alphaInterpolator = new LinearInterpolator();
this.reticleAlphaInterpolator = new LinearInterpolator();
this.initialCameraOrientation = new Quaternion();
this.targetCameraOrientation = Quaternion.createFromAxisAngle(Vector3.X_AXIS,-Math.PI / 2);
this.initialCameraPosition = new Vector3();
this.cameraPosition = new Vector3();
this.cameraOrientation = new Quaternion();
this.cameraMatrix = new Matrix4();
this.turretMatrix = new Matrix4();
this.cameraAngles = new Vector3();
this.reticleAlphaInterpolator.setInterval(0,1);
this.shaftModel = shaftModel;
this.targetCameraPosition = new Vector3(0,30,10);
this.tankModel = Main.osgi.getService(ITank) as TankModel;
}
public function enter(time:int) : void
{
this.savedTurnAcceleration = TankData.localTankData.tank.turretTurnAcceleration;
this.savedTurnSpred = TankData.localTankData.tank.maxTurretTurnSpeed;
TankData.localTankData.tank.turretTurnAcceleration = 2;
this.setTurretSpeedFactor(this.savedTurnSpred);
this.up = MathUtils.getBitValue(TankData.localTankData.tank.turretDirSign,1) != 0;
this.down = MathUtils.getBitValue(TankData.localTankData.tank.turretDirSign,2) != 0;
this.shaftModel.setEnergyMode(ShaftEnergyMode.DRAIN);
this.timeLeft = this.stateDuration;
this.alphaInterpolator.setInterval(this.skin.hullMesh.alpha,0);
this.fovInterpolator.setInterval(this.camera.fov,this.targetFOV);
this.calculateCameraInitialValues();
this.exitTime = -1;
this.fired = false;
this.chargingEffectActive = true;
this.battlefieldModel = Main.osgi.getService(IBattleField) as BattlefieldModel;
this.deactivationTask = new ShaftDeactivationTask(this.battlefieldModel.bfData.viewport.camera);
this.deactivationTask.setSkin(this.skin);
this.deactivationTask.stop();
this.shaftMode = ShaftModes.TARGET_ACTIVATION;
this.cameraController.reload();
this.battlefieldModel.initCameraController(this.cameraController);
this.battlefieldModel.hidableObjects.enable();
this.battlefieldModel.hidableObjects.setCenterAndRadius(TankData.localTankData.tank.state.pos,0);
this.initalEnegry = this.shaftModel.getEnergy(time);
this.shaftModel.targetModeOn();
this.tankModel.localUserData.tank.setTurretController(new ShaftTurretController(this.tankModel.localUserData));
this.tankModel.localUserData.tank.getTurretController().enableTurretSound(false);
this.sfxModel = WeaponsManager.getShaftSFX(WeaponsManager.getObjectFor(TankData.localTankData.turret.id));
}
public function exit() : void
{
this.deactivationTask.setTargetFov(CameraFovCalculator.getCameraFov(Main.stage.stageWidth,Main.stage.stageHeight));
this.deactivationTask.start();
TankData.localTankData.tank.turretTurnAcceleration = this.savedTurnAcceleration;
TankData.localTankData.tank.setMaxTurretTurnSpeed(this.savedTurnSpred,true);
this.tankModel.localUserData.tank.setTurretController(new DefaultTurretController(this.tankModel.localUserData));
this.tankModel.localUserData.tank.getTurretController().enableTurretSound(true);
this.sfxModel.playTargetingSound(this.tankModel.localUserData.turret,this.tankModel.localUserData.user,false);
this.battlefieldModel.hidableObjects.disnable();
this.battlefieldModel.hidableObjects.restore();
}
private function setTurretSpeedFactor(param1:Number) : void
{
TankData.localTankData.tank.setMaxTurretTurnSpeed(param1 * 0.5,false);
this.cameraController.setMaxElevationSpeedFactor(param1);
}
public function update(param1:int, param2:int) : void
{
var _loc3_:Number = NaN;
var _loc4_:Number = NaN;
var weaponEnegry:Number = NaN;
var en:Number = NaN;
var dir:int = 0;
switch(this.shaftMode)
{
case ShaftModes.TARGET_ACTIVATION:
_loc3_ = 0;
_loc4_ = 0;
if(this.timeLeft <= 0)
{
this.shaftMode = ShaftModes.TARGETING;
this.fovInterpolator.setInterval(this.camera.fov,this.targetFOV);
}
else
{
this.timeLeft -= param2;
_loc3_ = 1 - this.timeLeft / this.stateDuration;
if(_loc3_ > 1)
{
_loc3_ = 1;
}
_loc4_ = this.alphaInterpolator.interpolate(_loc3_);
this.skin.setAlpha(_loc4_);
this.updateCamera(_loc3_);
}
break;
case ShaftModes.TARGETING:
weaponEnegry = this.shaftModel.getEnergy(param1);
en = (this.initalEnegry - weaponEnegry) / 1000;
this.lastEnergy = en;
this.cameraController.setCameraFov(this.fovInterpolator.interpolate(en));
if(weaponEnegry == 0 && this.chargingEffectActive)
{
this.chargingEffectActive = false;
this.sfxModel.fadeChargingEffect(TankData.localTankData.turret,TankData.localTankData.user);
}
this.up = TankData.localTankData.ctrlBits & TankModel.FORWARD;
this.down = TankData.localTankData.ctrlBits & TankModel.BACK;
dir = int(this.up) - int(this.down);
this.sfxModel.playTargetingSound(TankData.localTankData.turret,TankData.localTankData.user,dir != 0 && !this.cameraController.isMaxElevation() || this.tankModel.localUserData.tank.turretTurnSpeed != 0);
this.cameraController.elevationDirection = dir;
this.battlefieldModel.hidableObjects.setCenterAndRadius(TankData.localTankData.tank.state.pos,this.rangeInterpolator.interpolate(en));
break;
case ShaftModes.TARGET_DEACTIVATION:
}
}
private function calculateCameraInitialValues() : void
{
var _loc1_:Object3D = this.skin.turretMesh;
this.turretMatrix.setMatrix(_loc1_.x,_loc1_.y,_loc1_.z,_loc1_.rotationX,_loc1_.rotationY,_loc1_.rotationZ);
this.cameraMatrix.setMatrix(this.camera.x,this.camera.y,this.camera.z,this.camera.rotationX,this.camera.rotationY,this.camera.rotationZ);
this.turretMatrix.invert();
this.cameraMatrix.append(this.turretMatrix);
this.cameraMatrix.getEulerAngles(this.cameraAngles);
this.initialCameraOrientation.setFromEulerAnglesXYZ(this.cameraAngles.x,this.cameraAngles.y,this.cameraAngles.z);
this.cameraMatrix.getAxis(3,this.initialCameraPosition);
}
private function updateCamera(param1:Number) : void
{
this.cameraPosition.interpolate(param1,this.initialCameraPosition,this.targetCameraPosition);
this.cameraOrientation.slerp(this.initialCameraOrientation,this.targetCameraOrientation,param1);
this.cameraOrientation.toMatrix4(this.cameraMatrix);
this.cameraMatrix.setPosition(this.cameraPosition);
var _loc2_:Object3D = this.skin.turretMesh;
this.turretMatrix.setMatrix(_loc2_.x,_loc2_.y,_loc2_.z,_loc2_.rotationX,_loc2_.rotationY,_loc2_.rotationZ);
this.cameraMatrix.append(this.turretMatrix);
this.cameraMatrix.getEulerAngles(this.cameraAngles);
this.camera.x = this.cameraMatrix.d;
this.camera.y = this.cameraMatrix.h;
this.camera.z = this.cameraMatrix.l;
this.camera.rotationX = this.cameraAngles.x;
this.camera.rotationY = this.cameraAngles.y;
this.camera.rotationZ = this.cameraAngles.z;
}
}
}
|
package alternativa.tanks.battle.objects.tank {
public interface HullTransformUpdater {
function reset() : void;
function update(param1:Number) : void;
}
}
|
package alternativa.tanks.model.quest.common.gui.window.buttons.skin {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.quest.common.gui.window.buttons.skin.GreenBigButtonSkin_rightDownClass.png")]
public class GreenBigButtonSkin_rightDownClass extends BitmapAsset {
public function GreenBigButtonSkin_rightDownClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.battle.jgr.killstreak {
import platform.client.fp10.core.resource.types.SoundResource;
public class KillStreakItem {
private var _count:int;
private var _messageToBoss:String;
private var _messageToVictims:String;
private var _sound:SoundResource;
public function KillStreakItem(param1:int = 0, param2:String = null, param3:String = null, param4:SoundResource = null) {
super();
this._count = param1;
this._messageToBoss = param2;
this._messageToVictims = param3;
this._sound = param4;
}
public function get count() : int {
return this._count;
}
public function set count(param1:int) : void {
this._count = param1;
}
public function get messageToBoss() : String {
return this._messageToBoss;
}
public function set messageToBoss(param1:String) : void {
this._messageToBoss = param1;
}
public function get messageToVictims() : String {
return this._messageToVictims;
}
public function set messageToVictims(param1:String) : void {
this._messageToVictims = param1;
}
public function get sound() : SoundResource {
return this._sound;
}
public function set sound(param1:SoundResource) : void {
this._sound = param1;
}
public function toString() : String {
var local1:String = "KillStreakItem [";
local1 += "count = " + this.count + " ";
local1 += "messageToBoss = " + this.messageToBoss + " ";
local1 += "messageToVictims = " + this.messageToVictims + " ";
local1 += "sound = " + this.sound + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.weapon.snowman
{
public class SnowmanGunData
{
public var shotRange:Number;
public var shotSpeed:Number;
public var shotRadius:Number;
public function SnowmanGunData()
{
super();
}
}
}
|
package projects.tanks.client.commons.models.layout.notify {
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 LobbyLayoutNotifyModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function LobbyLayoutNotifyModelServer(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 projects.tanks.client.battlefield.models.ultimate.effects.viking {
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 VikingUltimateModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function VikingUltimateModelServer(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 alternativa.tanks.gui.payment.forms.leogaming {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.payment.forms.mobile.PhoneNumberEvent;
import alternativa.tanks.gui.payment.forms.mobile.PhoneNumberInput;
import base.DiscreteSprite;
import controls.labels.MouseDisabledLabel;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class LeogamingPhoneForm extends DiscreteSprite {
[Inject]
public static var localeService:ILocaleService;
private static const LABEL_GAP:int = 7;
private static const WIDTH:int = 280;
private var phoneInput:PhoneNumberInput;
private var phoneLabel:MouseDisabledLabel;
public function LeogamingPhoneForm() {
super();
this.addPhoneLabel();
this.addPhoneInput();
this.render();
}
private function onNumberChanged(param1:PhoneNumberEvent) : void {
if(param1.isCorrectLength()) {
this.phoneInput.onValidNumber();
dispatchEvent(new ValidationEvent(ValidationEvent.VALID));
} else {
this.phoneInput.onInvalidNumber();
dispatchEvent(new ValidationEvent(ValidationEvent.INVALID));
}
}
private function addPhoneLabel() : void {
this.phoneLabel = new MouseDisabledLabel();
this.phoneLabel.text = localeService.getText(TanksLocale.TEXT_PHONE_NUMBER);
addChild(this.phoneLabel);
}
private function addPhoneInput() : void {
this.phoneInput = new PhoneNumberInput(true);
this.phoneInput.setCountryCode(380,9);
this.phoneInput.addEventListener(PhoneNumberEvent.CHANGED,this.onNumberChanged);
addChild(this.phoneInput);
}
public function getPhoneNumber() : String {
return this.phoneInput.getPhoneNumber();
}
public function destroy() : void {
this.phoneInput.removeEventListener(PhoneNumberEvent.CHANGED,this.onNumberChanged);
}
public function reset() : void {
this.phoneInput.reset();
}
private function render() : void {
this.phoneInput.x = WIDTH - this.phoneInput.width;
this.phoneLabel.x = this.phoneInput.x - LABEL_GAP - this.phoneLabel.width;
this.phoneLabel.y = this.phoneInput.height - this.phoneLabel.height >> 1;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.common {
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.Float;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapons.common.TargetPosition;
import projects.tanks.client.battlefield.types.Vector3d;
public class CodecTargetPosition implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_orientation:ICodec;
private var codec_position:ICodec;
private var codec_target:ICodec;
private var codec_turretAngle:ICodec;
public function CodecTargetPosition() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_orientation = param1.getCodec(new TypeCodecInfo(Vector3d,false));
this.codec_position = param1.getCodec(new TypeCodecInfo(Vector3d,false));
this.codec_target = param1.getCodec(new TypeCodecInfo(IGameObject,false));
this.codec_turretAngle = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:TargetPosition = new TargetPosition();
local2.orientation = this.codec_orientation.decode(param1) as Vector3d;
local2.position = this.codec_position.decode(param1) as Vector3d;
local2.target = this.codec_target.decode(param1) as IGameObject;
local2.turretAngle = this.codec_turretAngle.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:TargetPosition = TargetPosition(param2);
this.codec_orientation.encode(param1,local3.orientation);
this.codec_position.encode(param1,local3.position);
this.codec_target.encode(param1,local3.target);
this.codec_turretAngle.encode(param1,local3.turretAngle);
}
}
}
|
package projects.tanks.client.panel.model.presents {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class PresentsSettingsModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:PresentsSettingsModelServer;
private var client:IPresentsSettingsModelBase = IPresentsSettingsModelBase(this);
private var modelId:Long = Long.getLong(1701514952,2131242841);
public function PresentsSettingsModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new PresentsSettingsModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(PresentsSettingsCC,false)));
}
protected function getInitParam() : PresentsSettingsCC {
return PresentsSettingsCC(initParams[Model.object]);
}
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.sfx.drone {
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.battlefield.models.drone.DroneSFXModelBase;
import projects.tanks.client.battlefield.models.drone.IDroneSFXModelBase;
[ModelInfo]
public class DroneSFXModel extends DroneSFXModelBase implements IDroneSFXModelBase, DroneSFX, ObjectLoadListener {
public function DroneSFXModel() {
super();
}
public function objectLoaded() : void {
var local1:DroneSFXData = new DroneSFXData(getInitParam());
putData(DroneSFXData,local1);
}
public function getSfxData() : DroneSFXData {
return DroneSFXData(getData(DroneSFXData));
}
}
}
|
package alternativa.tanks.model.matchmaking.invitewindow {
import alternativa.tanks.view.mainview.groupinvite.GroupInviteWindow;
public interface InviteWindowService {
function getInviteWindow() : GroupInviteWindow;
function setInviteWindow(param1:GroupInviteWindow) : void;
}
}
|
package _codec.projects.tanks.client.chat.models.news.showing {
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.news.showing.NewsShowingCC;
public class VectorCodecNewsShowingCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecNewsShowingCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(NewsShowingCC,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.<NewsShowingCC> = new Vector.<NewsShowingCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = NewsShowingCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:NewsShowingCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<NewsShowingCC> = Vector.<NewsShowingCC>(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++;
}
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.