code stringlengths 57 237k |
|---|
package scpacker.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksI_coldload7 extends BitmapAsset
{
public function GTanksI_coldload7()
{
super();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p13 extends BitmapAsset
{
public function RangIconNormal_p13()
{
super();
}
}
}
|
package projects.tanks.clients.flash.commons.models.gpu {
import alternativa.Launcher;
import alternativa.osgi.OSGi;
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.launcherparams.ILauncherParams;
import flash.events.Event;
import projects.tanks.client.commons.models.gpu.GPUDetectorModelBase;
import projects.tanks.client.commons.models.gpu.IGPUDetectorModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.model.gpu.GPUDetector;
[ModelInfo]
public class GPUDetectorModel extends GPUDetectorModelBase implements IGPUDetectorModelBase, GPUDetector {
[Inject]
public static var display:IDisplay;
[Inject]
public static var launcherParams:ILauncherParams;
private var gpuCapabilities:GPUCapabilities;
public function GPUDetectorModel() {
super();
}
public function detectGPUCapabilities() : void {
if(this.gpuCapabilities != null) {
server.detectionGPUcompleted(this.isGpuEnabled());
return;
}
this.gpuCapabilities = new GPUCapabilities(display.stage);
this.gpuCapabilities.addEventListener(Event.COMPLETE,getFunctionWrapper(this.onGPUCapabilitiesReady));
this.gpuCapabilities.detect();
}
private function onGPUCapabilitiesReady(param1:Event) : void {
this.gpuCapabilities.removeEventListener(Event.COMPLETE,this.onGPUCapabilitiesReady);
this.loadAlternativa3D();
}
private function isGpuEnabled() : Boolean {
return Boolean(launcherParams.getParameter("force_gpu")) || GPUCapabilities.gpuEnabled;
}
private function loadAlternativa3D() : void {
var gpuEnabled:Boolean = false;
var launcher:Launcher = null;
gpuEnabled = this.isGpuEnabled();
var libraryName:String = gpuEnabled ? "hardware.swf" : "software.swf";
launcher = OSGi.getInstance().getService(Launcher);
var notifyServer:Function = getFunctionWrapper(function():void {
server.detectionGPUcompleted(gpuEnabled);
});
if(launcherParams.getParameter("develop") == null) {
launcher.loadLibrary(libraryName,function():void {
launcher.loadLibrary("game.swf",function():void {
launcher.initLibrary("GameActivator");
notifyServer();
});
});
} else {
notifyServer();
}
}
}
}
|
package alternativa.tanks.view.battleinfo {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.loader.IModalLoaderService;
import alternativa.tanks.service.achievement.IAchievementService;
import alternativa.tanks.view.battlelist.forms.ProBattlePassAlert;
import base.DiscreteSprite;
import controls.BigButton;
import flash.display.DisplayObjectContainer;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.Point;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import forms.TankWindowWithHeader;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.probattle.IUserProBattleService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.probattle.ProBattleEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
public class AbstractBattleInfoView extends DiscreteSprite {
[Inject]
public static var achievementService:IAchievementService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var userProBattleService:IUserProBattleService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var modalLoaderService:IModalLoaderService;
private static const MIN_FLASH_WIDTH:int = 970;
private static const MIN_FLASH_HEIGHT:int = 530;
private static const HEADER_HEIGHT:int = 60;
private var _timeOutResize:uint;
private var _buyAbonementButton:BigButton;
protected var initParams:BattleInfoBaseParams;
protected var _window:TankWindowWithHeader;
protected var proBattlePassAlert:ProBattlePassAlert;
public var battleInfoParamsView:BattleInfoParamsView;
public function AbstractBattleInfoView() {
super();
this._window = TankWindowWithHeader.createWindow(TanksLocale.TEXT_HEADER_BATTLE_INFO);
addChild(this._window);
this.battleInfoParamsView = new BattleInfoParamsView();
addChild(this.battleInfoParamsView);
this.createUserList();
this._buyAbonementButton = new BigButton();
this._buyAbonementButton.label = LocaleBattleInfo.buyAbonementButtonLabel;
this._buyAbonementButton.visible = false;
addChild(this._buyAbonementButton);
this.proBattlePassAlert = new ProBattlePassAlert(LocaleBattleInfo.proBattleAlertLabel);
addChild(this.proBattlePassAlert);
this.addControlsToPanel();
this.resize();
}
protected function createUserList() : void {
}
protected function addControlsToPanel() : void {
}
protected function setEvents() : void {
display.stage.addEventListener(Event.RESIZE,this.onResize);
userProBattleService.addEventListener(ProBattleEvent.OVER,this.onAbonementOver);
this.battleInfoParamsView.addEventListener(BattleInfoViewEvent.ENTER_SPECTATOR,this.onEnterSpectator);
this._buyAbonementButton.addEventListener(MouseEvent.CLICK,this.onBuyAbonementClick);
}
protected function removeEvents() : void {
display.stage.removeEventListener(Event.RESIZE,this.onResize);
userProBattleService.removeEventListener(ProBattleEvent.OVER,this.onAbonementOver);
this.battleInfoParamsView.removeEventListener(BattleInfoViewEvent.ENTER_SPECTATOR,this.onEnterSpectator);
this._buyAbonementButton.removeEventListener(MouseEvent.CLICK,this.onBuyAbonementClick);
}
private function onAbonementOver(param1:ProBattleEvent) : void {
this.showProBattlePassAlert();
this.resize();
}
public function update(param1:BattleInfoBaseParams) : void {
this.initParams = param1;
}
public function show() : void {
if(!this.container.contains(this)) {
battleInfoService.setCurrentSelectionBattle(this.initParams.battle.id,this.initParams.createParams.rankRange.min,this.initParams.createParams.rankRange.max);
this.setEvents();
this.container.addChild(this);
this.resize();
}
}
public function hide() : void {
if(this.container.contains(this)) {
battleInfoService.resetCurrentSelectionBattleId();
this.removeEvents();
this.container.removeChild(this);
achievementService.setBattleStartButtonTargetPoint(new Point());
}
}
public function destroy() : void {
this.removeEvents();
clearTimeout(this._timeOutResize);
this._window = null;
this.battleInfoParamsView.destroy();
this.battleInfoParamsView = null;
this.proBattlePassAlert = null;
this.initParams = null;
}
public function lock() : void {
mouseEnabled = false;
mouseChildren = false;
}
public function unlock() : void {
mouseEnabled = true;
mouseChildren = true;
}
protected function resize(param1:Boolean = true) : void {
var local2:Number = int(Math.max(MIN_FLASH_WIDTH,display.stage.stageWidth)) / 3;
var local3:Number = Math.max(display.stage.stageHeight - HEADER_HEIGHT,MIN_FLASH_HEIGHT);
this._window.width = local2;
this._window.height = local3;
this.x = local2 * 2;
this.y = HEADER_HEIGHT;
this.battleInfoParamsView.width = local2 - 22;
this.battleInfoParamsView.height = int(local3 * 0.4);
this.battleInfoParamsView.x = this.battleInfoParamsView.y = 11;
this.resizeUserList(local2,local3);
this.proBattlePassAlert.width = local2 - 30;
this.proBattlePassAlert.x = 15;
this.proBattlePassAlert.y = local3 - 85 - 55;
this._buyAbonementButton.width = Math.min(130,int((local2 - 110) / 2));
this._buyAbonementButton.x = local2 - this._buyAbonementButton.width - 11;
this._buyAbonementButton.y = local3 - 61;
this.resizeControlsPanel(local2,local3);
this.updateAchievementPosition();
if(param1) {
this.resizeWithDelay();
} else {
this.invalidateDataProviders();
}
}
protected function invalidateDataProviders() : void {
}
protected function resizeControlsPanel(param1:Number, param2:Number) : void {
}
protected function resizeUserList(param1:Number, param2:Number) : void {
}
public function resizeWithDelay(param1:int = 200) : void {
clearTimeout(this._timeOutResize);
this._timeOutResize = setTimeout(this.onResizeWithDelay,param1);
}
private function onResizeWithDelay() : void {
this.resize(false);
}
protected function updateAchievementPosition() : void {
}
public function showProBattlePassAlert() : void {
this.proBattlePassAlert.visible = true;
this._buyAbonementButton.visible = true;
}
public function hideNoSupplies() : void {
this.proBattlePassAlert.visible = false;
this._buyAbonementButton.visible = false;
}
public function updateScore(param1:BattleTeam, param2:int) : void {
}
private function onResize(param1:Event) : void {
this.resize();
}
private function onEnterSpectator(param1:BattleInfoViewEvent) : void {
dispatchEvent(param1.clone());
}
private function onBuyAbonementClick(param1:MouseEvent) : void {
modalLoaderService.show();
dispatchEvent(new BattleInfoViewEvent(BattleInfoViewEvent.BUY_PRO_ABONEMENT));
}
public function updateInBattleState() : void {
this.proBattlePassAlert.visible = false;
this._buyAbonementButton.visible = false;
if(this.initParams.createParams.proBattle && !userProBattleService.hasAbonement() && !clanUserInfoService.giveBonusesClan) {
this.showProBattlePassAlert();
} else {
this.hideNoSupplies();
}
this.battleInfoParamsView.updateSpectatorButton();
this.resize(true);
this.updateAchievementPosition();
}
private function get container() : DisplayObjectContainer {
return display.systemLayer;
}
public function invalidateUserList() : void {
this.resizeWithDelay(500);
}
public function updateBattleName() : void {
this.battleInfoParamsView.updateNameAndFormat();
}
}
}
|
package alternativa.tanks.models.dom.hud.panel
{
import alternativa.tanks.display.SquareSectorIndicator;
import alternativa.tanks.models.dom.Point;
import controls.Label;
import flash.display.Sprite;
import flash.geom.ColorTransform;
public class KeyPointHUDIndicator extends Sprite
{
private static const SIZE:int = 36;
private static const FONT_COLOR_RED:uint = 16742221;
private static const FONT_COLOR_BLUE:uint = 4760319;
private static const FONT_COLOR_NEUTRAL:uint = 16777215;
private static const BG_COLOR_RED:uint = 9249024;
private static const BG_COLOR_BLUE:uint = 16256;
private var point:Point;
private var label:Label;
private var progressIndicator:SquareSectorIndicator;
private var score:Number = 0;
public function KeyPointHUDIndicator(param1:Point)
{
super();
this.point = param1;
this.createProgressIndicator();
this.createLabel();
this.update();
}
public static function getColor(param1:int) : uint
{
if(param1 >= 100)
{
return FONT_COLOR_BLUE;
}
if(param1 <= -100)
{
return FONT_COLOR_RED;
}
return FONT_COLOR_NEUTRAL;
}
private function createProgressIndicator() : void
{
this.progressIndicator = new SquareSectorIndicator(SIZE,0,0,0);
addChild(this.progressIndicator);
}
private function createLabel() : void
{
this.label = new Label();
this.label.size = 18;
this.label.bold = true;
this.label.color = getColor(this.point.clientProgress);
this.label.text = this.point.id == 0 ? "A" : (this.point.id == 1 ? "B" : (this.point.id == 2 ? "C" : (this.point.id == 3 ? "D" : (this.point.id == 4 ? "E" : (this.point.id == 5 ? "F" : "G")))));
}
public function getLabel() : Label
{
return this.label;
}
public function update() : void
{
this.updateScore();
this.updateVisibility();
}
private function updateVisibility() : void
{
this.label.visible = true;
this.progressIndicator.visible = true;
}
private function setColorOffset(param1:uint) : void
{
var _loc2_:ColorTransform = this.progressIndicator.transform.colorTransform;
_loc2_.redOffset = param1;
_loc2_.greenOffset = param1;
_loc2_.blueOffset = param1;
this.progressIndicator.transform.colorTransform = _loc2_;
}
private function getLabelColor() : uint
{
if(this.point.clientProgress >= 100)
{
return FONT_COLOR_BLUE;
}
if(this.point.clientProgress <= -100)
{
return FONT_COLOR_RED;
}
return FONT_COLOR_NEUTRAL;
}
private function updateScore() : void
{
if(this.score != this.point.clientProgress)
{
this.score = this.point.clientProgress;
if(this.score < 0)
{
this.progressIndicator.setColor(BG_COLOR_RED,1);
}
else if(this.score > 0)
{
this.progressIndicator.setColor(BG_COLOR_BLUE,1);
}
else
{
this.progressIndicator.setColor(0,0);
}
this.label.color = this.getLabelColor();
this.progressIndicator.setProgress(Math.abs(this.score) / 100);
}
}
[Obfuscation(rename="false")]
override public function get width() : Number
{
return SIZE;
}
[Obfuscation(rename="false")]
override public function get height() : Number
{
return SIZE;
}
}
}
|
package projects.tanks.client.tanksservices.model.notifier.rank {
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 RankNotifierModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function RankNotifierModelServer(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.models.weapon.hwthunder
{
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.physics.collision.ICollisionDetector;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.register.ObjectRegister;
import alternativa.service.IModelService;
import alternativa.tanks.models.battlefield.BattlefieldData;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.sfx.shoot.hwthunder.IHWThunderSFXModel;
import alternativa.tanks.models.tank.ITank;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.tank.TankModel;
import alternativa.tanks.models.weapon.IWeaponController;
import alternativa.tanks.models.weapon.WeaponConst;
import alternativa.tanks.models.weapon.WeaponUtils;
import alternativa.tanks.models.weapon.common.HitInfo;
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapon.shared.CommonTargetEvaluator;
import alternativa.tanks.models.weapon.shared.CommonTargetSystem;
import alternativa.tanks.models.weapon.shared.shot.ShotData;
import alternativa.tanks.models.weapon.weakening.IWeaponWeakeningModel;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.sfx.EffectsPair;
import alternativa.tanks.vehicles.tanks.Tank;
import com.alternativaplatform.projects.tanks.client.commons.types.Vector3d;
import com.alternativaplatform.projects.tanks.client.models.tank.TankSpawnState;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.thunder.IThunderModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.thunder.ThunderModelBase;
import com.reygazu.anticheat.variables.SecureInt;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
import scpacker.tanks.WeaponsManager;
public class HWThunderModel extends ThunderModelBase implements IThunderModelBase, IWeaponController, IObjectLoadListener
{
private static const DECAL_RADIUS:Number = 250;
private static const DECAL:Class = HWThunderModel_DECAL;
private static var decalMaterial:TextureMaterial;
private var weaponUtils:WeaponUtils;
private var modelService:IModelService;
private var battlefieldModel:IBattleField;
private var tankInterface:TankModel;
private var commonModel:IWeaponCommonModel;
private var weakeningModel:IWeaponWeakeningModel;
private var sfxModel:IHWThunderSFXModel;
private var localTankData:TankData;
private var localShotData:ShotData;
private var localThunderData:HWThunderData;
private var localWeaponCommonData:WeaponCommonData;
private var _triggerPressed:Boolean;
private var nextReadyTime:SecureInt;
private var targetSystem:CommonTargetSystem;
private var hitInfo:HitInfo;
private var _hitPos:Vector3;
private var _hitPosLocal:Vector3;
private var _hitPosGlobal:Vector3;
private var _gunDirGlobal:Vector3;
private var _muzzlePosGlobal:Vector3;
private var _barrelOrigin:Vector3;
private var _xAxis:Vector3;
private var _vector:Vector3;
private var _rayOrigin:Vector3;
private var _rayInteresction:RayIntersection;
private var _hitPos3d:Vector3d;
private var _targetPos3d:Vector3d;
private var _splashTargetIds:Array;
private var _splashTargetIncarnations:Array;
private var _splashTargetDistances:Array;
private var _splashTargetPositions:Array;
private var testPointsAux:Vector.<Vector3>;
private var testPoints:Vector.<Vector3>;
private var targetEvaluator:CommonTargetEvaluator;
private var maxTargetingDistance:Number = 100000;
public function HWThunderModel()
{
this.weaponUtils = WeaponUtils.getInstance();
this.nextReadyTime = new SecureInt("nextReadyTime.value thunder");
this.hitInfo = new HitInfo();
this._hitPos = new Vector3();
this._hitPosLocal = new Vector3();
this._hitPosGlobal = new Vector3();
this._gunDirGlobal = new Vector3();
this._muzzlePosGlobal = new Vector3();
this._barrelOrigin = new Vector3();
this._xAxis = new Vector3();
this._vector = new Vector3();
this._rayOrigin = new Vector3();
this._rayInteresction = new RayIntersection();
this._hitPos3d = new Vector3d(0,0,0);
this._targetPos3d = new Vector3d(0,0,0);
this._splashTargetIds = [];
this._splashTargetIncarnations = [];
this._splashTargetDistances = [];
this._splashTargetPositions = [];
this.testPointsAux = Vector.<Vector3>([new Vector3(),new Vector3(),new Vector3()]);
this.testPoints = Vector.<Vector3>([new Vector3(),new Vector3(),new Vector3()]);
super();
_interfaces.push(IModel,IWeaponController,IObjectLoadListener);
if(decalMaterial == null)
{
decalMaterial = new TextureMaterial(new DECAL().bitmapData);
}
}
public function initObject(clientObject:ClientObject, impactForce:Number, maxSplashDamageRadius:Number, minSplashDamagePercent:Number, minSplashDamageRadius:Number) : void
{
var data:HWThunderData = new HWThunderData(maxSplashDamageRadius,minSplashDamageRadius,minSplashDamagePercent,impactForce * WeaponConst.BASE_IMPACT_FORCE);
clientObject.putParams(HWThunderModel,data);
WeaponsManager.getHWThunderSFX(WeaponsManager.getObjectFor(clientObject.id));
this.objectLoaded(clientObject);
}
public function fire(clientObject:ClientObject, shooterId:String, hitPoint:Vector3d, mainTargetId:String, weakeningCoeff:Number, splashTargetIds:Array, splashWeakeningCoeffs:Array) : void
{
var shooterData:TankData = null;
shooterData = null;
var mainTargetData:TankData = null;
var len:int = 0;
var i:int = 0;
var targetData:TankData = null;
var splashWeakeningCoeff:Number = NaN;
var objectRegister:ObjectRegister = clientObject.register;
shooterData = this.getTankData(shooterId,objectRegister);
if(shooterData == null || shooterData.tank == null || shooterData.tank.skin == null)
{
return;
}
if(this.tankInterface.localUserData != null)
{
if(shooterData.userName == this.tankInterface.localUserData.userName)
{
return;
}
}
var commonData:WeaponCommonData = this.commonModel.getCommonData(shooterData.turret);
this.weaponUtils.calculateGunParamsAux(shooterData.tank.skin.turretMesh,commonData.muzzles[0],this._muzzlePosGlobal,this._gunDirGlobal);
this.createShotEffects(shooterData,commonData.muzzles[0]);
this._vector.vCopy(this._gunDirGlobal).vScale(-commonData.kickback);
shooterData.tank.addWorldForce(this._muzzlePosGlobal,this._vector);
if(hitPoint == null || isNaN(hitPoint.x) || isNaN(hitPoint.y) || isNaN(hitPoint.z))
{
return;
}
this._hitPos.x = hitPoint.x;
this._hitPos.y = hitPoint.y;
this._hitPos.z = hitPoint.z;
var thunderData:HWThunderData = this.getData(shooterData.turret);
if(mainTargetId != null)
{
mainTargetData = this.getTankData(mainTargetId,objectRegister);
if(mainTargetData == null || mainTargetData.tank == null)
{
return;
}
mainTargetData.tank.baseMatrix.transformVector(this._hitPos,this._vector);
this._hitPos.vSum(this._vector,mainTargetData.tank.state.pos);
this.applyMainImpactForce(mainTargetData.tank,this._hitPos,this._gunDirGlobal,commonData.impactForce,thunderData.impactForce,weakeningCoeff);
this.battlefieldModel.tankHit(mainTargetData,this._gunDirGlobal,commonData.impactCoeff * weakeningCoeff);
}
else
{
this.battlefieldModel.addDecal(this._hitPos,this._barrelOrigin,DECAL_RADIUS,decalMaterial);
}
this.createExplosionEffects(shooterData,this._hitPos);
var impactCoeff:Number = thunderData.impactForce / WeaponConst.BASE_IMPACT_FORCE;
if(splashTargetIds != null)
{
len = splashTargetIds.length;
for(i = 0; i < len; i++)
{
targetData = this.getTankData(splashTargetIds[i],objectRegister);
if(!(targetData == null || targetData.tank == null))
{
this._vector.vDiff(targetData.tank.state.pos,this._hitPos).vNormalize();
splashWeakeningCoeff = 1;
this.battlefieldModel.tankHit(targetData,this._vector,splashWeakeningCoeff * impactCoeff);
this._vector.vScale(thunderData.impactForce * splashWeakeningCoeff);
targetData.tank.addForce(this._vector);
}
}
}
}
public function stopEffects(ownerTankData:TankData) : void
{
}
public function reset() : void
{
this._triggerPressed = false;
this.nextReadyTime.value = 0;
}
public function setLocalUser(localUserData:TankData) : void
{
this.localTankData = localUserData;
this.localShotData = WeaponsManager.shotDatas[localUserData.turret.id];
this.localThunderData = HWThunderData(localUserData.turret.getParams(HWThunderModel));
this.localWeaponCommonData = this.commonModel.getCommonData(localUserData.turret);
this.targetEvaluator = CommonTargetEvaluator.create(this.localTankData,this.localShotData,this.battlefieldModel,this.weakeningModel,this.modelService);
this.targetSystem = new CommonTargetSystem(this.maxTargetingDistance,this.localShotData.autoAimingAngleUp.value,this.localShotData.numRaysUp.value,this.localShotData.autoAimingAngleDown.value,this.localShotData.numRaysDown.value,this.battlefieldModel.getBattlefieldData().collisionDetector,this.targetEvaluator);
}
public function clearLocalUser() : void
{
this.localTankData = null;
this.localShotData = null;
this.localWeaponCommonData = null;
this.targetSystem = null;
this.targetEvaluator = null;
}
public function activateWeapon(time:int) : void
{
this._triggerPressed = true;
}
public function deactivateWeapon(time:int, sendServerCommand:Boolean) : void
{
this._triggerPressed = false;
}
public function update(time:int, deltaTime:int) : Number
{
var distance:Number = NaN;
var directImpactCoeff:Number = NaN;
var hitX:Number = NaN;
var hitY:Number = NaN;
var hitZ:Number = NaN;
var mainTarget:TankData = null;
var numSplashTargets:int = 0;
var splashRadiusSqr:Number = NaN;
var key:* = undefined;
var hitPos3d:Vector3d = null;
var mainTargetId:String = null;
var mainTargetIncarnation:int = 0;
var mainTargetPosition:Vector3d = null;
var splashTargetIds:Array = null;
var splashTargetIncarnations:Array = null;
var splashTargetDistances:Array = null;
var splashTargetPositions:Array = null;
var td:* = null;
var tank:Tank = null;
var targetPos:Vector3 = null;
var dx:Number = NaN;
var dy:Number = NaN;
var dz:Number = NaN;
var d:Number = NaN;
var targetPos3d:Vector3d = null;
var v:Vector3 = null;
if(!this._triggerPressed || time < this.nextReadyTime.value)
{
if(time < this.nextReadyTime.value)
{
return 1 + (time - this.nextReadyTime.value) / this.localShotData.reloadMsec.value;
}
return 1;
}
this.nextReadyTime.value = time + this.localShotData.reloadMsec.value;
this.weaponUtils.calculateGunParams(this.localTankData.tank.skin.turretMesh,this.localWeaponCommonData.muzzles[0],this._muzzlePosGlobal,this._barrelOrigin,this._xAxis,this._gunDirGlobal);
this._vector.vCopy(this._gunDirGlobal).vScale(-this.localWeaponCommonData.kickback);
this.localTankData.tank.addWorldForce(this._muzzlePosGlobal,this._vector);
this.createShotEffects(this.localTankData,this.localWeaponCommonData.muzzles[0]);
var bfData:BattlefieldData = this.battlefieldModel.getBattlefieldData();
var collisionDetector:ICollisionDetector = bfData.collisionDetector;
if(this.targetSystem.getTarget(this._barrelOrigin,this._gunDirGlobal,this._xAxis,this.localTankData.tank,this.hitInfo))
{
distance = this.hitInfo.distance * 0.01;
directImpactCoeff = this.weakeningModel.getImpactCoeff(this.localTankData.turret,distance);
hitX = this.hitInfo.position.x;
hitY = this.hitInfo.position.y;
hitZ = this.hitInfo.position.z;
splashRadiusSqr = 10000 * this.localThunderData.minSplashDamageRadius * this.localThunderData.minSplashDamageRadius;
for(td in bfData.activeTanks)
{
tank = td.tank;
if(td.spawnState != TankSpawnState.NEWCOME)
{
if(tank == this.hitInfo.body)
{
mainTarget = td;
}
else
{
targetPos = tank.state.pos;
dx = targetPos.x - hitX;
dy = targetPos.y - hitY;
dz = targetPos.z - hitZ;
d = dx * dx + dy * dy + dz * dz;
if(d <= splashRadiusSqr)
{
if(this.testForSplashHit(tank,this.hitInfo,collisionDetector))
{
d = Math.sqrt(d) * 0.01;
this._splashTargetIds[numSplashTargets] = td.user.id;
this._splashTargetIncarnations[numSplashTargets] = td.incarnation;
this._splashTargetDistances[numSplashTargets] = d;
targetPos3d = this._splashTargetPositions[numSplashTargets];
if(targetPos3d == null)
{
targetPos3d = new Vector3d(0,0,0);
this._splashTargetPositions[numSplashTargets] = targetPos3d;
}
targetPos3d.x = targetPos.x;
targetPos3d.y = targetPos.y;
targetPos3d.z = targetPos.z;
numSplashTargets++;
this._vector.vNormalize();
this._vector.vScale(this.localThunderData.impactForce * directImpactCoeff * this.getSplashImpactCoeff(d));
tank.addForce(this._vector);
}
}
}
}
}
hitPos3d = this._hitPos3d;
if(mainTarget != null)
{
mainTargetId = mainTarget.user.id;
mainTargetIncarnation = mainTarget.incarnation;
mainTargetPosition = this._targetPos3d;
v = mainTarget.tank.state.pos;
mainTargetPosition.x = v.x;
mainTargetPosition.y = v.y;
mainTargetPosition.z = v.z;
this.applyMainImpactForce(mainTarget.tank,this.hitInfo.position,this._gunDirGlobal,this.localWeaponCommonData.impactForce,this.localThunderData.impactForce,directImpactCoeff);
this._hitPosGlobal.vDiff(this.hitInfo.position,v);
mainTarget.tank.baseMatrix.transformVectorInverse(this._hitPosGlobal,this._hitPosLocal);
hitPos3d.x = this._hitPosLocal.x;
hitPos3d.y = this._hitPosLocal.y;
hitPos3d.z = this._hitPosLocal.z;
}
else
{
hitPos3d.x = hitX;
hitPos3d.y = hitY;
hitPos3d.z = hitZ;
}
if(numSplashTargets > 0)
{
splashTargetIds = this._splashTargetIds;
splashTargetIds.length = numSplashTargets;
splashTargetIncarnations = this._splashTargetIncarnations;
splashTargetIncarnations.length = numSplashTargets;
splashTargetDistances = this._splashTargetDistances;
splashTargetDistances.length = numSplashTargets;
splashTargetPositions = this._splashTargetPositions;
splashTargetPositions.length = numSplashTargets;
}
this.fireCommand(this.localTankData.turret,hitPos3d,mainTargetId,mainTargetIncarnation,mainTargetPosition,distance,splashTargetIds,splashTargetIncarnations,splashTargetDistances,splashTargetPositions);
this.createExplosionEffects(this.localTankData,this.hitInfo.position);
if(mainTarget == null)
{
this.battlefieldModel.addDecal(this.hitInfo.position,this._barrelOrigin,DECAL_RADIUS,decalMaterial);
}
}
else
{
this.fireCommand(this.localTankData.turret,null,null,0,null,0,null,null,null,null);
}
return 0;
}
private function fireCommand(turr:ClientObject, hitPos:Vector3d, mainTargetId:String, mainTargetIncarnation:int, mainTargetPosition:Vector3d, distance:int, splashTargetIds:Array, splashTargetIncarnations:Array, splashTargetDistances:Array, splashTargetPositions:Array) : void
{
var js:Object = new Object();
js.hitPos = hitPos;
js.mainTargetId = mainTargetId;
js.mainTargetPosition = mainTargetPosition;
js.distance = distance;
js.splashTargetIds = splashTargetIds;
js.splashTargetDistances = splashTargetDistances;
js.reloadTime = this.localShotData.reloadMsec.value;
Network(Main.osgi.getService(INetworker)).send("battle;fire;" + JSON.stringify(js));
}
public function objectLoaded(object:ClientObject) : void
{
if(this.commonModel == null)
{
this.modelService = IModelService(Main.osgi.getService(IModelService));
this.battlefieldModel = IBattleField(this.modelService.getModelsByInterface(IBattleField)[0]);
this.tankInterface = Main.osgi.getService(ITank) as TankModel;
this.commonModel = IWeaponCommonModel(this.modelService.getModelsByInterface(IWeaponCommonModel)[0]);
this.weakeningModel = IWeaponWeakeningModel(this.modelService.getModelsByInterface(IWeaponWeakeningModel)[0]);
this.sfxModel = WeaponsManager.getHWThunderSFX(WeaponsManager.getObjectFor(object.id));
}
this.nextReadyTime.value = 0;
}
public function objectUnloaded(object:ClientObject) : void
{
}
private function getSplashImpactCoeff(distance:Number) : Number
{
if(distance < this.localThunderData.maxSplashDamageRadius)
{
return 1;
}
return 0.01 * (this.localThunderData.minSplashDamagePercent + (this.localThunderData.minSplashDamageRadius - distance) * (100 - this.localThunderData.minSplashDamagePercent) / (this.localThunderData.minSplashDamageRadius - this.localThunderData.maxSplashDamageRadius));
}
private function getTankData(objectId:String, objectRegister:ObjectRegister) : TankData
{
var object:ClientObject = BattleController.activeTanks[objectId];
if(object == null)
{
return null;
}
return this.tankInterface.getTankData(object);
}
private function createShotEffects(tankData:TankData, muzzlePosLocal:Vector3) : void
{
var effects:EffectsPair = this.sfxModel.createShotEffects(WeaponsManager.getObjectFor(tankData.turret.id),muzzlePosLocal,tankData.tank.skin.turretMesh);
this.battlefieldModel.addGraphicEffect(effects.graphicEffect);
this.battlefieldModel.addSound3DEffect(effects.soundEffect);
}
private function createExplosionEffects(tankData:TankData, position:Vector3) : void
{
var effects:EffectsPair = this.sfxModel.createExplosionEffects(tankData.turret,position);
this.battlefieldModel.addGraphicEffect(effects.graphicEffect);
this.battlefieldModel.addSound3DEffect(effects.soundEffect);
}
private function testForSplashHit(tank:Tank, hitInfo:HitInfo, collisionDetector:ICollisionDetector) : Boolean
{
var v:Vector3 = null;
var offset:Number = 0.75 * tank.mainCollisionBox.hs.y;
Vector3(this.testPointsAux[0]).y = -offset;
Vector3(this.testPointsAux[2]).y = offset;
this._rayOrigin.vCopy(hitInfo.position).vAdd(hitInfo.normal);
var pos:Vector3 = tank.state.pos;
for(var i:int = 0; i < 3; i++)
{
v = this.testPoints[i];
tank.baseMatrix.transformVector(this.testPointsAux[i],v);
v.vAdd(pos);
this._vector.vDiff(v,hitInfo.position);
if(!collisionDetector.intersectRayWithStatic(this._rayOrigin,this._vector,CollisionGroup.STATIC,1,null,this._rayInteresction))
{
return true;
}
}
return false;
}
private function getData(clientObject:ClientObject) : HWThunderData
{
return HWThunderData(clientObject.getParams(HWThunderModel));
}
private function applyMainImpactForce(target:Tank, globalPos:Vector3, gunDir:Vector3, commonImpact:Number, thunderImpact:Number, weakeningCoeff:Number) : void
{
this._vector.vCopy(gunDir).vScale(commonImpact * weakeningCoeff);
target.addWorldForce(globalPos,this._vector);
this._vector.vDiff(target.state.pos,globalPos).vNormalize().vScale(thunderImpact * weakeningCoeff);
target.addForce(this._vector);
}
}
}
|
package com.lorentz.processing
{
import flash.display.Stage;
import flash.events.Event;
import flash.utils.getTimer;
public class ProcessExecutor
{
private static var _allowInstantiation:Boolean = false;
private static var _instance:ProcessExecutor;
public static function get instance():ProcessExecutor {
if(_instance == null){
_allowInstantiation = true;
_instance = new ProcessExecutor();
_allowInstantiation = false;
}
return _instance;
}
private var _stage:Stage;
private var _processes:Vector.<IProcess>;
private var _percentFrameProcessingTime:Number = 0.25; //Considering the use of 25% of the available time
public function ProcessExecutor()
{
if(!_allowInstantiation)
throw new Error("The class 'ProcessExecutor' is singleton.");
}
public function initialize(stage:Stage):void {
_stage = stage;
_processes = new Vector.<IProcess>();
}
public function get percentFrameProcessingTime():Number {
return _percentFrameProcessingTime;
}
public function set percentFrameProcessingTime(value:Number):void {
_percentFrameProcessingTime = value;
}
private function get internalFrameProcessingTime():Number {
return 1000 / _stage.frameRate * _percentFrameProcessingTime;
}
private function ensureInitialized():void {
if(_stage == null)
throw new Error("You must initialize the ProcessExecutor. Ex: ProcessExecutor.instance.initialize(stage)");
}
public function addProcess(process:IProcess):void {
ensureInitialized();
if(_processes.length == 0)
_stage.addEventListener(Event.ENTER_FRAME, enterFrameHandler);
_processes.push(process);
}
public function containsProcess(process:IProcess):Boolean {
return _processes.indexOf(process) != -1;
}
public function removeProcess(process:IProcess):void {
var index:int = _processes.indexOf(process);
if(index == -1)
return;
_processes.splice(index, 1);
if(_processes.length == 0)
_stage.removeEventListener(Event.ENTER_FRAME, enterFrameHandler);
}
private function enterFrameHandler(e:Event):void {
var timePerProcess:int = internalFrameProcessingTime / _processes.length;
for each(var process:IProcess in _processes)
executeProcess(process, timePerProcess);
}
private function executeProcess(process:IProcess, duration:int):void {
var endTime:int = getTimer() + duration;
var executeFunction:Function = process.executeLoop;
do {
if(executeFunction())
break;
} while(getTimer() < endTime);
}
}
} |
package platform.loading.errors {
import alternativa.types.Long;
public class ObjectClassNotFoundError extends Error {
public function ObjectClassNotFoundError(param1:Long, param2:Long) {
super();
message = "Object class not found. Class id: " + param1 + ". Object id: " + param2;
}
}
}
|
package alternativa.tanks.models.battlefield.gui.chat
{
import alternativa.tanks.models.battlefield.common.MessageLine;
import controls.Label;
public class SpectatorMessageLine extends MessageLine
{
private var message:String;
private var _width:int;
private var output:Label;
private var spectatorFrom:Label;
private var _namesWidth:int = 0;
public function SpectatorMessageLine(_width:int, message:String)
{
this.output = new Label();
this.spectatorFrom = new Label();
super();
this._width = _width;
this.message = message;
this.spectatorFrom.color = 16776960;
this.spectatorFrom.text = " [Наблюдатель]: ";
this.spectatorFrom.thickness = 50;
this.spectatorFrom.sharpness = 0;
this.output.color = 16777215;
this.output.multiline = true;
this.output.wordWrap = true;
this.output.mouseEnabled = false;
var fx:int = 0;
addChild(this.spectatorFrom);
this.spectatorFrom.x = fx;
fx += this.spectatorFrom.textWidth;
addChild(this.output);
this._namesWidth = fx;
if(this._namesWidth > _width / 2)
{
this.output.y = 15;
this.output.x = 0;
this.output.width = _width - 5;
}
else
{
this.output.x = this._namesWidth + 3;
this.output.y = 0;
this.output.width = _width - this._namesWidth - 8;
}
this.output.text = message;
}
override public function set width(value:Number) : void
{
this._width = int(value);
if(this._namesWidth > this._width / 2 && this.output.text.length * 8 > this._width - this._namesWidth)
{
this.output.y = 21;
this.output.x = 0;
this.output.width = this._width - 5;
this.output.height = 20;
}
else
{
this.output.x = this._namesWidth;
this.output.y = 0;
this.output.width = this._width - this._namesWidth - 5;
this.output.height = 20;
}
}
}
}
|
package alternativa.tanks.battle.scene3d {
public class Object3DNames {
public static const STATIC:String = "static";
public static const TANK_PART:String = "tankPart";
public function Object3DNames() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.garage.rankupsupplybonus {
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 platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.panel.model.garage.rankupsupplybonus.RankUpSupplyBonusInfo;
public class CodecRankUpSupplyBonusInfo implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_count:ICodec;
private var codec_preview:ICodec;
private var codec_text:ICodec;
public function CodecRankUpSupplyBonusInfo() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_count = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_preview = param1.getCodec(new TypeCodecInfo(ImageResource,false));
this.codec_text = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:RankUpSupplyBonusInfo = new RankUpSupplyBonusInfo();
local2.count = this.codec_count.decode(param1) as int;
local2.preview = this.codec_preview.decode(param1) as ImageResource;
local2.text = this.codec_text.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:RankUpSupplyBonusInfo = RankUpSupplyBonusInfo(param2);
this.codec_count.encode(param1,local3.count);
this.codec_preview.encode(param1,local3.preview);
this.codec_text.encode(param1,local3.text);
}
}
}
|
package projects.tanks.client.commons.models.gpu {
public interface IGPUDetectorModelBase {
}
}
|
package projects.tanks.client.panel.model.shop.challenges.battlepass {
public interface IBattlePassPackageModelBase {
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity {
public class LightingEffectEntity {
private var _effectName:String;
private var _items:Vector.<LightEffectItem>;
public function LightingEffectEntity(param1:String = null, param2:Vector.<LightEffectItem> = null) {
super();
this._effectName = param1;
this._items = param2;
}
public function get effectName() : String {
return this._effectName;
}
public function set effectName(param1:String) : void {
this._effectName = param1;
}
public function get items() : Vector.<LightEffectItem> {
return this._items;
}
public function set items(param1:Vector.<LightEffectItem>) : void {
this._items = param1;
}
public function toString() : String {
var local1:String = "LightingEffectEntity [";
local1 += "effectName = " + this.effectName + " ";
local1 += "items = " + this.items + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.display.usertitle {
import flash.display.Bitmap;
import flash.display.BitmapData;
import forms.ColorConstants;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class ProgressBarSkin {
private static var hpLeftDmCls:Class = ProgressBarSkin_hpLeftDmCls;
private static var hpLeftDm:BitmapData = Bitmap(new hpLeftDmCls()).bitmapData;
private static var hpRightDmCls:Class = ProgressBarSkin_hpRightDmCls;
private static var hpRightDm:BitmapData = Bitmap(new hpRightDmCls()).bitmapData;
private static var hpLeftBgDmCls:Class = ProgressBarSkin_hpLeftBgDmCls;
private static var hpLeftBgDm:BitmapData = Bitmap(new hpLeftBgDmCls()).bitmapData;
private static var hpRightBgDmCls:Class = ProgressBarSkin_hpRightBgDmCls;
private static var hpRightBgDm:BitmapData = Bitmap(new hpRightBgDmCls()).bitmapData;
private static var hpLeftBlueCls:Class = ProgressBarSkin_hpLeftBlueCls;
private static var hpLeftBlue:BitmapData = Bitmap(new hpLeftBlueCls()).bitmapData;
private static var hpRightBlueCls:Class = ProgressBarSkin_hpRightBlueCls;
private static var hpRightBlue:BitmapData = Bitmap(new hpRightBlueCls()).bitmapData;
private static var hpLeftBgBlueCls:Class = ProgressBarSkin_hpLeftBgBlueCls;
private static var hpLeftBgBlue:BitmapData = Bitmap(new hpLeftBgBlueCls()).bitmapData;
private static var hpRightBgBlueCls:Class = ProgressBarSkin_hpRightBgBlueCls;
private static var hpRightBgBlue:BitmapData = Bitmap(new hpRightBgBlueCls()).bitmapData;
private static var hpLeftRedCls:Class = ProgressBarSkin_hpLeftRedCls;
private static var hpLeftRed:BitmapData = Bitmap(new hpLeftRedCls()).bitmapData;
private static var hpRightRedCls:Class = ProgressBarSkin_hpRightRedCls;
private static var hpRightRed:BitmapData = Bitmap(new hpRightRedCls()).bitmapData;
private static var hpLeftBgRedCls:Class = ProgressBarSkin_hpLeftBgRedCls;
private static var hpLeftBgRed:BitmapData = Bitmap(new hpLeftBgRedCls()).bitmapData;
private static var hpRightBgRedCls:Class = ProgressBarSkin_hpRightBgRedCls;
private static var hpRightBgRed:BitmapData = Bitmap(new hpRightBgRedCls()).bitmapData;
private static var weaponLeftCls:Class = ProgressBarSkin_weaponLeftCls;
private static var weaponLeft:BitmapData = Bitmap(new weaponLeftCls()).bitmapData;
private static var weaponRightCls:Class = ProgressBarSkin_weaponRightCls;
private static var weaponRight:BitmapData = Bitmap(new weaponRightCls()).bitmapData;
private static var weaponLeftBgCls:Class = ProgressBarSkin_weaponLeftBgCls;
private static var weaponLeftBg:BitmapData = Bitmap(new weaponLeftBgCls()).bitmapData;
private static var weaponRightBgCls:Class = ProgressBarSkin_weaponRightBgCls;
private static var weaponRightBg:BitmapData = Bitmap(new weaponRightBgCls()).bitmapData;
private static var barShadowCls:Class = ProgressBarSkin_barShadowCls;
private static var barShadow:BitmapData = Bitmap(new barShadowCls()).bitmapData;
private static var barShadowLeftCls:Class = ProgressBarSkin_barShadowLeftCls;
private static var barShadowLeft:BitmapData = Bitmap(new barShadowLeftCls()).bitmapData;
private static var barShadowRightCls:Class = ProgressBarSkin_barShadowRightCls;
private static var barShadowRight:BitmapData = Bitmap(new barShadowRightCls()).bitmapData;
private static const COLOR_DM:uint = 4964125;
private static const COLOR_DM_BG:uint = 2448911;
private static const COLOR_TEAM_BLUE:uint = ColorConstants.USER_TITLE_BLUE;
private static const COLOR_TEAM_BLUE_BG:uint = 2181375;
private static const COLOR_TEAM_RED:uint = ColorConstants.USER_TITLE_RED;
private static const COLOR_TEAM_RED_BG:uint = 10556937;
private static const COLOR_WEAPON_BAR:uint = ColorConstants.USER_TITLE_YELLOW;
private static const COLOR_WEAPON_BAR_BG:uint = 7758340;
public static const HEALTHBAR_DM:ProgressBarSkin = new ProgressBarSkin(COLOR_DM,COLOR_DM_BG,hpLeftDm,hpLeftBgDm,hpRightDm,hpRightBgDm,barShadow,barShadowLeft,barShadowRight);
public static const HEALTHBAR_BLUE:ProgressBarSkin = new ProgressBarSkin(COLOR_TEAM_BLUE,COLOR_TEAM_BLUE_BG,hpLeftBlue,hpLeftBgBlue,hpRightBlue,hpRightBgBlue,barShadow,barShadowLeft,barShadowRight);
public static const HEALTHBAR_RED:ProgressBarSkin = new ProgressBarSkin(COLOR_TEAM_RED,COLOR_TEAM_RED_BG,hpLeftRed,hpLeftBgRed,hpRightRed,hpRightBgRed,barShadow,barShadowLeft,barShadowRight);
public static const WEAPONBAR:ProgressBarSkin = new ProgressBarSkin(COLOR_WEAPON_BAR,COLOR_WEAPON_BAR_BG,weaponLeft,weaponLeftBg,weaponRight,weaponRightBg,barShadow,barShadowLeft,barShadowRight);
public var color:uint;
public var bgColor:uint;
public var leftTipFg:BitmapData;
public var leftTipBg:BitmapData;
public var rightTipFg:BitmapData;
public var rightTipBg:BitmapData;
public var shadowLeftTip:BitmapData;
public var shadowRightTip:BitmapData;
public var shadow:BitmapData;
public function ProgressBarSkin(param1:uint, param2:uint, param3:BitmapData, param4:BitmapData, param5:BitmapData, param6:BitmapData, param7:BitmapData, param8:BitmapData, param9:BitmapData) {
super();
this.color = param1;
this.bgColor = param2;
this.leftTipFg = param3;
this.leftTipBg = param4;
this.rightTipFg = param5;
this.rightTipBg = param6;
this.shadow = param7;
this.shadowLeftTip = param8;
this.shadowRightTip = param9;
}
public static function getHealthBarSkin(param1:BattleTeam) : ProgressBarSkin {
switch(param1) {
case BattleTeam.BLUE:
return HEALTHBAR_BLUE;
case BattleTeam.RED:
return HEALTHBAR_RED;
default:
return HEALTHBAR_DM;
}
}
}
}
|
package projects.tanks.client.panel.model.donationalert.user.donation {
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 DonationProfileModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function DonationProfileModelServer(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 controls.labels {
import controls.timer.CountDownTimer;
import controls.timer.CountDownTimerOnCompleteBefore;
import controls.timer.CountDownTimerOnTick;
import flash.events.Event;
import utils.TimeFormatter;
public class CountDownTimerLabel extends MouseDisabledLabel implements CountDownTimerOnTick, CountDownTimerOnCompleteBefore {
private var timer:CountDownTimer = null;
public function CountDownTimerLabel() {
super();
addEventListener(Event.ADDED_TO_STAGE,this.onAdded);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemoved);
}
private static function formatTime(param1:int) : String {
if(param1 <= 0) {
return "";
}
return TimeFormatter.format(param1);
}
public function start(param1:CountDownTimer) : void {
this.stop();
this.timer = param1;
if(stage != null) {
this.addListeners();
}
this.onTick(param1);
}
public function stop() : void {
if(this.timer != null) {
if(stage != null) {
this.removeListeners();
}
this.timer = null;
text = "";
}
}
public function onTick(param1:CountDownTimer) : void {
text = formatTime(param1.getRemainingSeconds());
dispatchEvent(new Event(Event.CHANGE));
}
public function onCompleteBefore(param1:CountDownTimer, param2:Boolean) : void {
if(param1 == this.timer) {
this.timer = null;
text = "";
}
}
public function getCountDownTimer() : CountDownTimer {
return this.timer;
}
private function addListeners() : void {
this.timer.addListener(CountDownTimerOnTick,this);
this.timer.addListener(CountDownTimerOnCompleteBefore,this);
}
private function removeListeners() : void {
this.timer.removeListener(CountDownTimerOnTick,this);
this.timer.removeListener(CountDownTimerOnCompleteBefore,this);
}
private function onRemoved(param1:Event) : void {
if(this.timer != null) {
this.removeListeners();
}
}
private function onAdded(param1:Event) : void {
if(this.timer != null) {
this.addListeners();
this.onTick(this.timer);
}
}
}
}
|
package alternativa.tanks.models.drones {
import alternativa.engine3d.core.Object3D;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.sfx.MobileSound3DEffect;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.drone.DroneSFXData;
import platform.client.fp10.core.type.AutoClosable;
public class DroneEffects implements AutoClosable {
[Inject]
public static var battleService:BattleService;
private var sfxData:DroneSFXData;
private var soundEffect:MobileSound3DEffect;
private var object3D:Object3D;
public function DroneEffects(param1:DroneSFXData, param2:Object3D) {
super();
this.sfxData = param1;
this.object3D = param2;
}
public function close() : void {
this.sfxData = null;
}
public function playActivationSound() : void {
this.soundEffect = MobileSound3DEffect(battleService.getObjectPool().getObject(MobileSound3DEffect));
this.soundEffect.init(Sound3D.create(this.sfxData.activationSound),this.object3D);
battleService.addSound3DEffect(this.soundEffect);
}
public function stopSound() : void {
if(this.soundEffect != null) {
this.soundEffect.kill();
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.statistics.targetingmode {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.battlefield.models.statistics.targetingmode.TargetingMode;
public class CodecTargetingMode implements ICodec {
public function CodecTargetingMode() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:TargetingMode = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = TargetingMode.NONE;
break;
case 1:
local2 = TargetingMode.KEYBOARD;
break;
case 2:
local2 = TargetingMode.MOUSE_LOOK;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.formatbattle {
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 projects.tanks.client.tanksservices.model.formatbattle.EquipmentConstraintsCC;
import projects.tanks.client.tanksservices.model.formatbattle.EquipmentConstraintsModeInfo;
public class CodecEquipmentConstraintsCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_equipmentConstraintsModeInfos:ICodec;
public function CodecEquipmentConstraintsCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_equipmentConstraintsModeInfos = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(EquipmentConstraintsModeInfo,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:EquipmentConstraintsCC = new EquipmentConstraintsCC();
local2.equipmentConstraintsModeInfos = this.codec_equipmentConstraintsModeInfos.decode(param1) as Vector.<EquipmentConstraintsModeInfo>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:EquipmentConstraintsCC = EquipmentConstraintsCC(param2);
this.codec_equipmentConstraintsModeInfos.encode(param1,local3.equipmentConstraintsModeInfos);
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapBigRank01.png")]
public class DefaultRanksBitmaps_bitmapBigRank01 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapBigRank01() {
super();
}
}
}
|
package alternativa.tanks.battle.notificationpausefinish {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.utils.removeDisplayObject;
import controls.TankWindow;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.text.TextFieldAutoSize;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.blur.IBlurService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.AlertUtils;
import services.alertservice.AlertAnswer;
public class EndsPauseAlert extends DialogWindow {
[Inject]
public static var display:IDisplay;
[Inject]
public static var blurService:IBlurService;
[Inject]
public static var localeService:ILocaleService;
private static const TIME_REPLACE_PATTERN:String = "{time}";
private static const GAP_AROUND:int = 25;
private static const GAP_BETWEEN_BUTTON:int = 6;
private static const GAP_BETWEEN_LABEL_AND_BUTTON:int = 15;
private var _bgWindow:TankWindow;
private var _buttonYes:DefaultButtonBase;
private var _buttonNo:DefaultButtonBase;
private var _labelOne:LabelBase;
private var _labelTwo:LabelBase;
private var _seconds:int;
private var _pauseText:String;
public function EndsPauseAlert() {
super();
this._pauseText = localeService.getText(TanksLocale.TEXT_REARM_PAUSE_ALERT);
this._bgWindow = new TankWindow();
addChild(this._bgWindow);
this._labelOne = this.createLabel();
this._labelTwo = this.createLabel();
this._buttonYes = new DefaultButtonBase();
this._buttonYes.label = AlertAnswer.YES;
addChild(this._buttonYes);
this._buttonNo = new DefaultButtonBase();
this._buttonNo.label = AlertAnswer.NO;
addChild(this._buttonNo);
this.resize();
}
private function createLabel() : LabelBase {
var local1:LabelBase = new LabelBase();
local1.y = GAP_AROUND;
local1.autoSize = TextFieldAutoSize.LEFT;
local1.size = 14;
local1.width = 10;
local1.height = 10;
local1.multiline = true;
addChild(local1);
return local1;
}
public function set seconds(param1:int) : void {
if(this._seconds == param1) {
return;
}
this._seconds = param1;
var local2:int = this._seconds / 60;
this._seconds -= local2 * 60;
var local3:String = this._seconds < 10 ? "0" + this._seconds : this._seconds.toString();
var local4:Array = this._pauseText.replace(TIME_REPLACE_PATTERN,local2 + ":" + local3).split("\n");
this._labelOne.text = local4[0];
this._labelTwo.text = local4[1];
}
public function show() : void {
blurService.blurAllContent();
this.resize();
display.stage.addChild(this);
display.stage.focus = this;
this.setEvents();
}
private function resize() : void {
var local1:int = Math.max(this._labelOne.width + 2 * GAP_AROUND,this._labelTwo.width + 2 * GAP_AROUND);
this._bgWindow.width = Math.max(local1,this._buttonNo.width + this._buttonYes.width + GAP_BETWEEN_BUTTON + 2 * GAP_AROUND);
this._bgWindow.x = -int(this._bgWindow.width / 2);
this._labelOne.x = -int(this._labelOne.width / 2);
this._labelTwo.x = -int(this._labelTwo.width / 2);
this._labelTwo.y = this._labelOne.y + this._labelOne.height;
this._buttonYes.y = this._labelTwo.y + this._labelTwo.height + GAP_BETWEEN_LABEL_AND_BUTTON;
this._buttonNo.y = this._labelTwo.y + this._labelTwo.height + GAP_BETWEEN_LABEL_AND_BUTTON;
this._buttonYes.x = -this._buttonYes.width - GAP_BETWEEN_BUTTON / 2;
this._buttonNo.x = GAP_BETWEEN_BUTTON / 2;
this._bgWindow.height = this._buttonNo.y + this._buttonNo.height + GAP_AROUND;
this.x = display.stage.stageWidth >> 1;
this.y = display.stage.stageHeight - this.height >> 1;
}
private function setEvents() : void {
this._buttonYes.addEventListener(MouseEvent.CLICK,this.onYesClick);
this._buttonNo.addEventListener(MouseEvent.CLICK,this.onNoClick);
display.stage.addEventListener(Event.RESIZE,this.onStageResize);
display.stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUpThis);
}
private function onNoClick(param1:MouseEvent = null) : void {
dispatchEvent(new NotificationEndsPausedAlertEvent(NotificationEndsPausedAlertEvent.CLOSE_ALERT));
}
private function onYesClick(param1:MouseEvent = null) : void {
dispatchEvent(new NotificationEndsPausedAlertEvent(NotificationEndsPausedAlertEvent.RETURN_TO_BATTLE));
}
private function onStageResize(param1:Event) : void {
this.resize();
}
private function onKeyUpThis(param1:KeyboardEvent) : void {
if(AlertUtils.isCancelKey(param1.keyCode)) {
param1.stopImmediatePropagation();
this.onNoClick();
}
if(AlertUtils.isConfirmationKey(param1.keyCode)) {
param1.stopImmediatePropagation();
this.onYesClick();
}
}
public function destroy() : void {
this.removeEvents();
blurService.unblurAllContent();
removeDisplayObject(this);
this._bgWindow = null;
this._buttonYes = null;
this._buttonNo = null;
this._labelOne = null;
this._labelTwo = null;
}
private function removeEvents() : void {
this._buttonYes.removeEventListener(MouseEvent.CLICK,this.onYesClick);
this._buttonNo.removeEventListener(MouseEvent.CLICK,this.onNoClick);
display.stage.removeEventListener(Event.RESIZE,this.onStageResize);
display.stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUpThis);
}
}
}
|
package projects.tanks.client.clans.clan.clanfriends {
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 ClanFriendsModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ClanFriendsModelServer(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.models.effects.description {
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.EffectActivatedEvent;
import alternativa.tanks.battle.events.EffectStoppedEvent;
import alternativa.tanks.models.battle.gui.inventory.InventorySoundService;
import alternativa.tanks.models.effects.activeafetrdeath.IActiveAfterDeath;
import alternativa.tanks.models.effects.durationTime.IDuration;
import alternativa.tanks.models.effects.effectlevel.IEffectLevel;
import alternativa.tanks.models.inventory.InventoryItemType;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.ultimate.IUltimateModel;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.battlefield.models.effects.description.EffectCategory;
import projects.tanks.client.battlefield.models.effects.description.EffectDescriptionCC;
import projects.tanks.client.battlefield.models.effects.description.EffectDescriptionModelBase;
import projects.tanks.client.battlefield.models.effects.description.IEffectDescriptionModelBase;
[ModelInfo]
public class EffectDescriptionModel extends EffectDescriptionModelBase implements IEffectDescriptionModelBase, ObjectUnloadListener {
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var inventorySoundService:InventorySoundService;
public function EffectDescriptionModel() {
super();
}
[Obfuscation(rename="false")]
public function objectUnloaded() : void {
this.deactivated();
}
public function merged(param1:int) : void {
if(getInitParam().category == EffectCategory.OVERDRIVE) {
this.ultimateEffectMerged(param1);
} else {
this.deactivateIcon();
this.activateIcon(param1);
}
}
public function activated(param1:int) : void {
inventorySoundService.playActivationSound(getInitParam().tank,getInitParam().index);
if(getInitParam().category == EffectCategory.OVERDRIVE) {
this.ultimateEffectActivated(param1);
} else {
this.activateIcon(param1);
}
}
public function deactivated() : void {
var local1:ITankModel = ITankModel(getInitParam().tank.adapt(ITankModel));
if(local1.isLocal()) {
inventorySoundService.playDeactivationSound(getInitParam().index);
}
if(getInitParam().category == EffectCategory.OVERDRIVE) {
this.ultimateEffectDeactivated();
} else {
this.deactivateIcon();
}
}
private function activateIcon(param1:int) : void {
var local2:Boolean = getInitParam().category == EffectCategory.INVENTORY;
var local3:EffectDescriptionCC = getInitParam();
var local4:Boolean = this.getActiveAfterDeath();
var local5:int = !!object.hasModel(IEffectLevel) ? int(IEffectLevel(object.adapt(IEffectLevel)).getEffectLevel()) : 0;
var local6:Boolean = !!object.hasModel(IDuration) ? Boolean(IDuration(object.adapt(IDuration)).isInfinite()) : false;
battleEventDispatcher.dispatchEvent(new EffectActivatedEvent(local3.tank.id,local3.index,param1,local2,local4,local5,local6));
}
private function deactivateIcon() : void {
var local1:EffectDescriptionCC = getInitParam();
var local2:Boolean = this.getActiveAfterDeath();
if(local1.index != InventoryItemType.ULTIMATE) {
battleEventDispatcher.dispatchEvent(new EffectStoppedEvent(local1.tank.id,local1.index,local2));
}
}
private function ultimateEffectActivated(param1:int) : void {
var local3:IUltimateModel = null;
var local2:ITankModel = ITankModel(getInitParam().tank.adapt(ITankModel));
if(local2.isLocal()) {
local3 = IUltimateModel(getInitParam().tank.adapt(IUltimateModel));
local3.effectActivatedOrMerged(param1);
}
}
private function ultimateEffectMerged(param1:int) : void {
var local3:IUltimateModel = null;
var local2:ITankModel = ITankModel(getInitParam().tank.adapt(ITankModel));
if(local2.isLocal()) {
local3 = IUltimateModel(getInitParam().tank.adapt(IUltimateModel));
local3.effectActivatedOrMerged(param1);
}
}
private function ultimateEffectDeactivated() : void {
var local2:IUltimateModel = null;
var local1:ITankModel = ITankModel(getInitParam().tank.adapt(ITankModel));
if(local1.isLocal()) {
local2 = IUltimateModel(getInitParam().tank.adapt(IUltimateModel));
local2.effectDeactivated();
}
}
private function getActiveAfterDeath() : Boolean {
return Boolean(object.hasModel(IActiveAfterDeath)) && Boolean(IActiveAfterDeath(object.adapt(IActiveAfterDeath)).isEnabled());
}
}
}
|
package alternativa.tanks.gui {
import controls.base.DefaultButtonBase;
import flash.events.MouseEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class ThanksForConfirmationEmailWindow extends EmailReminderWindow {
public function ThanksForConfirmationEmailWindow() {
super();
addCautionImage(confirmEmailReminderBitmapData);
addCautionLabel(localeService.getText(TanksLocale.TEXT_ALERT_CRYSTALS_ADDED_FOR_CONFIRMED_EMAIL));
this.addCloseButton();
setWindowSize();
show();
}
private function addCloseButton() : void {
closeButton = new DefaultButtonBase();
closeButton.label = localeService.getText(TanksLocale.TEXT_CLOSE_LABEL);
closeButton.x = WINDOW_WIDTH - WINDOW_MARGIN - closeButton.width;
closeButton.y = labelInnerWindow.y + labelInnerWindow.height + GAP;
closeButton.addEventListener(MouseEvent.CLICK,this.onCloseButtonClick);
window.addChild(closeButton);
}
override protected function onCloseButtonClick(param1:MouseEvent = null) : void {
closeButton.removeEventListener(MouseEvent.CLICK,this.onCloseButtonClick);
dispatchEvent(new EnterEmailReminderWindowEvent(EnterEmailReminderWindowEvent.WINDOW_CLOSING));
dialogService.removeDialog(this);
}
override protected function confirmationKeyPressed() : void {
this.onCloseButtonClick();
}
}
}
|
package alternativa.engine3d.animation.keys {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.animation.AnimationState;
import flash.geom.Matrix3D;
import flash.geom.Orientation3D;
import flash.geom.Vector3D;
use namespace alternativa3d;
public class TransformTrack extends Track {
private static var tempQuat:Vector3D = new Vector3D();
private static var temp:TransformKey = new TransformKey();
private var keyList:TransformKey;
public function TransformTrack(param1:String) {
super();
this.object = param1;
}
override alternativa3d function get keyFramesList() : Keyframe {
return this.keyList;
}
override alternativa3d function set keyFramesList(param1:Keyframe) : void {
this.keyList = TransformKey(param1);
}
public function addKey(param1:Number, param2:Matrix3D) : TransformKey {
var local3:TransformKey = null;
local3 = new TransformKey();
local3.alternativa3d::_time = param1;
var local4:Vector.<Vector3D> = param2.decompose(Orientation3D.QUATERNION);
local3.alternativa3d::x = local4[0].x;
local3.alternativa3d::y = local4[0].y;
local3.alternativa3d::z = local4[0].z;
local3.alternativa3d::rotation = local4[1];
local3.alternativa3d::scaleX = local4[2].x;
local3.alternativa3d::scaleY = local4[2].y;
local3.alternativa3d::scaleZ = local4[2].z;
alternativa3d::addKeyToList(local3);
return local3;
}
public function addKeyComponents(param1:Number, param2:Number = 0, param3:Number = 0, param4:Number = 0, param5:Number = 0, param6:Number = 0, param7:Number = 0, param8:Number = 1, param9:Number = 1, param10:Number = 1) : TransformKey {
var local11:TransformKey = new TransformKey();
local11.alternativa3d::_time = param1;
local11.alternativa3d::x = param2;
local11.alternativa3d::y = param3;
local11.alternativa3d::z = param4;
local11.alternativa3d::rotation = this.createQuatFromEuler(param5,param6,param7);
local11.alternativa3d::scaleX = param8;
local11.alternativa3d::scaleY = param9;
local11.alternativa3d::scaleZ = param10;
alternativa3d::addKeyToList(local11);
return local11;
}
private function appendQuat(param1:Vector3D, param2:Vector3D) : void {
var local3:Number = param2.w * param1.w - param2.x * param1.x - param2.y * param1.y - param2.z * param1.z;
var local4:Number = param2.w * param1.x + param2.x * param1.w + param2.y * param1.z - param2.z * param1.y;
var local5:Number = param2.w * param1.y + param2.y * param1.w + param2.z * param1.x - param2.x * param1.z;
var local6:Number = param2.w * param1.z + param2.z * param1.w + param2.x * param1.y - param2.y * param1.x;
param1.w = local3;
param1.x = local4;
param1.y = local5;
param1.z = local6;
}
private function normalizeQuat(param1:Vector3D) : void {
var local2:Number = param1.w * param1.w + param1.x * param1.x + param1.y * param1.y + param1.z * param1.z;
if(local2 == 0) {
param1.w = 1;
} else {
local2 = 1 / Math.sqrt(local2);
param1.w *= local2;
param1.x *= local2;
param1.y *= local2;
param1.z *= local2;
}
}
private function setQuatFromAxisAngle(param1:Vector3D, param2:Number, param3:Number, param4:Number, param5:Number) : void {
param1.w = Math.cos(0.5 * param5);
var local6:Number = Math.sin(0.5 * param5) / Math.sqrt(param2 * param2 + param3 * param3 + param4 * param4);
param1.x = param2 * local6;
param1.y = param3 * local6;
param1.z = param4 * local6;
}
private function createQuatFromEuler(param1:Number, param2:Number, param3:Number) : Vector3D {
var local4:Vector3D = new Vector3D();
this.setQuatFromAxisAngle(local4,1,0,0,param1);
this.setQuatFromAxisAngle(tempQuat,0,1,0,param2);
this.appendQuat(local4,tempQuat);
this.normalizeQuat(local4);
this.setQuatFromAxisAngle(tempQuat,0,0,1,param3);
this.appendQuat(local4,tempQuat);
this.normalizeQuat(local4);
return local4;
}
override alternativa3d function blend(param1:Number, param2:Number, param3:AnimationState) : void {
var local4:TransformKey = null;
var local5:TransformKey = this.keyList;
while(local5 != null && local5.alternativa3d::_time < param1) {
local4 = local5;
local5 = local5.alternativa3d::next;
}
if(local4 != null) {
if(local5 != null) {
temp.interpolate(local4,local5,(param1 - local4.alternativa3d::_time) / (local5.alternativa3d::_time - local4.alternativa3d::_time));
param3.addWeightedTransform(temp,param2);
} else {
param3.addWeightedTransform(local4,param2);
}
} else if(local5 != null) {
param3.addWeightedTransform(local5,param2);
}
}
override alternativa3d function createKeyFrame() : Keyframe {
return new TransformKey();
}
override alternativa3d function interpolateKeyFrame(param1:Keyframe, param2:Keyframe, param3:Keyframe, param4:Number) : void {
TransformKey(param1).interpolate(TransformKey(param2),TransformKey(param3),param4);
}
override public function slice(param1:Number, param2:Number = 1.7976931348623157e+308) : Track {
var local3:TransformTrack = new TransformTrack(object);
alternativa3d::sliceImplementation(local3,param1,param2);
return local3;
}
}
}
|
package alternativa.tanks.models.dom.sfx
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class AllBeamProperties_redRayTip extends BitmapAsset
{
public function AllBeamProperties_redRayTip()
{
super();
}
}
}
|
package projects.tanks.client.battleselect.osgi {
import _codec.projects.tanks.client.battleselect.model.battle.CodecBattleInfoCC;
import _codec.projects.tanks.client.battleselect.model.battle.VectorCodecBattleInfoCCLevel1;
import _codec.projects.tanks.client.battleselect.model.battle.dm.CodecBattleDMInfoCC;
import _codec.projects.tanks.client.battleselect.model.battle.dm.VectorCodecBattleDMInfoCCLevel1;
import _codec.projects.tanks.client.battleselect.model.battle.entrance.user.CodecBattleInfoUser;
import _codec.projects.tanks.client.battleselect.model.battle.entrance.user.VectorCodecBattleInfoUserLevel1;
import _codec.projects.tanks.client.battleselect.model.battle.param.CodecBattleParamInfoCC;
import _codec.projects.tanks.client.battleselect.model.battle.param.VectorCodecBattleParamInfoCCLevel1;
import _codec.projects.tanks.client.battleselect.model.battle.team.CodecTeamBattleInfoCC;
import _codec.projects.tanks.client.battleselect.model.battle.team.VectorCodecTeamBattleInfoCCLevel1;
import _codec.projects.tanks.client.battleselect.model.battleselect.create.CodecBattleCreateCC;
import _codec.projects.tanks.client.battleselect.model.battleselect.create.VectorCodecBattleCreateCCLevel1;
import _codec.projects.tanks.client.battleselect.model.map.CodecMapInfoCC;
import _codec.projects.tanks.client.battleselect.model.map.VectorCodecMapInfoCCLevel1;
import _codec.projects.tanks.client.battleselect.model.matchmaking.group.invitewindow.CodecMatchMakingUserInfo;
import _codec.projects.tanks.client.battleselect.model.matchmaking.group.invitewindow.VectorCodecMatchMakingUserInfoLevel1;
import _codec.projects.tanks.client.battleselect.model.matchmaking.group.notify.CodecMatchmakingGroupCC;
import _codec.projects.tanks.client.battleselect.model.matchmaking.group.notify.CodecMatchmakingUserData;
import _codec.projects.tanks.client.battleselect.model.matchmaking.group.notify.CodecMountItemsUserData;
import _codec.projects.tanks.client.battleselect.model.matchmaking.group.notify.VectorCodecMatchmakingGroupCCLevel1;
import _codec.projects.tanks.client.battleselect.model.matchmaking.group.notify.VectorCodecMatchmakingUserDataLevel1;
import _codec.projects.tanks.client.battleselect.model.matchmaking.group.notify.VectorCodecMountItemsUserDataLevel1;
import _codec.projects.tanks.client.battleselect.model.matchmaking.modes.CodecMatchmakingModeRank;
import _codec.projects.tanks.client.battleselect.model.matchmaking.modes.VectorCodecMatchmakingModeRankLevel1;
import _codec.projects.tanks.client.battleselect.model.matchmaking.queue.CodecMatchmakingMode;
import _codec.projects.tanks.client.battleselect.model.matchmaking.queue.VectorCodecMatchmakingModeLevel1;
import _codec.projects.tanks.client.battleselect.model.matchmaking.view.CodecMatchmakingLayoutCC;
import _codec.projects.tanks.client.battleselect.model.matchmaking.view.VectorCodecMatchmakingLayoutCCLevel1;
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.client.battleselect.model.battle.BattleInfoCC;
import projects.tanks.client.battleselect.model.battle.dm.BattleDMInfoCC;
import projects.tanks.client.battleselect.model.battle.entrance.user.BattleInfoUser;
import projects.tanks.client.battleselect.model.battle.param.BattleParamInfoCC;
import projects.tanks.client.battleselect.model.battle.team.TeamBattleInfoCC;
import projects.tanks.client.battleselect.model.battleselect.create.BattleCreateCC;
import projects.tanks.client.battleselect.model.map.MapInfoCC;
import projects.tanks.client.battleselect.model.matchmaking.group.invitewindow.MatchMakingUserInfo;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.MatchmakingGroupCC;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.MatchmakingUserData;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.MountItemsUserData;
import projects.tanks.client.battleselect.model.matchmaking.modes.MatchmakingModeRank;
import projects.tanks.client.battleselect.model.matchmaking.queue.MatchmakingMode;
import projects.tanks.client.battleselect.model.matchmaking.view.MatchmakingLayoutCC;
public class Activator implements IBundleActivator {
public static var osgi:OSGi;
public function Activator() {
super();
}
public function start(param1:OSGi) : void {
var local4:ICodec = null;
osgi = param1;
var local2:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local2.register(Long.getLong(678248814,-1039722970),Long.getLong(1723702817,-1559950205));
local2.register(Long.getLong(678248814,-1039722970),Long.getLong(2079393446,1872275759));
local2.register(Long.getLong(678248814,-1039722970),Long.getLong(1595490780,1527833154));
local2.register(Long.getLong(678248814,-1039722970),Long.getLong(1955622129,800057322));
local2.register(Long.getLong(678248814,-1039722970),Long.getLong(1794766139,-788021385));
local2.register(Long.getLong(678248814,-1039722970),Long.getLong(571437576,1704127087));
local2.register(Long.getLong(231608534,1754662850),Long.getLong(1280686572,-165446809));
local2.register(Long.getLong(231608534,1754662850),Long.getLong(739099814,-1836001986));
local2.register(Long.getLong(231608534,1754662850),Long.getLong(1545032099,1699072587));
local2.register(Long.getLong(124040719,-2122162804),Long.getLong(1427344653,-225635033));
local2.register(Long.getLong(124040719,-2122162804),Long.getLong(1971172597,1526425495));
local2.register(Long.getLong(124040719,-2122162804),Long.getLong(1465029547,1591202968));
local2.register(Long.getLong(1548819686,-690668258),Long.getLong(1082637975,-979180615));
local2.register(Long.getLong(1548819686,-690668258),Long.getLong(1958615472,-14223454));
local2.register(Long.getLong(1548819686,-690668258),Long.getLong(1033012780,-1733683120));
local2.register(Long.getLong(1548819686,-690668258),Long.getLong(344688414,904593895));
local2.register(Long.getLong(1548819686,-690668258),Long.getLong(344688125,389346965));
local2.register(Long.getLong(600945976,725191480),Long.getLong(1673040790,-1477360154));
local2.register(Long.getLong(600945976,725191480),Long.getLong(1230896613,-954387929));
local2.register(Long.getLong(2006601986,1009878384),Long.getLong(197885668,-2032708814));
local2.register(Long.getLong(2006601986,1009878384),Long.getLong(1756028652,-1657837994));
local2.register(Long.getLong(2006601986,1009878384),Long.getLong(872763403,679070993));
local2.register(Long.getLong(2006601986,1009878384),Long.getLong(1102481331,-1022378385));
local2.register(Long.getLong(2006601986,1009878384),Long.getLong(1263225061,56978839));
local2.register(Long.getLong(443203981,347316300),Long.getLong(64042174,-63295164));
local2.register(Long.getLong(443203981,347316300),Long.getLong(1229034573,1475867490));
local2.register(Long.getLong(24345264,-1141305498),Long.getLong(457644934,1356384143));
local2.register(Long.getLong(24345264,-1141305498),Long.getLong(1473935785,1650079766));
local2.register(Long.getLong(24345264,-1141305498),Long.getLong(796961862,-1942684603));
local2.register(Long.getLong(24345264,-1141305498),Long.getLong(907288320,709901878));
local2.register(Long.getLong(24345264,-1141305498),Long.getLong(1710113617,1839810627));
local2.register(Long.getLong(1554280211,1562501796),Long.getLong(1122035593,599020768));
local2.register(Long.getLong(1554280211,1562501796),Long.getLong(490134730,1080398833));
local2.register(Long.getLong(1554280211,1562501796),Long.getLong(473112343,1371826939));
local2.register(Long.getLong(1554280211,1562501796),Long.getLong(374808837,1597389024));
local2.register(Long.getLong(1554280211,1562501796),Long.getLong(1122035483,-939007991));
local2.register(Long.getLong(1554280211,1562501796),Long.getLong(239302436,-1286419946));
local2.register(Long.getLong(1668041838,-577067222),Long.getLong(1292268413,1208036615));
local2.register(Long.getLong(1668041838,-577067222),Long.getLong(930952614,-2058633481));
local2.register(Long.getLong(1668041838,-577067222),Long.getLong(1706073111,946529251));
local2.register(Long.getLong(2143871783,-1643323062),Long.getLong(57273342,86368579));
local2.register(Long.getLong(1381232317,979335603),Long.getLong(684570251,-10047503));
local2.register(Long.getLong(1381232317,979335603),Long.getLong(741085905,-1689593046));
var local3:IProtocol = IProtocol(osgi.getService(IProtocol));
local4 = new CodecBattleInfoCC();
local3.registerCodec(new TypeCodecInfo(BattleInfoCC,false),local4);
local3.registerCodec(new TypeCodecInfo(BattleInfoCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecBattleDMInfoCC();
local3.registerCodec(new TypeCodecInfo(BattleDMInfoCC,false),local4);
local3.registerCodec(new TypeCodecInfo(BattleDMInfoCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecBattleInfoUser();
local3.registerCodec(new TypeCodecInfo(BattleInfoUser,false),local4);
local3.registerCodec(new TypeCodecInfo(BattleInfoUser,true),new OptionalCodecDecorator(local4));
local4 = new CodecBattleParamInfoCC();
local3.registerCodec(new TypeCodecInfo(BattleParamInfoCC,false),local4);
local3.registerCodec(new TypeCodecInfo(BattleParamInfoCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecTeamBattleInfoCC();
local3.registerCodec(new TypeCodecInfo(TeamBattleInfoCC,false),local4);
local3.registerCodec(new TypeCodecInfo(TeamBattleInfoCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecBattleCreateCC();
local3.registerCodec(new TypeCodecInfo(BattleCreateCC,false),local4);
local3.registerCodec(new TypeCodecInfo(BattleCreateCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecMapInfoCC();
local3.registerCodec(new TypeCodecInfo(MapInfoCC,false),local4);
local3.registerCodec(new TypeCodecInfo(MapInfoCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecMatchMakingUserInfo();
local3.registerCodec(new TypeCodecInfo(MatchMakingUserInfo,false),local4);
local3.registerCodec(new TypeCodecInfo(MatchMakingUserInfo,true),new OptionalCodecDecorator(local4));
local4 = new CodecMatchmakingGroupCC();
local3.registerCodec(new TypeCodecInfo(MatchmakingGroupCC,false),local4);
local3.registerCodec(new TypeCodecInfo(MatchmakingGroupCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecMatchmakingUserData();
local3.registerCodec(new TypeCodecInfo(MatchmakingUserData,false),local4);
local3.registerCodec(new TypeCodecInfo(MatchmakingUserData,true),new OptionalCodecDecorator(local4));
local4 = new CodecMountItemsUserData();
local3.registerCodec(new TypeCodecInfo(MountItemsUserData,false),local4);
local3.registerCodec(new TypeCodecInfo(MountItemsUserData,true),new OptionalCodecDecorator(local4));
local4 = new CodecMatchmakingModeRank();
local3.registerCodec(new TypeCodecInfo(MatchmakingModeRank,false),local4);
local3.registerCodec(new TypeCodecInfo(MatchmakingModeRank,true),new OptionalCodecDecorator(local4));
local4 = new CodecMatchmakingMode();
local3.registerCodec(new EnumCodecInfo(MatchmakingMode,false),local4);
local3.registerCodec(new EnumCodecInfo(MatchmakingMode,true),new OptionalCodecDecorator(local4));
local4 = new CodecMatchmakingLayoutCC();
local3.registerCodec(new TypeCodecInfo(MatchmakingLayoutCC,false),local4);
local3.registerCodec(new TypeCodecInfo(MatchmakingLayoutCC,true),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleInfoCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleInfoCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleInfoCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleInfoCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleInfoCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleInfoCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleDMInfoCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleDMInfoCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleDMInfoCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleDMInfoCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleDMInfoCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleDMInfoCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleInfoUserLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleInfoUser,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleInfoUser,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleInfoUserLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleInfoUser,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleInfoUser,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleParamInfoCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleParamInfoCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleParamInfoCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleParamInfoCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleParamInfoCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleParamInfoCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecTeamBattleInfoCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(TeamBattleInfoCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(TeamBattleInfoCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecTeamBattleInfoCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(TeamBattleInfoCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(TeamBattleInfoCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleCreateCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleCreateCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleCreateCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecBattleCreateCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleCreateCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleCreateCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMapInfoCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MapInfoCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MapInfoCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMapInfoCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MapInfoCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MapInfoCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchMakingUserInfoLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchMakingUserInfo,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchMakingUserInfo,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchMakingUserInfoLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchMakingUserInfo,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchMakingUserInfo,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchmakingGroupCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingGroupCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingGroupCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchmakingGroupCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingGroupCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingGroupCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchmakingUserDataLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingUserData,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingUserData,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchmakingUserDataLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingUserData,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingUserData,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMountItemsUserDataLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MountItemsUserData,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MountItemsUserData,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMountItemsUserDataLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MountItemsUserData,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MountItemsUserData,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchmakingModeRankLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingModeRank,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingModeRank,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchmakingModeRankLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingModeRank,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingModeRank,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchmakingModeLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(MatchmakingMode,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(MatchmakingMode,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchmakingModeLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(MatchmakingMode,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(MatchmakingMode,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchmakingLayoutCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingLayoutCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingLayoutCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecMatchmakingLayoutCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingLayoutCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(MatchmakingLayoutCC,true),true,1),new OptionalCodecDecorator(local4));
}
public function stop(param1:OSGi) : void {
}
}
}
|
package alternativa {
import flash.display.MovieClip;
public class Alternativa3D extends MovieClip {
public static const version:String = "7.11.0";
public function Alternativa3D() {
super();
}
}
}
|
package projects.tanks.client.garage.models.shopabonement {
import projects.tanks.client.commons.types.ShopCategoryEnum;
public class ShopAbonementCC {
private var _shopCategory:ShopCategoryEnum;
public function ShopAbonementCC(param1:ShopCategoryEnum = null) {
super();
this._shopCategory = param1;
}
public function get shopCategory() : ShopCategoryEnum {
return this._shopCategory;
}
public function set shopCategory(param1:ShopCategoryEnum) : void {
this._shopCategory = param1;
}
public function toString() : String {
var local1:String = "ShopAbonementCC [";
local1 += "shopCategory = " + this.shopCategory + " ";
return local1 + "]";
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.flamethrower {
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.flamethrower.FlameThrowerCC;
public class VectorCodecFlameThrowerCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecFlameThrowerCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(FlameThrowerCC,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.<FlameThrowerCC> = new Vector.<FlameThrowerCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = FlameThrowerCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:FlameThrowerCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<FlameThrowerCC> = Vector.<FlameThrowerCC>(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 {
import assets.combo.ComboUpButton;
[Embed(source="/_assets/assets.swf", symbol="symbol570")]
public dynamic class ComboBox_upSkin extends ComboUpButton {
public function ComboBox_upSkin() {
super();
}
}
}
|
package alternativa.tanks.models.dom.cp
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ControlPointSprite_redC extends BitmapAsset
{
public function ControlPointSprite_redC()
{
super();
}
}
}
|
package assets.icons {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol966")]
public class CheckIcons extends MovieClip {
public static const FRIENDLY_FIRE:int = 1;
public static const INVITE_ONLY:int = 2;
public static const AUTO_BALANCE:int = 3;
public static const CHECK_SIGN:int = 4;
public function CheckIcons() {
super();
this.type = CHECK_SIGN;
}
public function set type(param1:int) : void {
gotoAndStop(param1);
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.healing {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.EnumCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.weapon.healing.IsisState;
public class VectorCodecIsisStateLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecIsisStateLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(IsisState,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.<IsisState> = new Vector.<IsisState>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = IsisState(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:IsisState = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<IsisState> = Vector.<IsisState>(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.device {
import flash.events.Event;
public class DevicesLoadedEvent extends Event {
public static const DEVICES_LOADED:String = "DEVICES_LOADED";
public function DevicesLoadedEvent() {
super(DEVICES_LOADED);
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.members.ClanMembersList;
import alternativa.tanks.gui.components.button.ClanButtonActionListener;
import alternativa.tanks.gui.components.button.ClanIncomingRequestsButton;
import alternativa.tanks.models.clan.ClanModel;
import alternativa.tanks.models.clan.accepted.IClanAcceptedModel;
import alternativa.tanks.models.clan.membersdata.ClanMembersDataService;
import alternativa.tanks.models.service.ClanNotificationsManager;
import alternativa.tanks.models.service.ClanService;
import alternativa.tanks.service.clan.ClanMembersListEvent;
import alternativa.types.Long;
import base.DiscreteSprite;
import controls.TankWindow;
import controls.windowinner.WindowInner;
import flash.events.Event;
import flash.events.MouseEvent;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.AlertServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanFunctionsService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoService;
public class ClanUsersWindow extends DiscreteSprite {
[Inject]
public static var userInfoService:IUserInfoService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var clanService:ClanService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var clanFunctionsService:ClanFunctionsService;
[Inject]
public static var clanMembersData:ClanMembersDataService;
private static var currentUserId:Long;
private static var userIdToExclude:Long;
private static const MARGIN:int = 11;
private static const FRAME:int = 7;
private static const BUTTON_HEIGHT:int = 30;
private var usersInner:WindowInner;
private var usersWindow:TankWindow;
private var list:ClanMembersList;
private var outgoingButton:ClanButtonActionListener;
private var incomingButton:ClanIncomingRequestsButton;
private var _width:int;
private var _height:int;
private var clanObject:IGameObject;
public function ClanUsersWindow(param1:IGameObject) {
var local4:Long = null;
super();
this.clanObject = param1;
this.usersWindow = new TankWindow();
addChild(this.usersWindow);
this.usersInner = new WindowInner(this._width,this._height,WindowInner.GREEN);
this.usersInner.showBlink = true;
this.usersWindow.addChild(this.usersInner);
var local2:IClanAcceptedModel = IClanAcceptedModel(param1.adapt(IClanAcceptedModel));
this.list = new ClanMembersList();
var local3:Vector.<Object> = new Vector.<Object>();
for each(local4 in local2.getAcceptedUsers()) {
local3.push(clanMembersData.getClanMemberData(local4));
}
this.list.fillData(local3);
this.list.addEventListener(ClanMembersListEvent.REMOVE_USER,this.onRemoveUser);
this.usersInner.addChild(this.list);
this.outgoingButton = new ClanButtonActionListener(ClanAction.INVITE_TO_CLAN);
this.incomingButton = new ClanIncomingRequestsButton(this.outgoingButton,this);
this.outgoingButton.width = 120;
this.incomingButton.width = 120;
ClanActionsManager.addActionsUpdateListener(this.outgoingButton);
this.outgoingButton.label = localeService.getText(TanksLocale.TEXT_CLAN_INVITE);
this.outgoingButton.updateActions();
this.outgoingButton.addEventListener(MouseEvent.CLICK,this.onClickOutgoingButton);
addChild(this.outgoingButton);
ClanActionsManager.addActionsUpdateListener(this.incomingButton);
ClanNotificationsManager.addIncomingIndicatorListener(this.incomingButton);
this.incomingButton.label = localeService.getText(TanksLocale.TEXT_CLAN_INCOMING);
this.incomingButton.updateActions();
this.incomingButton.updateNotifications();
this.incomingButton.addEventListener(MouseEvent.CLICK,this.onClickIncomingButton);
addChild(this.incomingButton);
addEventListener(Event.ADDED_TO_STAGE,this.onAddResizeListener);
}
private static function getCurrentUserId() : Long {
if(currentUserId == null) {
currentUserId = userInfoService.getCurrentUserId();
}
return currentUserId;
}
private function onClickIncomingButton(param1:MouseEvent) : void {
new ClanIncomingRequestsDialog(this.clanObject);
}
private function onClickOutgoingButton(param1:MouseEvent) : void {
new ClanOutgoingRequestsDialog(this.clanObject);
}
private function onRemoveUser(param1:ClanMembersListEvent) : void {
if(param1.userId == getCurrentUserId()) {
alertService.showAlert(localeService.getText(TanksLocale.TEXT_CLAN_ALERT_LEAVE_CLAN),Vector.<String>([localeService.getText(TanksLocale.TEXT_FRIENDS_YES),localeService.getText(TanksLocale.TEXT_FRIENDS_CANCEL_BUTTON_TEXT)]));
alertService.addEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onClanLeavingConfirm);
} else {
alertService.showAlert(localeService.getText(TanksLocale.TEXT_CLAN_ALERT_REMOVE_PLAYER).replace(ClanModel.USER_NAME_PATTERN,param1.userUid),Vector.<String>([localeService.getText(TanksLocale.TEXT_FRIENDS_YES),localeService.getText(TanksLocale.TEXT_FRIENDS_CANCEL_BUTTON_TEXT)]));
alertService.addEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onExpelConfirm);
userIdToExclude = param1.userId;
}
}
private function onClanLeavingConfirm(param1:AlertServiceEvent) : void {
alertService.removeEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onClanLeavingConfirm);
if(param1.typeButton == localeService.getText(TanksLocale.TEXT_FRIENDS_YES)) {
clanFunctionsService.leave();
}
}
private function onExpelConfirm(param1:AlertServiceEvent) : void {
alertService.removeEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onExpelConfirm);
if(param1.typeButton == localeService.getText(TanksLocale.TEXT_FRIENDS_YES) && userIdToExclude != null) {
clanFunctionsService.exclude(userIdToExclude);
userIdToExclude = null;
}
}
private function onAddResizeListener(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.onAddResizeListener);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
stage.addEventListener(Event.RESIZE,this.onResize);
this.onResize();
}
private function onRemoveFromStage(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.onRemoveFromStage);
stage.removeEventListener(Event.RESIZE,this.onResize);
addEventListener(Event.ADDED_TO_STAGE,this.onAddResizeListener);
}
private function onResize(param1:Event = null) : void {
this.usersWindow.y = ClanTopManagementPanel.HEIGHT + MARGIN - 3;
this.usersWindow.width = this.width;
this.usersWindow.height = this.height - this.usersWindow.y;
this.usersInner.x = MARGIN;
this.usersInner.y = MARGIN;
this.usersInner.width = this.usersWindow.width - 2 * MARGIN;
this.usersInner.height = this.usersWindow.height - 2 * MARGIN - FRAME - BUTTON_HEIGHT;
this.list.x = 3;
this.list.y = 3;
this.list.width = this.usersInner.width - 6;
this.list.height = this.usersInner.height - 4;
this.incomingButton.x = this.width - this.incomingButton.width - MARGIN;
this.incomingButton.y = this.height - this.outgoingButton.height - MARGIN - 1;
this.outgoingButton.x = (this.incomingButton.visible ? this.incomingButton.x : this.width - MARGIN) - FRAME - this.outgoingButton.width;
this.outgoingButton.y = this.incomingButton.y;
}
override public function get width() : Number {
return this._width;
}
override public function set width(param1:Number) : void {
this._width = param1;
this.onResize();
}
override public function get height() : Number {
return this._height;
}
override public function set height(param1:Number) : void {
this._height = param1;
this.onResize();
}
public function addUser(param1:Long) : void {
this.list.addUser(clanMembersData.getClanMemberData(param1));
}
public function removeUser(param1:Long) : void {
this.list.removeUser(param1);
}
public function maxMembers() : void {
alertService.showOkAlert(localeService.getText(TanksLocale.TEXT_CLAN_ALERT_CLAN_FULL));
}
}
}
|
package alternativa.tanks.gui.buttons {
import controls.buttons.h50px.GreyBigButton;
import controls.labels.CountDownTimerLabel;
import controls.timer.CountDownTimer;
import controls.timer.CountDownTimerOnCompleteAfter;
import flash.filters.DropShadowFilter;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
public class TimerButton extends GreyBigButton implements CountDownTimerOnCompleteAfter {
private var timerLabel:CountDownTimerLabel;
private var timer:CountDownTimer;
public function TimerButton() {
super();
this.init();
}
private function init() : void {
this.timerLabel = new CountDownTimerLabel();
this.timerLabel.align = TextFormatAlign.CENTER;
this.timerLabel.autoSize = TextFieldAutoSize.NONE;
this.timerLabel.autoSize = TextFieldAutoSize.NONE;
this.timerLabel.selectable = false;
this.timerLabel.x = 2;
this.timerLabel.y = 25;
this.timerLabel.height = 24;
this.timerLabel.size = 14;
this.timerLabel.mouseEnabled = false;
this.timerLabel.filters = [new DropShadowFilter(1,45,0,0.7,1,1,1)];
addChild(this.timerLabel);
this.timerLabel.visible = false;
}
public function startTimer(param1:CountDownTimer) : void {
enabled = false;
this.timer = param1;
if(param1.getRemainingSeconds() > 0) {
this.showTime();
param1.addListener(CountDownTimerOnCompleteAfter,this);
}
}
private function showTime() : void {
this.timerLabel.width = int(width) - 4;
this.timerLabel.visible = true;
this.timerLabel.start(this.timer);
this.resize();
}
private function resize() : void {
if(this.timerLabel.visible) {
_label.y = 8;
} else {
_label.y = 15;
}
}
public function hideTime() : void {
if(this.timer != null) {
this.timer.removeListener(CountDownTimerOnCompleteAfter,this);
this.timer = null;
}
this.timerLabel.visible = false;
this.timerLabel.stop();
this.resize();
}
public function onCompleteAfter(param1:CountDownTimer, param2:Boolean) : void {
this.hideTime();
dispatchEvent(new TimerButtonEvent(TimerButtonEvent.TIME_ON_COMPLETE_TIMER_BUTTON));
}
}
}
|
package alternativa.tanks.models.tank.gearscore {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class GearScoreInfoAdapt implements GearScoreInfo {
private var object:IGameObject;
private var impl:GearScoreInfo;
public function GearScoreInfoAdapt(param1:IGameObject, param2:GearScoreInfo) {
super();
this.object = param1;
this.impl = param2;
}
public function getScore() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getScore());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.bigbutton_UP_LEFT.png")]
public dynamic class bigbutton_UP_LEFT extends BitmapData {
public function bigbutton_UP_LEFT(param1:int = 7, param2:int = 50) {
super(param1,param2);
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p14 extends BitmapAsset
{
public function RangsIcon_p14()
{
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank06.png")]
public class PremiumRankBitmaps_bitmapBigRank06 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank06() {
super();
}
}
}
|
package alternativa.tanks.view.forms.freeuids {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import controls.base.LabelBase;
import controls.dropdownlist.DPLBackground;
import flash.display.Sprite;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.ui.Keyboard;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class FreeUidsForm extends Sprite {
[Inject]
public static var display:IDisplay;
[Inject]
public static var localeService:ILocaleService;
public static const DEFAULT_WIDTH:int = 200;
public static const BGD_HEIGHT:int = 137;
public static const LABEL_POS_X:int = 6;
public static const LABEL_POS_Y:int = 3;
public static const ITEM_POS_Y:int = 36;
private var _background:DPLBackground;
private var _label:LabelBase;
private var _items:Array;
private var _selectedItemIndex:int = -1;
private var _width:int = 200;
public function FreeUidsForm() {
super();
this.init();
}
private function init() : void {
this.visible = false;
this._items = [];
this._background = new DPLBackground(this._width,BGD_HEIGHT);
addChild(this._background);
this._label = new LabelBase();
this._label.width = this._width;
this._label.text = localeService.getText(TanksLocale.TEXT_FREE_UIDS_FORM_HEADER);
this._label.x = LABEL_POS_X;
this._label.y = LABEL_POS_Y;
addChild(this._label);
}
public function create(param1:Vector.<String>) : void {
var local4:FreeUidsFormRender = null;
this.destroy();
var local2:int = int(param1.length);
var local3:int = 0;
while(local3 < local2) {
local4 = new FreeUidsFormRender(this._width,local3,param1[local3]);
if(local3 == 0) {
local4.y = ITEM_POS_Y;
} else {
local4.y = this._items[local3 - 1].y + this._items[local3 - 1].height;
}
local4.addEventListener(MouseEvent.ROLL_OVER,this.onRollOverItem);
local4.addEventListener(MouseEvent.ROLL_OUT,this.onRollOutItem);
local4.addEventListener(MouseEvent.CLICK,this.onClickItem);
addChild(local4);
this._items.push(local4);
local3++;
}
this.selectedItemIndex = 0;
this.show();
}
private function onRollOverItem(param1:MouseEvent) : void {
this.selectedItemIndex = FreeUidsFormRender(param1.currentTarget).index;
}
private function onRollOutItem(param1:MouseEvent) : void {
this.resetCurrentSelectedItem();
}
private function onClickItem(param1:MouseEvent) : void {
var local2:FreeUidsFormEvent = new FreeUidsFormEvent(FreeUidsFormEvent.CLICK_ITEM);
local2.uid = FreeUidsFormRender(param1.currentTarget).uid;
dispatchEvent(local2);
}
public function destroy() : void {
var local3:FreeUidsFormRender = null;
this.hide();
var local1:int = int(this._items.length);
var local2:int = 0;
while(local2 < local1) {
local3 = this._items[local2];
local3.removeEventListener(MouseEvent.ROLL_OVER,this.onRollOverItem);
local3.removeEventListener(MouseEvent.ROLL_OUT,this.onRollOutItem);
local3.removeEventListener(MouseEvent.CLICK,this.onClickItem);
removeChild(local3);
local2++;
}
this._selectedItemIndex = -1;
this._items = [];
}
public function show() : void {
this.visible = true;
display.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
}
private function onKeyDown(param1:KeyboardEvent) : void {
var local2:FreeUidsFormEvent = null;
if(param1.keyCode == Keyboard.TAB || param1.keyCode == Keyboard.ESCAPE) {
dispatchEvent(new FreeUidsFormEvent(FreeUidsFormEvent.FOCUS_OUT));
}
if(param1.keyCode == Keyboard.DOWN) {
this.setSelectedNextItem();
}
if(param1.keyCode == Keyboard.UP) {
this.setSelectedPreviousItem();
}
if(param1.keyCode == Keyboard.ENTER && this.hasSelectedItem()) {
local2 = new FreeUidsFormEvent(FreeUidsFormEvent.CLICK_ITEM);
local2.uid = this._items[this._selectedItemIndex].uid;
dispatchEvent(local2);
}
}
private function setSelectedNextItem() : void {
if(this.hasSelectedItem()) {
++this.selectedItemIndex;
} else {
this.selectedItemIndex = 0;
}
}
private function setSelectedPreviousItem() : void {
if(this.hasSelectedItem()) {
--this.selectedItemIndex;
} else {
this.selectedItemIndex = this.getLastItemIndex();
}
}
public function hide() : void {
this.visible = false;
display.stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
}
public function get selectedItemIndex() : int {
return this._selectedItemIndex;
}
public function set selectedItemIndex(param1:int) : void {
if(this._items.length == 0 || this._selectedItemIndex == param1) {
return;
}
this.resetCurrentSelectedItem();
if(param1 > this.getLastItemIndex()) {
this._selectedItemIndex = 0;
} else {
this._selectedItemIndex = param1;
}
if(this._selectedItemIndex < 0) {
this._selectedItemIndex = this.getLastItemIndex();
}
this._items[this._selectedItemIndex].setSelected(true);
}
private function resetCurrentSelectedItem() : void {
if(this.hasSelectedItem()) {
this._items[this._selectedItemIndex].setSelected(false);
this._selectedItemIndex = -1;
}
}
private function hasSelectedItem() : Boolean {
return this._selectedItemIndex != -1;
}
private function getLastItemIndex() : int {
return this._items.length - 1;
}
override public function get width() : Number {
return this._width;
}
override public function set width(param1:Number) : void {
this._width = param1;
this._background.width = this._width;
this._label.width = this._width;
}
}
}
|
package alternativa.engine3d.materials {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Canvas;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import flash.display.BitmapData;
import flash.filters.ConvolutionFilter;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.utils.ByteArray;
use namespace alternativa3d;
public class TextureMaterial extends Material {
private static const filter:ConvolutionFilter = new ConvolutionFilter(2,2,[1,1,1,1],4,0,false,true);
private static const matrix:Matrix = new Matrix(0.5,0,0,0.5);
private static const rect:Rectangle = new Rectangle();
private static const point:Point = new Point();
alternativa3d static var drawVertices:Vector.<Number> = new Vector.<Number>();
alternativa3d static var drawUVTs:Vector.<Number> = new Vector.<Number>();
alternativa3d static var drawIndices:Vector.<int> = new Vector.<int>();
alternativa3d static var drawMatrix:Matrix = new Matrix();
public var diffuseMapURL:String;
public var opacityMapURL:String;
public var repeat:Boolean = false;
public var smooth:Boolean = true;
public var resolution:Number = 1;
public var threshold:Number = 0.01;
public var correctUV:Boolean = false;
alternativa3d var _texture:BitmapData;
alternativa3d var _textureATF:ByteArray;
alternativa3d var _textureATFAlpha:ByteArray;
alternativa3d var _mipMapping:int = 0;
alternativa3d var _hardwareMipMaps:Boolean = false;
alternativa3d var mipMap:Vector.<BitmapData>;
alternativa3d var numMaps:int = 0;
public function TextureMaterial(param1:BitmapData = null, param2:Boolean = false, param3:Boolean = true, param4:int = 0, param5:Number = 1) {
super();
this.alternativa3d::_texture = param1;
this.repeat = param2;
this.smooth = param3;
this.alternativa3d::_mipMapping = 0;
if(this.alternativa3d::_texture != null && this.alternativa3d::_mipMapping > 0) {
this.alternativa3d::calculateMipMaps();
}
this.resolution = param5;
}
public function get texture() : BitmapData {
return this.alternativa3d::_texture;
}
public function set texture(param1:BitmapData) : void {
if(param1 != this.alternativa3d::_texture) {
this.alternativa3d::_texture = param1;
this.alternativa3d::disposeMipMaps();
if(param1 != null && this.alternativa3d::_mipMapping > 0) {
this.alternativa3d::calculateMipMaps();
}
}
}
public function get textureATF() : ByteArray {
return this.alternativa3d::_textureATF;
}
public function set textureATF(param1:ByteArray) : void {
if(param1 != this.alternativa3d::_textureATF) {
this.alternativa3d::_textureATF = param1;
}
}
public function get textureATFAlpha() : ByteArray {
return this.alternativa3d::_textureATFAlpha;
}
public function set textureATFAlpha(param1:ByteArray) : void {
if(param1 != this.alternativa3d::_textureATFAlpha) {
this.alternativa3d::_textureATFAlpha = param1;
}
}
public function get mipMapping() : int {
return this.alternativa3d::_mipMapping;
}
public function set mipMapping(param1:int) : void {
}
public function get hardwareMipMaps() : Boolean {
return this.alternativa3d::_hardwareMipMaps;
}
public function set hardwareMipMaps(param1:Boolean) : void {
if(param1 != this.alternativa3d::_hardwareMipMaps) {
this.alternativa3d::_hardwareMipMaps = param1;
}
}
override public function clone() : Material {
var local1:TextureMaterial = new TextureMaterial(this.alternativa3d::_texture,this.repeat,this.smooth,this.alternativa3d::_mipMapping,this.resolution);
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Material) : void {
super.clonePropertiesFrom(param1);
var local2:TextureMaterial = param1 as TextureMaterial;
this.diffuseMapURL = local2.diffuseMapURL;
this.opacityMapURL = local2.opacityMapURL;
this.threshold = local2.threshold;
this.correctUV = local2.correctUV;
this.alternativa3d::_textureATF = local2.alternativa3d::_textureATF;
this.alternativa3d::_textureATFAlpha = local2.alternativa3d::_textureATFAlpha;
}
alternativa3d function disposeMipMaps() : void {
var local1:int = 1;
while(local1 < this.alternativa3d::numMaps) {
(this.alternativa3d::mipMap[local1] as BitmapData).dispose();
local1++;
}
this.alternativa3d::mipMap = null;
this.alternativa3d::numMaps = 0;
}
alternativa3d function calculateMipMaps() : void {
var local1:BitmapData = null;
var local4:int = 0;
var local5:int = 0;
var local6:BitmapData = null;
var local7:Number = NaN;
var local8:Number = NaN;
this.alternativa3d::mipMap = new Vector.<BitmapData>();
this.alternativa3d::numMaps = 0;
this.alternativa3d::mipMap[this.alternativa3d::numMaps] = this.alternativa3d::_texture;
++this.alternativa3d::numMaps;
var local2:int = Math.pow(2,Math.ceil(Math.log(this.alternativa3d::_texture.width) / Math.LN2));
var local3:int = Math.pow(2,Math.ceil(Math.log(this.alternativa3d::_texture.height) / Math.LN2));
if(this.alternativa3d::_texture.width == local2 && this.alternativa3d::_texture.height == local3) {
local4 = this.alternativa3d::_texture.width;
local5 = this.alternativa3d::_texture.height;
while(local4 % 2 == 0 && local5 % 2 == 0) {
local4 >>= 1;
local5 >>= 1;
local1 = new BitmapData(local4,local5,this.alternativa3d::_texture.transparent,0);
matrix.a = local4 / this.alternativa3d::_texture.width;
matrix.d = local5 / this.alternativa3d::_texture.height;
local1.draw(this.alternativa3d::_texture,matrix,null,null,null,false);
this.alternativa3d::mipMap[this.alternativa3d::numMaps] = local1;
++this.alternativa3d::numMaps;
}
} else {
matrix.identity();
filter.preserveAlpha = !this.alternativa3d::_texture.transparent;
local1 = this.alternativa3d::_texture.width * this.alternativa3d::_texture.height > 16777215 ? this.alternativa3d::_texture.clone() : new BitmapData(this.alternativa3d::_texture.width,this.alternativa3d::_texture.height,this.alternativa3d::_texture.transparent);
local6 = this.alternativa3d::_texture;
local7 = rect.width = this.alternativa3d::_texture.width;
local8 = rect.height = this.alternativa3d::_texture.height;
while(local7 > 1 && local8 > 1 && rect.width > 1 && rect.height > 1) {
local1.applyFilter(local6,rect,point,filter);
rect.width = local7 >> 1;
rect.height = local8 >> 1;
matrix.a = rect.width / local7;
matrix.d = rect.height / local8;
local7 *= 0.5;
local8 *= 0.5;
local6 = new BitmapData(rect.width,rect.height,this.alternativa3d::_texture.transparent,0);
local6.draw(local1,matrix,null,null,null,false);
this.alternativa3d::mipMap[this.alternativa3d::numMaps] = local6;
++this.alternativa3d::numMaps;
}
local1.dispose();
}
}
override alternativa3d function draw(param1:Camera3D, param2:Canvas, param3:Face, param4:Number) : void {
var local5:Face = null;
var local6:Face = null;
var local7:Face = null;
var local8:Wrapper = null;
var local9:Vertex = null;
var local10:int = 0;
var local11:int = 0;
var local12:int = 0;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:int = 0;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local20:BitmapData = null;
var local26:int = 0;
var local27:int = 0;
var local28:int = 0;
var local29:int = 0;
var local33:int = 0;
var local34:Number = NaN;
var local35:Number = NaN;
var local36:Number = NaN;
var local37:int = 0;
var local38:int = 0;
var local39:Wrapper = null;
var local40:int = 0;
var local41:Number = NaN;
var local42:Number = NaN;
var local43:Wrapper = null;
var local44:Number = NaN;
var local45:Number = NaN;
var local46:Number = NaN;
var local47:Boolean = false;
var local48:Boolean = false;
var local49:Number = NaN;
var local50:Face = null;
var local51:Wrapper = null;
var local52:Wrapper = null;
var local53:Wrapper = null;
var local54:Vertex = null;
var local55:Vertex = null;
var local56:Vertex = null;
var local21:Number = Number(param1.alternativa3d::viewSizeX);
var local22:Number = Number(param1.alternativa3d::viewSizeY);
var local23:Vector.<Number> = alternativa3d::drawVertices;
var local24:Vector.<Number> = alternativa3d::drawUVTs;
var local25:Vector.<int> = alternativa3d::drawIndices;
var local30:int = int(param1.alternativa3d::numDraws);
var local31:int = 0;
var local32:int = 0;
if(this.alternativa3d::_texture == null) {
alternativa3d::clearLinks(param3);
return;
}
if(this.alternativa3d::_mipMapping < 2) {
local30++;
local26 = 0;
local27 = 0;
local28 = 0;
local29 = 0;
local5 = param3;
while(local5 != null) {
local6 = local5.alternativa3d::processNext;
local5.alternativa3d::processNext = null;
local8 = local5.alternativa3d::wrapper;
local9 = local8.alternativa3d::vertex;
if(local9.alternativa3d::drawId != local30) {
local13 = 1 / local9.alternativa3d::cameraZ;
local23[local27] = local9.alternativa3d::cameraX * local21 * local13;
local27++;
local23[local27] = local9.alternativa3d::cameraY * local22 * local13;
local27++;
local24[local28] = local9.u;
local28++;
local24[local28] = local9.v;
local28++;
local24[local28] = local13;
local28++;
local10 = local26;
local9.alternativa3d::index = local26++;
local9.alternativa3d::drawId = local30;
} else {
local10 = int(local9.alternativa3d::index);
}
local8 = local8.alternativa3d::next;
local9 = local8.alternativa3d::vertex;
if(local9.alternativa3d::drawId != local30) {
local13 = 1 / local9.alternativa3d::cameraZ;
local23[local27] = local9.alternativa3d::cameraX * local21 * local13;
local27++;
local23[local27] = local9.alternativa3d::cameraY * local22 * local13;
local27++;
local24[local28] = local9.u;
local28++;
local24[local28] = local9.v;
local28++;
local24[local28] = local13;
local28++;
local11 = local26;
local9.alternativa3d::index = local26++;
local9.alternativa3d::drawId = local30;
} else {
local11 = int(local9.alternativa3d::index);
}
local8 = local8.alternativa3d::next;
while(local8 != null) {
local9 = local8.alternativa3d::vertex;
if(local9.alternativa3d::drawId != local30) {
local13 = 1 / local9.alternativa3d::cameraZ;
local23[local27] = local9.alternativa3d::cameraX * local21 * local13;
local27++;
local23[local27] = local9.alternativa3d::cameraY * local22 * local13;
local27++;
local24[local28] = local9.u;
local28++;
local24[local28] = local9.v;
local28++;
local24[local28] = local13;
local28++;
local12 = local26;
local9.alternativa3d::index = local26++;
local9.alternativa3d::drawId = local30;
} else {
local12 = int(local9.alternativa3d::index);
}
alternativa3d::drawIndices[local29] = local10;
local29++;
alternativa3d::drawIndices[local29] = local11;
local29++;
alternativa3d::drawIndices[local29] = local12;
local29++;
local11 = local12;
local32++;
local8 = local8.alternativa3d::next;
}
local31++;
local5 = local6;
}
local23.length = local27;
local24.length = local28;
local25.length = local29;
if(this.alternativa3d::_mipMapping == 0) {
local20 = this.alternativa3d::_texture;
} else {
local14 = param1.alternativa3d::focalLength * this.resolution;
local33 = param4 >= local14 ? int(1 + Math.log(param4 / local14) * 1.4426950408889634) : 0;
if(local33 >= this.alternativa3d::numMaps) {
local33 = this.alternativa3d::numMaps - 1;
}
local20 = this.alternativa3d::mipMap[local33];
}
if(this.correctUV) {
local18 = -0.5 / (local20.width - 1);
local19 = -0.5 / (local20.height - 1);
local16 = 1 - local18 - local18;
local17 = 1 - local19 - local19;
local15 = 0;
while(local15 < local28) {
local24[local15] = local24[local15] * local16 + local18;
local15++;
local24[local15] = local24[local15] * local17 + local19;
local15++;
local15++;
}
}
param2.alternativa3d::gfx.beginBitmapFill(local20,null,this.repeat,this.smooth);
param2.alternativa3d::gfx.drawTriangles(local23,local25,local24,"none");
} else {
local35 = 1e+22;
local36 = -1;
local5 = param3;
while(local5 != null) {
local8 = local5.alternativa3d::wrapper;
while(local8 != null) {
local34 = Number(local8.alternativa3d::vertex.alternativa3d::cameraZ);
if(local34 < local35) {
local35 = local34;
}
if(local34 > local36) {
local36 = local34;
}
local8 = local8.alternativa3d::next;
}
local5 = local5.alternativa3d::processNext;
}
local14 = param1.alternativa3d::focalLength * this.resolution;
local37 = local35 >= local14 ? int(1 + Math.log(local35 / local14) * 1.4426950408889634) : 0;
if(local37 >= this.alternativa3d::numMaps) {
local37 = this.alternativa3d::numMaps - 1;
}
local38 = local36 >= local14 ? int(1 + Math.log(local36 / local14) * 1.4426950408889634) : 0;
if(local38 >= this.alternativa3d::numMaps) {
local38 = this.alternativa3d::numMaps - 1;
}
local34 = local14 * Math.pow(2,local38 - 1);
local40 = local38;
while(local40 >= local37) {
local30++;
local26 = 0;
local27 = 0;
local28 = 0;
local29 = 0;
local41 = local34 - this.threshold;
local42 = local34 + this.threshold;
local5 = param3;
param3 = null;
local7 = null;
while(local5 != null) {
local6 = local5.alternativa3d::processNext;
local5.alternativa3d::processNext = null;
local8 = null;
if(local40 == local37) {
local8 = local5.alternativa3d::wrapper;
} else {
local43 = local5.alternativa3d::wrapper;
local44 = Number(local43.alternativa3d::vertex.alternativa3d::cameraZ);
local43 = local43.alternativa3d::next;
local45 = Number(local43.alternativa3d::vertex.alternativa3d::cameraZ);
local43 = local43.alternativa3d::next;
local46 = Number(local43.alternativa3d::vertex.alternativa3d::cameraZ);
local43 = local43.alternativa3d::next;
local47 = local44 < local41 || local45 < local41 || local46 < local41;
local48 = local44 > local42 || local45 > local42 || local46 > local42;
while(local43 != null) {
local49 = Number(local43.alternativa3d::vertex.alternativa3d::cameraZ);
if(local49 < local41) {
local47 = true;
} else if(local49 > local42) {
local48 = true;
}
local43 = local43.alternativa3d::next;
}
if(!local47) {
local8 = local5.alternativa3d::wrapper;
} else if(!local48) {
if(param3 != null) {
local7.alternativa3d::processNext = local5;
} else {
param3 = local5;
}
local7 = local5;
} else {
local50 = local5.alternativa3d::create();
param1.alternativa3d::lastFace.alternativa3d::next = local50;
param1.alternativa3d::lastFace = local50;
local51 = null;
local52 = null;
local43 = local5.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next;
while(local43.alternativa3d::next != null) {
local43 = local43.alternativa3d::next;
}
local54 = local43.alternativa3d::vertex;
local44 = Number(local54.alternativa3d::cameraZ);
local43 = local5.alternativa3d::wrapper;
while(local43 != null) {
local55 = local43.alternativa3d::vertex;
local45 = Number(local55.alternativa3d::cameraZ);
if(local44 < local41 && local45 > local42 || local44 > local42 && local45 < local41) {
local13 = (local34 - local44) / (local45 - local44);
local56 = local55.alternativa3d::create();
param1.alternativa3d::lastVertex.alternativa3d::next = local56;
param1.alternativa3d::lastVertex = local56;
local56.alternativa3d::cameraX = local54.alternativa3d::cameraX + (local55.alternativa3d::cameraX - local54.alternativa3d::cameraX) * local13;
local56.alternativa3d::cameraY = local54.alternativa3d::cameraY + (local55.alternativa3d::cameraY - local54.alternativa3d::cameraY) * local13;
local56.alternativa3d::cameraZ = local34;
local56.u = local54.u + (local55.u - local54.u) * local13;
local56.v = local54.v + (local55.v - local54.v) * local13;
local53 = local43.alternativa3d::create();
local53.alternativa3d::vertex = local56;
if(local51 != null) {
local51.alternativa3d::next = local53;
} else {
local50.alternativa3d::wrapper = local53;
}
local51 = local53;
local53 = local43.alternativa3d::create();
local53.alternativa3d::vertex = local56;
if(local52 != null) {
local52.alternativa3d::next = local53;
} else {
local8 = local53;
}
local52 = local53;
}
if(local45 <= local42) {
local53 = local43.alternativa3d::create();
local53.alternativa3d::vertex = local55;
if(local51 != null) {
local51.alternativa3d::next = local53;
} else {
local50.alternativa3d::wrapper = local53;
}
local51 = local53;
}
if(local45 >= local41) {
local53 = local43.alternativa3d::create();
local53.alternativa3d::vertex = local55;
if(local52 != null) {
local52.alternativa3d::next = local53;
} else {
local8 = local53;
}
local52 = local53;
}
local54 = local55;
local44 = local45;
local43 = local43.alternativa3d::next;
}
if(param3 != null) {
local7.alternativa3d::processNext = local50;
} else {
param3 = local50;
}
local7 = local50;
local39 = local8;
}
}
if(local8 != null) {
local9 = local8.alternativa3d::vertex;
if(local9.alternativa3d::drawId != local30) {
local13 = 1 / local9.alternativa3d::cameraZ;
local23[local27] = local9.alternativa3d::cameraX * local21 * local13;
local27++;
local23[local27] = local9.alternativa3d::cameraY * local22 * local13;
local27++;
local24[local28] = local9.u;
local28++;
local24[local28] = local9.v;
local28++;
local24[local28] = local13;
local28++;
local10 = local26;
local9.alternativa3d::index = local26++;
local9.alternativa3d::drawId = local30;
} else {
local10 = int(local9.alternativa3d::index);
}
local8 = local8.alternativa3d::next;
local9 = local8.alternativa3d::vertex;
if(local9.alternativa3d::drawId != local30) {
local13 = 1 / local9.alternativa3d::cameraZ;
local23[local27] = local9.alternativa3d::cameraX * local21 * local13;
local27++;
local23[local27] = local9.alternativa3d::cameraY * local22 * local13;
local27++;
local24[local28] = local9.u;
local28++;
local24[local28] = local9.v;
local28++;
local24[local28] = local13;
local28++;
local11 = local26;
local9.alternativa3d::index = local26++;
local9.alternativa3d::drawId = local30;
} else {
local11 = int(local9.alternativa3d::index);
}
local8 = local8.alternativa3d::next;
while(local8 != null) {
local9 = local8.alternativa3d::vertex;
if(local9.alternativa3d::drawId != local30) {
local13 = 1 / local9.alternativa3d::cameraZ;
local23[local27] = local9.alternativa3d::cameraX * local21 * local13;
local27++;
local23[local27] = local9.alternativa3d::cameraY * local22 * local13;
local27++;
local24[local28] = local9.u;
local28++;
local24[local28] = local9.v;
local28++;
local24[local28] = local13;
local28++;
local12 = local26;
local9.alternativa3d::index = local26++;
local9.alternativa3d::drawId = local30;
} else {
local12 = int(local9.alternativa3d::index);
}
alternativa3d::drawIndices[local29] = local10;
local29++;
alternativa3d::drawIndices[local29] = local11;
local29++;
alternativa3d::drawIndices[local29] = local12;
local29++;
local11 = local12;
local32++;
local8 = local8.alternativa3d::next;
}
local31++;
if(local39 != null) {
local8 = local39;
while(local8 != null) {
local8.alternativa3d::vertex = null;
local8 = local8.alternativa3d::next;
}
param1.alternativa3d::lastWrapper.alternativa3d::next = local39;
param1.alternativa3d::lastWrapper = local52;
local39 = null;
}
}
local5 = local6;
}
local34 *= 0.5;
local23.length = local27;
local24.length = local28;
local25.length = local29;
local20 = this.alternativa3d::mipMap[local40];
if(this.correctUV) {
local18 = -0.5 / (local20.width - 1);
local19 = -0.5 / (local20.height - 1);
local16 = 1 - local18 - local18;
local17 = 1 - local19 - local19;
local15 = 0;
while(local15 < local28) {
local24[local15] = local24[local15] * local16 + local18;
local15++;
local24[local15] = local24[local15] * local17 + local19;
local15++;
local15++;
}
}
param2.alternativa3d::gfx.beginBitmapFill(local20,null,this.repeat,this.smooth);
param2.alternativa3d::gfx.drawTriangles(local23,local25,local24,"none");
local40--;
}
}
param1.alternativa3d::numDraws = local30;
param1.alternativa3d::numPolygons += local31;
param1.alternativa3d::numTriangles += local32;
}
override alternativa3d function drawViewAligned(param1:Camera3D, param2:Canvas, param3:Face, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Number) : void {
var local13:Face = null;
var local14:Face = null;
var local15:BitmapData = null;
var local18:Number = NaN;
var local19:int = 0;
var local20:Wrapper = null;
var local21:Vertex = null;
var local22:int = 0;
var local11:Number = Number(param1.alternativa3d::viewSizeX);
var local12:Number = Number(param1.alternativa3d::viewSizeY);
if(this.alternativa3d::_texture == null) {
alternativa3d::clearLinks(param3);
return;
}
if(this.alternativa3d::_mipMapping == 0) {
local15 = this.alternativa3d::_texture;
} else {
local18 = param1.alternativa3d::focalLength * this.resolution;
local19 = param4 >= local18 ? int(1 + Math.log(param4 / local18) * 1.4426950408889634) : 0;
if(local19 >= this.alternativa3d::numMaps) {
local19 = this.alternativa3d::numMaps - 1;
}
local15 = this.alternativa3d::mipMap[local19];
}
var local16:Number = local15.width;
var local17:Number = local15.height;
alternativa3d::drawMatrix.a = param5 / local16;
alternativa3d::drawMatrix.b = param6 / local16;
alternativa3d::drawMatrix.c = param7 / local17;
alternativa3d::drawMatrix.d = param8 / local17;
alternativa3d::drawMatrix.tx = param9;
alternativa3d::drawMatrix.ty = param10;
param2.alternativa3d::gfx.beginBitmapFill(local15,alternativa3d::drawMatrix,this.repeat,this.smooth);
local13 = param3;
while(local13 != null) {
local14 = local13.alternativa3d::processNext;
local13.alternativa3d::processNext = null;
local20 = local13.alternativa3d::wrapper;
local21 = local20.alternativa3d::vertex;
param2.alternativa3d::gfx.moveTo(local21.alternativa3d::cameraX * local11 / param4,local21.alternativa3d::cameraY * local12 / param4);
local22 = -1;
local20 = local20.alternativa3d::next;
while(local20 != null) {
local21 = local20.alternativa3d::vertex;
param2.alternativa3d::gfx.lineTo(local21.alternativa3d::cameraX * local11 / param4,local21.alternativa3d::cameraY * local12 / param4);
local22++;
local20 = local20.alternativa3d::next;
}
param1.alternativa3d::numTriangles += local22;
++param1.alternativa3d::numPolygons;
local13 = local14;
}
++param1.alternativa3d::numDraws;
}
public function disposeResource() : void {
}
}
}
|
package projects.tanks.clients.flash.commons.services.fullscreen {
import alternativa.osgi.service.display.IDisplay;
import flash.display.StageDisplayState;
import flash.events.FullScreenEvent;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenStateService;
public class FullscreenStateServiceImpl implements FullscreenStateService {
private static const EVENT_HANDLERS_DELAY:int = 250;
private var _fullScreenWithDelay:Boolean;
private var _setFullscreenFalseTimeout:uint;
public function FullscreenStateServiceImpl(param1:IDisplay, param2:Boolean) {
super();
if(param2) {
param1.stage.addEventListener(FullScreenEvent.FULL_SCREEN,this.onFullscreen);
this._fullScreenWithDelay = param1.stage.displayState != StageDisplayState.NORMAL;
}
}
private function onFullscreen(param1:FullScreenEvent) : void {
clearTimeout(this._setFullscreenFalseTimeout);
if(param1.fullScreen) {
this._fullScreenWithDelay = true;
} else {
this._setFullscreenFalseTimeout = setTimeout(this.setFullScreenFalse,EVENT_HANDLERS_DELAY);
}
}
private function setFullScreenFalse() : void {
this._fullScreenWithDelay = false;
}
public function isFullscreen() : Boolean {
return this._fullScreenWithDelay;
}
}
}
|
package projects.tanks.client.clans.panel.notification {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class ClanPanelNotificationModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ClanPanelNotificationModelServer;
private var client:IClanPanelNotificationModelBase = IClanPanelNotificationModelBase(this);
private var modelId:Long = Long.getLong(606942677,1590617894);
private var _addedId:Long = Long.getLong(1587343137,-1916924187);
private var _removedId:Long = Long.getLong(723365112,-1678221051);
private var _updateRestrictionTimeJoinClanId:Long = Long.getLong(1322847239,424158635);
private var _updateRestrictionTimeJoinClan_restrictionTimeJoinClanInSecCodec:ICodec;
public function ClanPanelNotificationModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ClanPanelNotificationModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ClanPanelNotificationCC,false)));
this._updateRestrictionTimeJoinClan_restrictionTimeJoinClanInSecCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
protected function getInitParam() : ClanPanelNotificationCC {
return ClanPanelNotificationCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._addedId:
this.client.added();
break;
case this._removedId:
this.client.removed();
break;
case this._updateRestrictionTimeJoinClanId:
this.client.updateRestrictionTimeJoinClan(int(this._updateRestrictionTimeJoinClan_restrictionTimeJoinClanInSecCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.entrance.model.entrance.invite {
public class InviteEntranceCC {
private var _enabled:Boolean;
public function InviteEntranceCC(param1:Boolean = false) {
super();
this._enabled = param1;
}
public function get enabled() : Boolean {
return this._enabled;
}
public function set enabled(param1:Boolean) : void {
this._enabled = param1;
}
public function toString() : String {
var local1:String = "InviteEntranceCC [";
local1 += "enabled = " + this.enabled + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.battlefield.models.bonus.battle.battlefield {
import alternativa.types.Long;
import projects.tanks.client.battlefield.models.bonus.battle.BonusSpawnData;
public interface IBattlefieldBonusesModelBase {
function attemptToTakeBonusFailedTankNotActive(param1:Long) : void;
function bonusTaken(param1:Long) : void;
function removeBonuses(param1:Vector.<Long>) : void;
function spawnBonuses(param1:Vector.<BonusSpawnData>) : void;
function spawnBonusesOnGround(param1:Vector.<BonusSpawnData>) : void;
}
}
|
package alternativa.tanks.models.effects.effectlevel {
[ModelInterface]
public interface IEffectLevel {
function getEffectLevel() : int;
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.customname {
import alternativa.tanks.gui.shop.shopitems.item.AbstractGarageItemShopItemButton;
import platform.client.fp10.core.type.IGameObject;
public class ShopButtonWithCustomName extends AbstractGarageItemShopItemButton {
private var shopItemName:String;
public function ShopButtonWithCustomName(param1:IGameObject, param2:String) {
this.shopItemName = param2;
super(param1);
}
override protected function getNameLabelValue(param1:IGameObject) : String {
return this.shopItemName;
}
}
}
|
package alternativa.tanks.JPGencoder {
import flash.display.*;
import flash.utils.*;
public class JPGEncoder {
private var ZigZag:Array = [0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18,24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63];
private var YTable:Array = new Array(64);
private var UVTable:Array = new Array(64);
private var fdtbl_Y:Array = new Array(64);
private var fdtbl_UV:Array = new Array(64);
private var YDC_HT:Array;
private var UVDC_HT:Array;
private var YAC_HT:Array;
private var UVAC_HT:Array;
private var std_dc_luminance_nrcodes:Array = [0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0];
private var std_dc_luminance_values:Array = [0,1,2,3,4,5,6,7,8,9,10,11];
private var std_ac_luminance_nrcodes:Array = [0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,125];
private var std_ac_luminance_values:Array = [1,2,3,0,4,17,5,18,33,49,65,6,19,81,97,7,34,113,20,50,129,145,161,8,35,66,177,193,21,82,209,240,36,51,98,114,130,9,10,22,23,24,25,26,37,38,39,40,41,42,52,53,54,55,56,57,58,67,68,69,70,71,72,73,74,83,84,85,86,87,88,89,90,99,100,101,102,103,104,105,106,115,116,117,118,119,120,121,122,131,132,133,134,135,136,137,138,146,147,148,149,150,151,152,153,154,162,163,164,165,166,167,168,169,170,178,179,180,181,182,183,184,185,186,194,195,196,197,198,199,200,201,202,210,211,212,213,214,215,216,217,218,225,226,227,228,229,230,231,232,233,234,241,242,243,244,245,246,247,248,249,250];
private var std_dc_chrominance_nrcodes:Array = [0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0];
private var std_dc_chrominance_values:Array = [0,1,2,3,4,5,6,7,8,9,10,11];
private var std_ac_chrominance_nrcodes:Array = [0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,119];
private var std_ac_chrominance_values:Array = [0,1,2,3,17,4,5,33,49,6,18,65,81,7,97,113,19,34,50,129,8,20,66,145,161,177,193,9,35,51,82,240,21,98,114,209,10,22,36,52,225,37,241,23,24,25,26,38,39,40,41,42,53,54,55,56,57,58,67,68,69,70,71,72,73,74,83,84,85,86,87,88,89,90,99,100,101,102,103,104,105,106,115,116,117,118,119,120,121,122,130,131,132,133,134,135,136,137,138,146,147,148,149,150,151,152,153,154,162,163,164,165,166,167,168,169,170,178,179,180,181,182,183,184,185,186,194,195,196,197,198,199,200,201,202,210,211,212,213,214,215,216,217,218,226,227,228,229,230,231,232,233,234,242,243,244,245,246,247,248,249,250];
private var bitcode:Array = new Array(65535);
private var category:Array = new Array(65535);
private var byteout:ByteArray;
private var bytenew:int = 0;
private var bytepos:int = 7;
private var DU:Array = new Array(64);
private var YDU:Array = new Array(64);
private var UDU:Array = new Array(64);
private var VDU:Array = new Array(64);
private var image:BitmapData;
private var DCY:Number = 0;
private var DCU:Number = 0;
private var DCV:Number = 0;
private var xpos:int = 0;
private var ypos:int = 0;
public function JPGEncoder(param1:Number = 50) {
super();
if(param1 <= 0) {
param1 = 1;
}
if(param1 > 100) {
param1 = 100;
}
var local2:int = 0;
if(param1 < 50) {
local2 = int(5000 / param1);
} else {
local2 = int(200 - param1 * 2);
}
this.initHuffmanTbl();
this.initCategoryNumber();
this.initQuantTables(local2);
}
private function initQuantTables(param1:int) : void {
var local2:int = 0;
var local3:Number = NaN;
var local8:int = 0;
var local4:Array = [16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22,37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99];
local2 = 0;
while(local2 < 64) {
local3 = Math.floor((local4[local2] * param1 + 50) / 100);
if(local3 < 1) {
local3 = 1;
} else if(local3 > 255) {
local3 = 255;
}
this.YTable[this.ZigZag[local2]] = local3;
local2++;
}
var local5:Array = [17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99];
local2 = 0;
while(local2 < 64) {
local3 = Math.floor((local5[local2] * param1 + 50) / 100);
if(local3 < 1) {
local3 = 1;
} else if(local3 > 255) {
local3 = 255;
}
this.UVTable[this.ZigZag[local2]] = local3;
local2++;
}
var local6:Array = [1,1.387039845,1.306562965,1.175875602,1,0.785694958,0.5411961,0.275899379];
local2 = 0;
var local7:int = 0;
while(local7 < 8) {
local8 = 0;
while(local8 < 8) {
this.fdtbl_Y[local2] = 1 / (this.YTable[this.ZigZag[local2]] * local6[local7] * local6[local8] * 8);
this.fdtbl_UV[local2] = 1 / (this.UVTable[this.ZigZag[local2]] * local6[local7] * local6[local8] * 8);
local2++;
local8++;
}
local7++;
}
}
private function computeHuffmanTbl(param1:Array, param2:Array) : Array {
var local7:int = 0;
var local3:int = 0;
var local4:int = 0;
var local5:Array = new Array();
var local6:int = 1;
while(local6 <= 16) {
local7 = 1;
while(local7 <= param1[local6]) {
local5[param2[local4]] = new BitString();
local5[param2[local4]].val = local3;
local5[param2[local4]].len = local6;
local4++;
local3++;
local7++;
}
local3 *= 2;
local6++;
}
return local5;
}
private function initHuffmanTbl() : void {
this.YDC_HT = this.computeHuffmanTbl(this.std_dc_luminance_nrcodes,this.std_dc_luminance_values);
this.UVDC_HT = this.computeHuffmanTbl(this.std_dc_chrominance_nrcodes,this.std_dc_chrominance_values);
this.YAC_HT = this.computeHuffmanTbl(this.std_ac_luminance_nrcodes,this.std_ac_luminance_values);
this.UVAC_HT = this.computeHuffmanTbl(this.std_ac_chrominance_nrcodes,this.std_ac_chrominance_values);
}
private function initCategoryNumber() : void {
var local3:int = 0;
var local1:int = 1;
var local2:int = 2;
var local4:int = 1;
while(local4 <= 15) {
local3 = local1;
while(local3 < local2) {
this.category[32767 + local3] = local4;
this.bitcode[32767 + local3] = new BitString();
this.bitcode[32767 + local3].len = local4;
this.bitcode[32767 + local3].val = local3;
local3++;
}
local3 = -(local2 - 1);
while(local3 <= -local1) {
this.category[32767 + local3] = local4;
this.bitcode[32767 + local3] = new BitString();
this.bitcode[32767 + local3].len = local4;
this.bitcode[32767 + local3].val = local2 - 1 + local3;
local3++;
}
local1 <<= 1;
local2 <<= 1;
local4++;
}
}
private function writeBits(param1:BitString) : void {
var local2:int = param1.val;
var local3:int = param1.len - 1;
while(local3 >= 0) {
if(Boolean(local2 & uint(1 << local3))) {
this.bytenew |= uint(1 << this.bytepos);
}
local3--;
--this.bytepos;
if(this.bytepos < 0) {
if(this.bytenew == 255) {
this.writeByte(255);
this.writeByte(0);
} else {
this.writeByte(this.bytenew);
}
this.bytepos = 7;
this.bytenew = 0;
}
}
}
private function writeByte(param1:int) : void {
this.byteout.writeByte(param1);
}
private function writeWord(param1:int) : void {
this.writeByte(param1 >> 8 & 0xFF);
this.writeByte(param1 & 0xFF);
}
private function fDCTQuant(param1:Array, param2:Array) : Array {
var local3:Number = NaN;
var local4:Number = NaN;
var local5:Number = NaN;
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 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:Number = NaN;
var local22:int = 0;
var local23:int = 0;
local22 = 0;
while(local22 < 8) {
local3 = param1[local23 + 0] + param1[local23 + 7];
local10 = param1[local23 + 0] - param1[local23 + 7];
local4 = param1[local23 + 1] + param1[local23 + 6];
local9 = param1[local23 + 1] - param1[local23 + 6];
local5 = param1[local23 + 2] + param1[local23 + 5];
local8 = param1[local23 + 2] - param1[local23 + 5];
local6 = param1[local23 + 3] + param1[local23 + 4];
local7 = param1[local23 + 3] - param1[local23 + 4];
local11 = local3 + local6;
local14 = local3 - local6;
local12 = local4 + local5;
local13 = local4 - local5;
param1[local23 + 0] = local11 + local12;
param1[local23 + 4] = local11 - local12;
local15 = (local13 + local14) * 0.707106781;
param1[local23 + 2] = local14 + local15;
param1[local23 + 6] = local14 - local15;
local11 = local7 + local8;
local12 = local8 + local9;
local13 = local9 + local10;
local19 = (local11 - local13) * 0.382683433;
local16 = 0.5411961 * local11 + local19;
local18 = 1.306562965 * local13 + local19;
local17 = local12 * 0.707106781;
local20 = local10 + local17;
local21 = local10 - local17;
param1[local23 + 5] = local21 + local16;
param1[local23 + 3] = local21 - local16;
param1[local23 + 1] = local20 + local18;
param1[local23 + 7] = local20 - local18;
local23 += 8;
local22++;
}
local23 = 0;
local22 = 0;
while(local22 < 8) {
local3 = param1[local23 + 0] + param1[local23 + 56];
local10 = param1[local23 + 0] - param1[local23 + 56];
local4 = param1[local23 + 8] + param1[local23 + 48];
local9 = param1[local23 + 8] - param1[local23 + 48];
local5 = param1[local23 + 16] + param1[local23 + 40];
local8 = param1[local23 + 16] - param1[local23 + 40];
local6 = param1[local23 + 24] + param1[local23 + 32];
local7 = param1[local23 + 24] - param1[local23 + 32];
local11 = local3 + local6;
local14 = local3 - local6;
local12 = local4 + local5;
local13 = local4 - local5;
param1[local23 + 0] = local11 + local12;
param1[local23 + 32] = local11 - local12;
local15 = (local13 + local14) * 0.707106781;
param1[local23 + 16] = local14 + local15;
param1[local23 + 48] = local14 - local15;
local11 = local7 + local8;
local12 = local8 + local9;
local13 = local9 + local10;
local19 = (local11 - local13) * 0.382683433;
local16 = 0.5411961 * local11 + local19;
local18 = 1.306562965 * local13 + local19;
local17 = local12 * 0.707106781;
local20 = local10 + local17;
local21 = local10 - local17;
param1[local23 + 40] = local21 + local16;
param1[local23 + 24] = local21 - local16;
param1[local23 + 8] = local20 + local18;
param1[local23 + 56] = local20 - local18;
local23++;
local22++;
}
local22 = 0;
while(local22 < 64) {
param1[local22] = Math.round(param1[local22] * param2[local22]);
local22++;
}
return param1;
}
private function writeAPP0() : void {
this.writeWord(65504);
this.writeWord(16);
this.writeByte(74);
this.writeByte(70);
this.writeByte(73);
this.writeByte(70);
this.writeByte(0);
this.writeByte(1);
this.writeByte(1);
this.writeByte(0);
this.writeWord(1);
this.writeWord(1);
this.writeByte(0);
this.writeByte(0);
}
private function writeSOF0(param1:int, param2:int) : void {
this.writeWord(65472);
this.writeWord(17);
this.writeByte(8);
this.writeWord(param2);
this.writeWord(param1);
this.writeByte(3);
this.writeByte(1);
this.writeByte(17);
this.writeByte(0);
this.writeByte(2);
this.writeByte(17);
this.writeByte(1);
this.writeByte(3);
this.writeByte(17);
this.writeByte(1);
}
private function writeDQT() : void {
var local1:int = 0;
this.writeWord(65499);
this.writeWord(132);
this.writeByte(0);
local1 = 0;
while(local1 < 64) {
this.writeByte(this.YTable[local1]);
local1++;
}
this.writeByte(1);
local1 = 0;
while(local1 < 64) {
this.writeByte(this.UVTable[local1]);
local1++;
}
}
private function writeDHT() : void {
var local1:int = 0;
this.writeWord(65476);
this.writeWord(418);
this.writeByte(0);
local1 = 0;
while(local1 < 16) {
this.writeByte(this.std_dc_luminance_nrcodes[local1 + 1]);
local1++;
}
local1 = 0;
while(local1 <= 11) {
this.writeByte(this.std_dc_luminance_values[local1]);
local1++;
}
this.writeByte(16);
local1 = 0;
while(local1 < 16) {
this.writeByte(this.std_ac_luminance_nrcodes[local1 + 1]);
local1++;
}
local1 = 0;
while(local1 <= 161) {
this.writeByte(this.std_ac_luminance_values[local1]);
local1++;
}
this.writeByte(1);
local1 = 0;
while(local1 < 16) {
this.writeByte(this.std_dc_chrominance_nrcodes[local1 + 1]);
local1++;
}
local1 = 0;
while(local1 <= 11) {
this.writeByte(this.std_dc_chrominance_values[local1]);
local1++;
}
this.writeByte(17);
local1 = 0;
while(local1 < 16) {
this.writeByte(this.std_ac_chrominance_nrcodes[local1 + 1]);
local1++;
}
local1 = 0;
while(local1 <= 161) {
this.writeByte(this.std_ac_chrominance_values[local1]);
local1++;
}
}
private function writeSOS() : void {
this.writeWord(65498);
this.writeWord(12);
this.writeByte(3);
this.writeByte(1);
this.writeByte(0);
this.writeByte(2);
this.writeByte(17);
this.writeByte(3);
this.writeByte(17);
this.writeByte(0);
this.writeByte(63);
this.writeByte(0);
}
private function processDU(param1:Array, param2:Array, param3:Number, param4:Array, param5:Array) : Number {
var local8:int = 0;
var local12:int = 0;
var local13:int = 0;
var local14:int = 0;
var local6:BitString = param5[0];
var local7:BitString = param5[240];
var local9:Array = this.fDCTQuant(param1,param2);
local8 = 0;
while(local8 < 64) {
this.DU[this.ZigZag[local8]] = local9[local8];
local8++;
}
var local10:int = this.DU[0] - param3;
param3 = Number(this.DU[0]);
if(local10 == 0) {
this.writeBits(param4[0]);
} else {
this.writeBits(param4[this.category[32767 + local10]]);
this.writeBits(this.bitcode[32767 + local10]);
}
var local11:int = 63;
while(local11 > 0 && this.DU[local11] == 0) {
local11--;
}
if(local11 == 0) {
this.writeBits(local6);
return param3;
}
local8 = 1;
while(local8 <= local11) {
local12 = local8;
while(this.DU[local8] == 0 && local8 <= local11) {
local8++;
}
local13 = local8 - local12;
if(local13 >= 16) {
local14 = 1;
while(local14 <= local13 / 16) {
this.writeBits(local7);
local14++;
}
local13 = int(local13 & 0x0F);
}
this.writeBits(param5[local13 * 16 + this.category[32767 + this.DU[local8]]]);
this.writeBits(this.bitcode[32767 + this.DU[local8]]);
local8++;
}
if(local11 != 63) {
this.writeBits(local6);
}
return param3;
}
private function RGB2YUV(param1:BitmapData, param2:int, param3:int) : void {
var local6:int = 0;
var local7:uint = 0;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local4:int = 0;
var local5:int = 0;
while(local5 < 8) {
local6 = 0;
while(local6 < 8) {
local7 = param1.getPixel32(param2 + local6,param3 + local5);
local8 = Number(local7 >> 16 & 0xFF);
local9 = Number(local7 >> 8 & 0xFF);
local10 = Number(local7 & 0xFF);
this.YDU[local4] = 0.299 * local8 + 0.587 * local9 + 0.114 * local10 - 128;
this.UDU[local4] = -0.16874 * local8 + -0.33126 * local9 + 0.5 * local10;
this.VDU[local4] = 0.5 * local8 + -0.41869 * local9 + -0.08131 * local10;
local4++;
local6++;
}
local5++;
}
}
public function startEncode(param1:BitmapData) : void {
this.image = param1;
this.byteout = new ByteArray();
this.bytenew = 0;
this.bytepos = 7;
this.writeWord(65496);
this.writeAPP0();
this.writeDQT();
this.writeSOF0(param1.width,param1.height);
this.writeDHT();
this.writeSOS();
this.bytenew = 0;
this.bytepos = 7;
}
public function encode() : Boolean {
var local1:int = 0;
while(local1 < 32) {
if(this._encode()) {
return true;
}
local1++;
}
return false;
}
private function _encode() : Boolean {
this.RGB2YUV(this.image,this.xpos,this.ypos);
this.DCY = this.processDU(this.YDU,this.fdtbl_Y,this.DCY,this.YDC_HT,this.YAC_HT);
this.DCU = this.processDU(this.UDU,this.fdtbl_UV,this.DCU,this.UVDC_HT,this.UVAC_HT);
this.DCV = this.processDU(this.VDU,this.fdtbl_UV,this.DCV,this.UVDC_HT,this.UVAC_HT);
this.xpos += 8;
if(this.xpos >= this.image.width) {
this.xpos = 0;
this.ypos += 8;
}
return this.ypos >= this.image.height;
}
public function finishEncode() : ByteArray {
var local1:BitString = null;
if(this.bytepos >= 0) {
local1 = new BitString();
local1.len = this.bytepos + 1;
local1.val = (1 << this.bytepos + 1) - 1;
this.writeBits(local1);
}
this.writeWord(65497);
return this.byteout;
}
}
}
|
package alternativa.tanks.view.mainview.grouplist.item {
import alternativa.osgi.service.locale.ILocaleService;
import fl.controls.listClasses.CellRenderer;
import fl.controls.listClasses.ListData;
import flash.display.DisplayObject;
import flash.events.Event;
import flash.events.MouseEvent;
import forms.Styles;
public class GroupUsersListRenderer extends CellRenderer {
[Inject]
public static var localeService:ILocaleService;
private var item:GroupUserItem;
public function GroupUsersListRenderer() {
super();
}
override public function set data(param1:Object) : void {
_data = param1;
mouseEnabled = false;
mouseChildren = true;
buttonMode = useHandCursor = false;
var local2:Boolean = Boolean(data.ready) || Boolean(data.isInviteSlot);
var local3:DisplayObject = new GroupUserCellStyle(local2,false);
var local4:DisplayObject = new GroupUserCellStyle(local2,true);
setStyle(Styles.UP_SKIN,local3);
setStyle(Styles.DOWN_SKIN,local3);
setStyle(Styles.OVER_SKIN,local3);
setStyle(Styles.SELECTED_UP_SKIN,local4);
setStyle(Styles.SELECTED_OVER_SKIN,local4);
setStyle(Styles.SELECTED_DOWN_SKIN,local4);
if(_data.id != null || Boolean(_data.isInviteSlot)) {
this.item = new GroupUserItem(_data);
addChild(this.item);
}
addEventListener(Event.RESIZE,this.onResize,false,0,true);
addEventListener(MouseEvent.ROLL_OVER,this.onRollOver,false,0,true);
addEventListener(MouseEvent.ROLL_OUT,this.onRollOut,false,0,true);
this.onResize();
}
protected function onResize(param1:Event = null) : void {
if(this.item != null) {
this.item.width = width;
}
}
private function onRollOver(param1:MouseEvent) : void {
if(this.item != null) {
this.item.showDeleteIndicator();
super.selected = true;
}
}
private function onRollOut(param1:MouseEvent) : void {
if(this.item != null) {
this.item.hideDeleteIndicator();
super.selected = false;
}
}
override public function set listData(param1:ListData) : void {
_listData = param1;
label = _listData.label;
if(this.item != null) {
setStyle("icon",this.item);
}
}
override public function set selected(param1:Boolean) : void {
}
}
}
|
package controls.scroller.red {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.scroller.red.ScrollSkinRed_trackTop.png")]
public class ScrollSkinRed_trackTop extends BitmapAsset {
public function ScrollSkinRed_trackTop() {
super();
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _e501fd44903933ae5055c84e2be7a1471401548208ab4ed91116e89c22ac5e07_flash_display_Sprite extends Sprite {
public function _e501fd44903933ae5055c84e2be7a1471401548208ab4ed91116e89c22ac5e07_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.friend {
import flash.events.Event;
public class FriendInfoLabelUpdaterEvent extends Event {
public static const CHANGE_STATE:String = "FriendInfoLabelUpdaterEvent.CHANGE_STATE";
public function FriendInfoLabelUpdaterEvent(param1:String, param2:Boolean = false, param3:Boolean = false) {
super(param1,param2,param3);
}
}
}
|
package alternativa.osgi.service.console {
public class ConsoleVarChangeError extends Error {
public function ConsoleVarChangeError(param1:String, param2:String, param3:String) {
super("Can not change variable " + param1 + ", value=" + param2 + ", message=" + param3);
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.shot
{
import scpacker.Base;
public class ShotModelBase extends Base
{
public function ShotModelBase()
{
super();
}
}
}
|
package _codec.projects.tanks.client.garage.models.user.present {
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.garage.models.user.present.PresentItem;
public class VectorCodecPresentItemLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecPresentItemLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(PresentItem,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.<PresentItem> = new Vector.<PresentItem>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = PresentItem(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:PresentItem = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<PresentItem> = Vector.<PresentItem>(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.panel.model.payment.modes.errors {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class ErrorsDescriptionModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ErrorsDescriptionModelServer;
private var client:IErrorsDescriptionModelBase = IErrorsDescriptionModelBase(this);
private var modelId:Long = Long.getLong(1456185857,-299115092);
private var _showErrorId:Long = Long.getLong(1139481512,922626302);
private var _showError_msgCodec:ICodec;
public function ErrorsDescriptionModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ErrorsDescriptionModelServer(IModel(this));
this._showError_msgCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._showErrorId:
this.client.showError(String(this._showError_msgCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.physics {
import alternativa.tanks.utils.BitVector;
public class TankBodyIdProvider {
private static const MAX_IDS:int = 64;
private static const instance:TankBodyIdProvider = new TankBodyIdProvider();
private const ids:Vector.<int> = new Vector.<int>(MAX_IDS,true);
private const claimedIds:BitVector = new BitVector(MAX_IDS);
private var firstFreeIdIndex:int;
public function TankBodyIdProvider() {
super();
this.reset();
}
public static function claimId() : int {
return instance.claim();
}
public static function releaseId(param1:int) : void {
instance.release(param1);
}
public static function resetIds() : void {
instance.reset();
}
public function claim() : int {
var local1:int = 0;
if(this.firstFreeIdIndex < MAX_IDS) {
local1 = this.ids[this.firstFreeIdIndex++];
this.claimedIds.setBit(local1);
return local1;
}
throw new Error();
}
public function release(param1:int) : void {
if(this.claimedIds.getBit(param1) == 1) {
this.claimedIds.clearBit(param1);
var local2:* = --this.firstFreeIdIndex;
this.ids[local2] = param1;
}
}
public function reset() : void {
this.firstFreeIdIndex = 0;
var local1:int = 0;
while(local1 < MAX_IDS) {
this.ids[local1] = local1;
local1++;
}
this.claimedIds.clear();
}
}
}
|
package alternativa.tanks.bonuses {
import alternativa.math.Vector3;
import alternativa.types.Long;
public interface Bonus {
function get bonusId() : Long;
function spawn(param1:Vector3, param2:int, param3:Number, param4:Boolean, param5:Function) : void;
function pickup() : void;
function remove() : void;
function enableTrigger() : void;
}
}
|
package alternativa.tanks.models.weapon.shared.shot {
import alternativa.tanks.utils.EncryptedInt;
import alternativa.tanks.utils.EncryptedIntImpl;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.battlefield.models.tankparts.weapon.shot.DiscreteShotModelBase;
import projects.tanks.client.battlefield.models.tankparts.weapon.shot.IDiscreteShotModelBase;
[ModelInfo]
public class DiscreteShotModel extends DiscreteShotModelBase implements IDiscreteShotModelBase, IShotModel, ObjectLoadListener {
public function DiscreteShotModel() {
super();
}
public function objectLoaded() : void {
putData(EncryptedInt,new EncryptedIntImpl(getInitParam().reloadMsec));
}
public function getReloadMS() : int {
return EncryptedInt(getData(EncryptedInt)).getInt();
}
public function reconfigureWeapon(param1:int) : void {
var local2:EncryptedInt = EncryptedInt(getData(EncryptedInt));
var local3:int = int(local2.getInt());
local2.setInt(param1);
WeaponReloadTimeChangedListener(object.event(WeaponReloadTimeChangedListener)).weaponReloadTimeChanged(local3,param1);
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.shot {
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.shotgun.shot.ShotgunShotCC;
public class VectorCodecShotgunShotCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecShotgunShotCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ShotgunShotCC,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.<ShotgunShotCC> = new Vector.<ShotgunShotCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ShotgunShotCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ShotgunShotCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ShotgunShotCC> = Vector.<ShotgunShotCC>(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.camera {
public class CameraBookmarks {
private var bookmarks:Vector.<CameraBookmark>;
public function CameraBookmarks(param1:int) {
super();
this.bookmarks = new Vector.<CameraBookmark>(param1);
}
public function getBookmark(param1:uint) : CameraBookmark {
if(param1 < this.bookmarks.length) {
return this.bookmarks[param1];
}
return null;
}
public function saveCurrentPositionCameraToBookmark(param1:uint) : void {
if(param1 < this.bookmarks.length) {
this.getOrCreateBookmark(param1).saveCurrentPossitionCamera();
}
}
private function getOrCreateBookmark(param1:uint) : CameraBookmark {
if(this.bookmarks[param1] == null) {
this.bookmarks[param1] = new CameraBookmark();
}
return this.bookmarks[param1];
}
}
}
|
package projects.tanks.client.panel.model.shop.discount {
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 ShopDiscountModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ShopDiscountModelServer;
private var client:IShopDiscountModelBase = IShopDiscountModelBase(this);
private var modelId:Long = Long.getLong(1969380491,159728732);
public function ShopDiscountModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ShopDiscountModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ShopDiscountCC,false)));
}
protected function getInitParam() : ShopDiscountCC {
return ShopDiscountCC(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 controls.buttons.h71px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h71px.GreyHugeButtonSkin_rightUpClass.png")]
public class GreyHugeButtonSkin_rightUpClass extends BitmapAsset {
public function GreyHugeButtonSkin_rightUpClass() {
super();
}
}
}
|
package projects.tanks.client.partners.impl.vkontakte {
public interface IVkontaktePaymentModelBase {
function receivePaymentTransaction(param1:String) : void;
}
}
|
package projects.tanks.client.battlefield.models.user.spawn {
import projects.tanks.client.battlefield.types.Vector3d;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public interface ITankSpawnerModelBase {
function prepareToSpawn(param1:Vector3d, param2:Vector3d) : void;
function spawn(param1:BattleTeam, param2:Vector3d, param3:Vector3d, param4:int, param5:int) : void;
}
}
|
package alternativa.tanks.battle.objects.tank {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.FillMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.engine3d.primitives.Box;
import alternativa.math.Matrix3;
import alternativa.math.Matrix4;
import alternativa.math.Quaternion;
import alternativa.math.Vector3;
import alternativa.osgi.OSGi;
import alternativa.osgi.service.logging.LogService;
import alternativa.physics.Body;
import alternativa.physics.BodyState;
import alternativa.physics.PhysicsMaterial;
import alternativa.physics.PhysicsScene;
import alternativa.physics.PhysicsUtils;
import alternativa.physics.collision.BodyCollisionFilter;
import alternativa.physics.collision.CollisionDetector;
import alternativa.physics.collision.CollisionShape;
import alternativa.physics.collision.primitives.CollisionBox;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.BattleRunner;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.Dust;
import alternativa.tanks.battle.PhysicsController;
import alternativa.tanks.battle.PhysicsInterpolator;
import alternativa.tanks.battle.PostPhysicsController;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.objects.tank.controllers.LocalChassisController;
import alternativa.tanks.battle.objects.tank.tankchassis.SuspensionParams;
import alternativa.tanks.battle.objects.tank.tankchassis.Track;
import alternativa.tanks.battle.objects.tank.tankchassis.TrackedChassis;
import alternativa.tanks.battle.objects.tank.tankskin.TankHullSkinCacheItem;
import alternativa.tanks.battle.objects.tank.tankskin.TankSkin;
import alternativa.tanks.battle.objects.tank.tankskin.TracksAnimator;
import alternativa.tanks.battle.objects.tank.tankskin.turret.TurretGeometryItem;
import alternativa.tanks.battle.objects.tank.tankskin.turret.TurretSkinCacheItem;
import alternativa.tanks.battle.scene3d.BattleScene3D;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.camera.CameraTarget;
import alternativa.tanks.camera.FollowCameraController;
import alternativa.tanks.display.usertitle.UserTitle;
import alternativa.tanks.models.battle.gui.markers.PointIndicatorStateProvider;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.bosstate.IBossState;
import alternativa.tanks.models.tank.ultimate.mammoth.ImpactEnable;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.BasicGlobalGunParams;
import alternativa.tanks.models.weapon.WeaponUtils;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TankBody;
import alternativa.tanks.physics.TankBodyIdProvider;
import alternativa.tanks.sfx.TankSoundEffects;
import alternativa.tanks.sfx.floatingmessage.FloatingTextEffect;
import alternativa.tanks.utils.CircularObjectBuffer;
import alternativa.tanks.utils.DataUnitValidator;
import alternativa.tanks.utils.DataValidationErrorEvent;
import flash.display.BitmapData;
import flash.geom.Vector3D;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.user.bossstate.BossRelationRole;
import projects.tanks.client.battlefield.types.Vector3d;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class Tank implements PhysicsController, PostPhysicsController, PhysicsInterpolator, Renderer, BodyCollisionFilter, CameraTarget, PointIndicatorStateProvider, WeaponPlatform {
public static var logService:LogService;
private static const _v:Vector3 = new Vector3();
private static const _rayOrigin:Vector3 = new Vector3();
private static const _rayVector:Vector3 = new Vector3();
private static const _point:Vector3 = new Vector3();
private static const _rayHit:RayHit = new RayHit();
private static const _m:Matrix3 = new Matrix3();
private static const _rm:Matrix3 = new Matrix3();
public var user:IGameObject;
public var health:Number = 0;
public var state:ClientTankState;
private var _teamType:BattleTeam;
private var _incarnation:int;
private var weapon:Weapon;
private var _weaponMount:WeaponMount;
private var battleService:BattleService;
private var tankBody:TankBody;
private var collisionCount:int;
private var skin:TankSkin;
private var maxSpeedSmoother:ValueSmoother = new EncryptedValueSmoother(100,1000,0,0);
private var maxTurnSpeedSmoother:ValueSmoother = new EncryptedValueSmoother(0.3,10,0,0);
private var suspensionParams:SuspensionParams = new SuspensionParams();
internal var skinCenterOffset:Vector3 = new Vector3();
private var visibilityPoints:Vector.<Vector3>;
public var interpolatedPosition:Vector3 = new Vector3();
internal var interpolatedOrientation:Quaternion = new Quaternion();
internal var interpolatedTransform:Matrix4 = new Matrix4();
private var validator:TankDataValidator;
private var chassis:TrackedChassis;
private var tracksAnimator:TracksAnimator;
private var title:UserTitle;
private var sounds:TankSoundEffects;
private var bodyStateValidator:BodyPhysicsStateValidator;
private var battleEventDispatcher:BattleEventDispatcher;
private var halfLength:Number;
private var savedBodyState:BodyState = new BodyState();
private var floatingTextEffect:FloatingTextEffect;
private var temperature:Number = 0;
private var maxHealth:int;
private var hullTransformUpdater:HullTransformUpdater;
private var boundSphereRadius:Number;
private var logBuffer:CircularObjectBuffer;
private var _stunned:Boolean;
public var lastHitPoint:Vector3 = new Vector3();
public var isLastHitPointSet:Boolean;
public var turretCollisions:Vector.<CollisionBox> = new Vector.<CollisionBox>();
public function Tank(param1:IGameObject, param2:Number, param3:Number, param4:TankSoundEffects, param5:TankSkin, param6:WeaponMount, param7:Weapon, param8:UserTitle, param9:BattleEventDispatcher, param10:int) {
super();
this.user = param1;
this.skin = param5;
this.sounds = param4;
this.battleEventDispatcher = param9;
this.maxHealth = param10;
this.suspensionParams.dampingCoeff = param3;
param4.setTank(this);
var local11:Vector3 = calculateSizeForMesh(param5.getHullDescriptor().mesh);
var local12:Vector3 = new Vector3(local11.x / 2,local11.y / 2,local11.z / 2);
this.halfLength = local12.y;
this.calculateSkinCenterOffset(local11);
this.createBody(param2,local12);
this.createCollisionPrimitives(local12);
this.createVisibilityPoints(local12);
this.initTurretGeometry(param5);
this.chassis = new TrackedChassis(this.tankBody.body,this.suspensionParams,this.maxSpeedSmoother,local11);
this.tracksAnimator = new TracksAnimator(this.chassis,param5,this.maxSpeedSmoother);
this.state = ClientTankState.ACTIVE;
this.bodyStateValidator = new BodyPhysicsStateValidator(this.tankBody.body,param9);
this._weaponMount = param6;
this.weapon = param7;
param7.init(this);
this.title = param8;
logService = LogService(OSGi.getInstance().getService(LogService));
this.tankBody.onTankInited();
}
private static function calculateSizeForMesh(param1:Mesh) : Vector3 {
return new Vector3(param1.boundMaxX - param1.boundMinX,param1.boundMaxY - param1.boundMinY,param1.boundMaxZ - param1.boundMinZ);
}
private static function _getPhysicsState(param1:BodyState, param2:Vector3d, param3:Vector3d, param4:Vector3d, param5:Vector3d) : void {
BattleUtils.copyToVector3d(param1.position,param2);
var local6:Quaternion = param1.orientation;
local6.getEulerAngles(_v);
param3.x = _v.x;
param3.y = _v.y;
param3.z = _v.z;
BattleUtils.copyToVector3d(param1.velocity,param4);
BattleUtils.copyToVector3d(param1.angularVelocity,param5);
}
private function initTurretGeometry(param1:TankSkin) : void {
var local3:TurretGeometryItem = null;
var local4:CollisionBox = null;
var local2:Vector.<TurretGeometryItem> = param1.getTurretGeometry();
for each(local3 in local2) {
local4 = this.createTurretCollision(local3.getHalfSize());
this.turretCollisions.push(local4);
this.tankBody.body.addCollisionShape(local4,new Matrix4());
}
this.updateTurretPhysics(0);
}
public function getWeaponMount() : WeaponMount {
return this._weaponMount;
}
private function createTurretCollision(param1:Vector3) : CollisionBox {
return new CollisionBox(param1,0,PhysicsMaterial.DEFAULT_MATERIAL);
}
private function initView() : void {
}
private function createViewByCollision(param1:CollisionBox, param2:uint = 65535) : Box {
var local3:Vector3 = param1.hs;
var local4:Box = new Box(local3.x * 2,local3.y * 2,local3.z * 2);
local4.setMaterialToAllFaces(new FillMaterial(param2,0.9));
return local4;
}
public function log(param1:String) : void {
}
public function getLogStrings() : Vector.<String> {
return new Vector.<String>();
}
public function setHullTransformUpdater(param1:HullTransformUpdater) : void {
this.hullTransformUpdater = param1;
}
public function get teamType() : BattleTeam {
return this._teamType;
}
public function get incarnation() : int {
return this._incarnation;
}
public function getAllGunParams(param1:AllGlobalGunParams, param2:int = 0) : void {
WeaponUtils.calculateMainGunParams(this.skin.getBarrel3D(),this.skin.getTurretDescriptor().muzzles[param2],param1);
}
public function getBasicGunParams(param1:BasicGlobalGunParams, param2:int = 0) : void {
WeaponUtils.calculateBasicGunParams(this.skin.getBarrel3D(),this.skin.getTurretDescriptor().muzzles[param2],param1);
}
public function getLocalMuzzlePosition(param1:int = 0) : Vector3 {
return this.skin.getTurretDescriptor().muzzles[param1];
}
public function getLaserLocalPosition() : Vector3 {
return this.skin.getTurretDescriptor().laserPoint;
}
public function getBarrelLength(param1:int = 0) : Number {
return Vector3(this.skin.getTurretDescriptor().muzzles[param1]).y;
}
public function getTurret3D() : Object3D {
return this.skin.getTurret3D();
}
public function getHullMesh() : Mesh {
return this.skin.getHullMesh();
}
public function getSkin() : TankSkin {
return this.skin;
}
public function getTitle() : UserTitle {
return this.title;
}
public function showTitle() : void {
this.title.show();
}
public function hideTitle() : void {
this.title.hide();
}
public function addDust(param1:int = 7) : void {
var local2:Dust = null;
var local3:int = 0;
if(this.battleService != null) {
local2 = this.battleService.getBattleScene3D().getDustEngine();
local3 = 0;
while(local3 < param1) {
local2.addTankDust(this,0,0.9);
local3++;
}
}
}
public function getCameraParams(param1:Vector3, param2:Vector3) : void {
var local4:Number = NaN;
var local5:Number = NaN;
var local3:Object3D = this.skin.getTurret3D();
param1.reset(local3.x,local3.y,local3.z + 10);
if(FollowCameraController.getFollowCameraMode() == FollowCameraController.CAMERA_FOLLOWS_TURRET) {
_m.setRotationMatrix(local3.rotationX,local3.rotationY,local3.rotationZ);
param2.reset(_m.m01,_m.m11,_m.m21);
if(_m.m22 < -0.999) {
param2.scale(-1);
} else {
local4 = Math.PI / 6;
local5 = Math.sin(local4);
if(_m.m22 < local5) {
_v.reset(_m.m02,_m.m12,_m.m22);
_v.cross(Vector3.Z_AXIS).normalize();
_rm.fromAxisAngle(_v,local4 - Math.asin(_m.m22));
_m.append(_rm);
param2.reset(_m.m01,_m.m11,_m.m21);
}
}
} else {
BattleUtils.fillDirectionVector(param2,FollowCameraController.getFollowCameraDirection());
}
}
public function stopMovement() : void {
this.sounds.setIdleMode();
}
public function lockMovement(param1:Boolean) : void {
var local2:ITankModel = ITankModel(this.user.adapt(ITankModel));
var local3:LocalChassisController = LocalChassisController(local2.getChassisController());
if(param1) {
local3.lock(TankControlLockBits.SHAFT);
} else {
local3.unlock(TankControlLockBits.SHAFT);
}
}
public function getNumberOfBarrels() : int {
return this.skin.getTurretDescriptor().muzzles.length;
}
public function enableTurretSound(param1:Boolean) : void {
this.sounds.turretSoundEnabled = param1;
}
public function spawn(param1:BattleTeam, param2:int) : void {
this._teamType = param1;
this._incarnation = param2;
this.title.setTeamType(param1);
this.sounds.setIdleMode();
this.sounds.turretSoundEnabled = true;
this.skin.resetColorTransform();
this.skin.setNormalState();
this.maxSpeedSmoother.reset(this.maxSpeedSmoother.getTargetValue());
this.maxTurnSpeedSmoother.reset(this.maxTurnSpeedSmoother.getTargetValue());
}
public function kill() : void {
this.state = ClientTankState.DEAD;
this.health = 0;
this.sounds.enabled = false;
this.battleService.getBattleRunner().getSoundManager().removeEffect(this.sounds);
this.title.hideIndicators();
this.title.hide();
}
public function disable() : void {
this.title.hideIndicators();
}
public function isSameTeam(param1:BattleTeam) : Boolean {
return this._teamType == param1 && param1 != BattleTeam.NONE;
}
public function getUser() : IGameObject {
return this.user;
}
public function getMainCollisionBox() : CollisionBox {
return this.tankBody.tankCollisionBox;
}
public function setSemiActivatedState() : void {
this.state = ClientTankState.SEMI_ACTIVE;
this.setBodyCollisionGroup(CollisionGroup.TANK);
this.setTracksCollisionGroup(CollisionGroup.INACTIVE_TRACK);
this.skin.setAlpha(0.5);
this.tankBody.body.postCollisionFilter = this;
}
public function setActivatedState() : void {
this.state = ClientTankState.ACTIVE;
this.setBodyCollisionGroup(CollisionGroup.TANK | CollisionGroup.ACTIVE_TRACK | CollisionGroup.WEAPON);
this.setTracksCollisionGroup(CollisionGroup.ACTIVE_TRACK);
this.skin.setAlpha(1);
this.tankBody.body.postCollisionFilter = null;
}
public function considerBodies(param1:Body, param2:Body) : Boolean {
if(param1.postCollisionFilter != null && param2.postCollisionFilter == null) {
++param1.tank.collisionCount;
} else if(param1.postCollisionFilter == null && param2.postCollisionFilter != null) {
++param2.tank.collisionCount;
}
return false;
}
public function addToBattle(param1:BattleService) : void {
var local2:BattleRunner = null;
var local3:BattleScene3D = null;
if(this.battleService == null) {
this.battleService = param1;
this.tankBody.id = TankBodyIdProvider.claimId();
local2 = param1.getBattleRunner();
local2.addBodyWrapper(this.tankBody);
local2.addPhysicsController(this);
local2.addPostPhysicsController(this);
local2.addPhysicsInterpolator(this);
this.skin.addToScene();
this.title.addToContainer();
local3 = param1.getBattleScene3D();
local3.addTank(this);
local2.getSoundManager().addEffect(this.sounds);
this.hullTransformUpdater.reset();
local3.getDustEngine().addTank(this);
}
}
private function addDebugViewToScene(param1:BattleScene3D) : void {
}
public function removeFromBattle() : void {
var local1:BattleRunner = null;
var local2:BattleScene3D = null;
if(this.battleService != null) {
this.battleService.getBattleScene3D().getDustEngine().removeTank(this);
local1 = this.battleService.getBattleRunner();
local2 = this.battleService.getBattleScene3D();
local1.removeBodyWrapper(this.tankBody);
local1.removePhysicsController(this);
local1.removePostPhysicsController(this);
local1.removePhysicsInterpolator(this);
TankBodyIdProvider.releaseId(this.tankBody.id);
this.skin.removeFromScene();
this.title.removeFromContainer();
if(this.floatingTextEffect != null) {
this.floatingTextEffect.kill();
}
local2.removeTank(this);
local1.getSoundManager().removeEffect(this.sounds);
this.temperature = 0;
this.tankBody.body.clearAccumulators();
this._weaponMount.reset();
this.weapon.deactivate();
this.weapon.reset();
this.battleService = null;
}
}
private function removeDebugViewFromScene(param1:BattleScene3D) : void {
}
public function destroy() : void {
this.user = null;
this.state = ClientTankState.DEAD;
this.skin.dispose();
this.skin = null;
this.weapon.destroy();
this.tankBody.destroy();
if(this.validator != null) {
this.validator.destroy();
}
}
public function setMaxSpeed(param1:Number, param2:Boolean) : void {
if(param2) {
this.maxSpeedSmoother.reset(param1);
} else {
this.maxSpeedSmoother.setTargetValue(param1);
}
}
public function setMaxTurnSpeed(param1:Number, param2:Boolean) : void {
if(param2) {
this.maxTurnSpeedSmoother.reset(param1);
} else {
this.maxTurnSpeedSmoother.setTargetValue(param1);
}
}
public function runBeforePhysicsUpdate(param1:Number) : void {
this.collisionCount = 0;
var local2:Number = Number(this.maxSpeedSmoother.update(param1));
var local3:Number = Number(this.maxTurnSpeedSmoother.update(param1));
this.tankBody.body.setMaxSpeedXY(local2);
this.chassis.applyForces(local2,local3,param1);
this.tankBody.body.slipperyMode = !this.hasTracksContactsWithStatic() && this.tankBody.isSoaring();
this.rotateTurret(param1);
this.validateBodyState();
}
public function runAfterPhysicsUpdate(param1:Number) : void {
this.ensureBodyStateIsValid();
this.bodyStateValidator.refresh();
this._weaponMount.updatePhysics(this.getBody());
}
private function ensureBodyStateIsValid() : void {
var local1:Body = this.tankBody.body;
var local2:BodyState = local1.state;
if(!local2.isValid()) {
local2.copy(this.savedBodyState);
local1.saveState();
}
}
public function updatePhysicsState() : void {
this.interpolatePhysicsState(1,16);
this.hullTransformUpdater.update(0);
this.skin.updateTurretTransform(this._weaponMount.getTurretInterpolatedDirection(),this._weaponMount.getBarrelInterpolatedElevation());
}
public function interpolatePhysicsState(param1:Number, param2:int) : void {
this.tankBody.body.interpolate(param1,this.interpolatedPosition,this.interpolatedOrientation);
this.interpolatedOrientation.normalize();
this.interpolatedOrientation.toMatrix4(this.interpolatedTransform);
this.interpolatedTransform.setPosition(this.interpolatedPosition);
this._weaponMount.interpolate(param1,param2);
}
public function resetInterpolatedState() : void {
var local1:BodyState = this.tankBody.body.state;
this.interpolatedPosition.copy(local1.position);
this.interpolatedOrientation.copy(local1.orientation);
this.interpolatedOrientation.toMatrix4(this.interpolatedTransform);
this.interpolatedTransform.setPosition(this.interpolatedPosition);
}
public function render(param1:int, param2:int) : void {
var local4:Object3D = null;
var local3:Number = param2 * 0.001;
this.hullTransformUpdater.update(local3);
this.skin.updateTurretTransform(this._weaponMount.getTurretInterpolatedDirection(),this._weaponMount.getBarrelInterpolatedElevation());
this.skin.setColorTransformByTemperature(this.temperature);
this.tracksAnimator.animate(local3);
local4 = this.skin.getTurret3D();
_v.x = local4.x;
_v.y = local4.y;
_v.z = local4.z;
this.title.setWeaponStatus(100 * this.weapon.getStatus());
this.title.update(_v);
var local5:TankHullSkinCacheItem = this.skin.getHullDescriptor();
if(local5.hasIncorrectData()) {
this.battleEventDispatcher.dispatchEventOnce(new DataValidationErrorEvent(local5.getType()));
}
var local6:TurretSkinCacheItem = this.skin.getTurretDescriptor();
if(local6.hasIncorrectData()) {
this.battleEventDispatcher.dispatchEventOnce(new DataValidationErrorEvent(local6.getType()));
}
}
private function renderDebugView() : void {
}
public function setViewPositionByCollision(param1:Object3D, param2:CollisionBox) : void {
var local3:Matrix4 = param2.transform;
local3.getEulerAngles(_v);
param1.rotationX = _v.x;
param1.rotationY = _v.y;
param1.rotationZ = _v.z;
param1.x = local3.m03;
param1.y = local3.m13;
param1.z = local3.m23;
}
public function getValidator() : DataUnitValidator {
if(this.validator == null) {
this.validator = new TankDataValidator(this.tankBody.body.collisionShapes);
}
return this.validator;
}
public function isInvisible(param1:Vector3) : Boolean {
var local2:int = int(this.visibilityPoints.length);
var local3:int = 0;
while(local3 < local2) {
_point.copy(this.visibilityPoints[local3]);
if(this.isPointVisible(_point,param1)) {
return false;
}
local3++;
}
return true;
}
private function isPointVisible(param1:Vector3, param2:Vector3) : Boolean {
var local3:Body = this.tankBody.body;
param1.transform3(local3.baseMatrix);
var local4:BodyState = local3.state;
param1.add(local4.position);
_rayOrigin.copy(param2);
_rayVector.diff(param1,_rayOrigin);
var local5:PhysicsScene = local3.scene;
if(local5 == null) {
return false;
}
var local6:CollisionDetector = local5.collisionDetector;
return !local6.raycastStatic(_rayOrigin,_rayVector,CollisionGroup.STATIC,1,null,_rayHit);
}
public function getBodyCollisionGroup() : int {
return CollisionShape(this.tankBody.tankCollisionBox).collisionGroup;
}
public function setBodyCollisionGroup(param1:int) : void {
var local2:CollisionBox = null;
this.tankBody.tankCollisionBox.collisionGroup = param1;
for each(local2 in this.turretCollisions) {
local2.collisionGroup = param1 & CollisionGroup.WEAPON;
}
}
public function setTracksCollisionGroup(param1:int) : void {
this.chassis.setTracksCollisionGroup(param1);
}
public function setMovementParams(param1:int, param2:int, param3:int, param4:Boolean) : void {
this.chassis.movementDirection = param1;
this.chassis.turnDirection = param2;
this.chassis.turnSpeedNumber = param3;
this.chassis.inverseBackTurnMovement = param4;
if(param1 != 0) {
this.sounds.setAccelerationMode();
} else if(param2 != 0) {
this.sounds.setTurningMode();
} else {
this.sounds.setIdleMode();
}
}
public function setPhysicsState(param1:Vector3d, param2:Vector3d, param3:Vector3d, param4:Vector3d) : void {
var local5:Body = this.tankBody.body;
var local6:BodyState = local5.state;
BattleUtils.copyToVector3(param1,local6.position);
local6.orientation.setFromEulerAnglesXYZ(param2.x,param2.y,param2.z);
BattleUtils.copyToVector3(param3,local6.velocity);
BattleUtils.copyToVector3(param4,local6.angularVelocity);
local5.saveState();
local5.calcDerivedData();
this.bodyStateValidator.refresh();
}
public function getPhysicsPosition(param1:Vector3) : void {
var local2:Vector3 = this.tankBody.body.state.position;
param1.reset(local2.x,local2.y,local2.z);
}
public function getPhysicsState(param1:Vector3d, param2:Vector3d, param3:Vector3d, param4:Vector3d) : void {
_getPhysicsState(this.tankBody.body.state,param1,param2,param3,param4);
}
public function getPreviousPhysicsState(param1:Vector3d, param2:Vector3d, param3:Vector3d, param4:Vector3d) : void {
_getPhysicsState(this.tankBody.body.prevState,param1,param2,param3,param4);
}
public function getBody() : Body {
return this.tankBody.body;
}
public function setTemperature(param1:Number) : void {
this.temperature = param1;
}
public function getTemperature() : Number {
return this.temperature;
}
private function rotateTurret(param1:Number) : void {
this._weaponMount.rotate(param1,this.tankBody.body.baseMatrix);
this.updateTurretPhysics(this._weaponMount.getTurretPhysicsDirection());
this.sounds.playTurretSound(this._weaponMount.isRotating());
}
private function updateTurretPhysics(param1:Number) : void {
var local5:CollisionBox = null;
var local6:Matrix4 = null;
var local7:TurretGeometryItem = null;
var local2:TankHullSkinCacheItem = this.skin.getHullDescriptor();
var local3:Vector.<TurretGeometryItem> = this.skin.getTurretGeometry();
var local4:int = 0;
while(local4 < this.turretCollisions.length) {
local5 = this.turretCollisions[local4];
local6 = local5.localTransform;
local6.setMatrix(local2.getTurretMountPointX() + this.skinCenterOffset.x,local2.getTurretMountPointY() + this.skinCenterOffset.y,local2.getTurretMountPointZ() + this.skinCenterOffset.z,0,0,param1);
local7 = local3[local4];
local6.prepend(local7.getTransform());
local4++;
}
}
private function validateBodyState() : void {
this.savedBodyState.copy(this.tankBody.body.state);
this.bodyStateValidator.validate();
}
private function createBody(param1:Number, param2:Vector3) : void {
var local3:Body = new Body(param1,Matrix3.IDENTITY,0);
PhysicsUtils.setBoxInvInertia(param1,param2,local3.invInertia);
local3.tank = this;
this.tankBody = new TankBody(local3);
}
private function createCollisionPrimitives(param1:Vector3) : void {
var local2:Number = 2 * param1.z - (this.suspensionParams.nominalRayLength - TankConst.RAY_OFFSET);
CollisionBoxesBuilder.createTankCollisionBox(param1,local2,this.tankBody);
CollisionBoxesBuilder.createStaticCollisionBoxes(param1,local2,this.tankBody);
this.setBoundSphereRadius(param1,local2);
}
private function setBoundSphereRadius(param1:Vector3, param2:Number) : void {
var local3:Vector3 = new Vector3(param1.x,param1.y,param2 / 2);
var local4:Matrix4 = this.tankBody.tankCollisionBox.localTransform;
this.boundSphereRadius = local3.length() + Math.abs(local4.m23);
}
private function createVisibilityPoints(param1:Vector3) : void {
var local2:Number = param1.x;
var local3:Number = param1.y;
this.visibilityPoints = Vector.<Vector3>([new Vector3(-local2,local3,0),new Vector3(local2,local3,0),new Vector3(-local2,0,0),new Vector3(local2,0,0),new Vector3(-local2,-local3,0),new Vector3(local2,-local3,0)]);
}
private function calculateSkinCenterOffset(param1:Vector3) : void {
var local2:Mesh = this.skin.getHullMesh();
local2.calculateBounds();
this.skinCenterOffset.x = -0.5 * (local2.boundMinX + local2.boundMaxX);
this.skinCenterOffset.y = -0.5 * (local2.boundMinY + local2.boundMaxY);
this.skinCenterOffset.z = -0.5 * param1.z - this.suspensionParams.nominalRayLength + TankConst.RAY_OFFSET;
}
public function getSkinCenterOffset() : Vector3 {
return this.skinCenterOffset;
}
public function getTitleTexture() : BitmapData {
return this.title.getTexture();
}
public function readTitlePosition(param1:Vector3D) : void {
this.title.readPosition(param1);
}
public function getHalfLength() : Number {
return this.halfLength;
}
public function getMaxHealth() : int {
return this.maxHealth;
}
public function getBoundSphereRadius() : Number {
return this.boundSphereRadius;
}
public function applyWeaponHit(param1:Vector3, param2:Vector3, param3:Number) : void {
if(this.health > 0) {
if(this.isImpactEnabled()) {
this.tankBody.body.addWorldForceScaled(param1,param2,param3);
this.tankBody.additionForcesSum.addScaled(param3,param2);
}
this.setLastHitPoint(param1);
}
}
private function isImpactEnabled() : Boolean {
var local1:IGameObject = ITankModel(this.user.adapt(ITankModel)).getTankSet().hull;
if(local1.hasModel(ImpactEnable)) {
return ImpactEnable(local1.adapt(ImpactEnable)).isImpactEnabled();
}
return true;
}
public function getLeftTrack() : Track {
return this.chassis.leftTrack;
}
public function getRightTrack() : Track {
return this.chassis.rightTrack;
}
public function hasTracksContactsWithStatic() : Boolean {
return this.getLeftTrack().hasContactsWithStatic() || this.getRightTrack().hasContactsWithStatic();
}
public function hasCollisionWithStatic() : Boolean {
return this.tankBody.hasContactsWithStatic;
}
public function hasCollisionWithOtherBodies() : Boolean {
return this.tankBody.hasContactsWithOtherBodies();
}
public function getPenetratedBodies() : Vector.<Body> {
return this.tankBody.penetratedBodies;
}
public function setAcceleration(param1:Number) : void {
this.chassis.setAcceleration(param1);
}
public function setReverseAcceleration(param1:Number) : void {
this.chassis.setReverseAcceleration(param1);
}
public function setSideAcceleration(param1:Number) : void {
this.chassis.setSideAcceleration(param1);
}
public function setTurnAcceleration(param1:Number) : void {
this.chassis.setTurnAcceleration(param1);
}
public function setReverseTurnAcceleration(param1:Number) : void {
this.chassis.setReverseTurnAcceleration(param1);
}
public function setStabilizationAcceleration(param1:Number) : void {
this.chassis.setStabilizationAcceleration(param1);
}
public function isInBattle() : Boolean {
return this.battleService != null;
}
public function isJumpBegin() : Boolean {
return this.tankBody.isJumpBegin();
}
public function isJumpEnd() : Boolean {
return this.tankBody.isJumpEnd();
}
public function isElasticStaticCollisionWhenSoaring() : Boolean {
return this.tankBody.isElasticStaticCollisionWhenSoaring();
}
public function setLastHitPoint(param1:Vector3) : void {
this.lastHitPoint.copy(param1);
BattleUtils.globalToLocal(this.getBody(),this.lastHitPoint);
this.isLastHitPointSet = true;
}
public function getInterpolatedTurretWorldDirection() : Number {
BattleUtils.fillDirectionVector(_v,this._weaponMount.getTurretInterpolatedDirection());
_v.deltaTransform4(this.interpolatedTransform);
return BattleUtils.getDirectionAngle(_v);
}
public function get stunned() : Boolean {
return this._stunned;
}
public function set stunned(param1:Boolean) : void {
this._stunned = param1;
}
public function getIndicatorPosition() : Vector3 {
return this.tankBody.body.state.position;
}
public function isIndicatorActive(param1:Vector3 = null) : Boolean {
return this.state == ClientTankState.ACTIVE && IBossState(this.user.adapt(IBossState)).role() != BossRelationRole.BOSS;
}
public function zOffset() : Number {
return 0;
}
}
}
|
package alternativa.tanks.models.weapon.railgun {
[ModelInterface]
public interface IRailgunSFXModel {
function getEffects() : IRailgunEffects;
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_heavycapacitorsIconClass.png")]
public class DeviceIcons_heavycapacitorsIconClass extends BitmapAsset {
public function DeviceIcons_heavycapacitorsIconClass() {
super();
}
}
}
|
package forms
{
public class AlertAnswer
{
public static var YES:String;
public static var NO:String;
public static var OK:String;
public static var CANCEL:String;
public static var SEND:String;
public static var RETURN:String;
public static var GARAGE:String;
public static var PROCEED:String;
public function AlertAnswer()
{
super();
}
}
}
|
package alternativa.tanks.models.battle.commonflag {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.models.battle.assault.PointBaseIndicatorPlane;
import alternativa.tanks.models.battle.gui.markers.PointIndicatorStateProvider;
import alternativa.tanks.models.battle.gui.markers.PointMarker;
import alternativa.utils.TextureMaterialRegistry;
import flash.display.BitmapData;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class MarkersUtils {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var materialRegistry:TextureMaterialRegistry;
public function MarkersUtils() {
super();
}
public static function createMarkers(param1:BattleTeam, param2:BitmapData, param3:BitmapData, param4:PointIndicatorStateProvider, param5:Boolean = false) : void {
initMarker2D(param2,param4,param5);
initMarker3D(param1,param3,param4);
}
public static function initMarker2D(param1:BitmapData, param2:PointIndicatorStateProvider, param3:Boolean = false) : PointMarker {
var local4:PointMarker = new PointMarker(battleService.getBattleScene3D().getCamera(),param1,param2,param3);
battleService.getBattleScene3D().addRenderer(local4,0);
return local4;
}
public static function initMarker3D(param1:BattleTeam, param2:BitmapData, param3:PointIndicatorStateProvider) : PointBaseIndicatorPlane {
var local4:TextureMaterial = getCircleMaterial(param2);
var local5:PointBaseIndicatorPlane = new PointBaseIndicatorPlane(param1,local4,battleService,param3);
battleService.getBattleScene3D().addRenderer(local5,0);
battleService.getBattleScene3D().addObject(local5);
return local5;
}
private static function getCircleMaterial(param1:BitmapData) : TextureMaterial {
var local2:TextureMaterial = materialRegistry.getMaterial(param1,false);
local2.resolution = 1000 / param1.width;
return local2;
}
}
}
|
package projects.tanks.client.battlefield.models.battle.cp {
import alternativa.types.Long;
import projects.tanks.client.battlefield.types.Vector3d;
public class ClientPointData {
private var _id:int;
private var _name:String;
private var _position:Vector3d;
private var _score:Number;
private var _scoreChangeRate:Number;
private var _state:ControlPointState;
private var _tankIds:Vector.<Long>;
public function ClientPointData(param1:int = 0, param2:String = null, param3:Vector3d = null, param4:Number = 0, param5:Number = 0, param6:ControlPointState = null, param7:Vector.<Long> = null) {
super();
this._id = param1;
this._name = param2;
this._position = param3;
this._score = param4;
this._scoreChangeRate = param5;
this._state = param6;
this._tankIds = param7;
}
public function get id() : int {
return this._id;
}
public function set id(param1:int) : void {
this._id = param1;
}
public function get name() : String {
return this._name;
}
public function set name(param1:String) : void {
this._name = param1;
}
public function get position() : Vector3d {
return this._position;
}
public function set position(param1:Vector3d) : void {
this._position = param1;
}
public function get score() : Number {
return this._score;
}
public function set score(param1:Number) : void {
this._score = param1;
}
public function get scoreChangeRate() : Number {
return this._scoreChangeRate;
}
public function set scoreChangeRate(param1:Number) : void {
this._scoreChangeRate = param1;
}
public function get state() : ControlPointState {
return this._state;
}
public function set state(param1:ControlPointState) : void {
this._state = param1;
}
public function get tankIds() : Vector.<Long> {
return this._tankIds;
}
public function set tankIds(param1:Vector.<Long>) : void {
this._tankIds = param1;
}
public function toString() : String {
var local1:String = "ClientPointData [";
local1 += "id = " + this.id + " ";
local1 += "name = " + this.name + " ";
local1 += "position = " + this.position + " ";
local1 += "score = " + this.score + " ";
local1 += "scoreChangeRate = " + this.scoreChangeRate + " ";
local1 += "state = " + this.state + " ";
local1 += "tankIds = " + this.tankIds + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.gui.friends.list.renderer.background {
import alternativa.tanks.gui.friends.list.AcceptedList;
import alternativa.tanks.gui.friends.list.renderer.HeaderAcceptedList;
import controls.cellrenderer.ButtonState;
import flash.display.Sprite;
public class RendererBackGroundAcceptedList extends Sprite {
protected var tabs:Vector.<Number>;
protected var _width:int = 100;
public function RendererBackGroundAcceptedList(param1:Boolean, param2:Boolean = false) {
var local3:ButtonState = null;
this.tabs = new Vector.<Number>();
super();
var local4:int = int(HeaderAcceptedList.HEADERS.length);
var local5:int = 0;
while(local5 < local4) {
if(param1) {
if(param2) {
local3 = new FriendCellSelected();
} else {
local3 = new FriendCellNormal();
}
} else if(param2) {
local3 = new UserOfflineCellSelected();
} else {
local3 = new UserOfflineCellNormal();
}
addChild(local3);
local5++;
}
this.resize();
}
protected function resize() : void {
var local1:ButtonState = null;
if(this.isScroll()) {
this.tabs = Vector.<Number>([0,this._width - 224,this._width - 1]);
} else {
this.tabs = Vector.<Number>([0,this._width - 233,this._width - 1]);
}
var local2:int = int(HeaderAcceptedList.HEADERS.length);
var local3:int = 0;
while(local3 < local2) {
local1 = getChildAt(local3) as ButtonState;
local1.width = this.tabs[local3 + 1] - this.tabs[local3] - 2;
local1.height = 18;
local1.x = this.tabs[local3];
local3++;
}
graphics.clear();
graphics.beginFill(16711680,0);
graphics.drawRect(0,0,this._width - 1,18);
graphics.endFill();
}
protected function isScroll() : Boolean {
return AcceptedList.SCROLL_ON;
}
override public function set width(param1:Number) : void {
this._width = Math.floor(param1);
this.resize();
}
}
}
|
package alternativa.tanks.utils
{
public class MathUtils
{
public static const PI2:Number = 2 * Math.PI;
public function MathUtils()
{
super();
}
public static function clamp(value:Number, min:Number, max:Number) : Number
{
if(value < min)
{
return min;
}
if(value > max)
{
return max;
}
return value;
}
public static function clampAngle(radians:Number) : Number
{
radians %= PI2;
if(radians < -Math.PI)
{
return PI2 + radians;
}
if(radians > Math.PI)
{
return radians - PI2;
}
return radians;
}
public static function clampAngleFast(radians:Number) : Number
{
if(radians < -Math.PI)
{
return PI2 + radians;
}
if(radians > Math.PI)
{
return radians - PI2;
}
return radians;
}
public static function getBitValue(param1:int, param2:int) : int
{
return param1 >> param2 & 1;
}
public static function nearestPowerOf2(param1:int) : int
{
return 1 << Math.ceil(Math.log(param1) / Math.LN2);
}
}
}
|
package alternativa.tanks.model.payment.shop.indemnity {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IndemnityAdapt implements Indemnity {
private var object:IGameObject;
private var impl:Indemnity;
public function IndemnityAdapt(param1:IGameObject, param2:Indemnity) {
super();
this.object = param1;
this.impl = param2;
}
public function getIndemnitySize() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getIndemnitySize());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.gui {
import alternativa.engine3d.objects.SkyBox;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.buttons.GarageButton;
import alternativa.tanks.gui.category.CategoryButtonsList;
import alternativa.tanks.gui.garagelist.GarageList;
import alternativa.tanks.gui.garagelist.GarageListController;
import alternativa.tanks.gui.tankpreview.EventTankPreview;
import alternativa.tanks.gui.tankpreview.TankPreviewWindow;
import alternativa.tanks.model.item.info.ItemActionPanel;
import alternativa.tanks.model.item.shopabonement.ShopAbonement;
import alternativa.tanks.service.item.ItemService;
import alternativa.tanks.service.item3d.ITank3DViewer;
import alternativa.tanks.tracker.ITrackerService;
import base.DiscreteSprite;
import controls.TankWindow;
import controls.TankWindowInner;
import controls.buttons.ButtonStates;
import controls.timer.CountDownTimer;
import flash.events.MouseEvent;
import flash.geom.Point;
import flash.utils.getTimer;
import forms.events.PartsListEvent;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.types.ItemViewCategoryEnum;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.AlertServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.BattleInfoServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.garage.UserGarageActionsService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.removeDisplayObject;
import services.alertservice.AlertAnswer;
public class GarageWindow extends DiscreteSprite implements IGarageWindow {
[Inject]
public static var itemService:ItemService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var trackerService:ITrackerService;
[Inject]
public static var userGarageActionsService:UserGarageActionsService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var tank3DViewer:ITank3DViewer;
[Inject]
public static var paymentDisplayService:PaymentDisplayService;
private static const GA_CATEGORY:String = "garage";
private static const windowMargin:int = 11;
private static const itemInfoPanelWidth:int = 412;
public var timersKitCouldBeBoughtContext:Vector.<TimerKitCouldBeBoughtContext>;
public var itemInfoPanel:ItemInfoPanel;
public var tankPreview:TankPreviewWindow;
private var _windowSize:Point;
private var _selectedItem:IGameObject;
private var _garageListWindow:TankWindow;
private var _garageListInner:TankWindowInner;
private var _garageList:GarageList;
private var _categoryButtons:CategoryButtonsList;
private var _garageListController:GarageListController;
public function GarageWindow(param1:Boolean) {
super();
this.timersKitCouldBeBoughtContext = new Vector.<TimerKitCouldBeBoughtContext>();
this.itemInfoPanel = new ItemInfoPanel(param1,itemInfoPanelWidth);
addChild(this.itemInfoPanel);
this._garageListWindow = new TankWindow();
addChild(this._garageListWindow);
this._garageListInner = new TankWindowInner(0,0,TankWindowInner.GREEN);
this._garageListInner.showBlink = true;
addChild(this._garageListInner);
this._garageList = new GarageList();
addChild(this._garageList);
this._categoryButtons = new CategoryButtonsList();
addChild(this._categoryButtons);
this._garageListController = new GarageListController(this._garageList,this._categoryButtons);
this.updateNavigationLock();
this.setEvents();
}
public function initTankPreviewWindow(param1:Tanks3DSResource, param2:SkyBox) : void {
this.tankPreview = param1.id.low == 500360050 ? new TankPreviewWindow() : new EventTankPreview();
this.tankPreview.init(param1,param2);
addChild(this.tankPreview);
tank3DViewer.setView(this.tankPreview);
if(this._windowSize != null) {
this.tankPreview.resize(this._windowSize.x - itemInfoPanelWidth,this._windowSize.y - this._garageListWindow.height);
}
}
private function onGarageItemDoubleClick(param1:PartsListEvent) : void {
this.onSelectGarageListItem(param1);
if(this._selectedItem.hasModel(ItemActionPanel)) {
ItemActionPanel(this._selectedItem.adapt(ItemActionPanel)).handleDoubleClickOnItemPreview();
return;
}
if(this._selectedItem.hasModel(ShopAbonement)) {
paymentDisplayService.openPaymentAt(ShopAbonement(this._selectedItem.adapt(ShopAbonement)).getShopCategory());
} else if(Boolean(this.itemInfoPanel.equipButton.visible) && this.itemInfoPanel.equipButton.getState() == ButtonStates.UP) {
this.equip();
} else if(this.itemInfoPanel.upgradeButton.visible && this.itemInfoPanel.upgradeButton.getState() == ButtonStates.UP) {
this.itemInfoPanel.upgradeSelectedItem();
} else if(Boolean(this.itemInfoPanel.buyButton.visible) && this.itemInfoPanel.buyButton.getState() == ButtonStates.UP) {
this.onButtonBuyClickInternal();
} else if(Boolean(this.itemInfoPanel.deletePresentButton.visible) && this.itemInfoPanel.deletePresentButton.getState() == ButtonStates.UP) {
this.deletePresentInternal();
}
}
private function setEvents() : void {
this._garageList.addEventListener(PartsListEvent.SELECT_PARTS_LIST_ITEM,this.onSelectGarageListItem);
this._garageList.addEventListener(PartsListEvent.ITEM_DOUBLE_CLICK,this.onGarageItemDoubleClick);
this.itemInfoPanel.buyButton.addEventListener(MouseEvent.CLICK,this.onButtonBuyClick);
this.itemInfoPanel.equipButton.addEventListener(MouseEvent.CLICK,this.onButtonEquipClick);
this.itemInfoPanel.deletePresentButton.addEventListener(MouseEvent.CLICK,this.onButtonDeletePresentClick);
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.BEGIN_LAYOUT_SWITCH,this.updateNavigationLock);
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.updateNavigationLock);
battleInfoService.addEventListener(BattleInfoServiceEvent.BATTLE_START,this.onBattleStart);
}
private function onBattleStart(param1:BattleInfoServiceEvent) : void {
if(this._selectedItem != null) {
this.itemInfoPanel.updateEquipButton();
}
}
private function deletePresentInternal() : void {
alertService.showAlert(localeService.getText(TanksLocale.TEXT_PRESENT_WILL_BE_REMOVED_ALERT),Vector.<String>([AlertAnswer.OK,AlertAnswer.CANCEL]));
alertService.addEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onAlertAnswer);
}
private function onButtonDeletePresentClick(param1:MouseEvent) : void {
this.deletePresentInternal();
}
private function onAlertAnswer(param1:AlertServiceEvent) : void {
alertService.removeEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onAlertAnswer);
if(param1.typeButton == AlertAnswer.OK) {
dispatchEvent(new GarageWindowEvent(GarageWindowEvent.DELETE_PRESENT,this._selectedItem));
this.removeItemFromDepot(this._selectedItem);
if(this._garageListController.getCurrentCategoryItemsCount() > 0) {
this.updateSelection();
} else {
this._categoryButtons.setCategoryButtonVisibility(ItemViewCategoryEnum.GIVEN_PRESENTS,false);
this.showDefaultCategory();
}
}
}
private function onSelectGarageListItem(param1:PartsListEvent) : void {
this._selectedItem = this._garageList.selectedItem;
var local2:Boolean = this._garageListController.isItemInDepot(this._selectedItem);
this.showItemInfo(this._selectedItem,!local2);
if(local2) {
dispatchEvent(new GarageWindowEvent(GarageWindowEvent.WAREHOUSE_ITEM_SELECTED,this._selectedItem));
} else {
dispatchEvent(new GarageWindowEvent(GarageWindowEvent.STORE_ITEM_SELECTED,this._selectedItem));
}
userGarageActionsService.selectItem(this._selectedItem);
}
private function onButtonBuyClickInternal() : void {
var local1:IGameObject = null;
if(Boolean(itemService.isModificationItem(this._selectedItem)) && this.isItemInDepot(this._selectedItem)) {
local1 = itemService.getMaxAvailableModification(this._selectedItem);
userGarageActionsService.buyItemModification(local1);
trackerService.trackEvent(GA_CATEGORY,GarageWindowEvent.UPGRADE_ITEM,itemService.getName(this._selectedItem));
} else {
local1 = this._selectedItem;
userGarageActionsService.buyItem(local1);
trackerService.trackEvent(GA_CATEGORY,GarageWindowEvent.BUY_ITEM,itemService.getName(this._selectedItem));
}
dispatchEvent(new GarageWindowEvent(GarageWindowEvent.BUY_ITEM,local1));
}
private function onButtonBuyClick(param1:MouseEvent) : void {
this.onButtonBuyClickInternal();
}
private function equip() : void {
trackerService.trackEvent(GA_CATEGORY,GarageWindowEvent.SETUP_ITEM,itemService.getName(this._selectedItem));
dispatchEvent(new GarageWindowEvent(GarageWindowEvent.SETUP_ITEM,this._selectedItem));
}
private function onButtonEquipClick(param1:MouseEvent) : void {
this.equip();
}
private function removeEvents() : void {
this._garageList.removeEventListener(PartsListEvent.SELECT_PARTS_LIST_ITEM,this.onSelectGarageListItem);
this.itemInfoPanel.buyButton.removeEventListener(MouseEvent.CLICK,this.onButtonBuyClick);
this.itemInfoPanel.equipButton.removeEventListener(MouseEvent.CLICK,this.onButtonEquipClick);
this.itemInfoPanel.deletePresentButton.removeEventListener(MouseEvent.CLICK,this.onButtonDeletePresentClick);
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.BEGIN_LAYOUT_SWITCH,this.updateNavigationLock);
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.updateNavigationLock);
battleInfoService.removeEventListener(BattleInfoServiceEvent.BATTLE_START,this.onBattleStart);
this.removeTimerListeners();
}
private function removeTimerListeners() : void {
var local1:TimerKitCouldBeBoughtContext = null;
for each(local1 in this.timersKitCouldBeBoughtContext) {
local1.removeListener();
}
}
private function updateNavigationLock(param1:LobbyLayoutServiceEvent = null) : void {
var local2:GarageButton = this.itemInfoPanel.buyButton;
if(lobbyLayoutService.isSwitchInProgress()) {
local2.mouseEnabled = false;
local2.mouseChildren = false;
} else {
local2.mouseEnabled = local2.enabled;
local2.mouseChildren = local2.enabled;
}
}
public function destroy() : void {
this.removeEvents();
if(this.tankPreview != null) {
removeDisplayObject(this.tankPreview);
this.tankPreview.destroy();
this.tankPreview = null;
}
this.itemInfoPanel.destroy();
this.itemInfoPanel = null;
removeDisplayObject(this._garageListWindow);
this._garageListWindow = null;
removeDisplayObject(this._garageListInner);
this._garageListInner = null;
this._garageListController.destroy();
this._garageListController = null;
this._garageList = null;
this._categoryButtons = null;
this._selectedItem = null;
}
public function resize(param1:int, param2:int) : void {
this._windowSize = new Point(param1,param2);
this._garageListWindow.width = param1;
this._garageListWindow.height = 205;
this._garageListWindow.x = 0;
this._garageListWindow.y = param2 - this._garageListWindow.height;
this._garageListInner.width = param1 - windowMargin * 2;
this._garageListInner.height = 169 - windowMargin * 2;
this._garageListInner.x = windowMargin;
this._garageListInner.y = this._garageListWindow.y + windowMargin;
this._garageList.width = this._garageListWindow.width - windowMargin * 2 - 8;
this._garageList.height = 169 - windowMargin * 2 + 1;
this._garageList.x = windowMargin + 4;
this._garageList.y = this._garageListWindow.y + windowMargin + 4;
this._categoryButtons.width = param1 - windowMargin * 2 - 8;
this._categoryButtons.x = windowMargin;
this._categoryButtons.y = this._garageList.y + this._garageList.height;
if(this.tankPreview != null) {
this.tankPreview.resize(param1 - itemInfoPanelWidth,param2 - this._garageListWindow.height);
}
this.itemInfoPanel.resize(itemInfoPanelWidth,param2 - this._garageListWindow.height);
this.itemInfoPanel.x = param1 - itemInfoPanelWidth;
}
public function isItemInStore(param1:IGameObject) : Boolean {
return this._garageListController.isItemInStore(param1);
}
public function isItemInDepot(param1:IGameObject) : Boolean {
return this._garageListController.isItemInDepot(param1);
}
public function addItemToDepot(param1:IGameObject) : void {
this._garageListController.addItemToDepot(param1);
}
public function addItemToStore(param1:IGameObject) : void {
this._garageListController.addItemToStore(param1);
}
public function updateKitsContainsItem(param1:IGameObject) : void {
this._garageListController.updateKitsContainsItem(param1);
}
public function removeItemFromDepot(param1:IGameObject) : void {
this._garageListController.removeItemFromDepot(param1);
}
public function removeItemFromStore(param1:IGameObject) : void {
this._garageListController.removeItemFromStore(param1);
}
public function get itemsOnDepot() : Vector.<IGameObject> {
return this._garageListController.itemsInDepot;
}
public function unmountItem(param1:IGameObject) : void {
this._garageList.unmount(param1);
}
public function mountItem(param1:IGameObject) : void {
this._garageList.mount(param1);
}
public function showItemInfo(param1:IGameObject, param2:Boolean) : void {
this.itemInfoPanel.showItemInfo(param1,param2);
this.itemInfoPanel.resize(itemInfoPanelWidth,this._windowSize.y - this._garageListWindow.height);
}
public function removeAllModifications(param1:IGameObject) : void {
var local3:IGameObject = null;
var local2:Vector.<IGameObject> = itemService.getModifications(param1);
for each(local3 in local2) {
if(this.isItemInDepot(local3)) {
this.removeItemFromDepot(local3);
}
if(this.isItemInStore(local3)) {
this.removeItemFromStore(local3);
}
}
}
public function updateCount(param1:IGameObject) : void {
this._garageList.updateCount(param1,itemService.getCount(param1));
}
public function updateDiscount(param1:IGameObject) : void {
if(this._selectedItem == param1) {
this.showItemInfo(this._selectedItem,this.isItemInStore(this._selectedItem));
}
this._garageListController.updateDiscount(param1);
}
public function getSelectedItem() : IGameObject {
return this._selectedItem;
}
public function getItemInfoPanel() : ItemInfoPanel {
return this.itemInfoPanel;
}
public function initDepot(param1:Vector.<IGameObject>) : void {
this._garageListController.initDepot(param1);
}
public function initStore(param1:Vector.<IGameObject>) : void {
this.checkIfTimersKitCouldBeBoughtContext(param1);
this._garageListController.initStore(param1);
}
private function checkIfTimersKitCouldBeBoughtContext(param1:Vector.<IGameObject>) : void {
var local4:IGameObject = null;
var local5:int = 0;
var local6:int = 0;
var local7:uint = 0;
var local8:CountDownTimer = null;
var local2:int = int(param1.length);
var local3:int = 0;
while(local3 < local2) {
local4 = param1[local3];
if(Boolean(itemService.isKit(local4)) && Boolean(itemService.canBuy(local4)) && Boolean(itemService.isEnabledItem(local4))) {
local5 = int(itemService.getTimeLeftInSeconds(local4));
local6 = 2592000;
if(!itemService.isTimelessItem(local4) && local5 > 0 && local5 <= local6) {
local7 = uint(local5 * 1000);
local8 = new CountDownTimer();
local8.start(local7 + getTimer());
this.timersKitCouldBeBoughtContext.push(new TimerKitCouldBeBoughtContext(local4,local8,this));
}
}
local3++;
}
}
public function itemFullUpgraded(param1:IGameObject) : void {
var local2:IGameObject = null;
if(itemService.isModificationItem(this._selectedItem)) {
local2 = itemService.getNextModification(param1);
if(local2 != null) {
this.updateDiscount(local2);
}
}
}
public function showDefaultCategory() : void {
this._garageListController.showDefaultCategory();
}
public function showCategory(param1:ItemViewCategoryEnum) : void {
this._garageListController.showCategory(param1);
}
public function showItemInCategory(param1:IGameObject) : void {
this._garageListController.showItemInCategory(param1);
}
public function updateSelection() : void {
this._garageListController.updateSelection();
}
public function getTimersKitCouldBeBoughtContext() : Vector.<TimerKitCouldBeBoughtContext> {
return this.timersKitCouldBeBoughtContext;
}
public function setCategoryButtonVisibility(param1:ItemViewCategoryEnum, param2:Boolean) : void {
this._categoryButtons.setCategoryButtonVisibility(param1,param2);
}
}
}
|
package alternativa.tanks.model.news
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class NewsIcons_sale_20 extends BitmapAsset
{
public function NewsIcons_sale_20()
{
super();
}
}
}
|
package _codec.projects.tanks.client.battleservice.model.createparams {
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.battleservice.model.createparams.BattleLimits;
public class VectorCodecBattleLimitsLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattleLimitsLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BattleLimits,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.<BattleLimits> = new Vector.<BattleLimits>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattleLimits(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattleLimits = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattleLimits> = Vector.<BattleLimits>(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.banners
{
import scpacker.Base;
public class BannerModelBase extends Base
{
public function BannerModelBase()
{
super();
}
}
}
|
package alternativa.tanks.gui.socialnetwork.vk {
import alternativa.tanks.gui.socialnetwork.AbstractSNGroupEnteringWindow;
import flash.display.Bitmap;
import flash.display.BitmapData;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class VkGroupThanksForEnteringWindow extends AbstractSNGroupEnteringWindow {
private static var thanksForEnteringBitmapDataClass:Class = VkGroupThanksForEnteringWindow_thanksForEnteringBitmapDataClass;
protected static var thanksForEnteringBitmapData:BitmapData = Bitmap(new thanksForEnteringBitmapDataClass()).bitmapData;
public function VkGroupThanksForEnteringWindow() {
super(thanksForEnteringBitmapData,VkGroupReminderWindow.SN_GROUP_URL,localeService.getText(TanksLocale.TEXT_VK_ENTER_GROUP_BONUS));
}
}
}
|
package assets.window.elemets {
import flash.display.Sprite;
[Embed(source="/_assets/assets.swf", symbol="symbol1073")]
public class WindowTopRightCorner extends Sprite {
public function WindowTopRightCorner() {
super();
}
}
}
|
package scpacker.server.models.inventory
{
import alternativa.init.Main;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import alternativa.tanks.models.battlefield.inventory.IInventoryItemModel;
import alternativa.tanks.models.battlefield.inventory.InventoryItemModel;
import alternativa.tanks.models.battlefield.inventory.InventoryModel;
import alternativa.tanks.models.effectsvisualization.EffectsVisualizationModel;
import alternativa.tanks.models.effectsvisualization.IEffectsVisualizationModel;
import alternativa.tanks.models.inventory.IInventory;
import flash.utils.Dictionary;
public class ServerInventoryModel
{
private var inventoryModel:InventoryModel;
private var inventoryItemModel:InventoryItemModel;
private var effectModel:EffectsVisualizationModel;
private var modelsService:IModelService;
private var _objects:Dictionary;
public function ServerInventoryModel()
{
super();
}
public function init() : void
{
this.modelsService = IModelService(Main.osgi.getService(IModelService));
this.inventoryModel = InventoryModel(this.modelsService.getModelsByInterface(IInventory)[0]);
this.inventoryItemModel = InventoryItemModel(this.modelsService.getModelsByInterface(IInventoryItemModel)[0]);
this.effectModel = EffectsVisualizationModel(this.modelsService.getModelsByInterface(IEffectsVisualizationModel)[0]);
this._objects = new Dictionary();
}
public function initInventory(items:Array) : void
{
var data:ServerInventoryData = null;
var clientObject:ClientObject = null;
this.inventoryModel.objectLoaded(null);
for each(data in items)
{
clientObject = this.getClientObject(data.id);
this.inventoryItemModel.initObject(clientObject,null,data.count,data.itemEffectTime,data.slotId,data.itemRestSec);
this._objects[data.id] = clientObject;
}
}
public function updateInventory(items:Array) : void
{
var data:ServerInventoryData = null;
if(this.inventoryModel == null || this.inventoryItemModel == null)
{
return;
}
for each(data in items)
{
this.inventoryItemModel.updateItemCount(this._objects[data.id],data.count);
}
}
public function activateItem(id:String) : void
{
this.inventoryItemModel.activated(this._objects[id]);
}
public function enableEffects(clientObject:ClientObject, effects:Array) : void
{
this.effectModel.initObject(clientObject,effects);
}
public function enableEffect(clientObject:ClientObject, itemIndex:int, duration:int) : void
{
this.effectModel.effectActivated(clientObject,clientObject.id,itemIndex,duration);
}
public function disnableEffect(clientObject:ClientObject, itemIndex:int) : void
{
this.effectModel.effectStopped(clientObject,clientObject.id,itemIndex);
}
public function localTankKilled() : void
{
if(this.inventoryModel == null)
{
return;
}
this.inventoryModel.killCurrentUser(null);
}
private function getClientObject(id:String) : ClientObject
{
return new ClientObject(id,null,id,null);
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _93df922425d86063798d3a2248bbbb810d83ac1e831d8c4a345ee09bd87fe744_flash_display_Sprite extends Sprite {
public function _93df922425d86063798d3a2248bbbb810d83ac1e831d8c4a345ee09bd87fe744_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package alternativa.tanks.models.battlefield.hidableobjects
{
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
public class HidableObject3DWrapper implements HidableGraphicObject
{
private var object:Object3D;
public function HidableObject3DWrapper(param1:Object3D)
{
super();
this.object = param1;
}
public function readPosition(param1:Vector3) : void
{
param1.x = this.object.x;
param1.y = this.object.y;
param1.z = this.object.z;
}
public function setAlphaMultiplier(param1:Number) : void
{
this.object.alpha = param1;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.engine {
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 EngineModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:EngineModelServer;
private var client:IEngineModelBase = IEngineModelBase(this);
private var modelId:Long = Long.getLong(923418047,-17313881);
public function EngineModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new EngineModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(EngineCC,false)));
}
protected function getInitParam() : EngineCC {
return EngineCC(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 projects.tanks.client.tanksservices.model.rankloader {
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 RankLoaderModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:RankLoaderModelServer;
private var client:IRankLoaderModelBase = IRankLoaderModelBase(this);
private var modelId:Long = Long.getLong(821241413,-534454215);
public function RankLoaderModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new RankLoaderModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(RankLoaderCC,false)));
}
protected function getInitParam() : RankLoaderCC {
return RankLoaderCC(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.gui
{
import flash.events.Event;
public class ReferalWindowEvent extends Event
{
public static const SEND_MAIL:String = "ReferalWindowEventSendMail";
public var adresses:String;
public var letterText:String;
public function ReferalWindowEvent(type:String, addresses:String = "", letterText:String = "")
{
super(type);
this.adresses = addresses;
this.letterText = letterText;
}
}
}
|
package alternativa.tanks.model.item.itemforpartners {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ItemEnabledForPartnerEvents implements ItemEnabledForPartner {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ItemEnabledForPartnerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function isAvailable() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:ItemEnabledForPartner = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ItemEnabledForPartner(this.impl[i]);
result = Boolean(m.isAvailable());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.services.battlegui {
import alternativa.osgi.service.display.IDisplay;
import alternativa.utils.removeDisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.Sprite;
import flash.events.EventDispatcher;
public class BattleGUIServiceImpl extends EventDispatcher implements BattleGUIService {
[Inject]
public static var display:IDisplay;
private var viewportContainer:Sprite = new Sprite();
private var guiContainer:Sprite = new Sprite();
private var tabContainer:Sprite = new Sprite();
private var _positionXDefaultLayout:int;
private var _positionXInventory:int;
public function BattleGUIServiceImpl() {
super();
this.viewportContainer.mouseEnabled = false;
this.guiContainer.mouseEnabled = false;
this.tabContainer.mouseEnabled = false;
}
public function getViewportContainer() : DisplayObjectContainer {
return this.viewportContainer;
}
public function getGuiContainer() : DisplayObjectContainer {
return this.guiContainer;
}
public function getTabContainer() : DisplayObjectContainer {
return this.tabContainer;
}
public function hide() : void {
removeDisplayObject(this.viewportContainer);
removeDisplayObject(this.guiContainer);
removeDisplayObject(this.tabContainer);
}
public function show() : void {
display.contentLayer.addChild(this.viewportContainer);
display.contentUILayer.addChild(this.guiContainer);
display.contentUILayer.addChild(this.tabContainer);
}
public function setPositionXDefaultLayout(param1:int) : void {
this._positionXDefaultLayout = param1;
dispatchEvent(new BattleGUIServiceEvent(BattleGUIServiceEvent.ON_CHANGE_POSITION_DEFAULT_LAYOUT));
}
public function getPositionXDefaultLayout() : int {
return this._positionXDefaultLayout;
}
public function setPositionXInventory(param1:int) : void {
this._positionXInventory = param1;
dispatchEvent(new InventoryChangePositionEvent());
}
public function getPositionXInventory() : int {
return this._positionXInventory;
}
public function resetPositionXInventory() : void {
this._positionXInventory = 0;
}
}
}
|
package alternativa.tanks.models.panel {
import alternativa.tanks.models.service.ClanService;
import alternativa.tanks.service.clan.ClanPanelNotificationService;
import alternativa.tanks.service.panel.IPanelView;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.clans.panel.loadingclan.ClanLoadingPanelModelBase;
import projects.tanks.client.clans.panel.loadingclan.IClanLoadingPanelModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.gamescreen.UserChangeGameScreenService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.UserPropertiesServiceEvent;
import services.buttonbar.IButtonBarService;
import services.contextmenu.ContextMenuServiceEvent;
import services.contextmenu.IContextMenuService;
[ModelInfo]
public class ClanLoadingPanelModel extends ClanLoadingPanelModelBase implements IClanLoadingPanelModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var buttonBarService:IButtonBarService;
[Inject]
public static var userChangeGameScreenService:UserChangeGameScreenService;
[Inject]
public static var contextMenuService:IContextMenuService;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var panel:IPanelView;
[Inject]
public static var clanService:ClanService;
[Inject]
public static var clanPanelNotification:ClanPanelNotificationService;
public function ClanLoadingPanelModel() {
super();
}
public function objectLoaded() : void {
contextMenuService.addEventListener(ContextMenuServiceEvent.SHOW_CLAN,getFunctionWrapper(this.onShowClan));
userPropertiesService.addEventListener(UserPropertiesServiceEvent.UPDATE_RANK,getFunctionWrapper(this.updateRank));
clanService.minRankForCreateClan = getInitParam().minRankForCreateClan;
clanPanelNotification.clanButtonVisible = getInitParam().clanButtonVisible;
}
private function updateRank(param1:UserPropertiesServiceEvent) : void {
clanPanelNotification.clanButtonVisible = userPropertiesService.rank >= getInitParam().minRankForCreateClan;
}
private function onShowClan(param1:ContextMenuServiceEvent) : void {
server.showClan(param1.clanId);
}
public function objectUnloaded() : void {
contextMenuService.removeEventListener(ContextMenuServiceEvent.SHOW_CLAN,getFunctionWrapper(this.onShowClan));
}
}
}
|
package alternativa.tanks.models.battle.rugby {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.models.battle.ctf.FlagMessage;
import controls.chat.MessageColor;
import flash.utils.Dictionary;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class RugbyMessages {
[Inject]
public static var localeService:ILocaleService;
public static const TAKE:String = "take";
public static const LOST:String = "lost";
public static const GOAL:String = "goal";
private var readyToFaceOff:FlagMessage = FlagMessage.fromTextId(TanksLocale.TEXT_RUGBY_READY_TO_FACE_OFF,MessageColor.YELLOW);
private var facedOffMessage:FlagMessage = FlagMessage.fromTextId(TanksLocale.TEXT_RUGBY_FACE_OFF,MessageColor.YELLOW);
private var blueMessages:Dictionary = new Dictionary();
private var redMessages:Dictionary = new Dictionary();
private var battleLogMessages:Dictionary = new Dictionary();
public function RugbyMessages() {
super();
this.battleLogMessages[TAKE] = localeService.getText(TanksLocale.TEXT_RUGBY_BALL_TAKEN_USER);
this.battleLogMessages[LOST] = localeService.getText(TanksLocale.TEXT_RUGBY_BALL_LOST_USER);
this.battleLogMessages[GOAL] = localeService.getText(TanksLocale.TEXT_RUGBY_GOAL_USER);
this.redMessages[TAKE] = FlagMessage.fromTextId(TanksLocale.TEXT_RUGBY_BALL_TAKEN_RED,MessageColor.RED);
this.redMessages[LOST] = FlagMessage.fromTextId(TanksLocale.TEXT_RUGBY_BALL_LOST_RED,MessageColor.RED);
this.redMessages[GOAL] = FlagMessage.fromTextId(TanksLocale.TEXT_RUGBY_GOAL_RED,MessageColor.RED);
this.blueMessages[TAKE] = FlagMessage.fromTextId(TanksLocale.TEXT_RUGBY_BALL_TAKEN_BLUE,MessageColor.BLUE);
this.blueMessages[LOST] = FlagMessage.fromTextId(TanksLocale.TEXT_RUGBY_BALL_LOST_BLUE,MessageColor.BLUE);
this.blueMessages[GOAL] = FlagMessage.fromTextId(TanksLocale.TEXT_RUGBY_GOAL_BLUE,MessageColor.BLUE);
}
public function getFacedOffMessage() : FlagMessage {
return this.facedOffMessage;
}
public function getBattleLogMessage(param1:String) : String {
return this.battleLogMessages[param1];
}
public function getMessage(param1:String, param2:BattleTeam) : FlagMessage {
var local3:Dictionary = param2 == BattleTeam.RED ? this.redMessages : this.blueMessages;
return local3[param1];
}
public function getReadyToFaceOffMessage() : FlagMessage {
return this.readyToFaceOff;
}
}
}
|
package alternativa.tanks.models.sfx.shoot.hwthunder
{
import alternativa.engine3d.materials.Material;
import flash.media.Sound;
public class HWThunderSFXData
{
public var shotMaterial:Material;
public var explosionMaterials:Vector.<Material>;
public var shotSound:Sound;
public var explosionSound:Sound;
public function HWThunderSFXData()
{
super();
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.railgun
{
public interface IRailgunModelBase
{
}
}
|
package {
import flash.display.LoaderInfo;
import flash.display.Sprite;
import flash.events.Event;
import flash.system.ApplicationDomain;
import flash.system.Security;
import flash.utils.Dictionary;
import flash.utils.getDefinitionByName;
import flashx.textLayout.compose.ISWFContext;
import mx.core.EmbeddedFontRegistry;
import mx.core.IFlexModule;
import mx.core.IFlexModuleFactory;
import mx.core.RSLData;
import mx.core.Singleton;
[ExcludeClass]
public class _f54075b8ed70759ce4948fb5363c91eb2d84a9e5d0bf7f61678b3a6147cb0804_mx_core_FlexModuleFactory extends Sprite implements IFlexModuleFactory, ISWFContext {
private var _info:Object;
public function _f54075b8ed70759ce4948fb5363c91eb2d84a9e5d0bf7f61678b3a6147cb0804_mx_core_FlexModuleFactory() {
super();
this.root.loaderInfo.addEventListener(Event.COMPLETE,this.RSLRootCompleteListener);
}
public function callInContext(param1:Function, param2:Object, param3:Array, param4:Boolean = true) : * {
if(param4) {
return param1.apply(param2,param3);
}
param1.apply(param2,param3);
}
public function addPreloadedRSL(param1:LoaderInfo, param2:Vector.<RSLData>) : void {
}
public function getImplementation(param1:String) : Object {
return null;
}
public function registerImplementation(param1:String, param2:Object) : void {
}
public function create(... rest) : Object {
var local2:String = String(rest[0]);
var local3:Class = Class(getDefinitionByName(local2));
if(!local3) {
return null;
}
var local4:Object = new local3();
if(local4 is IFlexModule) {
IFlexModule(local4).moduleFactory = this;
}
if(rest.length == 0) {
Singleton.registerClass("mx.core::IEmbeddedFontRegistry",Class(getDefinitionByName("mx.core::EmbeddedFontRegistry")));
EmbeddedFontRegistry.registerFonts(this.info()["fonts"],this);
}
return local4;
}
public function info() : Object {
if(!this._info) {
this._info = {
"currentDomain":ApplicationDomain.currentDomain,
"fonts":{
"IRANSans":{
"regular":true,
"bold":true,
"italic":false,
"boldItalic":false
},
"IRANYekan":{
"regular":false,
"bold":true,
"italic":false,
"boldItalic":false
},
"MyriadPro":{
"regular":true,
"bold":true,
"italic":false,
"boldItalic":false
},
"Quadrat":{
"regular":true,
"bold":false,
"italic":false,
"boldItalic":false
}
}
};
}
return this._info;
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
public function get allowDomainsInNewRSLs() : Boolean {
return false;
}
public function set allowDomainsInNewRSLs(param1:Boolean) : void {
}
public function get allowInsecureDomainsInNewRSLs() : Boolean {
return false;
}
public function set allowInsecureDomainsInNewRSLs(param1:Boolean) : void {
}
public function get preloadedRSLs() : Dictionary {
return null;
}
public function allowDomain(... rest) : void {
}
public function allowInsecureDomain(... rest) : void {
}
private function RSLRootCompleteListener(param1:Event) : void {
EmbeddedFontRegistry.registerFonts(this.info()["fonts"],this);
this.root.removeEventListener(Event.COMPLETE,this.RSLRootCompleteListener);
}
}
}
|
package alternativa.engine3d.materials
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import alternativa.gfx.core.IndexBufferResource;
import alternativa.gfx.core.VertexBufferResource;
import flash.display.BitmapData;
use namespace alternativa3d;
public class FillMaterial extends TextureMaterial
{
public var color:int;
public var alpha:Number;
public var lineThickness:Number;
public var lineColor:int;
public function FillMaterial(param1:int = 8355711, param2:Number = 1, param3:Number = -1, param4:int = 16777215)
{
super();
this.color = param1;
this.alpha = param2;
this.lineThickness = param3;
this.lineColor = param4;
}
override alternativa3d function get transparent() : Boolean
{
return this.alpha < 1;
}
override public function clone() : Material
{
var _loc1_:FillMaterial = new FillMaterial(this.color,this.alpha,this.lineThickness,this.lineColor);
_loc1_.clonePropertiesFrom(this);
return _loc1_;
}
override alternativa3d function drawOpaque(param1:Camera3D, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D) : void
{
var _loc7_:uint = (this.alpha * 255 << 24) + this.color;
var _loc8_:BitmapData = texture;
if(_loc8_ != null)
{
if(_loc7_ != _loc8_.getPixel32(0,0))
{
_loc8_.setPixel32(0,0,_loc7_);
}
super.drawOpaque(param1,param2,param3,param4,param5,param6);
}
}
override alternativa3d function drawTransparent(param1:Camera3D, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D, param7:Boolean = false) : void
{
var _loc8_:uint = (this.alpha * 255 << 24) + this.color;
var _loc9_:BitmapData = texture;
if(_loc9_ != null)
{
if(_loc8_ != _loc9_.getPixel32(0,0))
{
_loc9_.setPixel32(0,0,_loc8_);
}
super.drawTransparent(param1,param2,param3,param4,param5,param6,param7);
}
}
}
}
|
package alternativa.tanks.models.battle.battlefield.map {
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.PhysicsMaterial;
import alternativa.physics.collision.CollisionShape;
import alternativa.physics.collision.primitives.CollisionBox;
import alternativa.physics.collision.primitives.CollisionRect;
import alternativa.physics.collision.primitives.CollisionTriangle;
public class CollisionGeometryParser {
private static const MATERIAL:PhysicsMaterial = new PhysicsMaterial(0,1);
private static const STATIC_COLLISION_GROUP:int = 255;
private static const halfSize:Vector3 = new Vector3();
private static const position:Vector3 = new Vector3();
private static const rotation:Vector3 = new Vector3();
private static const rotationMatrix:Matrix3 = new Matrix3();
public function CollisionGeometryParser() {
super();
}
public static function parse(param1:XML) : Vector.<CollisionShape> {
var local2:Vector.<CollisionShape> = new Vector.<CollisionShape>();
putAll(parseCollisionPlanes(param1),local2);
putAll(parseCollisionBoxes(param1),local2);
putAll(parseCollisionTrinagles(param1),local2);
return local2;
}
private static function putAll(param1:Vector.<CollisionShape>, param2:Vector.<CollisionShape>) : void {
var local3:CollisionShape = null;
for each(local3 in param1) {
param2.push(local3);
}
}
private static function parseCollisionPlanes(param1:XML) : Vector.<CollisionShape> {
var local4:XML = null;
var local5:CollisionShape = null;
var local2:Vector.<CollisionShape> = new Vector.<CollisionShape>();
var local3:XMLList = param1.elements("collision-geometry")[0].elements("collision-plane");
for each(local4 in local3) {
halfSize.x = 0.5 * Number(local4.width);
halfSize.y = 0.5 * Number(local4.length);
halfSize.z = 0;
local5 = new CollisionRect(halfSize,STATIC_COLLISION_GROUP,MATERIAL);
setCollisionPrimitiveOrientation(local5,local4);
local2.push(local5);
}
return local2;
}
private static function parseCollisionBoxes(param1:XML) : Vector.<CollisionShape> {
var local4:XML = null;
var local5:CollisionShape = null;
var local2:Vector.<CollisionShape> = new Vector.<CollisionShape>();
var local3:XMLList = param1.elements("collision-geometry")[0].elements("collision-box");
for each(local4 in local3) {
readVector3(local4.size,halfSize);
halfSize.scale(0.5);
local5 = new CollisionBox(halfSize,STATIC_COLLISION_GROUP,MATERIAL);
setCollisionPrimitiveOrientation(local5,local4);
local2.push(local5);
}
return local2;
}
private static function parseCollisionTrinagles(param1:XML) : Vector.<CollisionShape> {
var local7:XML = null;
var local8:CollisionShape = null;
var local2:Vector.<CollisionShape> = new Vector.<CollisionShape>();
var local3:Vector3 = new Vector3();
var local4:Vector3 = new Vector3();
var local5:Vector3 = new Vector3();
var local6:XMLList = param1.elements("collision-geometry")[0].elements("collision-triangle");
for each(local7 in local6) {
readVector3(local7.v0,local3);
readVector3(local7.v1,local4);
readVector3(local7.v2,local5);
local8 = new CollisionTriangle(local3,local4,local5,STATIC_COLLISION_GROUP,MATERIAL);
setCollisionPrimitiveOrientation(local8,local7);
local2.push(local8);
}
return local2;
}
private static function setCollisionPrimitiveOrientation(param1:CollisionShape, param2:XML) : void {
readVector3(param2.position,position);
readVector3(param2.rotation,rotation);
rotationMatrix.setRotationMatrix(rotation.x,rotation.y,rotation.z);
param1.transform.setFromMatrix3(rotationMatrix,position);
}
private static function readVector3(param1:XMLList, param2:Vector3) : void {
var local3:XML = null;
if(param1.length() > 0) {
local3 = param1[0];
param2.x = parseFloat(local3.x);
param2.y = parseFloat(local3.y);
param2.z = parseFloat(local3.z);
} else {
param2.reset(0,0,0);
}
}
}
}
|
package alternativa.tanks.models.effects.common.bonuscommon
{
import flash.utils.Dictionary;
public class BonusCache
{
private static var parachuteCache:ObjectCache = new ObjectCache();
private static var cordsCache:ObjectCache = new ObjectCache();
private static var boxCaches:Dictionary = new Dictionary();
public function BonusCache()
{
super();
}
public static function isParachuteCacheEmpty() : Boolean
{
return parachuteCache.isEmpty();
}
public static function getParachute() : Parachute
{
return Parachute(parachuteCache.get());
}
public static function putParachute(parachute:Parachute) : void
{
parachuteCache.put(parachute);
}
public static function isCordsCacheEmpty() : Boolean
{
return cordsCache.isEmpty();
}
public static function getCords() : Cords
{
return Cords(cordsCache.get());
}
public static function putCords(cords:Cords) : void
{
cordsCache.put(cords);
}
public static function isBonusMeshCacheEmpty(objectId:String) : Boolean
{
return getBonusMeshCache(objectId.split("_")[0]).isEmpty();
}
public static function getBonusMesh(objectId:String) : BonusMesh
{
return BonusMesh(getBonusMeshCache(objectId.split("_")[0]).get());
}
public static function putBonusMesh(bonusMesh:BonusMesh) : void
{
getBonusMeshCache(bonusMesh.getObjectId().split("_")[0]).put(bonusMesh);
}
private static function getBonusMeshCache(objectId:String) : ObjectCache
{
var cache:ObjectCache = boxCaches[objectId];
if(cache == null)
{
cache = new ObjectCache();
boxCaches[objectId] = cache;
}
return cache;
}
public static function destroy() : void
{
parachuteCache = new ObjectCache();
cordsCache = new ObjectCache();
boxCaches = new Dictionary();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.