code
stringlengths 57
237k
|
|---|
package alternativa.tanks.gui.shop.forms {
import alternativa.tanks.calculators.ExchangeCalculator;
import alternativa.tanks.gui.payment.controls.PaymentButton;
import alternativa.tanks.gui.payment.controls.exchange.ExchangeGroup;
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.gui.shop.windows.ShopWindow;
import controls.base.LabelBase;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.net.URLRequest;
import flash.net.navigateToURL;
import flash.text.TextFieldAutoSize;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.payment.modes.terminal.TerminalInstance;
import projects.tanks.client.panel.model.payment.modes.terminal.TerminalPaymentCC;
public class TerminalForm extends PayModeForm {
private static const CALCULATOR_LABEL_HEIGHT:int = 50;
private static const CALCULATOR_LABEL_OFFSET:int = 12;
private var exchangeGroup:ExchangeGroup;
private var calculatorLabel:LabelBase = new LabelBase();
private var exchangeCalculator:ExchangeCalculator = new ExchangeCalculator(1,"RUB",0,50);
private var terminalButtonsContainer:Sprite;
private var withCalculator:Boolean;
public function TerminalForm(param1:IGameObject, param2:TerminalPaymentCC) {
super(param1);
this.withCalculator = param2.withCalculator;
if(this.withCalculator) {
this.addCalculator(param2.text);
}
this.addTerminalLinkButtons(param2.terminals);
}
private function addCalculator(param1:String) : void {
this.calculatorLabel.autoSize = TextFieldAutoSize.NONE;
this.calculatorLabel.multiline = true;
this.calculatorLabel.wordWrap = true;
this.calculatorLabel.htmlText = param1;
this.calculatorLabel.size = 14;
addChild(this.calculatorLabel);
this.exchangeGroup = new ExchangeGroup();
this.exchangeGroup.hideButtons();
this.exchangeGroup.setCalculator(this.exchangeCalculator);
this.exchangeGroup.currency = "руб";
addChild(this.exchangeGroup);
this.exchangeGroup.width = int(ShopWindow.WINDOW_WIDTH / 2);
this.exchangeGroup.x = int(ShopWindow.WINDOW_WIDTH / 2 - this.exchangeGroup.calculatorWidth() / 2) + 200;
this.calculatorLabel.width = this.exchangeGroup.calculatorWidth();
this.calculatorLabel.x = this.exchangeGroup.x + (this.exchangeGroup.width - this.calculatorLabel.width) / 2;
this.calculatorLabel.y = this.exchangeGroup.y + this.exchangeGroup.calculatorHeight() + CALCULATOR_LABEL_OFFSET;
this.calculatorLabel.height = CALCULATOR_LABEL_HEIGHT;
}
private function addTerminalLinkButtons(param1:Vector.<TerminalInstance>) : void {
var local6:TerminalInstance = null;
var local7:PaymentButton = null;
var local8:Boolean = false;
this.terminalButtonsContainer = new Sprite();
var local2:int = this.withCalculator ? 3 : 5;
var local3:int = 0;
var local4:int = 0;
var local5:int = 0;
for each(local6 in param1) {
local7 = new PaymentButton(local6.image);
local7.url = local6.url;
local8 = local3 % local2 == 0;
local7.y = local8 ? local3 / local2 * (local7.height + 2) : local4;
local7.x = local8 ? 0 : local5 + local7.width + 2;
local7.addEventListener(MouseEvent.CLICK,this.onTerminalSelect);
this.terminalButtonsContainer.addChild(local7);
local4 = local7.y;
local5 = local7.x;
local3++;
}
addChild(this.terminalButtonsContainer);
}
private function onTerminalSelect(param1:MouseEvent) : void {
navigateToURL(new URLRequest(PaymentButton(param1.target).url),"_blank");
}
override public function activate() : void {
if(this.withCalculator) {
this.exchangeCalculator.init(1,0,50);
this.exchangeGroup.outputMaxValue = 19999;
this.exchangeGroup.outputMinValue = 1;
this.exchangeGroup.resetValue();
}
}
override public function destroy() : void {
var local1:PaymentButton = null;
super.destroy();
for each(local1 in this.terminalButtonsContainer) {
local1.removeEventListener(MouseEvent.CLICK,this.onTerminalSelect);
}
}
override public function isWithoutChosenItem() : Boolean {
return true;
}
}
}
|
package projects.tanks.client.panel.model.bonus.showing.image {
public interface IBonusImageShowingModelBase {
}
}
|
package alternativa.tanks.models.sfx.shoot.thunder
{
import alternativa.console.ConsoleVarFloat;
import alternativa.engine3d.core.Object3D;
import alternativa.init.Main;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.model.IModel;
import alternativa.object.ClientObject;
import alternativa.tanks.engine3d.MaterialType;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.sfx.AnimatedLightEffect;
import alternativa.tanks.models.sfx.LightDataManager;
import alternativa.tanks.models.sfx.MuzzlePositionProvider;
import alternativa.tanks.services.materialregistry.IMaterialRegistry;
import alternativa.tanks.services.objectpool.IObjectPoolService;
import alternativa.tanks.sfx.AnimatedSpriteEffect;
import alternativa.tanks.sfx.EffectsPair;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.sfx.SoundOptions;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import com.alternativaplatform.projects.tanks.client.warfare.models.sfx.shoot.thunder.IThunderShootSFXModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.sfx.shoot.thunder.ThunderShootSFXModelBase;
import flash.display.BitmapData;
import scpacker.resource.ResourceType;
import scpacker.resource.ResourceUtil;
public class ThunderSFXModel extends ThunderShootSFXModelBase implements IThunderShootSFXModelBase, IThunderSFXModel
{
private static const MIPMAP_RESOLUTION:Number = 2;
private static var materialRegistry:IMaterialRegistry;
private static var objectPoolService:IObjectPoolService;
private static var turretMatrix:Matrix4 = new Matrix4();
private static var muzzlePosition:Vector3 = new Vector3();
private static var explosionSize:ConsoleVarFloat = new ConsoleVarFloat("thunder_explosion_size",750,1,2000);
private var bfModel:BattlefieldModel;
public function ThunderSFXModel()
{
this.bfModel = Main.osgi.getService(IBattleField) as BattlefieldModel;
super();
_interfaces.push(IModel,IThunderSFXModel);
materialRegistry = IMaterialRegistry(Main.osgi.getService(IMaterialRegistry));
objectPoolService = IObjectPoolService(Main.osgi.getService(IObjectPoolService));
}
public function initObject(clientObject:ClientObject, explosionResourceId:String, explosionSoundResourceId:String, shotResourceId:String, shotSoundResourceId:String) : void
{
var data:ThunderSFXData = new ThunderSFXData();
if(ResourceUtil.getResource(ResourceType.IMAGE,shotResourceId) == null)
{
return;
}
data.shotMaterial = materialRegistry.textureMaterialRegistry.getMaterial(MaterialType.EFFECT,ResourceUtil.getResource(ResourceType.IMAGE,shotResourceId).bitmapData,MIPMAP_RESOLUTION,false);
var explosionTexture:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,explosionResourceId).bitmapData;
data.explosionMaterials = materialRegistry.materialSequenceRegistry.getSequence(MaterialType.EFFECT,explosionTexture,explosionTexture.height,3).materials;
data.shotSound = ResourceUtil.getResource(ResourceType.SOUND,shotSoundResourceId).sound;
data.explosionSound = ResourceUtil.getResource(ResourceType.SOUND,explosionSoundResourceId).sound;
clientObject.putParams(ThunderSFXModel,data);
}
public function createShotEffects(clientObject:ClientObject, muzzleLocalPos:Vector3, turret:Object3D) : EffectsPair
{
var data:ThunderSFXData = this.getSfxData(clientObject);
var graphicEffect:ThunderShotEffect = ThunderShotEffect(objectPoolService.objectPool.getObject(ThunderShotEffect));
graphicEffect.init(turret,muzzleLocalPos,data.shotMaterial);
var sound:Sound3D = Sound3D.create(data.shotSound,SoundOptions.nearRadius,SoundOptions.farRadius,SoundOptions.farDelimiter,0.7);
turretMatrix.setMatrix(turret.x,turret.y,turret.z,turret.rotationX,turret.rotationY,turret.rotationZ);
turretMatrix.transformVector(muzzleLocalPos,muzzlePosition);
var soundEffect:Sound3DEffect = Sound3DEffect.create(objectPoolService.objectPool,null,muzzlePosition,sound);
return new EffectsPair(graphicEffect,soundEffect);
}
public function createShotLightEffects(param1:Vector3, param2:Object3D, turretObj:ClientObject) : void
{
var _loc3_:AnimatedLightEffect = AnimatedLightEffect(objectPoolService.objectPool.getObject(AnimatedLightEffect));
var _loc4_:MuzzlePositionProvider = MuzzlePositionProvider(objectPoolService.objectPool.getObject(MuzzlePositionProvider));
_loc4_.init(param2,param1);
_loc3_.init(_loc4_,LightDataManager.getLightDataMuzzle(turretObj.id));
this.bfModel.addGraphicEffect(_loc3_);
}
public function createExplosionEffects(clientObject:ClientObject, position:Vector3) : EffectsPair
{
var data:ThunderSFXData = this.getSfxData(clientObject);
var graphicEffect:AnimatedSpriteEffect = AnimatedSpriteEffect(objectPoolService.objectPool.getObject(AnimatedSpriteEffect));
graphicEffect = graphicEffect == null ? new AnimatedSpriteEffect(objectPoolService.objectPool) : graphicEffect;
graphicEffect.init(explosionSize.value,explosionSize.value,data.explosionMaterials,position,Math.random() * 2 * Math.PI,150,29,false);
var sound:Sound3D = Sound3D.create(data.explosionSound,SoundOptions.nearRadius,SoundOptions.farRadius,SoundOptions.farDelimiter,0.7);
var soundEffect:Sound3DEffect = Sound3DEffect.create(objectPoolService.objectPool,null,position,sound);
return new EffectsPair(graphicEffect,soundEffect);
}
private function createExplosionLightEffect(param1:Vector3, turretObj:ClientObject) : void
{
var _loc2_:AnimatedLightEffect = AnimatedLightEffect(objectPoolService.objectPool.getObject(AnimatedLightEffect));
var _loc3_:StaticObject3DPositionProvider = StaticObject3DPositionProvider(objectPoolService.objectPool.getObject(StaticObject3DPositionProvider));
_loc3_.init(param1,110);
_loc2_.init(_loc3_,LightDataManager.getLightDataExplosion(turretObj.id));
this.bfModel.addGraphicEffect(_loc2_);
}
private function getSfxData(clientObject:ClientObject) : ThunderSFXData
{
return ThunderSFXData(clientObject.getParams(ThunderSFXModel));
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher {
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.ultimate.hunter.stun.UltimateStunListener;
import alternativa.tanks.models.weapon.IWeaponModel;
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import alternativa.tanks.models.weapon.common.WeaponBuffListener;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.RemoteRocketLauncherWeapon;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.RocketLauncherWeapon;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.RocketLauncherWeaponProvider;
import alternativa.tanks.models.weapon.shared.shot.WeaponReloadTimeChangedListener;
import alternativa.tanks.models.weapons.shell.ShellWeaponListener;
import alternativa.tanks.models.weapons.shell.TargetShellWeaponListener;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher.IRocketLauncherModelBase;
import projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher.RocketLauncherCC;
import projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher.RocketLauncherModelBase;
[ModelInfo]
public class RocketLauncherModel extends RocketLauncherModelBase implements IRocketLauncherModelBase, ShellWeaponListener, TargetShellWeaponListener, ObjectLoadListener, IWeaponModel, WeaponBuffListener, RocketLauncherWeaponProvider, WeaponReloadTimeChangedListener, UltimateStunListener {
public function RocketLauncherModel() {
super();
}
public function createLocalWeapon(param1:IGameObject) : Weapon {
var local2:RocketLauncherObject = new RocketLauncherObject(object);
var local3:RocketLauncherWeapon = new RocketLauncherWeapon(param1,local2,getInitParam());
putData(RocketLauncherWeapon,local3);
return local3;
}
public function createRemoteWeapon(param1:IGameObject) : Weapon {
var local2:RocketLauncherObject = new RocketLauncherObject(object);
local2.markAsRemote();
var local3:RemoteRocketLauncherWeapon = new RemoteRocketLauncherWeapon(local2,getInitParam());
putData(RemoteRocketLauncherWeapon,local3);
return local3;
}
[Obfuscation(rename="false")]
public function objectLoaded() : void {
var local1:RocketLauncherCC = getInitParam();
local1.minSpeed = BattleUtils.toClientScale(local1.minSpeed);
local1.maxSpeed = BattleUtils.toClientScale(local1.maxSpeed);
local1.shellRadius = BattleUtils.toClientScale(local1.shellRadius);
local1.shotRange = BattleUtils.toClientScale(local1.shotRange);
}
public function onShot(param1:int, param2:int, param3:Vector3) : void {
this.remoteWeapon().simpleShoot(param1,param3,param2);
}
public function onDummyShot(param1:int) : void {
this.remoteWeapon().dummyShoot(param1);
}
public function onShotWithTarget(param1:int, param2:int, param3:Vector3, param4:Tank, param5:Vector3) : void {
this.remoteWeapon().salvoShoot(param1,param3,param2,param4,param5);
}
public function remoteWeapon() : RemoteRocketLauncherWeapon {
return RemoteRocketLauncherWeapon(getData(RemoteRocketLauncherWeapon));
}
public function localWeapon() : RocketLauncherWeapon {
return RocketLauncherWeapon(getData(RocketLauncherWeapon));
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
var local3:RocketLauncherWeapon = null;
if(this.isLocalWeapon()) {
local3 = this.localWeapon();
if(local3 != null) {
local3.weaponReloadTimeChanged(param1,param2);
}
}
}
public function weaponBuffStateChanged(param1:IGameObject, param2:Boolean, param3:Number) : void {
var local4:RocketLauncherWeapon = this.localWeapon();
if(local4 != null) {
local4.setBuffState(param2);
local4.updateRecoilForce(param3);
if(!param2) {
local4.fullyRecharge();
}
} else {
this.remoteWeapon().updateRecoilForce(param3);
}
}
private function isLocalWeapon() : Boolean {
var local1:Tank = IWeaponCommonModel(object.adapt(IWeaponCommonModel)).getTank();
return ITankModel(local1.user.adapt(ITankModel)).isLocal();
}
public function onStun(param1:Tank, param2:Boolean) : void {
if(param2) {
this.localWeapon().stun();
}
}
public function onCalm(param1:Tank, param2:Boolean, param3:int) : void {
if(param2) {
this.localWeapon().calm(param3);
}
}
}
}
|
package projects.tanks.client.battlefield.gui.models.inventory.item
{
public interface IInventoryItemModelBase
{
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_gameActiveIconMakeUp.png")]
public class MakeUp_gameActiveIconMakeUp extends BitmapAsset {
public function MakeUp_gameActiveIconMakeUp() {
super();
}
}
}
|
package alternativa.engine3d.lights
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Light3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import flash.display.Sprite;
use namespace alternativa3d;
public class SpotLight extends Light3D
{
public var attenuationBegin:Number;
public var attenuationEnd:Number;
public var hotspot:Number;
public var falloff:Number;
public function SpotLight(param1:uint, param2:Number, param3:Number, param4:Number, param5:Number)
{
super();
this.color = param1;
this.attenuationBegin = param2;
this.attenuationEnd = param3;
this.hotspot = param4;
this.falloff = param5;
calculateBounds();
}
public function lookAt(param1:Number, param2:Number, param3:Number) : void
{
var _loc5_:Number = NaN;
var _loc4_:Number = NaN;
_loc4_ = param1 - this.x;
_loc5_ = param2 - this.y;
var _loc6_:Number = param3 - this.z;
rotationX = Math.atan2(_loc6_,Math.sqrt(_loc4_ * _loc4_ + _loc5_ * _loc5_)) - Math.PI / 2;
rotationY = 0;
rotationZ = -Math.atan2(_loc4_,_loc5_);
}
override public function clone() : Object3D
{
var _loc1_:SpotLight = new SpotLight(color,this.attenuationBegin,this.attenuationEnd,this.hotspot,this.falloff);
_loc1_.clonePropertiesFrom(this);
return _loc1_;
}
override alternativa3d function drawDebug(param1:Camera3D) : void
{
var _loc3_:Sprite = null;
var _loc4_:Number = NaN;
var _loc5_:Number = NaN;
var _loc6_:Number = NaN;
var _loc7_:int = 0;
var _loc8_:Number = NaN;
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc13_:Number = NaN;
var _loc14_:Number = NaN;
var _loc15_:Number = NaN;
var _loc16_:Number = NaN;
var _loc17_:Number = NaN;
var _loc18_:Number = NaN;
var _loc19_:Number = NaN;
var _loc20_:Number = NaN;
var _loc21_:Number = NaN;
var _loc22_:Number = NaN;
var _loc23_:Number = NaN;
var _loc24_:Number = NaN;
var _loc25_:Number = NaN;
var _loc26_:Number = NaN;
var _loc27_:Number = NaN;
var _loc28_:Number = NaN;
var _loc29_:Number = NaN;
var _loc30_:Number = NaN;
var _loc31_:Number = NaN;
var _loc32_:Number = NaN;
var _loc33_:Number = NaN;
var _loc34_:Number = NaN;
var _loc35_:Number = NaN;
var _loc36_:Number = NaN;
var _loc37_:Number = NaN;
var _loc38_:Number = NaN;
var _loc39_:Number = NaN;
var _loc40_:Number = NaN;
var _loc41_:Number = NaN;
var _loc42_:Number = NaN;
var _loc43_:Number = NaN;
var _loc44_:Number = NaN;
var _loc45_:Number = NaN;
var _loc46_:Number = NaN;
var _loc47_:Number = NaN;
var _loc2_:int = param1.checkInDebug(this);
if(_loc2_ > 0)
{
_loc3_ = param1.view.canvas;
if(_loc2_ & Debug.LIGHTS && ml > param1.nearClipping)
{
_loc4_ = (color >> 16 & 255) * intensity;
_loc5_ = (color >> 8 & 255) * intensity;
_loc6_ = (color & 255) * intensity;
_loc7_ = ((_loc4_ > 255 ? 255 : _loc4_) << 16) + ((_loc5_ > 255 ? 255 : _loc5_) << 8) + (_loc6_ > 255 ? 255 : _loc6_);
_loc8_ = 0;
_loc9_ = md * param1.viewSizeX / param1.focalLength;
_loc10_ = mh * param1.viewSizeY / param1.focalLength;
_loc11_ = ml;
_loc12_ = mc * param1.viewSizeX / param1.focalLength;
_loc13_ = mg * param1.viewSizeY / param1.focalLength;
_loc14_ = mk;
_loc15_ = Math.sqrt(_loc12_ * _loc12_ + _loc13_ * _loc13_ + _loc14_ * _loc14_);
_loc8_ += _loc15_;
_loc12_ /= _loc15_;
_loc13_ /= _loc15_;
_loc14_ /= _loc15_;
_loc16_ = ma * param1.viewSizeX / param1.focalLength;
_loc17_ = me * param1.viewSizeY / param1.focalLength;
_loc18_ = mi;
_loc8_ += Math.sqrt(_loc16_ * _loc16_ + _loc17_ * _loc17_ + _loc18_ * _loc18_);
_loc19_ = _loc18_ * _loc13_ - _loc17_ * _loc14_;
_loc20_ = _loc16_ * _loc14_ - _loc18_ * _loc12_;
_loc21_ = _loc17_ * _loc12_ - _loc16_ * _loc13_;
_loc15_ = Math.sqrt(_loc19_ * _loc19_ + _loc20_ * _loc20_ + _loc21_ * _loc21_);
_loc19_ /= _loc15_;
_loc20_ /= _loc15_;
_loc21_ /= _loc15_;
_loc16_ = mb * param1.viewSizeX / param1.focalLength;
_loc17_ = mf * param1.viewSizeY / param1.focalLength;
_loc18_ = mj;
_loc8_ += Math.sqrt(_loc16_ * _loc16_ + _loc17_ * _loc17_ + _loc18_ * _loc18_);
_loc8_ /= 3;
_loc16_ = _loc21_ * _loc13_ - _loc20_ * _loc14_;
_loc17_ = _loc19_ * _loc14_ - _loc21_ * _loc12_;
_loc18_ = _loc20_ * _loc12_ - _loc19_ * _loc13_;
_loc22_ = Math.cos(this.hotspot / 2);
_loc23_ = Math.sin(this.hotspot / 2);
_loc24_ = _loc9_ + (_loc12_ * _loc22_ + _loc16_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc25_ = _loc10_ + (_loc13_ * _loc22_ + _loc17_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc26_ = _loc11_ + (_loc14_ * _loc22_ + _loc18_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc27_ = _loc9_ + (_loc12_ * _loc22_ + (_loc16_ + _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc28_ = _loc10_ + (_loc13_ * _loc22_ + (_loc17_ + _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc29_ = _loc11_ + (_loc14_ * _loc22_ + (_loc18_ + _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc30_ = _loc9_ + (_loc12_ * _loc22_ + _loc19_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc31_ = _loc10_ + (_loc13_ * _loc22_ + _loc20_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc32_ = _loc11_ + (_loc14_ * _loc22_ + _loc21_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc33_ = _loc9_ + (_loc12_ * _loc22_ - (_loc16_ - _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc34_ = _loc10_ + (_loc13_ * _loc22_ - (_loc17_ - _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc35_ = _loc11_ + (_loc14_ * _loc22_ - (_loc18_ - _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc36_ = _loc9_ + (_loc12_ * _loc22_ - _loc16_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc37_ = _loc10_ + (_loc13_ * _loc22_ - _loc17_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc38_ = _loc11_ + (_loc14_ * _loc22_ - _loc18_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc39_ = _loc9_ + (_loc12_ * _loc22_ - (_loc16_ + _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc40_ = _loc10_ + (_loc13_ * _loc22_ - (_loc17_ + _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc41_ = _loc11_ + (_loc14_ * _loc22_ - (_loc18_ + _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc42_ = _loc9_ + (_loc12_ * _loc22_ - _loc19_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc43_ = _loc10_ + (_loc13_ * _loc22_ - _loc20_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc44_ = _loc11_ + (_loc14_ * _loc22_ - _loc21_ * _loc23_) * _loc8_ * this.attenuationBegin;
_loc45_ = _loc9_ + (_loc12_ * _loc22_ + (_loc16_ - _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc46_ = _loc10_ + (_loc13_ * _loc22_ + (_loc17_ - _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
_loc47_ = _loc11_ + (_loc14_ * _loc22_ + (_loc18_ - _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationBegin;
if(_loc26_ > param1.nearClipping && _loc29_ > param1.nearClipping && _loc32_ > param1.nearClipping && _loc35_ > param1.nearClipping && _loc38_ > param1.nearClipping && _loc41_ > param1.nearClipping && _loc44_ > param1.nearClipping && _loc47_ > param1.nearClipping)
{
_loc3_.graphics.lineStyle(1,_loc7_);
_loc3_.graphics.moveTo(_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_);
_loc3_.graphics.curveTo(_loc27_ * param1.focalLength / _loc29_,_loc28_ * param1.focalLength / _loc29_,_loc30_ * param1.focalLength / _loc32_,_loc31_ * param1.focalLength / _loc32_);
_loc3_.graphics.curveTo(_loc33_ * param1.focalLength / _loc35_,_loc34_ * param1.focalLength / _loc35_,_loc36_ * param1.focalLength / _loc38_,_loc37_ * param1.focalLength / _loc38_);
_loc3_.graphics.curveTo(_loc39_ * param1.focalLength / _loc41_,_loc40_ * param1.focalLength / _loc41_,_loc42_ * param1.focalLength / _loc44_,_loc43_ * param1.focalLength / _loc44_);
_loc3_.graphics.curveTo(_loc45_ * param1.focalLength / _loc47_,_loc46_ * param1.focalLength / _loc47_,_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_);
_loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_);
_loc3_.graphics.lineTo(_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_);
_loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_);
_loc3_.graphics.lineTo(_loc30_ * param1.focalLength / _loc32_,_loc31_ * param1.focalLength / _loc32_);
_loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_);
_loc3_.graphics.lineTo(_loc36_ * param1.focalLength / _loc38_,_loc37_ * param1.focalLength / _loc38_);
_loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_);
_loc3_.graphics.lineTo(_loc42_ * param1.focalLength / _loc44_,_loc43_ * param1.focalLength / _loc44_);
}
_loc22_ = Math.cos(this.falloff / 2);
_loc23_ = Math.sin(this.falloff / 2);
_loc24_ = _loc9_ + (_loc12_ * _loc22_ + _loc16_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc25_ = _loc10_ + (_loc13_ * _loc22_ + _loc17_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc26_ = _loc11_ + (_loc14_ * _loc22_ + _loc18_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc27_ = _loc9_ + (_loc12_ * _loc22_ + (_loc16_ + _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc28_ = _loc10_ + (_loc13_ * _loc22_ + (_loc17_ + _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc29_ = _loc11_ + (_loc14_ * _loc22_ + (_loc18_ + _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc30_ = _loc9_ + (_loc12_ * _loc22_ + _loc19_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc31_ = _loc10_ + (_loc13_ * _loc22_ + _loc20_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc32_ = _loc11_ + (_loc14_ * _loc22_ + _loc21_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc33_ = _loc9_ + (_loc12_ * _loc22_ - (_loc16_ - _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc34_ = _loc10_ + (_loc13_ * _loc22_ - (_loc17_ - _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc35_ = _loc11_ + (_loc14_ * _loc22_ - (_loc18_ - _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc36_ = _loc9_ + (_loc12_ * _loc22_ - _loc16_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc37_ = _loc10_ + (_loc13_ * _loc22_ - _loc17_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc38_ = _loc11_ + (_loc14_ * _loc22_ - _loc18_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc39_ = _loc9_ + (_loc12_ * _loc22_ - (_loc16_ + _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc40_ = _loc10_ + (_loc13_ * _loc22_ - (_loc17_ + _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc41_ = _loc11_ + (_loc14_ * _loc22_ - (_loc18_ + _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc42_ = _loc9_ + (_loc12_ * _loc22_ - _loc19_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc43_ = _loc10_ + (_loc13_ * _loc22_ - _loc20_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc44_ = _loc11_ + (_loc14_ * _loc22_ - _loc21_ * _loc23_) * _loc8_ * this.attenuationEnd;
_loc45_ = _loc9_ + (_loc12_ * _loc22_ + (_loc16_ - _loc19_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc46_ = _loc10_ + (_loc13_ * _loc22_ + (_loc17_ - _loc20_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
_loc47_ = _loc11_ + (_loc14_ * _loc22_ + (_loc18_ - _loc21_) * 0.9 * _loc23_) * _loc8_ * this.attenuationEnd;
if(_loc26_ > param1.nearClipping && _loc29_ > param1.nearClipping && _loc32_ > param1.nearClipping && _loc35_ > param1.nearClipping && _loc38_ > param1.nearClipping && _loc41_ > param1.nearClipping && _loc44_ > param1.nearClipping && _loc47_ > param1.nearClipping)
{
_loc3_.graphics.lineStyle(1,_loc7_,0.5);
_loc3_.graphics.moveTo(_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_);
_loc3_.graphics.curveTo(_loc27_ * param1.focalLength / _loc29_,_loc28_ * param1.focalLength / _loc29_,_loc30_ * param1.focalLength / _loc32_,_loc31_ * param1.focalLength / _loc32_);
_loc3_.graphics.curveTo(_loc33_ * param1.focalLength / _loc35_,_loc34_ * param1.focalLength / _loc35_,_loc36_ * param1.focalLength / _loc38_,_loc37_ * param1.focalLength / _loc38_);
_loc3_.graphics.curveTo(_loc39_ * param1.focalLength / _loc41_,_loc40_ * param1.focalLength / _loc41_,_loc42_ * param1.focalLength / _loc44_,_loc43_ * param1.focalLength / _loc44_);
_loc3_.graphics.curveTo(_loc45_ * param1.focalLength / _loc47_,_loc46_ * param1.focalLength / _loc47_,_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_);
_loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_);
_loc3_.graphics.lineTo(_loc24_ * param1.focalLength / _loc26_,_loc25_ * param1.focalLength / _loc26_);
_loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_);
_loc3_.graphics.lineTo(_loc30_ * param1.focalLength / _loc32_,_loc31_ * param1.focalLength / _loc32_);
_loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_);
_loc3_.graphics.lineTo(_loc36_ * param1.focalLength / _loc38_,_loc37_ * param1.focalLength / _loc38_);
_loc3_.graphics.moveTo(_loc9_ * param1.focalLength / _loc11_,_loc10_ * param1.focalLength / _loc11_);
_loc3_.graphics.lineTo(_loc42_ * param1.focalLength / _loc44_,_loc43_ * param1.focalLength / _loc44_);
}
}
if(_loc2_ & Debug.BOUNDS)
{
Debug.drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ,10092288);
}
}
}
override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void
{
var _loc5_:Vertex = null;
var _loc3_:Number = this.falloff < Math.PI ? Number(Number(Math.sin(this.falloff / 2) * this.attenuationEnd)) : Number(Number(this.attenuationEnd));
var _loc4_:Number = this.falloff < Math.PI ? Number(Number(0)) : Number(Number(Math.cos(this.falloff / 2) * this.attenuationEnd));
if(param2 != null)
{
_loc5_ = boundVertexList;
_loc5_.x = -_loc3_;
_loc5_.y = -_loc3_;
_loc5_.z = _loc4_;
_loc5_ = _loc5_.next;
_loc5_.x = _loc3_;
_loc5_.y = -_loc3_;
_loc5_.z = _loc4_;
_loc5_ = _loc5_.next;
_loc5_.x = -_loc3_;
_loc5_.y = _loc3_;
_loc5_.z = _loc4_;
_loc5_ = _loc5_.next;
_loc5_.x = _loc3_;
_loc5_.y = _loc3_;
_loc5_.z = _loc4_;
_loc5_ = _loc5_.next;
_loc5_.x = -_loc3_;
_loc5_.y = -_loc3_;
_loc5_.z = this.attenuationEnd;
_loc5_ = _loc5_.next;
_loc5_.x = _loc3_;
_loc5_.y = -_loc3_;
_loc5_.z = this.attenuationEnd;
_loc5_ = _loc5_.next;
_loc5_.x = -_loc3_;
_loc5_.y = _loc3_;
_loc5_.z = this.attenuationEnd;
_loc5_ = _loc5_.next;
_loc5_.x = _loc3_;
_loc5_.y = _loc3_;
_loc5_.z = this.attenuationEnd;
_loc5_ = boundVertexList;
while(_loc5_ != null)
{
_loc5_.cameraX = param2.ma * _loc5_.x + param2.mb * _loc5_.y + param2.mc * _loc5_.z + param2.md;
_loc5_.cameraY = param2.me * _loc5_.x + param2.mf * _loc5_.y + param2.mg * _loc5_.z + param2.mh;
_loc5_.cameraZ = param2.mi * _loc5_.x + param2.mj * _loc5_.y + param2.mk * _loc5_.z + param2.ml;
if(_loc5_.cameraX < param1.boundMinX)
{
param1.boundMinX = _loc5_.cameraX;
}
if(_loc5_.cameraX > param1.boundMaxX)
{
param1.boundMaxX = _loc5_.cameraX;
}
if(_loc5_.cameraY < param1.boundMinY)
{
param1.boundMinY = _loc5_.cameraY;
}
if(_loc5_.cameraY > param1.boundMaxY)
{
param1.boundMaxY = _loc5_.cameraY;
}
if(_loc5_.cameraZ < param1.boundMinZ)
{
param1.boundMinZ = _loc5_.cameraZ;
}
if(_loc5_.cameraZ > param1.boundMaxZ)
{
param1.boundMaxZ = _loc5_.cameraZ;
}
_loc5_ = _loc5_.next;
}
}
else
{
if(-_loc3_ < param1.boundMinX)
{
param1.boundMinX = -_loc3_;
}
if(_loc3_ > param1.boundMaxX)
{
param1.boundMaxX = _loc3_;
}
if(-_loc3_ < param1.boundMinY)
{
param1.boundMinY = -_loc3_;
}
if(_loc3_ > param1.boundMaxY)
{
param1.boundMaxY = _loc3_;
}
if(_loc4_ < param1.boundMinZ)
{
param1.boundMinZ = _loc4_;
}
if(this.attenuationEnd > param1.boundMaxZ)
{
param1.boundMaxZ = this.attenuationEnd;
}
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.battlefield {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.battle.battlefield.BattlefieldCC;
import projects.tanks.client.battlefield.models.battle.battlefield.types.BattlefieldSounds;
import projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity.LightingSFXEntity;
import projects.tanks.client.battleservice.Range;
public class CodecBattlefieldCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_active:ICodec;
private var codec_battleId:ICodec;
private var codec_battlefieldSounds:ICodec;
private var codec_colorTransformMultiplier:ICodec;
private var codec_idleKickPeriodMsec:ICodec;
private var codec_map:ICodec;
private var codec_mineExplosionLighting:ICodec;
private var codec_proBattle:ICodec;
private var codec_range:ICodec;
private var codec_reArmorEnabled:ICodec;
private var codec_respawnDuration:ICodec;
private var codec_shadowMapCorrectionFactor:ICodec;
private var codec_showAddressLink:ICodec;
private var codec_spectator:ICodec;
private var codec_withoutBonuses:ICodec;
private var codec_withoutDrones:ICodec;
private var codec_withoutSupplies:ICodec;
public function CodecBattlefieldCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_active = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_battleId = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_battlefieldSounds = param1.getCodec(new TypeCodecInfo(BattlefieldSounds,false));
this.codec_colorTransformMultiplier = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_idleKickPeriodMsec = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_map = param1.getCodec(new TypeCodecInfo(IGameObject,false));
this.codec_mineExplosionLighting = param1.getCodec(new TypeCodecInfo(LightingSFXEntity,false));
this.codec_proBattle = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_range = param1.getCodec(new TypeCodecInfo(Range,false));
this.codec_reArmorEnabled = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_respawnDuration = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_shadowMapCorrectionFactor = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_showAddressLink = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_spectator = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_withoutBonuses = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_withoutDrones = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_withoutSupplies = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BattlefieldCC = new BattlefieldCC();
local2.active = this.codec_active.decode(param1) as Boolean;
local2.battleId = this.codec_battleId.decode(param1) as Long;
local2.battlefieldSounds = this.codec_battlefieldSounds.decode(param1) as BattlefieldSounds;
local2.colorTransformMultiplier = this.codec_colorTransformMultiplier.decode(param1) as Number;
local2.idleKickPeriodMsec = this.codec_idleKickPeriodMsec.decode(param1) as int;
local2.map = this.codec_map.decode(param1) as IGameObject;
local2.mineExplosionLighting = this.codec_mineExplosionLighting.decode(param1) as LightingSFXEntity;
local2.proBattle = this.codec_proBattle.decode(param1) as Boolean;
local2.range = this.codec_range.decode(param1) as Range;
local2.reArmorEnabled = this.codec_reArmorEnabled.decode(param1) as Boolean;
local2.respawnDuration = this.codec_respawnDuration.decode(param1) as int;
local2.shadowMapCorrectionFactor = this.codec_shadowMapCorrectionFactor.decode(param1) as Number;
local2.showAddressLink = this.codec_showAddressLink.decode(param1) as Boolean;
local2.spectator = this.codec_spectator.decode(param1) as Boolean;
local2.withoutBonuses = this.codec_withoutBonuses.decode(param1) as Boolean;
local2.withoutDrones = this.codec_withoutDrones.decode(param1) as Boolean;
local2.withoutSupplies = this.codec_withoutSupplies.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BattlefieldCC = BattlefieldCC(param2);
this.codec_active.encode(param1,local3.active);
this.codec_battleId.encode(param1,local3.battleId);
this.codec_battlefieldSounds.encode(param1,local3.battlefieldSounds);
this.codec_colorTransformMultiplier.encode(param1,local3.colorTransformMultiplier);
this.codec_idleKickPeriodMsec.encode(param1,local3.idleKickPeriodMsec);
this.codec_map.encode(param1,local3.map);
this.codec_mineExplosionLighting.encode(param1,local3.mineExplosionLighting);
this.codec_proBattle.encode(param1,local3.proBattle);
this.codec_range.encode(param1,local3.range);
this.codec_reArmorEnabled.encode(param1,local3.reArmorEnabled);
this.codec_respawnDuration.encode(param1,local3.respawnDuration);
this.codec_shadowMapCorrectionFactor.encode(param1,local3.shadowMapCorrectionFactor);
this.codec_showAddressLink.encode(param1,local3.showAddressLink);
this.codec_spectator.encode(param1,local3.spectator);
this.codec_withoutBonuses.encode(param1,local3.withoutBonuses);
this.codec_withoutDrones.encode(param1,local3.withoutDrones);
this.codec_withoutSupplies.encode(param1,local3.withoutSupplies);
}
}
}
|
package com.alternativaplatform.projects.tanks.client.models.ctf
{
import scpacker.Base;
public class CaptureTheFlagModelBase extends Base
{
public function CaptureTheFlagModelBase()
{
super();
}
}
}
|
package alternativa.math {
import alternativa.engine3d.core.Object3D;
import flash.geom.Vector3D;
import flash.utils.getQualifiedClassName;
public class Matrix3 {
public static const ZERO:Matrix3 = new Matrix3(0,0,0,0,0,0,0,0,0);
public static const IDENTITY:Matrix3 = new Matrix3();
private static const xAxis:Vector3 = new Vector3();
private static const yAxis:Vector3 = new Vector3();
private static const zAxis:Vector3 = new Vector3();
public var m00:Number;
public var m01:Number;
public var m02:Number;
public var m10:Number;
public var m11:Number;
public var m12:Number;
public var m20:Number;
public var m21:Number;
public var m22:Number;
public function Matrix3(param1:Number = 1, param2:Number = 0, param3:Number = 0, param4:Number = 0, param5:Number = 1, param6:Number = 0, param7:Number = 0, param8:Number = 0, param9:Number = 1) {
super();
this.m00 = param1;
this.m01 = param2;
this.m02 = param3;
this.m10 = param4;
this.m11 = param5;
this.m12 = param6;
this.m20 = param7;
this.m21 = param8;
this.m22 = param9;
}
public function toIdentity() : Matrix3 {
this.m00 = this.m11 = this.m22 = 1;
this.m01 = this.m02 = this.m10 = this.m12 = this.m20 = this.m21 = 0;
return this;
}
public function invert() : Matrix3 {
var local1:Number = this.m00;
var local2:Number = this.m01;
var local3:Number = this.m02;
var local4:Number = this.m10;
var local5:Number = this.m11;
var local6:Number = this.m12;
var local7:Number = this.m20;
var local8:Number = this.m21;
var local9:Number = this.m22;
var local10:Number = 1 / (-local3 * local5 * local7 + local2 * local6 * local7 + local3 * local4 * local8 - local1 * local6 * local8 - local2 * local4 * local9 + local1 * local5 * local9);
this.m00 = (local5 * local9 - local6 * local8) * local10;
this.m01 = (local3 * local8 - local2 * local9) * local10;
this.m02 = (local2 * local6 - local3 * local5) * local10;
this.m10 = (local6 * local7 - local4 * local9) * local10;
this.m11 = (local1 * local9 - local3 * local7) * local10;
this.m12 = (local3 * local4 - local1 * local6) * local10;
this.m20 = (local4 * local8 - local5 * local7) * local10;
this.m21 = (local2 * local7 - local1 * local8) * local10;
this.m22 = (local1 * local5 - local2 * local4) * local10;
return this;
}
public function append(param1:Matrix3) : Matrix3 {
var local2:Number = this.m00;
var local3:Number = this.m01;
var local4:Number = this.m02;
var local5:Number = this.m10;
var local6:Number = this.m11;
var local7:Number = this.m12;
var local8:Number = this.m20;
var local9:Number = this.m21;
var local10:Number = this.m22;
this.m00 = param1.m00 * local2 + param1.m01 * local5 + param1.m02 * local8;
this.m01 = param1.m00 * local3 + param1.m01 * local6 + param1.m02 * local9;
this.m02 = param1.m00 * local4 + param1.m01 * local7 + param1.m02 * local10;
this.m10 = param1.m10 * local2 + param1.m11 * local5 + param1.m12 * local8;
this.m11 = param1.m10 * local3 + param1.m11 * local6 + param1.m12 * local9;
this.m12 = param1.m10 * local4 + param1.m11 * local7 + param1.m12 * local10;
this.m20 = param1.m20 * local2 + param1.m21 * local5 + param1.m22 * local8;
this.m21 = param1.m20 * local3 + param1.m21 * local6 + param1.m22 * local9;
this.m22 = param1.m20 * local4 + param1.m21 * local7 + param1.m22 * local10;
return this;
}
public function prepend(param1:Matrix3) : Matrix3 {
var local2:Number = this.m00;
var local3:Number = this.m01;
var local4:Number = this.m02;
var local5:Number = this.m10;
var local6:Number = this.m11;
var local7:Number = this.m12;
var local8:Number = this.m20;
var local9:Number = this.m21;
var local10:Number = this.m22;
this.m00 = local2 * param1.m00 + local3 * param1.m10 + local4 * param1.m20;
this.m01 = local2 * param1.m01 + local3 * param1.m11 + local4 * param1.m21;
this.m02 = local2 * param1.m02 + local3 * param1.m12 + local4 * param1.m22;
this.m10 = local5 * param1.m00 + local6 * param1.m10 + local7 * param1.m20;
this.m11 = local5 * param1.m01 + local6 * param1.m11 + local7 * param1.m21;
this.m12 = local5 * param1.m02 + local6 * param1.m12 + local7 * param1.m22;
this.m20 = local8 * param1.m00 + local9 * param1.m10 + local10 * param1.m20;
this.m21 = local8 * param1.m01 + local9 * param1.m11 + local10 * param1.m21;
this.m22 = local8 * param1.m02 + local9 * param1.m12 + local10 * param1.m22;
return this;
}
public function prependTransposed(param1:Matrix3) : Matrix3 {
var local2:Number = this.m00;
var local3:Number = this.m01;
var local4:Number = this.m02;
var local5:Number = this.m10;
var local6:Number = this.m11;
var local7:Number = this.m12;
var local8:Number = this.m20;
var local9:Number = this.m21;
var local10:Number = this.m22;
this.m00 = local2 * param1.m00 + local3 * param1.m01 + local4 * param1.m02;
this.m01 = local2 * param1.m10 + local3 * param1.m11 + local4 * param1.m12;
this.m02 = local2 * param1.m20 + local3 * param1.m21 + local4 * param1.m22;
this.m10 = local5 * param1.m00 + local6 * param1.m01 + local7 * param1.m02;
this.m11 = local5 * param1.m10 + local6 * param1.m11 + local7 * param1.m12;
this.m12 = local5 * param1.m20 + local6 * param1.m21 + local7 * param1.m22;
this.m20 = local8 * param1.m00 + local9 * param1.m01 + local10 * param1.m02;
this.m21 = local8 * param1.m10 + local9 * param1.m11 + local10 * param1.m12;
this.m22 = local8 * param1.m20 + local9 * param1.m21 + local10 * param1.m22;
return this;
}
public function add(param1:Matrix3) : Matrix3 {
this.m00 += param1.m00;
this.m01 += param1.m01;
this.m02 += param1.m02;
this.m10 += param1.m10;
this.m11 += param1.m11;
this.m12 += param1.m12;
this.m20 += param1.m20;
this.m21 += param1.m21;
this.m22 += param1.m22;
return this;
}
public function subtract(param1:Matrix3) : Matrix3 {
this.m00 -= param1.m00;
this.m01 -= param1.m01;
this.m02 -= param1.m02;
this.m10 -= param1.m10;
this.m11 -= param1.m11;
this.m12 -= param1.m12;
this.m20 -= param1.m20;
this.m21 -= param1.m21;
this.m22 -= param1.m22;
return this;
}
public function transpose() : Matrix3 {
var local1:Number = this.m01;
this.m01 = this.m10;
this.m10 = local1;
local1 = this.m02;
this.m02 = this.m20;
this.m20 = local1;
local1 = this.m12;
this.m12 = this.m21;
this.m21 = local1;
return this;
}
public function transformVector(param1:Vector3, param2:Vector3) : void {
param2.x = this.m00 * param1.x + this.m01 * param1.y + this.m02 * param1.z;
param2.y = this.m10 * param1.x + this.m11 * param1.y + this.m12 * param1.z;
param2.z = this.m20 * param1.x + this.m21 * param1.y + this.m22 * param1.z;
}
public function transformVectorInverse(param1:Vector3, param2:Vector3) : void {
param2.x = this.m00 * param1.x + this.m10 * param1.y + this.m20 * param1.z;
param2.y = this.m01 * param1.x + this.m11 * param1.y + this.m21 * param1.z;
param2.z = this.m02 * param1.x + this.m12 * param1.y + this.m22 * param1.z;
}
public function transformVector3To3D(param1:Vector3, param2:Vector3D) : void {
param2.x = this.m00 * param1.x + this.m01 * param1.y + this.m02 * param1.z;
param2.y = this.m10 * param1.x + this.m11 * param1.y + this.m12 * param1.z;
param2.z = this.m20 * param1.x + this.m21 * param1.y + this.m22 * param1.z;
}
public function createSkewSymmetric(param1:Vector3) : Matrix3 {
this.m00 = this.m11 = this.m22 = 0;
this.m01 = -param1.z;
this.m02 = param1.y;
this.m10 = param1.z;
this.m12 = -param1.x;
this.m20 = -param1.y;
this.m21 = param1.x;
return this;
}
public function copy(param1:Matrix3) : Matrix3 {
this.m00 = param1.m00;
this.m01 = param1.m01;
this.m02 = param1.m02;
this.m10 = param1.m10;
this.m11 = param1.m11;
this.m12 = param1.m12;
this.m20 = param1.m20;
this.m21 = param1.m21;
this.m22 = param1.m22;
return this;
}
public function setRotationMatrix(param1:Number, param2:Number, param3:Number) : Matrix3 {
var local4:Number = Math.cos(param1);
var local5:Number = Math.sin(param1);
var local6:Number = Math.cos(param2);
var local7:Number = Math.sin(param2);
var local8:Number = Math.cos(param3);
var local9:Number = Math.sin(param3);
var local10:Number = local8 * local7;
var local11:Number = local9 * local7;
this.m00 = local8 * local6;
this.m01 = local10 * local5 - local9 * local4;
this.m02 = local10 * local4 + local9 * local5;
this.m10 = local9 * local6;
this.m11 = local11 * local5 + local8 * local4;
this.m12 = local11 * local4 - local8 * local5;
this.m20 = -local7;
this.m21 = local6 * local5;
this.m22 = local6 * local4;
return this;
}
public function setRotationMatrixForObject3D(param1:Object3D) : void {
this.setRotationMatrix(param1.rotationX,param1.rotationY,param1.rotationZ);
}
public function fromAxisAngle(param1:Vector3, param2:Number) : void {
var local3:Number = Math.cos(param2);
var local4:Number = Math.sin(param2);
var local5:Number = 1 - local3;
var local6:Number = param1.x;
var local7:Number = param1.y;
var local8:Number = param1.z;
this.m00 = local5 * local6 * local6 + local3;
this.m01 = local5 * local6 * local7 - local8 * local4;
this.m02 = local5 * local6 * local8 + local7 * local4;
this.m10 = local5 * local6 * local7 + local8 * local4;
this.m11 = local5 * local7 * local7 + local3;
this.m12 = local5 * local7 * local8 - local6 * local4;
this.m20 = local5 * local6 * local8 - local7 * local4;
this.m21 = local5 * local7 * local8 + local6 * local4;
this.m22 = local5 * local8 * local8 + local3;
}
public function clone() : Matrix3 {
return new Matrix3(this.m00,this.m01,this.m02,this.m10,this.m11,this.m12,this.m20,this.m21,this.m22);
}
public function toString() : String {
return getQualifiedClassName(this) + " (" + this.m00 + ", " + this.m01 + ", " + this.m02 + "), (" + this.m10 + ", " + this.m11 + ", " + this.m12 + "), (" + this.m20 + ", " + this.m21 + ", " + this.m22 + ")";
}
public function getEulerAngles(param1:Vector3) : void {
if(-1 < this.m20 && this.m20 < 1) {
param1.x = Math.atan2(this.m21,this.m22);
param1.y = -Math.asin(this.m20);
param1.z = Math.atan2(this.m10,this.m00);
} else {
param1.x = 0;
param1.y = this.m20 <= -1 ? Math.PI : -Math.PI;
param1.y *= 0.5;
param1.z = Math.atan2(-this.m01,this.m11);
}
}
public function getRight(param1:Vector3) : void {
this.getAxis(0,param1);
}
public function getForward(param1:Vector3) : void {
this.getAxis(1,param1);
}
public function getUp(param1:Vector3) : void {
this.getAxis(2,param1);
}
public function getAxis(param1:int, param2:Vector3) : void {
switch(param1) {
case 0:
param2.reset(this.m00,this.m10,this.m20);
break;
case 1:
param2.reset(this.m01,this.m11,this.m21);
break;
case 2:
param2.reset(this.m02,this.m12,this.m22);
}
}
public function setDirectionVector(param1:Vector3) : void {
yAxis.copy(param1).normalize();
if(yAxis.dot(Vector3.X_AXIS) < 0.9) {
zAxis.cross2(Vector3.X_AXIS,yAxis);
} else {
zAxis.cross2(yAxis,Vector3.Y_AXIS);
}
zAxis.normalize();
xAxis.cross2(yAxis,zAxis).normalize();
this.setAxis(xAxis,yAxis,zAxis);
}
public function setAxis(param1:Vector3, param2:Vector3, param3:Vector3) : void {
this.m00 = param1.x;
this.m01 = param2.x;
this.m02 = param3.x;
this.m10 = param1.y;
this.m11 = param2.y;
this.m12 = param3.y;
this.m20 = param1.z;
this.m21 = param2.z;
this.m22 = param3.z;
}
public function rotationMatrixToQuaternion(param1:Quaternion) : void {
var local3:Number = NaN;
var local2:Number = this.m00 + this.m11 + this.m22;
if(local2 > 0) {
local3 = Math.sqrt(local2 + 1) * 2;
param1.w = 0.25 * local3;
param1.x = (this.m21 - this.m12) / local3;
param1.y = (this.m02 - this.m20) / local3;
param1.z = (this.m10 - this.m01) / local3;
} else if(this.m00 > this.m11 && this.m00 > this.m22) {
local3 = Math.sqrt(1 + this.m00 - this.m11 - this.m22) * 2;
param1.w = (this.m21 - this.m12) / local3;
param1.x = 0.25 * local3;
param1.y = (this.m01 + this.m10) / local3;
param1.z = (this.m02 + this.m20) / local3;
} else if(this.m11 > this.m22) {
local3 = Math.sqrt(1 + this.m11 - this.m00 - this.m22) * 2;
param1.w = (this.m02 - this.m20) / local3;
param1.x = (this.m01 + this.m10) / local3;
param1.y = 0.25 * local3;
param1.z = (this.m12 + this.m21) / local3;
} else {
local3 = Math.sqrt(1 + this.m22 - this.m00 - this.m11) * 2;
param1.w = (this.m10 - this.m01) / local3;
param1.x = (this.m02 + this.m20) / local3;
param1.y = (this.m12 + this.m21) / local3;
param1.z = 0.25 * local3;
}
}
}
}
|
package controls.buttons.h30px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h30px.GrayFrameMediumLabelSkin_left.png")]
public class GrayFrameMediumLabelSkin_left extends BitmapAsset {
public function GrayFrameMediumLabelSkin_left() {
super();
}
}
}
|
package alternativa.tanks.servermodels {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IEntranceEvents implements IEntrance {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IEntranceEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function currentState(param1:ILeavableEntranceState) : void {
var i:int = 0;
var m:IEntrance = null;
var state:ILeavableEntranceState = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IEntrance(this.impl[i]);
m.currentState(state);
i++;
}
}
finally {
Model.popObject();
}
}
public function decideWhereToGoAfterStandAloneCaptcha(param1:ILeavableEntranceState, param2:Boolean) : void {
var i:int = 0;
var m:IEntrance = null;
var captchaModel:ILeavableEntranceState = param1;
var confirmEmail:Boolean = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IEntrance(this.impl[i]);
m.decideWhereToGoAfterStandAloneCaptcha(captchaModel,confirmEmail);
i++;
}
}
finally {
Model.popObject();
}
}
public function antiAddiction() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:IEntrance = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IEntrance(this.impl[i]);
result = Boolean(m.antiAddiction());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package forms.buttons
{
import flash.display.Bitmap;
public class MainPanelRatingButton extends MainPanelWideButton
{
[Embed(source="1162.png")]
private static const iconN:Class;
[Embed(source="820.png")]
private static const overBtn:Class;
private static const normalBtn:Class = MainPanelRatingButton_normalBtn;
public function MainPanelRatingButton()
{
super(new Bitmap(new iconN().bitmapData),3,3,new Bitmap(new overBtn().bitmapData),new Bitmap(new normalBtn().bitmapData));
}
}
}
|
package projects.tanks.client.clans.user.accepted {
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 ClanUserAcceptedModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ClanUserAcceptedModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.kit {
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 platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.garage.models.item.kit.GarageKitCC;
import projects.tanks.client.garage.models.item.kit.KitItem;
public class CodecGarageKitCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_discountInPercent:ICodec;
private var codec_image:ICodec;
private var codec_kitItems:ICodec;
public function CodecGarageKitCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_discountInPercent = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_image = param1.getCodec(new TypeCodecInfo(ImageResource,false));
this.codec_kitItems = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(KitItem,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:GarageKitCC = new GarageKitCC();
local2.discountInPercent = this.codec_discountInPercent.decode(param1) as int;
local2.image = this.codec_image.decode(param1) as ImageResource;
local2.kitItems = this.codec_kitItems.decode(param1) as Vector.<KitItem>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:GarageKitCC = GarageKitCC(param2);
this.codec_discountInPercent.encode(param1,local3.discountInPercent);
this.codec_image.encode(param1,local3.image);
this.codec_kitItems.encode(param1,local3.kitItems);
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_overdriveVikingIconClass.png")]
public class HudInventoryIcon_overdriveVikingIconClass extends BitmapAsset {
public function HudInventoryIcon_overdriveVikingIconClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.androidspecialoffer.offers.purchaseofupgrades {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class AndroidPurchaseOfUpgradesModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:AndroidPurchaseOfUpgradesModelServer;
private var client:IAndroidPurchaseOfUpgradesModelBase = IAndroidPurchaseOfUpgradesModelBase(this);
private var modelId:Long = Long.getLong(654539994,-1291774074);
public function AndroidPurchaseOfUpgradesModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new AndroidPurchaseOfUpgradesModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.controller.commands.captcha {
import alternativa.tanks.controller.events.CheckCaptchaAnswerEvent;
import alternativa.tanks.controller.events.RegisterEvent;
import alternativa.tanks.model.EntranceServerParamsModel;
import org.robotlegs.mvcs.Command;
import projects.tanks.client.commons.models.captcha.CaptchaLocation;
public class CheckRegistrationCaptchaCommand extends Command {
[Inject]
public var event:RegisterEvent;
[Inject]
public var serverParams:EntranceServerParamsModel;
public function CheckRegistrationCaptchaCommand() {
super();
}
override public function execute() : void {
var local1:RegisterEvent = new RegisterEvent(RegisterEvent.REGISTER_AFTER_CAPTCHA_CHECKED,this.event.callsign,this.event.email,this.event.password,this.event.rememberMe,this.event.realName,this.event.idNumber,this.event.captchaAnswer);
if(this.serverParams.registrationCaptchaEnabled) {
dispatch(new CheckCaptchaAnswerEvent(this.event.captchaAnswer,CaptchaLocation.REGISTER_FORM,local1));
} else {
dispatch(local1);
}
}
}
}
|
package projects.tanks.clients.fp10.StandaloneLoader {
import flash.desktop.NativeApplication;
import flash.display.Bitmap;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.display.Screen;
import flash.display.Sprite;
import flash.display.StageAlign;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.net.URLLoader;
import flash.net.URLLoaderDataFormat;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import flash.utils.ByteArray;
[SWF(width="256",height="256",backgroundColor="#000000",frameRate="40")]
public class StandaloneLoader extends Sprite {
private var logo:Class = StandaloneLoader_logo;
private var logoBmp:Bitmap;
private var guiLayer:Sprite;
private var prelauncher:Loader;
private var locale:String;
protected var prelauncherSwf:String;
public function StandaloneLoader() {
super();
addEventListener(Event.ADDED_TO_STAGE,this.init);
}
private function init(e:Event = null) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.init);
this.prelauncherSwf = loaderInfo.parameters["prelauncher"] || "http://tankionline.com/Prelauncher.swf";
this.locale = loaderInfo.parameters["locale"] || "ru";
LocalizedTexts.setLocale(this.locale);
this.configureStage();
this.createGUI();
this.loadStandalone();
}
private function configureStage() : void {
stage.align = StageAlign.TOP_LEFT;
var size:int = 256;
stage.stageWidth = size;
stage.stageHeight = size;
stage.nativeWindow.maxSize = new Point(stage.nativeWindow.width,stage.nativeWindow.height);
stage.nativeWindow.minSize = new Point(stage.nativeWindow.width,stage.nativeWindow.height);
this.setCenterPosition();
}
private function createGUI() : void {
this.guiLayer = new Sprite();
this.logoBmp = new this.logo() as Bitmap;
this.guiLayer.addChild(this.logoBmp);
this.logoBmp.scaleX = 0.5;
this.logoBmp.scaleY = 0.5;
this.logoBmp.x = -(this.logoBmp.bitmapData.width * this.logoBmp.scaleX - stage.stageWidth) / 2;
this.logoBmp.y = -(this.logoBmp.bitmapData.height * this.logoBmp.scaleY - stage.stageHeight) / 2;
stage.addChild(this.guiLayer);
}
private function removeGUI() : void {
stage.removeChild(this.guiLayer);
}
private function get version() : String {
var xml:XML = NativeApplication.nativeApplication.applicationDescriptor;
var ns:Namespace = xml.namespace();
return xml.ns::versionNumber;
}
private function loadStandalone() : void {
if(this.prelauncherSwf.indexOf("file") < 0) {
this.prelauncherSwf += "?rand=" + Math.random().toString();
}
var urlReq:URLRequest = new URLRequest(this.prelauncherSwf);
var urlLoader:URLLoader = new URLLoader();
urlLoader.dataFormat = URLLoaderDataFormat.BINARY;
urlLoader.addEventListener(Event.COMPLETE,this.byteArrayLoadComplete);
urlLoader.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadingError);
urlLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadingError);
urlLoader.load(urlReq);
}
private function onLoadingError(event:Event) : void {
Alert.showMessage(LocalizedTexts.CONNECTION_ERROR);
}
private function isNewVersionAvailable(version:String) : Boolean {
if(this.version != version) {
Alert.showMessage(LocalizedTexts.NEW_VERSION_AVAILABLE(version,this.version));
}
return this.version == version;
}
private function byteArrayLoadComplete(event:Event) : void {
var bytes:ByteArray = URLLoader(event.target).data as ByteArray;
this.prelauncher = new Loader();
var loaderInfo:LoaderInfo = this.prelauncher.contentLoaderInfo;
loaderInfo.addEventListener(Event.COMPLETE,this.onLauncherLoadingComplete);
loaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadingError);
loaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadingError);
var loaderContext:LoaderContext = new LoaderContext(false,ApplicationDomain.currentDomain);
loaderContext.allowCodeImport = true;
loaderContext.parameters = this.loaderInfo.parameters;
this.prelauncher.loadBytes(bytes,loaderContext);
}
private function setCenterPosition() : void {
var appBounds:Rectangle = stage.nativeWindow.bounds;
var screen:Screen = Screen.getScreensForRectangle(appBounds)[0];
stage.nativeWindow.x = (screen.bounds.width - stage.nativeWindow.width) / 2;
stage.nativeWindow.y = (screen.bounds.height - stage.nativeWindow.height) / 2;
}
private function onLauncherLoadingComplete(event:Event) : void {
this.removeGUI();
if(this.isNewVersionAvailable(this.prelauncher.getChildAt(0)["version"])) {
stage.nativeWindow.maxSize = new Point(1050,650);
stage.nativeWindow.minSize = new Point(stage.nativeWindow.width,stage.nativeWindow.height);
stage.nativeWindow.width = 1000;
stage.nativeWindow.height = 600;
this.addChild(this.prelauncher.getChildAt(0));
stage.stageWidth = 1000;
stage.stageHeight = 600;
stage.nativeWindow.maxSize = new Point(stage.nativeWindow.width,stage.nativeWindow.height);
stage.nativeWindow.minSize = new Point(stage.nativeWindow.width,stage.nativeWindow.height);
this.setCenterPosition();
}
}
}
}
|
package projects.tanks.client.partners.impl.mailru.login {
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 MailruGamesLoginModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function MailruGamesLoginModelServer(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.view.icons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.icons.BattleParamsBattleInfoIcons_bonusesClass.png")]
public class BattleParamsBattleInfoIcons_bonusesClass extends BitmapAsset {
public function BattleParamsBattleInfoIcons_bonusesClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.railgun {
import alternativa.math.Vector3;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.sfx.AnimatedPlane;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class RailgunPowEffect extends PooledObject implements GraphicEffect {
private var position:Vector3 = new Vector3();
private var direction:Vector3 = new Vector3();
private var currentTime:int;
private var maxTime:int;
private var plane:AnimatedPlane;
private var container:Scene3DContainer;
public function RailgunPowEffect(param1:Pool) {
super(param1);
this.plane = new AnimatedPlane(30,200,0,-100,0);
}
public function init(param1:Vector3, param2:Vector3, param3:TextureAnimation) : void {
this.position.copy(param1);
this.direction.copy(param2);
this.plane.init(param3,0.001 * param3.fps);
this.maxTime = this.plane.getOneLoopTime();
this.currentTime = 0;
this.plane.x = param1.x;
this.plane.y = param1.y;
this.plane.z = param1.z;
}
public function play(param1:int, param2:GameCamera) : Boolean {
if(this.currentTime >= this.maxTime) {
return false;
}
this.plane.setTime(this.currentTime);
this.currentTime += param1;
SFXUtils.alignObjectPlaneToView(this.plane,this.position,this.direction,param2.position);
return true;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.plane);
}
public function destroy() : void {
this.container.removeChild(this.plane);
this.container = null;
this.plane.clear();
recycle();
}
public function kill() : void {
this.currentTime = this.maxTime;
}
}
}
|
package {
import controls.panel.BaseButton;
[Embed(source="/_assets/assets.swf", symbol="symbol851")]
public dynamic class MainPanelHelpButton extends BaseButton {
public function MainPanelHelpButton() {
super();
}
}
}
|
package alternativa.protocol
{
import alternativa.init.ProtocolActivator;
import alternativa.osgi.service.console.IConsoleService;
import alternativa.protocol.codec.ICodec;
import alternativa.protocol.codec.NullMap;
import alternativa.protocol.factory.ICodecFactory;
import flash.utils.ByteArray;
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
public class Protocol
{
private static const INPLACE_MASK_FLAG:int = 128;
private static const MASK_LENGTH_2_BYTES_FLAG:int = 64;
private static const INPLACE_MASK_1_BYTES:int = 32;
private static const INPLACE_MASK_3_BYTES:int = 96;
private static const INPLACE_MASK_2_BYTES:int = 64;
private static const MASK_LENGTH_1_BYTE:int = 128;
private static const MASK_LEGTH_3_BYTE:int = 12582912;
private var codecFactory:ICodecFactory;
private var rootTargetClass:Class;
public function Protocol(codecFactory:ICodecFactory, rootTargetClass:Class)
{
super();
this.codecFactory = codecFactory;
this.rootTargetClass = rootTargetClass;
}
public function encode(dest:IDataOutput, object:Object) : void
{
var codec:ICodec = this.codecFactory.getCodec(this.rootTargetClass);
var nullMap:NullMap = new NullMap();
var dataWriter:ByteArray = new ByteArray();
codec.encode(IDataOutput(dataWriter),object,nullMap,true);
var nullmapEncoded:ByteArray = this.encodeNullMap(nullMap);
dataWriter.position = 0;
nullmapEncoded.position = 0;
dest.writeBytes(nullmapEncoded,0,nullmapEncoded.length);
dest.writeBytes(dataWriter,0,dataWriter.length);
}
public function decode(reader:IDataInput) : Object
{
var b:String = null;
var codec:ICodec = this.codecFactory.getCodec(this.rootTargetClass);
var nullMap:NullMap = this.decodeNullMap(reader);
IConsoleService(ProtocolActivator.osgi.getService(IConsoleService)).writeToConsoleChannel("PROTOCOL","Protocol decode nullMap:");
var map:ByteArray = nullMap.getMap();
map.position = 0;
var mapString:String = "";
while(map.bytesAvailable)
{
b = map.readUnsignedByte().toString(2);
while(b.length < 8)
{
b = 0 + b;
}
mapString += b + " ";
}
IConsoleService(ProtocolActivator.osgi.getService(IConsoleService)).writeToConsoleChannel("PROTOCOL"," " + mapString);
IConsoleService(ProtocolActivator.osgi.getService(IConsoleService)).writeToConsoleChannel("PROTOCOL"," ");
map.position = 0;
nullMap.reset();
return codec.decode(reader,nullMap,true);
}
private function encodeNullMap(nullMap:NullMap) : ByteArray
{
var sizeInBytes:int = 0;
var firstByte:int = 0;
var sizeEncoded:int = 0;
var secondByte:int = 0;
var thirdByte:int = 0;
var nullMapSize:int = nullMap.getSize();
var map:ByteArray = nullMap.getMap();
var res:ByteArray = new ByteArray();
if(nullMapSize <= 5)
{
res.writeByte(int((map[0] & 255) >>> 3));
return res;
}
if(nullMapSize <= 13)
{
res.writeByte(int(((map[0] & 255) >>> 3) + INPLACE_MASK_1_BYTES));
res.writeByte(((map[1] & 255) >>> 3) + (map[0] << 5));
return res;
}
if(nullMapSize <= 21)
{
res.writeByte(int(((map[0] & 255) >>> 3) + INPLACE_MASK_2_BYTES));
res.writeByte(int(((map[1] & 255) >>> 3) + (map[0] << 5)));
res.writeByte(int(((map[2] & 255) >>> 3) + (map[1] << 5)));
return res;
}
if(nullMapSize <= 29)
{
res.writeByte(int(((map[0] & 255) >>> 3) + INPLACE_MASK_3_BYTES));
res.writeByte(int(((map[1] & 255) >>> 3) + (map[0] << 5)));
res.writeByte(int(((map[2] & 255) >>> 3) + (map[1] << 5)));
res.writeByte(int(((map[3] & 255) >>> 3) + (map[2] << 5)));
return res;
}
if(nullMapSize <= 504)
{
sizeInBytes = (nullMapSize >>> 3) + ((nullMapSize & 7) == 0 ? 0 : 1);
firstByte = int((sizeInBytes & 255) + MASK_LENGTH_1_BYTE);
res.writeByte(firstByte);
res.writeBytes(map,0,sizeInBytes);
return res;
}
if(nullMapSize <= 33554432)
{
sizeInBytes = (nullMapSize >>> 3) + ((nullMapSize & 7) == 0 ? 0 : 1);
sizeEncoded = sizeInBytes + MASK_LEGTH_3_BYTE;
firstByte = int((sizeEncoded & 16711680) >>> 16);
secondByte = int((sizeEncoded & 65280) >>> 8);
thirdByte = int(sizeEncoded & 255);
res.writeByte(firstByte);
res.writeByte(secondByte);
res.writeByte(thirdByte);
res.writeBytes(map,0,sizeInBytes);
return res;
}
throw new Error("NullMap overflow");
}
private function decodeNullMap(reader:IDataInput) : NullMap
{
var maskLength:int = 0;
var firstByteValue:int = 0;
var isLength22bit:Boolean = false;
var sizeInBits:int = 0;
var secondByte:int = 0;
var thirdByte:int = 0;
var fourthByte:int = 0;
var mask:ByteArray = new ByteArray();
var firstByte:int = reader.readByte();
var isLongNullMap:Boolean = (firstByte & INPLACE_MASK_FLAG) != 0;
if(isLongNullMap)
{
firstByteValue = firstByte & 63;
isLength22bit = (firstByte & MASK_LENGTH_2_BYTES_FLAG) != 0;
if(isLength22bit)
{
secondByte = reader.readByte();
thirdByte = reader.readByte();
maskLength = (firstByteValue << 16) + ((secondByte & 255) << 8) + (thirdByte & 255);
}
else
{
maskLength = firstByteValue;
}
reader.readBytes(mask,0,maskLength);
sizeInBits = maskLength << 3;
return new NullMap(sizeInBits,mask);
}
firstByteValue = int(firstByte << 3);
maskLength = int((firstByte & 96) >> 5);
switch(maskLength)
{
case 0:
mask.writeByte(firstByteValue);
return new NullMap(5,mask);
case 1:
secondByte = reader.readByte();
mask.writeByte(int(firstByteValue + ((secondByte & 255) >>> 5)));
mask.writeByte(int(secondByte << 3));
return new NullMap(13,mask);
case 2:
secondByte = reader.readByte();
thirdByte = reader.readByte();
mask.writeByte(int(firstByteValue + ((secondByte & 255) >>> 5)));
mask.writeByte(int((secondByte << 3) + ((thirdByte & 255) >>> 5)));
mask.writeByte(int(thirdByte << 3));
return new NullMap(21,mask);
case 3:
secondByte = reader.readByte();
thirdByte = reader.readByte();
fourthByte = reader.readByte();
mask.writeByte(int(firstByteValue + ((secondByte & 255) >>> 5)));
mask.writeByte(int((secondByte << 3) + ((thirdByte & 255) >>> 5)));
mask.writeByte(int((thirdByte << 3) + ((fourthByte & 255) >>> 5)));
mask.writeByte(int(fourthByte << 3));
return new NullMap(29,mask);
default:
return null;
}
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.socialnetworks {
import alternativa.types.Long;
import flash.utils.Dictionary;
import projects.tanks.client.tanksservices.model.notifier.socialnetworks.ISNUidNotifierModelBase;
import projects.tanks.client.tanksservices.model.notifier.socialnetworks.SNUidNotifierData;
import projects.tanks.client.tanksservices.model.notifier.socialnetworks.SNUidNotifierModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.model.UserRefresh;
import projects.tanks.clients.fp10.libraries.tanksservices.model.listener.UserNotifier;
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.UserInfoConsumer;
[ModelInfo]
public class SNUidNotifierModel extends SNUidNotifierModelBase implements ISNUidNotifierModelBase, UserRefresh {
private var data:Dictionary = new Dictionary();
public function SNUidNotifierModel() {
super();
}
public function setSNUid(param1:Vector.<SNUidNotifierData>) : void {
var local2:SNUidNotifierData = null;
for each(local2 in param1) {
this.setAndUpdateConsumer(local2);
}
}
private function setAndUpdateConsumer(param1:SNUidNotifierData) : void {
var local4:UserInfoConsumer = null;
var local2:Long = param1.userId;
this.data[local2] = param1.snUid;
var local3:UserNotifier = UserNotifier(object.adapt(UserNotifier));
if(local3.hasDataConsumer(local2)) {
local4 = local3.getDataConsumer(local2);
local4.setSNUid(param1.snUid);
}
}
public function refresh(param1:Long, param2:UserInfoConsumer) : void {
if(param1 in this.data) {
param2.setSNUid(this.data[param1]);
}
}
public function remove(param1:Long) : void {
delete this.data[param1];
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.effects.description {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.battlefield.models.effects.description.EffectCategory;
public class CodecEffectCategory implements ICodec {
public function CodecEffectCategory() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:EffectCategory = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = EffectCategory.INVENTORY;
break;
case 1:
local2 = EffectCategory.BONUS;
break;
case 2:
local2 = EffectCategory.OVERDRIVE;
break;
case 3:
local2 = EffectCategory.OTHER;
}
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 projects.tanks.client.commons.types {
public class ItemGarageProperty {
public static const HULL_ARMOR:ItemGarageProperty = new ItemGarageProperty(0,"HULL_ARMOR");
public static const HULL_SPEED:ItemGarageProperty = new ItemGarageProperty(1,"HULL_SPEED");
public static const HULL_TURN_SPEED:ItemGarageProperty = new ItemGarageProperty(2,"HULL_TURN_SPEED");
public static const HULL_POWER:ItemGarageProperty = new ItemGarageProperty(3,"HULL_POWER");
public static const HULL_MASS:ItemGarageProperty = new ItemGarageProperty(4,"HULL_MASS");
public static const ALL_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(5,"ALL_RESISTANCE");
public static const FIREBIRD_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(6,"FIREBIRD_RESISTANCE");
public static const SMOKY_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(7,"SMOKY_RESISTANCE");
public static const TWINS_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(8,"TWINS_RESISTANCE");
public static const RAILGUN_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(9,"RAILGUN_RESISTANCE");
public static const ISIS_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(10,"ISIS_RESISTANCE");
public static const MINE_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(11,"MINE_RESISTANCE");
public static const THUNDER_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(12,"THUNDER_RESISTANCE");
public static const FREEZE_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(13,"FREEZE_RESISTANCE");
public static const RICOCHET_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(14,"RICOCHET_RESISTANCE");
public static const SHAFT_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(15,"SHAFT_RESISTANCE");
public static const SHOTGUN_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(16,"SHOTGUN_RESISTANCE");
public static const MACHINE_GUN_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(17,"MACHINE_GUN_RESISTANCE");
public static const ROCKET_LAUNCHER_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(18,"ROCKET_LAUNCHER_RESISTANCE");
public static const ARTILLERY_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(19,"ARTILLERY_RESISTANCE");
public static const GAUSS_RESISTANCE:ItemGarageProperty = new ItemGarageProperty(20,"GAUSS_RESISTANCE");
public static const DAMAGE:ItemGarageProperty = new ItemGarageProperty(21,"DAMAGE");
public static const DAMAGE_PER_SECOND:ItemGarageProperty = new ItemGarageProperty(22,"DAMAGE_PER_SECOND");
public static const WEAPON_COOLDOWN_TIME:ItemGarageProperty = new ItemGarageProperty(23,"WEAPON_COOLDOWN_TIME");
public static const AIMING_MODE_COOLDOWN_TIME:ItemGarageProperty = new ItemGarageProperty(24,"AIMING_MODE_COOLDOWN_TIME");
public static const CRITICAL_HIT_CHANCE:ItemGarageProperty = new ItemGarageProperty(25,"CRITICAL_HIT_CHANCE");
public static const CRITICAL_HIT_DAMAGE:ItemGarageProperty = new ItemGarageProperty(26,"CRITICAL_HIT_DAMAGE");
public static const SHOT_RANGE:ItemGarageProperty = new ItemGarageProperty(27,"SHOT_RANGE");
public static const TURRET_TURN_SPEED:ItemGarageProperty = new ItemGarageProperty(28,"TURRET_TURN_SPEED");
public static const AIMING_ERROR:ItemGarageProperty = new ItemGarageProperty(29,"AIMING_ERROR");
public static const SHOT_AREA:ItemGarageProperty = new ItemGarageProperty(30,"SHOT_AREA");
public static const CONE_ANGLE:ItemGarageProperty = new ItemGarageProperty(31,"CONE_ANGLE");
public static const CHARGING_TIME:ItemGarageProperty = new ItemGarageProperty(32,"CHARGING_TIME");
public static const FIRE_DAMAGE:ItemGarageProperty = new ItemGarageProperty(33,"FIRE_DAMAGE");
public static const WEAPON_WEAKENING_COEFF:ItemGarageProperty = new ItemGarageProperty(34,"WEAPON_WEAKENING_COEFF");
public static const ISIS_DAMAGE:ItemGarageProperty = new ItemGarageProperty(35,"ISIS_DAMAGE");
public static const ISIS_HEALING_PER_SECOND:ItemGarageProperty = new ItemGarageProperty(36,"ISIS_HEALING_PER_SECOND");
public static const AIMING_MODE_DAMAGE:ItemGarageProperty = new ItemGarageProperty(37,"AIMING_MODE_DAMAGE");
public static const AIMING_WEAPON_DISCHARGE_RATE:ItemGarageProperty = new ItemGarageProperty(38,"AIMING_WEAPON_DISCHARGE_RATE");
public static const SHAFT_AIMED_SHOT_IMPACT:ItemGarageProperty = new ItemGarageProperty(39,"SHAFT_AIMED_SHOT_IMPACT");
public static const SHAFT_TARGETING_SPEED:ItemGarageProperty = new ItemGarageProperty(40,"SHAFT_TARGETING_SPEED");
public static const SHAFT_ARCADE_DAMAGE:ItemGarageProperty = new ItemGarageProperty(41,"SHAFT_ARCADE_DAMAGE");
public static const GAUSS_AIMING_MODE_DAMAGE:ItemGarageProperty = new ItemGarageProperty(42,"GAUSS_AIMING_MODE_DAMAGE");
public static const WEAPON_IMPACT_FORCE:ItemGarageProperty = new ItemGarageProperty(43,"WEAPON_IMPACT_FORCE");
public static const WEAPON_KICKBACK:ItemGarageProperty = new ItemGarageProperty(44,"WEAPON_KICKBACK");
public static const SHELL_SPEED:ItemGarageProperty = new ItemGarageProperty(45,"SHELL_SPEED");
public static const WEAPON_CHARGE_RATE:ItemGarageProperty = new ItemGarageProperty(46,"WEAPON_CHARGE_RATE");
public static const WEAPON_MIN_DAMAGE_PERCENT:ItemGarageProperty = new ItemGarageProperty(47,"WEAPON_MIN_DAMAGE_PERCENT");
public static const THUNDER_MIN_SPLASH_DAMAGE_PERCENT:ItemGarageProperty = new ItemGarageProperty(48,"THUNDER_MIN_SPLASH_DAMAGE_PERCENT");
public static const DEPENDENCY_FIRST_AID_SEC:ItemGarageProperty = new ItemGarageProperty(49,"DEPENDENCY_FIRST_AID_SEC");
public static const DEPENDENCY_DOUBLE_ARMOR_SEC:ItemGarageProperty = new ItemGarageProperty(50,"DEPENDENCY_DOUBLE_ARMOR_SEC");
public static const DEPENDENCY_DOUBLE_DAMAGE_SEC:ItemGarageProperty = new ItemGarageProperty(51,"DEPENDENCY_DOUBLE_DAMAGE_SEC");
public static const DEPENDENCY_NITRO_SEC:ItemGarageProperty = new ItemGarageProperty(52,"DEPENDENCY_NITRO_SEC");
public static const DEPENDENCY_MINE_SEC:ItemGarageProperty = new ItemGarageProperty(53,"DEPENDENCY_MINE_SEC");
public static const DEPENDENCY_DROPPABLE_GOLD_SEC:ItemGarageProperty = new ItemGarageProperty(54,"DEPENDENCY_DROPPABLE_GOLD_SEC");
public static const COOLDOWN_FIRST_AID_SEC:ItemGarageProperty = new ItemGarageProperty(55,"COOLDOWN_FIRST_AID_SEC");
public static const COOLDOWN_DOUBLE_ARMOR_SEC:ItemGarageProperty = new ItemGarageProperty(56,"COOLDOWN_DOUBLE_ARMOR_SEC");
public static const COOLDOWN_DOUBLE_DAMAGE_SEC:ItemGarageProperty = new ItemGarageProperty(57,"COOLDOWN_DOUBLE_DAMAGE_SEC");
public static const COOLDOWN_NITRO_SEC:ItemGarageProperty = new ItemGarageProperty(58,"COOLDOWN_NITRO_SEC");
public static const COOLDOWN_MINE_SEC:ItemGarageProperty = new ItemGarageProperty(59,"COOLDOWN_MINE_SEC");
public static const COOLDOWN_DROPPABLE_GOLD_SEC:ItemGarageProperty = new ItemGarageProperty(60,"COOLDOWN_DROPPABLE_GOLD_SEC");
public static const DURATION_FIRST_AID_SEC:ItemGarageProperty = new ItemGarageProperty(61,"DURATION_FIRST_AID_SEC");
public static const DURATION_DOUBLE_ARMOR_SEC:ItemGarageProperty = new ItemGarageProperty(62,"DURATION_DOUBLE_ARMOR_SEC");
public static const DURATION_DOUBLE_DAMAGE_SEC:ItemGarageProperty = new ItemGarageProperty(63,"DURATION_DOUBLE_DAMAGE_SEC");
public static const DURATION_NITRO_SEC:ItemGarageProperty = new ItemGarageProperty(64,"DURATION_NITRO_SEC");
public static const ATTACK_EFFECT:ItemGarageProperty = new ItemGarageProperty(65,"ATTACK_EFFECT");
public static const FIRST_AID_EFFECT_INSTANT:ItemGarageProperty = new ItemGarageProperty(66,"FIRST_AID_EFFECT_INSTANT");
public static const FIRST_AID_EFFECT:ItemGarageProperty = new ItemGarageProperty(67,"FIRST_AID_EFFECT");
public static const PROTECTION_EFFECT:ItemGarageProperty = new ItemGarageProperty(68,"PROTECTION_EFFECT");
public static const SPEED_EFFECT:ItemGarageProperty = new ItemGarageProperty(69,"SPEED_EFFECT");
public static const SHOTGUN_IMPACT_FORCE:ItemGarageProperty = new ItemGarageProperty(70,"SHOTGUN_IMPACT_FORCE");
public static const DISCHARGE_SPEED:ItemGarageProperty = new ItemGarageProperty(71,"DISCHARGE_SPEED");
public static const FREEZE_PER_TICK:ItemGarageProperty = new ItemGarageProperty(72,"FREEZE_PER_TICK");
public static const VERTICAL_ANGLES:ItemGarageProperty = new ItemGarageProperty(73,"VERTICAL_ANGLES");
public static const DRONE_RELOAD:ItemGarageProperty = new ItemGarageProperty(74,"DRONE_RELOAD");
public static const DRONE_REPAIR_HEALTH:ItemGarageProperty = new ItemGarageProperty(75,"DRONE_REPAIR_HEALTH");
public static const DRONE_INVENTORY:ItemGarageProperty = new ItemGarageProperty(76,"DRONE_INVENTORY");
public static const DRONE_INVENTORY_ADD:ItemGarageProperty = new ItemGarageProperty(77,"DRONE_INVENTORY_ADD");
public static const DRONE_BONUS_ADD:ItemGarageProperty = new ItemGarageProperty(78,"DRONE_BONUS_ADD");
public static const DRONE_FIRST_AID_BONUS_ADD:ItemGarageProperty = new ItemGarageProperty(79,"DRONE_FIRST_AID_BONUS_ADD");
public static const DRONE_OVERDRIVE_BOOST:ItemGarageProperty = new ItemGarageProperty(80,"DRONE_OVERDRIVE_BOOST");
public static const DRONE_DEFEND:ItemGarageProperty = new ItemGarageProperty(81,"DRONE_DEFEND");
public static const DRONE_ARMOR_BOOST:ItemGarageProperty = new ItemGarageProperty(82,"DRONE_ARMOR_BOOST");
public static const DRONE_MINE:ItemGarageProperty = new ItemGarageProperty(83,"DRONE_MINE");
public static const DRONE_ADDITIONAL_MINES:ItemGarageProperty = new ItemGarageProperty(84,"DRONE_ADDITIONAL_MINES");
public static const DRONE_MINES_ACTIVATION_DELAY:ItemGarageProperty = new ItemGarageProperty(85,"DRONE_MINES_ACTIVATION_DELAY");
public static const DRONE_MINES_PLACEMENT_RADIUS:ItemGarageProperty = new ItemGarageProperty(86,"DRONE_MINES_PLACEMENT_RADIUS");
public static const DRONE_INVENTORY_COOLDOWN_BOOST:ItemGarageProperty = new ItemGarageProperty(87,"DRONE_INVENTORY_COOLDOWN_BOOST");
public static const DRONE_POWER_BOOST:ItemGarageProperty = new ItemGarageProperty(88,"DRONE_POWER_BOOST");
public static const DRONE_POWER_DURATION:ItemGarageProperty = new ItemGarageProperty(89,"DRONE_POWER_DURATION");
public static const DRONE_CRITICAL_HEALTH:ItemGarageProperty = new ItemGarageProperty(90,"DRONE_CRITICAL_HEALTH");
public static const DRONE_REPAIR_RADIUS:ItemGarageProperty = new ItemGarageProperty(91,"DRONE_REPAIR_RADIUS");
public static const DRONE_INVENTORY_RADIUS:ItemGarageProperty = new ItemGarageProperty(92,"DRONE_INVENTORY_RADIUS");
public static const DRONE_COOLDOWN_RADIUS:ItemGarageProperty = new ItemGarageProperty(93,"DRONE_COOLDOWN_RADIUS");
public static const DRONE_CONSTANT_ARMOR_PERCENT:ItemGarageProperty = new ItemGarageProperty(94,"DRONE_CONSTANT_ARMOR_PERCENT");
public static const DRONE_CONSTANT_POWER_PERCENT:ItemGarageProperty = new ItemGarageProperty(95,"DRONE_CONSTANT_POWER_PERCENT");
public static const ULTIMATE_HEAL_HP:ItemGarageProperty = new ItemGarageProperty(96,"ULTIMATE_HEAL_HP");
public static const ULTIMATE_CHARGE_PER_SEC:ItemGarageProperty = new ItemGarageProperty(97,"ULTIMATE_CHARGE_PER_SEC");
public static const ULTIMATE_CHARGE_PER_SCORE_POINT:ItemGarageProperty = new ItemGarageProperty(98,"ULTIMATE_CHARGE_PER_SCORE_POINT");
public static const ULTIMATE_SCORE_COOLDOWN_SEC:ItemGarageProperty = new ItemGarageProperty(99,"ULTIMATE_SCORE_COOLDOWN_SEC");
public static const ULTIMATE_ACTIVATION_DISCHARGE_PER_SEC:ItemGarageProperty = new ItemGarageProperty(100,"ULTIMATE_ACTIVATION_DISCHARGE_PER_SEC");
private var _value:int;
private var _name:String;
public function ItemGarageProperty(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<ItemGarageProperty> {
var local1:Vector.<ItemGarageProperty> = new Vector.<ItemGarageProperty>();
local1.push(HULL_ARMOR);
local1.push(HULL_SPEED);
local1.push(HULL_TURN_SPEED);
local1.push(HULL_POWER);
local1.push(HULL_MASS);
local1.push(ALL_RESISTANCE);
local1.push(FIREBIRD_RESISTANCE);
local1.push(SMOKY_RESISTANCE);
local1.push(TWINS_RESISTANCE);
local1.push(RAILGUN_RESISTANCE);
local1.push(ISIS_RESISTANCE);
local1.push(MINE_RESISTANCE);
local1.push(THUNDER_RESISTANCE);
local1.push(FREEZE_RESISTANCE);
local1.push(RICOCHET_RESISTANCE);
local1.push(SHAFT_RESISTANCE);
local1.push(SHOTGUN_RESISTANCE);
local1.push(MACHINE_GUN_RESISTANCE);
local1.push(ROCKET_LAUNCHER_RESISTANCE);
local1.push(ARTILLERY_RESISTANCE);
local1.push(GAUSS_RESISTANCE);
local1.push(DAMAGE);
local1.push(DAMAGE_PER_SECOND);
local1.push(WEAPON_COOLDOWN_TIME);
local1.push(AIMING_MODE_COOLDOWN_TIME);
local1.push(CRITICAL_HIT_CHANCE);
local1.push(CRITICAL_HIT_DAMAGE);
local1.push(SHOT_RANGE);
local1.push(TURRET_TURN_SPEED);
local1.push(AIMING_ERROR);
local1.push(SHOT_AREA);
local1.push(CONE_ANGLE);
local1.push(CHARGING_TIME);
local1.push(FIRE_DAMAGE);
local1.push(WEAPON_WEAKENING_COEFF);
local1.push(ISIS_DAMAGE);
local1.push(ISIS_HEALING_PER_SECOND);
local1.push(AIMING_MODE_DAMAGE);
local1.push(AIMING_WEAPON_DISCHARGE_RATE);
local1.push(SHAFT_AIMED_SHOT_IMPACT);
local1.push(SHAFT_TARGETING_SPEED);
local1.push(SHAFT_ARCADE_DAMAGE);
local1.push(GAUSS_AIMING_MODE_DAMAGE);
local1.push(WEAPON_IMPACT_FORCE);
local1.push(WEAPON_KICKBACK);
local1.push(SHELL_SPEED);
local1.push(WEAPON_CHARGE_RATE);
local1.push(WEAPON_MIN_DAMAGE_PERCENT);
local1.push(THUNDER_MIN_SPLASH_DAMAGE_PERCENT);
local1.push(DEPENDENCY_FIRST_AID_SEC);
local1.push(DEPENDENCY_DOUBLE_ARMOR_SEC);
local1.push(DEPENDENCY_DOUBLE_DAMAGE_SEC);
local1.push(DEPENDENCY_NITRO_SEC);
local1.push(DEPENDENCY_MINE_SEC);
local1.push(DEPENDENCY_DROPPABLE_GOLD_SEC);
local1.push(COOLDOWN_FIRST_AID_SEC);
local1.push(COOLDOWN_DOUBLE_ARMOR_SEC);
local1.push(COOLDOWN_DOUBLE_DAMAGE_SEC);
local1.push(COOLDOWN_NITRO_SEC);
local1.push(COOLDOWN_MINE_SEC);
local1.push(COOLDOWN_DROPPABLE_GOLD_SEC);
local1.push(DURATION_FIRST_AID_SEC);
local1.push(DURATION_DOUBLE_ARMOR_SEC);
local1.push(DURATION_DOUBLE_DAMAGE_SEC);
local1.push(DURATION_NITRO_SEC);
local1.push(ATTACK_EFFECT);
local1.push(FIRST_AID_EFFECT_INSTANT);
local1.push(FIRST_AID_EFFECT);
local1.push(PROTECTION_EFFECT);
local1.push(SPEED_EFFECT);
local1.push(SHOTGUN_IMPACT_FORCE);
local1.push(DISCHARGE_SPEED);
local1.push(FREEZE_PER_TICK);
local1.push(VERTICAL_ANGLES);
local1.push(DRONE_RELOAD);
local1.push(DRONE_REPAIR_HEALTH);
local1.push(DRONE_INVENTORY);
local1.push(DRONE_INVENTORY_ADD);
local1.push(DRONE_BONUS_ADD);
local1.push(DRONE_FIRST_AID_BONUS_ADD);
local1.push(DRONE_OVERDRIVE_BOOST);
local1.push(DRONE_DEFEND);
local1.push(DRONE_ARMOR_BOOST);
local1.push(DRONE_MINE);
local1.push(DRONE_ADDITIONAL_MINES);
local1.push(DRONE_MINES_ACTIVATION_DELAY);
local1.push(DRONE_MINES_PLACEMENT_RADIUS);
local1.push(DRONE_INVENTORY_COOLDOWN_BOOST);
local1.push(DRONE_POWER_BOOST);
local1.push(DRONE_POWER_DURATION);
local1.push(DRONE_CRITICAL_HEALTH);
local1.push(DRONE_REPAIR_RADIUS);
local1.push(DRONE_INVENTORY_RADIUS);
local1.push(DRONE_COOLDOWN_RADIUS);
local1.push(DRONE_CONSTANT_ARMOR_PERCENT);
local1.push(DRONE_CONSTANT_POWER_PERCENT);
local1.push(ULTIMATE_HEAL_HP);
local1.push(ULTIMATE_CHARGE_PER_SEC);
local1.push(ULTIMATE_CHARGE_PER_SCORE_POINT);
local1.push(ULTIMATE_SCORE_COOLDOWN_SEC);
local1.push(ULTIMATE_ACTIVATION_DISCHARGE_PER_SEC);
return local1;
}
public function toString() : String {
return "ItemGarageProperty [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.models.weapon.machinegun {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.battle.objects.tank.WeaponMount;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.speedcharacteristics.SpeedCharacteristics;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapon.machinegun.sfx.MachineGunEffects;
import alternativa.tanks.models.weapon.machinegun.sfx.MachineGunSFXData;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapons.machinegun.cc.MachineGunCC;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class MachineGunCommonWeapon implements Weapon {
[Inject]
public static var battleService:BattleService;
private static var gunParams:AllGlobalGunParams = new AllGlobalGunParams();
private static const MAX_GYROSCOPE_COEFF:Number = 0.5;
private var tank:Tank;
private var speedCharacteristics:SpeedCharacteristics;
private var spinUpTime:int;
private var spinUpSpeed:Number;
private var spinDownSpeed:Number;
private var _state:Number = 0;
private var weaponPlatform:WeaponPlatform;
private var weaponCommonParams:WeaponCommonData;
private var tankModel:ITankModel;
private var params:MachineGunCC;
private var sfxData:MachineGunSFXData;
private var effects:MachineGunEffects;
public function MachineGunCommonWeapon(param1:IGameObject, param2:MachineGunCC, param3:MachineGunSFXData, param4:WeaponCommonData) {
super();
this.tankModel = ITankModel(param1.adapt(ITankModel));
this.speedCharacteristics = SpeedCharacteristics(param1.adapt(SpeedCharacteristics));
this.sfxData = param3;
this.spinUpTime = param2.spinUpTime;
this.spinUpSpeed = 1 / param2.spinUpTime;
this.spinDownSpeed = 1 / param2.spinDownTime;
this.params = param2;
this.weaponCommonParams = param4;
this._state = this.params.state;
}
public function init(param1:WeaponPlatform) : void {
this.weaponPlatform = param1;
this.effects = new MachineGunEffects(param1,this.params,this.sfxData);
}
public function activate() : void {
this.tank = this.tankModel.getTank();
}
public function start() : void {
}
public function stop() : void {
}
public function get state() : Number {
return this._state;
}
public function stopEffects() : void {
this.effects.update(0,0,false);
}
public function updateCharacteristicsAndEffects(param1:int, param2:Boolean) : void {
this.updateState(param1,param2);
this.updateSpeed();
this.effects.update(param1,this.state,param2);
}
public function updateGunParams() : AllGlobalGunParams {
this.weaponPlatform.getAllGunParams(gunParams);
return gunParams;
}
public function addRecoilForShooter(param1:Vector3, param2:Number) : void {
this.applyForce(this.tank.getBody(),gunParams.muzzlePosition,param1,-this.weaponCommonParams.getRecoilForce() * param2);
}
public function addImpactForTarget(param1:Body, param2:Vector3, param3:Vector3, param4:Number) : void {
this.applyForce(param1,param2,param3,this.weaponCommonParams.getImpactForce() * param4);
}
public function getPowerCoeff(param1:int, param2:int, param3:int) : Number {
return Math.max(param1 + Math.min(param2 - param3,0),0) / 1000;
}
public function setTargetPosition(param1:Vector3, param2:Boolean) : void {
if(this.isTurretAboveGround()) {
this.effects.setTargetPosition(param1,param2);
} else {
this.effects.clearTargetPosition(true);
}
}
public function clearTargetPosition() : void {
this.effects.clearTargetPosition(!this.isTurretAboveGround());
}
public function reset() : void {
this._state = 0;
if(this.tank != null) {
this.tank.getWeaponMount().setGyroscopePower(0);
}
}
public function destroy() : void {
this.effects.destroy();
this.effects = null;
if(this.weaponPlatform != null) {
this.weaponPlatform = null;
}
if(this.tank != null) {
this.tank = null;
}
this.tankModel = null;
this.speedCharacteristics = null;
this.sfxData = null;
this.params = null;
this.weaponCommonParams = null;
}
public function deactivate() : void {
}
public function enable() : void {
}
public function disable(param1:Boolean) : void {
}
public function getStatus() : Number {
return 0;
}
private function applyForce(param1:Body, param2:Vector3, param3:Vector3, param4:Number) : void {
param1.addWorldForceScaled(param2,param3,param4);
var local5:Tank = param1.tank;
var local6:int = local5.getLeftTrack().numContacts + local5.getRightTrack().numContacts;
if(local6 == 0 || BattleUtils.isTurnedOver(param1)) {
param1.addScaledForce(param3,-param4);
}
}
private function isTurretAboveGround() : Boolean {
return BattleUtils.isTurretAboveGround(this.weaponPlatform.getBody(),gunParams);
}
private function updateState(param1:int, param2:Boolean) : void {
if(param2) {
this._state = Math.min(1,this.state + param1 * this.spinUpSpeed);
} else {
this._state = Math.max(0,this.state - param1 * this.spinDownSpeed);
}
}
private function updateSpeed() : void {
var local2:WeaponMount = null;
var local1:Number = this.params.weaponTurnDecelerationCoeff + this.rotationCoeff() * (1 - this.params.weaponTurnDecelerationCoeff);
if(this.tank != null) {
local2 = this.tank.getWeaponMount();
local2.setMaxTurnSpeed(this.speedCharacteristics.getMaxTurretTurnSpeed() * local1,true);
local2.setTurnAcceleration(this.weaponCommonParams.getTurretRotationAcceleration() * local1);
local2.setGyroscopePower(MAX_GYROSCOPE_COEFF * this.state);
}
}
private function rotationCoeff() : Number {
return 1 - this.state;
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.MACHINE_GUN_RESISTANCE;
}
public function updateRecoilForce(param1:Number) : void {
this.weaponCommonParams.setRecoilForce(param1);
}
public function fullyRecharge() : void {
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
}
public function updateSpinTimes(param1:int, param2:int) : void {
this.spinUpTime = param1;
this.spinUpSpeed = 1 / param1;
this.spinDownSpeed = 1 / param2;
}
public function getCurrentSpinUpTime() : int {
return this.spinUpTime;
}
public function stun() : void {
}
public function calm(param1:int) : void {
}
public function spin() : void {
this._state = 1;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.notifier {
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.battle.BattleLinkData;
public interface UserInfoConsumer {
function setOnline(param1:Boolean, param2:int) : void;
function setUid(param1:String) : void;
function setRank(param1:int) : void;
function setBattleUrl(param1:BattleLinkData) : void;
function setSNUid(param1:String) : void;
function setIsReferral(param1:Boolean) : void;
}
}
|
package projects.tanks.client.battlefield.gui.models.statistics
{
public class BattleStatInfo
{
public var scoreLimit:int;
public var timeLimit:int;
public var fund:int;
public var timeLeft:int;
public var blueScore:int;
public var redScore:int;
public var teamPlay:Boolean;
public function BattleStatInfo()
{
super();
}
}
}
|
package alternativa.tanks.models.longterm
{
import alternativa.model.IModel;
import alternativa.object.ClientObject;
import alternativa.types.Long;
import com.alternativaplatform.projects.tanks.client.warfare.models.common.longterm.ILongTermBonusModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.common.longterm.LongTermBonusModelBase;
public class LongTermBonusModel extends LongTermBonusModelBase implements ILongTermBonusModelBase
{
public function LongTermBonusModel()
{
super();
_interfaces.push(IModel,ILongTermBonusModelBase);
}
public function effectStart(clientObject:ClientObject, tankId:Long, durationSec:int) : void
{
}
public function effectStop(clientObject:ClientObject, tankId:Long) : void
{
}
}
}
|
package alternativa.tanks.model.battle {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class BattleEntranceEvents implements BattleEntrance {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function BattleEntranceEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function fight(param1:BattleTeam = null) : void {
var i:int = 0;
var m:BattleEntrance = null;
var team:BattleTeam = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattleEntrance(this.impl[i]);
m.fight(team);
i++;
}
}
finally {
Model.popObject();
}
}
public function enterAsSpectator() : void {
var i:int = 0;
var m:BattleEntrance = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattleEntrance(this.impl[i]);
m.enterAsSpectator();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.engine3d.debug
{
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.engine3d.ITextureMaterialRegistry;
import alternativa.tanks.engine3d.MaterialType;
import alternativa.tanks.engine3d.TanksTextureMaterial;
import alternativa.tanks.materials.AnimatedPaintMaterial;
import alternativa.tanks.materials.PaintMaterial;
import flash.display.BitmapData;
import scpacker.resource.images.ImageResource;
public class TextureMaterialRegistry implements ITextureMaterialRegistry
{
private var mapMaterial:TanksTextureMaterial;
private var tankMaterial:TanksTextureMaterial;
private var effectMaterial:TanksTextureMaterial;
public function TextureMaterialRegistry()
{
super();
this.mapMaterial = new TanksTextureMaterial(new DebugTexture(24,6,12615551,6684672),false,false,0,0);
this.tankMaterial = new TanksTextureMaterial(new DebugTexture(24,12,8372351,26112),false,false,0,0);
this.effectMaterial = new TanksTextureMaterial(new DebugTexture(24,6,8355776,102),false,false,0,0);
}
public function getAnimatedPaint(imageResource:ImageResource, lightmap:BitmapData, details:BitmapData, objId:String) : AnimatedPaintMaterial
{
return null;
}
public function getPaint1(imageResource:ImageResource, lightmap:BitmapData, details:BitmapData, objId:String) : PaintMaterial
{
return null;
}
public function set timerInterval(value:int) : void
{
}
public function set resoluion(value:Number) : void
{
}
public function get useMipMapping() : Boolean
{
return false;
}
public function set useMipMapping(value:Boolean) : void
{
}
public function getMaterial(materialType:MaterialType, texture:BitmapData, mipMapResolution:Number, disposeMainTexure:Boolean = false) : TextureMaterial
{
switch(materialType)
{
case MaterialType.EFFECT:
return this.effectMaterial;
case MaterialType.MAP:
return this.mapMaterial;
case MaterialType.TANK:
return this.tankMaterial;
default:
return null;
}
}
public function clear() : void
{
}
public function getDump() : String
{
return "";
}
public function disposeMaterial(material:TextureMaterial) : void
{
}
}
}
|
package projects.tanks.clients.fp10.TanksLauncher.service {
import flash.external.ExternalInterface;
public class YandexMetricaService {
private static const YM_REACH_GOAL:String = "YMReachGoal";
private static const YM_LOADED:String = "checkYMLoaded";
private static const COOKIE_EXISTS_FUNC:String = "Cookie.exists";
private static const WAS_IN_TUTORIAL:String = "FROM_TUTORIAL";
public function YandexMetricaService() {
super();
}
public static function reachGoalIfPlayerWasInTutorial(param1:String) : void {
if(ExternalInterface.available && ExternalInterface.call(YM_LOADED) && ExternalInterface.call(COOKIE_EXISTS_FUNC,WAS_IN_TUTORIAL) > 0) {
ExternalInterface.call(YM_REACH_GOAL,param1);
}
}
}
}
|
package alternativa.tanks.models.weapon.thunder {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
public interface IThunderEffects {
function createShotEffects(param1:Vector3, param2:Object3D) : void;
function createExplosionEffects(param1:Vector3) : void;
function createExplosionMark(param1:Vector3, param2:Vector3) : void;
}
}
|
package alternativa.tanks.service.fps {
public interface FPSService {
function getFps() : Number;
function getFrameTimeMS() : Number;
}
}
|
package projects.tanks.client.entrance.model.entrance.telegram {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class TelegramEntranceModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _loginId:Long = Long.getLong(808470229,1758443450);
private var _login_jsonCodec:ICodec;
private var model:IModel;
public function TelegramEntranceModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._login_jsonCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function login(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._login_jsonCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._loginId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.emailrequired {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.shop.emailrequired.EmailRequiredCC;
public class VectorCodecEmailRequiredCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecEmailRequiredCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(EmailRequiredCC,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.<EmailRequiredCC> = new Vector.<EmailRequiredCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = EmailRequiredCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:EmailRequiredCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<EmailRequiredCC> = Vector.<EmailRequiredCC>(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 flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _6c197dabc736b49abc6996ef058b574251aa1e4795522a3d95168d4922876ec9_flash_display_Sprite extends Sprite {
public function _6c197dabc736b49abc6996ef058b574251aa1e4795522a3d95168d4922876ec9_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.view.icons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.icons.BattleParamsCheckButtonIcons_clanVsClanClass.png")]
public class BattleParamsCheckButtonIcons_clanVsClanClass extends BitmapAsset {
public function BattleParamsCheckButtonIcons_clanVsClanClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.thunder {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.sfx.AnimatedLightEffect;
import alternativa.tanks.sfx.AnimatedSpriteEffect;
import alternativa.tanks.sfx.MuzzlePositionProvider;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.objectpool.ObjectPool;
public class ThunderEffects implements IThunderEffects {
private static const SHOT_VOLUME:Number = 0.7;
private static const EXPLOSION_VOLUME:Number = 0.7;
private static const EXPLOSION_OFFSET_TO_CAMERA:Number = 110;
private static const DECAL_RADIUS:Number = 250;
private static const turretMatrix:Matrix4 = new Matrix4();
private static const muzzlePosition:Vector3 = new Vector3();
private var battleService:BattleService;
private var sfxData:ThunderSFXData;
public function ThunderEffects(param1:BattleService, param2:ThunderSFXData) {
super();
this.battleService = param1;
this.sfxData = param2;
}
public function createShotEffects(param1:Vector3, param2:Object3D) : void {
var local3:ThunderShotEffect = ThunderShotEffect(this.battleService.getObjectPool().getObject(ThunderShotEffect));
local3.init(param2,param1,this.sfxData.muzzleFlashMaterial);
this.battleService.addGraphicEffect(local3);
turretMatrix.setMatrix(param2.x,param2.y,param2.z,param2.rotationX,param2.rotationY,param2.rotationZ);
turretMatrix.transformVector(param1,muzzlePosition);
var local4:Sound3D = Sound3D.create(this.sfxData.shotSound,SHOT_VOLUME);
this.battleService.addSound3DEffect(Sound3DEffect.create(muzzlePosition,local4));
this.createShotLightEffects(param1,param2);
}
public function createShotLightEffects(param1:Vector3, param2:Object3D) : void {
var local3:AnimatedLightEffect = AnimatedLightEffect(this.battleService.getObjectPool().getObject(AnimatedLightEffect));
var local4:MuzzlePositionProvider = MuzzlePositionProvider(this.battleService.getObjectPool().getObject(MuzzlePositionProvider));
local4.init(param2,param1);
local3.init(local4,this.sfxData.shotLightAnimation);
this.battleService.addGraphicEffect(local3);
}
public function createExplosionEffects(param1:Vector3) : void {
this.createExplosionGraphicEffect(param1);
this.createExplosionSoundEffect(param1);
this.createExplosionLightEffect(param1);
}
private function createExplosionLightEffect(param1:Vector3) : void {
var local2:AnimatedLightEffect = AnimatedLightEffect(this.battleService.getObjectPool().getObject(AnimatedLightEffect));
var local3:StaticObject3DPositionProvider = StaticObject3DPositionProvider(this.battleService.getObjectPool().getObject(StaticObject3DPositionProvider));
local3.init(param1,EXPLOSION_OFFSET_TO_CAMERA);
local2.init(local3,this.sfxData.hitLightAnimation);
this.battleService.addGraphicEffect(local2);
}
public function createExplosionMark(param1:Vector3, param2:Vector3) : void {
this.battleService.getBattleScene3D().addDecal(param2,param1,DECAL_RADIUS,this.sfxData.explosionMarkMaterial);
}
private function createExplosionGraphicEffect(param1:Vector3) : void {
var local2:ObjectPool = this.battleService.getObjectPool();
var local3:StaticObject3DPositionProvider = StaticObject3DPositionProvider(local2.getObject(StaticObject3DPositionProvider));
local3.init(param1,EXPLOSION_OFFSET_TO_CAMERA);
var local4:AnimatedSpriteEffect = AnimatedSpriteEffect(local2.getObject(AnimatedSpriteEffect));
local4.init(this.sfxData.explosionSize,this.sfxData.explosionSize,this.sfxData.explosionAnimation,Math.random() * 2 * Math.PI,local3);
this.battleService.addGraphicEffect(local4);
}
private function createExplosionSoundEffect(param1:Vector3) : void {
var local2:Sound3D = Sound3D.create(this.sfxData.explosionSound,EXPLOSION_VOLUME);
this.battleService.addSound3DEffect(Sound3DEffect.create(param1,local2));
}
}
}
|
package _codec.projects.tanks.client.commons.models.externalauth {
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.commons.models.externalauth.ExternalAuthParameters;
public class VectorCodecExternalAuthParametersLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecExternalAuthParametersLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ExternalAuthParameters,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.<ExternalAuthParameters> = new Vector.<ExternalAuthParameters>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ExternalAuthParameters(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ExternalAuthParameters = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ExternalAuthParameters> = Vector.<ExternalAuthParameters>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.socialnetwork {
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.panel.model.socialnetwork.SocialNetworkPanelCC;
import projects.tanks.client.panel.model.socialnetwork.SocialNetworkPanelParams;
public class CodecSocialNetworkPanelCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_passwordCreated:ICodec;
private var codec_socialNetworkParams:ICodec;
public function CodecSocialNetworkPanelCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_passwordCreated = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_socialNetworkParams = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(SocialNetworkPanelParams,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:SocialNetworkPanelCC = new SocialNetworkPanelCC();
local2.passwordCreated = this.codec_passwordCreated.decode(param1) as Boolean;
local2.socialNetworkParams = this.codec_socialNetworkParams.decode(param1) as Vector.<SocialNetworkPanelParams>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:SocialNetworkPanelCC = SocialNetworkPanelCC(param2);
this.codec_passwordCreated.encode(param1,local3.passwordCreated);
this.codec_socialNetworkParams.encode(param1,local3.socialNetworkParams);
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.ActionOutputLine_cpPointNeutralRedIcon.png")]
public class ActionOutputLine_cpPointNeutralRedIcon extends BitmapAsset {
public function ActionOutputLine_cpPointNeutralRedIcon() {
super();
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.china.partner7k7k {
import flash.net.URLRequest;
import flash.net.navigateToURL;
import flash.utils.Dictionary;
import platform.client.core.general.socialnetwork.types.LoginParameters;
import platform.client.fp10.core.service.address.AddressService;
import platform.clients.fp10.libraries.alternativapartners.type.IParametersListener;
import platform.clients.fp10.libraries.alternativapartners.type.IPartner;
import projects.tanks.client.partners.impl.china.partner7k7k.IPartner7k7kModelBase;
import projects.tanks.client.partners.impl.china.partner7k7k.Partner7k7kModelBase;
[ModelInfo]
public class Partner7k7kModel extends Partner7k7kModelBase implements IPartner7k7kModelBase, IPartner {
[Inject]
public static var addressService:AddressService;
private static const PAYMENT_URL:String = "http://pay.web.7k7k.com/?g=293&s=";
private var server_id:String;
private var userid:String;
public function Partner7k7kModel() {
super();
}
public function getLoginParameters(param1:IParametersListener) : void {
var local2:Dictionary = new Dictionary();
this.userid = addressService.getQueryParameter("userid");
local2["userid"] = this.userid;
local2["username"] = addressService.getQueryParameter("username");
local2["time"] = addressService.getQueryParameter("time");
this.server_id = addressService.getQueryParameter("server_id");
local2["server_id"] = this.server_id;
local2["isAdult"] = addressService.getQueryParameter("isAdult");
local2["flag"] = addressService.getQueryParameter("flag");
param1.onSetParameters(new LoginParameters(local2));
}
public function getFailRedirectUrl() : String {
return "http://web.7k7k.com/games/3dtk";
}
public function isExternalLoginAllowed() : Boolean {
return false;
}
public function hasPaymentAction() : Boolean {
return true;
}
public function paymentAction() : void {
navigateToURL(new URLRequest(PAYMENT_URL + this.server_id + "&uid=" + this.userid),"_blank");
}
public function hasRatings() : Boolean {
return false;
}
}
}
|
package controls
{
import alternativa.init.Main;
import fl.controls.List;
import fl.data.DataProvider;
import fl.events.ListEvent;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.text.GridFitType;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFieldType;
import scpacker.gui.combo.DPLBackground;
public class TankCombo extends Sprite
{
private var button:ComboButton;
private var listBg:DPLBackground;
private var list:List;
private var dp:DataProvider;
private var state:Boolean = true;
private var _label:Label;
private var _selectedItem:Object;
private var hiddenInput:TextField;
private var _selectedIndex:int = 0;
private var _width:int;
public var _value:String;
public function TankCombo()
{
this.button = new ComboButton();
this.listBg = new DPLBackground(100,275);
this.list = new List();
this.dp = new DataProvider();
super();
this._label = new Label();
this._label.x = -10;
this._label.y = 7;
this._label.gridFitType = GridFitType.SUBPIXEL;
try
{
addChild(this.listBg);
addChild(this.list);
addChild(this.button);
addChild(this._label);
}
catch(e:Error)
{
}
this.listBg.y = 3;
this.list.y = 33;
this.list.x = 3;
this.list.setSize(144,115);
this.list.rowHeight = 20;
this.list.dataProvider = this.dp;
this.list.setStyle("cellRenderer",ComboListRenderer);
this.button.addEventListener(MouseEvent.CLICK,this.switchState);
this.hiddenInput = new TextField();
this.hiddenInput.visible = false;
this.hiddenInput.type = TextFieldType.INPUT;
this.switchState();
this.list.addEventListener(ListEvent.ITEM_CLICK,this.onItemClick);
addEventListener(Event.ADDED_TO_STAGE,this.Conf);
}
public function get selectedItem() : Object
{
return this._selectedItem;
}
public function set selectedItem(item:Object) : void
{
if(item == null)
{
this._selectedItem = null;
this.button.label = "";
}
else
{
this._selectedIndex = this.dp.getItemIndex(item);
this._selectedItem = this.dp.getItemAt(this._selectedIndex);
this.button.label = item.gameName;
}
dispatchEvent(new Event(Event.CHANGE));
}
public function get selectedIndex() : int
{
return this._selectedIndex;
}
public function set label(value:String) : void
{
this._label.text = value;
this._label.autoSize = TextFieldAutoSize.RIGHT;
}
private function Conf(e:Event) : void
{
}
private function onItemClick(e:ListEvent) : void
{
var item:Object = e.item;
this._selectedIndex = e.index;
if(item.rang == 0)
{
this.button.label = item.gameName;
this._selectedItem = item;
}
this.switchState();
dispatchEvent(new Event(Event.CHANGE));
}
public function test() : void
{
}
private function switchStateClose(e:MouseEvent = null) : void
{
if(e.currentTarget as DisplayObject != this.button)
{
this.state = false;
this.listBg.visible = this.list.visible = this.state;
}
}
private function switchState(e:MouseEvent = null) : void
{
this.state = !this.state;
this.listBg.visible = this.list.visible = this.state;
if(!this.state)
{
this.hiddenInput.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUpHiddenInput);
if(Main.stage.focus == this.hiddenInput)
{
Main.stage.focus = null;
}
}
else
{
Main.stage.addChild(this.hiddenInput);
Main.stage.focus = this.hiddenInput;
this.hiddenInput.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUpHiddenInput);
}
}
private function onKeyUpHiddenInput(param1:KeyboardEvent) : void
{
this.getItemByFirstChar(this.hiddenInput.text.substr(0,1));
this.hiddenInput.text = "";
}
public function getItemByFirstChar(param1:String) : Object
{
var _loc4_:Object = null;
var _loc2_:uint = this.dp.length;
var _loc3_:int = 0;
while(_loc3_ < _loc2_)
{
_loc4_ = this.dp.getItemAt(_loc3_);
if(_loc4_["gameName"].substr(0,1).toLowerCase() == param1.toLowerCase())
{
this._selectedItem = _loc4_;
this._value = this._selectedItem["gameName"];
this.button.label = this._value.toString();
this.list.selectedIndex = _loc3_;
this.list.verticalScrollPosition = _loc3_ * 20;
dispatchEvent(new Event(Event.CHANGE));
return _loc4_;
}
_loc3_++;
}
return null;
}
public function addItem(obj:Object) : void
{
var item:Object = null;
this.dp.addItem(obj);
item = this.dp.getItemAt(0);
this._selectedItem = item;
this.button.label = item.gameName;
}
public function sortOn(fieldName:Object, options:Object = null) : void
{
var item:Object = null;
this.dp.sortOn(fieldName,options);
item = this.dp.getItemAt(0);
this._selectedItem = item;
this._value = this._selectedItem.gameName;
this.button.label = item.gameName;
}
public function clear() : void
{
this.dp = new DataProvider();
this.list.dataProvider = this.dp;
this.button.label = "";
}
override public function set width(w:Number) : void
{
this._width = int(w);
this.listBg.width = this._width;
this.button.width = this._width;
this.list.width = this._width;
this.list.invalidate();
}
public function get listWidth() : Number
{
return this.list.width;
}
public function set listWidth(w:Number) : void
{
this.list.width = w;
}
override public function set height(h:Number) : void
{
this.listBg.height = h;
this.list.height = h - 35;
this.list.invalidate();
}
public function set value(str:String) : void
{
var item:Object = null;
this._value = "";
this.button.label = this._value;
this._selectedItem = null;
for(var i:int = 0; i < this.dp.length; i++)
{
item = this.dp.getItemAt(i);
if(item.gameName == str)
{
this._selectedItem = item;
this._value = this._selectedItem.gameName;
this.button.label = this._value;
this.list.selectedIndex = i;
this.list.scrollToSelected();
}
}
dispatchEvent(new Event(Event.CHANGE));
}
public function get value() : String
{
return this._value;
}
}
}
|
package scpacker.test.spectator
{
import alternativa.console.ConsoleVarFloat;
import alternativa.math.Vector3;
import alternativa.tanks.camera.GameCamera;
public class WalkMovement implements MovementMethod
{
private static const direction:Vector3 = new Vector3();
private static const localDirection:Vector3 = new Vector3();
private var conSpeed:ConsoleVarFloat;
private var conAcceleration:ConsoleVarFloat;
public function WalkMovement(param1:ConsoleVarFloat, param2:ConsoleVarFloat)
{
super();
this.conSpeed = param1;
this.conAcceleration = param2;
}
public function getDisplacement(param1:UserInput, param2:GameCamera, param3:Number) : Vector3
{
localDirection.y = param1.getForwardDirection();
localDirection.x = param1.getSideDirection();
var _loc4_:Number = Math.cos(param2.rotationZ);
var _loc5_:Number = Math.sin(param2.rotationZ);
direction.x = localDirection.x * _loc4_ - localDirection.y * _loc5_;
direction.y = localDirection.x * _loc5_ + localDirection.y * _loc4_;
direction.z = param1.getVerticalDirection();
if(direction.lengthSqr() > 0)
{
direction.vNormalize();
}
if(param1.isAcceleratied())
{
direction.scale(this.conSpeed.value * this.conAcceleration.value * param3);
}
else
{
direction.scale(this.conSpeed.value * param3);
}
return direction;
}
}
}
|
package projects.tanks.client.panel.model.coin {
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 CoinInfoModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:CoinInfoModelServer;
private var client:ICoinInfoModelBase = ICoinInfoModelBase(this);
private var modelId:Long = Long.getLong(462774872,33170034);
private var _changeById:Long = Long.getLong(1574353768,-896343414);
private var _changeBy_deltaCodec:ICodec;
private var _setCoinsId:Long = Long.getLong(1574353870,-939206877);
private var _setCoins_coinsCodec:ICodec;
public function CoinInfoModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new CoinInfoModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(CoinInfoCC,false)));
this._changeBy_deltaCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._setCoins_coinsCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
protected function getInitParam() : CoinInfoCC {
return CoinInfoCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._changeById:
this.client.changeBy(int(this._changeBy_deltaCodec.decode(param2)));
break;
case this._setCoinsId:
this.client.setCoins(int(this._setCoins_coinsCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.sfx.damageindicator {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Sprite3D;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import controls.Label;
import filters.Filters;
import flash.display.BitmapData;
public class DamageIndicatorEffect extends PooledObject implements GraphicEffect {
[Inject]
public static var battleService:BattleService;
private static const POP_HEIGHT:Number = 100;
private static const REST_HEIGHT:Number = 250;
private static const MAX_HEIGHT:Number = 300;
private static const POP_SPEED:Number = 1000;
private static const REST_SPEED:Number = 100;
private static var label:Label = new Label();
private var sprite:Sprite3D;
private var time:int;
private var z:Number;
private var origin:Vector3 = new Vector3();
private var container:Scene3DContainer;
private var variationX:Number;
private var variationY:Number;
public function DamageIndicatorEffect(param1:Pool) {
super(param1);
this.sprite = new Sprite3D(0,0);
this.sprite.perspectiveScale = false;
this.sprite.material = new TextureMaterial(null,false,false);
this.sprite.useShadowMap = false;
this.sprite.useLight = false;
this.sprite.depthTest = false;
label.size = 16;
label.filters = Filters.SHADOW_FILTERS;
}
public static function start(param1:Vector3, param2:uint, param3:int) : void {
var local4:DamageIndicatorEffect = DamageIndicatorEffect(battleService.getObjectPool().getObject(DamageIndicatorEffect));
local4.init(param1,param2,param3);
battleService.getBattleScene3D().addGraphicEffect(local4);
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = battleService.getBattleScene3D().getFrontContainer();
this.container.addChild(this.sprite);
}
public function play(param1:int, param2:GameCamera) : Boolean {
this.sprite.x = this.origin.x + this.z * this.variationX;
this.sprite.y = this.origin.y + this.z * this.variationY;
this.sprite.z = this.origin.z + this.z;
this.time += param1;
var local3:Number = this.z < POP_HEIGHT ? POP_SPEED : REST_SPEED;
this.z += local3 * param1 * 0.001;
if(this.z < REST_HEIGHT) {
this.sprite.alpha = 1;
} else {
this.sprite.alpha = (MAX_HEIGHT - this.z) / (MAX_HEIGHT - REST_HEIGHT);
if(this.sprite.alpha < 0) {
this.sprite.alpha = 0;
return false;
}
}
return true;
}
public function destroy() : void {
this.container.removeChild(this.sprite);
this.container = null;
recycle();
}
public function kill() : void {
this.sprite.alpha = 0;
}
private function init(param1:Vector3, param2:uint, param3:int) : void {
this.origin.copy(param1);
this.time = 0;
this.z = 0;
this.variationX = Math.random() - 0.5;
this.variationY = Math.random() - 0.5;
label.text = param3.toString();
label.color = param2;
var local4:BitmapData = new BitmapData(60,20,true,0);
local4.draw(label);
TextureMaterial(this.sprite.material).texture = local4;
this.sprite.width = local4.width;
this.sprite.height = local4.height;
this.sprite.calculateBounds();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p29 extends BitmapAsset
{
public function RangIconNormal_p29()
{
super();
}
}
}
|
package _codec.projects.tanks.client.clans.space.createclan {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.clans.space.createclan.ClanCreateCC;
public class CodecClanCreateCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_minRankForCreateClan:ICodec;
public function CodecClanCreateCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_minRankForCreateClan = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ClanCreateCC = new ClanCreateCC();
local2.minRankForCreateClan = this.codec_minRankForCreateClan.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ClanCreateCC = ClanCreateCC(param2);
this.codec_minRankForCreateClan.encode(param1,local3.minRankForCreateClan);
}
}
}
|
package _codec.projects.tanks.client.entrance.model.users.antiaddiction {
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.entrance.model.users.antiaddiction.ChangeIdNumberResult;
public class VectorCodecChangeIdNumberResultLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecChangeIdNumberResultLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(ChangeIdNumberResult,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.<ChangeIdNumberResult> = new Vector.<ChangeIdNumberResult>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ChangeIdNumberResult(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ChangeIdNumberResult = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ChangeIdNumberResult> = Vector.<ChangeIdNumberResult>(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.users.model.friends.incomingnotificator {
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;
import projects.tanks.client.users.model.friends.container.UserContainerCC;
public class FriendsIncomingNotificatorModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:FriendsIncomingNotificatorModelServer;
private var client:IFriendsIncomingNotificatorModelBase = IFriendsIncomingNotificatorModelBase(this);
private var modelId:Long = Long.getLong(1435596993,-649634714);
private var _onAddingId:Long = Long.getLong(1727765184,1572488911);
private var _onAdding_userIdCodec:ICodec;
private var _onRemovedId:Long = Long.getLong(2021113166,-552663310);
private var _onRemoved_userIdCodec:ICodec;
public function FriendsIncomingNotificatorModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new FriendsIncomingNotificatorModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(UserContainerCC,false)));
this._onAdding_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._onRemoved_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
}
protected function getInitParam() : UserContainerCC {
return UserContainerCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._onAddingId:
this.client.onAdding(Long(this._onAdding_userIdCodec.decode(param2)));
break;
case this._onRemovedId:
this.client.onRemoved(Long(this._onRemoved_userIdCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package platform.client.fp10.core.resource {
import alternativa.osgi.service.launcherparams.ILauncherParams;
import alternativa.osgi.service.logging.LogService;
import alternativa.osgi.service.logging.Logger;
import alternativa.types.Long;
import flash.utils.ByteArray;
import flash.utils.getQualifiedClassName;
import flash.utils.getTimer;
import platform.client.fp10.core.registry.ResourceRegistry;
import platform.client.fp10.core.service.IResourceTimer;
public class Resource {
[Inject]
public static var resourceRegistry:ResourceRegistry;
[Inject]
public static var resourceTimer:IResourceTimer;
[Inject]
public static var launcherParams:ILauncherParams;
[Inject]
public static var logService:LogService;
public static var logger:Logger;
public static const DEFAULT_CLASSIFIER:String = "default";
public var status:String;
protected var resourceInfo:ResourceInfo;
protected var baseUrl:String;
protected var listener:IResourceLoadingListener;
protected var flags:int;
internal var lastActivityTime:int;
private var numReloadAttempts:int;
private var dependents:Vector.<Resource>;
private var numDependencies:int = 0;
private var batchLoader:BatchResourceLoader;
public function Resource(param1:ResourceInfo) {
super();
if(param1 == null) {
throw new ArgumentError("Parameter resourceInfo is null");
}
logger = logger || logService.getLogger(ResourceLogChannel.NAME);
this.resourceInfo = param1;
}
private static function getClassName(param1:Object) : String {
var local2:String = getQualifiedClassName(param1);
var local3:int = int(local2.indexOf("::"));
if(local3 >= 0) {
return local2.substr(local3 + 2);
}
return local2;
}
public function addDependent(param1:Resource) : void {
if(this.dependents == null) {
this.dependents = new Vector.<Resource>();
}
this.dependents.push(param1);
}
public function isHasDependencies() : Boolean {
return this.numDependencies > 0;
}
public function setBatchLoader(param1:BatchResourceLoader) : void {
this.batchLoader = param1;
}
public function addDependence(param1:Resource) : void {
param1.addDependent(this);
++this.numDependencies;
}
public function handleDependenceLoaded() : void {
if(--this.numDependencies == 0) {
if(this.batchLoader != null) {
this.batchLoader.loadResource(this);
}
}
}
public function toString() : String {
return "resource id: " + this.id + ", version: " + this.version.low + ", lazy: " + this.isLazy + ", class: " + getClassName(this) + ", status: " + this.status;
}
final public function get id() : Long {
return this.resourceInfo.id;
}
final public function get version() : Long {
return this.resourceInfo.version;
}
final public function get isLazy() : Boolean {
return this.resourceInfo.isLazy;
}
final public function get isLoaded() : Boolean {
return (this.flags & ResourceFlags.LOADED) != 0;
}
final public function get isLoading() : Boolean {
return (this.flags & ResourceFlags.IS_LOADING) != 0;
}
public function getReloadURLPostfix() : String {
if(this.numReloadAttempts > 0) {
return "?reloadRand=" + Math.random() + "&numReload=" + this.numReloadAttempts;
}
return "";
}
final public function loadLazyResource(param1:IResourceLoadingListener) : void {
if(this.isLoaded) {
throw new Error("Resource is already loaded. Resource id: " + this.id);
}
resourceRegistry.loadLazyResource(this,param1);
}
final public function removeLazyListener(param1:IResourceLoadingListener) : void {
if(this.isLazy && !this.isLoaded) {
resourceRegistry.removeLazyListener(this,param1);
}
}
final public function addLazyListener(param1:IResourceLoadingListener) : void {
if(!this.isLazy) {
throw new Error("Resource is not lazy. Resource id: " + this.id);
}
if(this.isLoaded) {
throw new Error("Resource is already loaded. Resource id: " + this.id);
}
resourceRegistry.addLazyListener(this,param1);
}
public function load(param1:String, param2:IResourceLoadingListener) : void {
if(param2 == null) {
throw new ArgumentError("Parameter listener is null");
}
this.baseUrl = param1;
this.listener = param2;
}
public function close() : void {
}
public function get classifier() : String {
return DEFAULT_CLASSIFIER;
}
public function loadBytes(param1:ByteArray, param2:IResourceLoadingListener) : Boolean {
return false;
}
public function serialize(param1:IResourceSerializationListener) : void {
}
public function get description() : String {
return null;
}
public function unload() : void {
}
final public function setFlags(param1:int) : void {
this.flags |= param1;
}
final public function clearFlags(param1:int) : void {
this.flags &= ~param1;
}
final public function hasAllFlags(param1:int) : Boolean {
return (this.flags & param1) == param1;
}
final public function hasAnyFlags(param1:int) : Boolean {
return (this.flags & param1) != 0;
}
final public function reload() : void {
if(this.numReloadAttempts >= resourceTimer.getMaxReloadAttemts()) {
if(this.createDummyData()) {
this.markLoaded();
this.listener.onResourceLoadingError(this,"No reload attempts left");
this.status = "Dummy data is used";
} else {
this.listener.onResourceLoadingFatalError(this,"No reload attempts left and no default data available.");
}
} else {
++this.numReloadAttempts;
logger.info("Reloading resource id: %1, type: %2. Attempt %3 out of %4.",[this.id,this,this.numReloadAttempts,resourceTimer.getMaxReloadAttemts()]);
this.doReload();
}
}
protected function doReload() : void {
this.listener.onResourceLoadingFatalError(this,"Cannot reload resource (not implemented)");
}
final protected function markLoaded() : void {
this.flags |= ResourceFlags.LOADED;
}
protected function updateLastActivityTime() : void {
this.lastActivityTime = getTimer();
}
protected function startTimeoutTracking() : void {
this.updateLastActivityTime();
resourceTimer.addResource(this);
}
protected function stopTimeoutTracking() : void {
resourceTimer.removeResource(this);
}
protected function createDummyData() : Boolean {
return false;
}
protected function completeLoading() : void {
var local1:Resource = null;
if(this.dependents != null) {
for each(local1 in this.dependents) {
local1.handleDependenceLoaded();
}
this.dependents = null;
}
this.stopTimeoutTracking();
this.setFlags(ResourceFlags.LOADED);
this.status = ResourceStatus.LOADED;
this.listener.onResourceLoadingComplete(this);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.battle {
import alternativa.types.Long;
import flash.events.EventDispatcher;
import projects.tanks.client.battleservice.BattleRoundParameters;
import projects.tanks.clients.fp10.libraries.tanksservices.service.address.TanksAddressService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.servername.ServerNumberToLocaleServerService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
public class BattleInfoService extends EventDispatcher implements IBattleInfoService {
[Inject]
public static var addressService:TanksAddressService;
[Inject]
public static var serverNameService:ServerNumberToLocaleServerService;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
private var _currentBattleId:Long;
private var _currentSelectionBattleId:Long;
private var _minRank:int;
private var _maxRank:int;
private var _spectatorMode:Boolean;
private var _reArmorEnabled:Boolean;
private var _enterGarageCausesExitBattle:Boolean = false;
private var _withoutSupplies:Boolean;
private var _withoutBonuses:Boolean;
private var _withoutDrones:Boolean;
private var _running:Boolean;
private var userIsInBattle:Boolean;
public function BattleInfoService() {
super();
}
public function get currentSelectionBattleId() : Long {
return this._currentSelectionBattleId;
}
public function setCurrentSelectionBattleAndNotify(param1:Long, param2:int, param3:int) : void {
this.setBattleData(param1,param2,param3);
addressService.setBattle(param1);
dispatchEvent(new BattleInfoServiceEvent(BattleInfoServiceEvent.SELECTION_BATTLE));
}
private function setBattleData(param1:Long, param2:int, param3:int) : void {
this._currentSelectionBattleId = param1;
this._minRank = param2;
this._maxRank = param3;
}
public function setCurrentSelectionBattle(param1:Long, param2:int, param3:int) : void {
this.setBattleData(param1,param2,param3);
addressService.setBattle(param1);
}
public function get currentBattleId() : Long {
return this._currentBattleId;
}
public function set currentBattleId(param1:Long) : void {
this._currentBattleId = param1;
addressService.setBattle(param1);
}
public function resetCurrentBattle() : void {
this._spectatorMode = false;
this._currentBattleId = null;
if(this._currentSelectionBattleId != null) {
addressService.setBattle(this._currentSelectionBattleId);
} else {
addressService.resetBattle();
}
dispatchEvent(new BattleInfoServiceEvent(BattleInfoServiceEvent.BATTLE_UNLOAD));
}
public function resetCurrentSelectionBattleId() : void {
if(this._currentBattleId == this._currentSelectionBattleId) {
this._currentSelectionBattleId = null;
if(Boolean(serverNameService) && Boolean(serverNameService.isLocalServer())) {
addressService.resetBattle();
dispatchEvent(new BattleInfoServiceEvent(BattleInfoServiceEvent.RESET_SELECTION_BATTLE));
}
}
}
public function hasCurrentSelectionBattleId() : Boolean {
return this._currentSelectionBattleId != null;
}
public function hasCurrentBattleId() : Boolean {
return this._currentBattleId != null;
}
public function isSpectatorMode() : Boolean {
return this._spectatorMode;
}
public function set spectatorMode(param1:Boolean) : void {
this._spectatorMode = param1;
}
public function get reArmorEnabled() : Boolean {
return this._reArmorEnabled;
}
public function set reArmorEnabled(param1:Boolean) : void {
this._reArmorEnabled = param1;
}
public function availableRank(param1:int) : Boolean {
if(this.hasCurrentSelectionBattleId()) {
return param1 >= this._minRank && param1 <= this._maxRank;
}
return false;
}
public function isAvailableSelectionBattle() : Boolean {
return this.availableRank(userPropertiesService.rank);
}
public function restoreCurrentBattleIdInAddressService() : void {
if(this.hasCurrentBattleId()) {
addressService.setBattle(this.currentBattleId);
}
}
public function battleRestart() : void {
dispatchEvent(new BattleInfoServiceEvent(BattleInfoServiceEvent.BATTLE_RESTART));
}
public function battleLoad() : void {
dispatchEvent(new BattleInfoServiceEvent(BattleInfoServiceEvent.BATTLE_LOAD));
}
public function get withoutSupplies() : Boolean {
return this._withoutSupplies;
}
public function set withoutSupplies(param1:Boolean) : void {
this._withoutSupplies = param1;
}
public function get withoutBonuses() : Boolean {
return this._withoutBonuses;
}
public function get withoutDrones() : Boolean {
return this._withoutDrones;
}
public function set withoutBonuses(param1:Boolean) : void {
this._withoutBonuses = param1;
}
public function set withoutDrones(param1:Boolean) : void {
this._withoutDrones = param1;
}
public function battleStart(param1:BattleRoundParameters) : void {
this._reArmorEnabled = param1.reArmorEnabled;
dispatchEvent(new BattleInfoServiceEvent(BattleInfoServiceEvent.BATTLE_START));
}
public function forceResetCurrentSelectionBattleId() : void {
this._currentSelectionBattleId = null;
}
public function get running() : Boolean {
return this._running;
}
public function set running(param1:Boolean) : void {
this._running = param1;
}
public function isInBattle() : Boolean {
return this.userIsInBattle;
}
public function setInBattle(param1:Boolean) : void {
this.userIsInBattle = param1;
}
public function get enterGarageCausesExitBattle() : Boolean {
return this._enterGarageCausesExitBattle;
}
public function set enterGarageCausesExitBattle(param1:Boolean) : void {
this._enterGarageCausesExitBattle = param1;
}
}
}
|
package projects.tanks.clients.flash.commons.services.validate {
public class ChinaCardIdValidator {
private static const KEY:Vector.<int> = Vector.<int>([7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2]);
private static const AUTH:Vector.<String> = Vector.<String>(["1","0","x","9","8","7","6","5","4","3","2"]);
private static const REGIONS_LIST:Vector.<String> = Vector.<String>(["11","12","13","14","15","21","22","23","31","32","33","34","35","36","37","41","42","43","44","45","46","50","51","52","53","54","61","62","63","64","65","71","81","82","91"]);
private static const VALID_ID_LENGTH:int = 18;
private static const MOD_CHECK_SUM:int = 11;
public function ChinaCardIdValidator() {
super();
}
public static function isValidIdNumber(param1:String) : Boolean {
var local13:Number = NaN;
var local2:int = param1.length;
if(local2 != VALID_ID_LENGTH) {
return false;
}
var local3:int = 0;
while(local3 < local2) {
local13 = Number(param1.charCodeAt(local3));
if(local13 < 48 || local13 > 57) {
return false;
}
local3++;
}
var local4:String = param1.substr(0,2);
if(REGIONS_LIST.indexOf(local4) == -1) {
return false;
}
var local5:Date = new Date();
var local6:Number = local5.fullYear;
var local7:int = parseInt(param1.substr(6,4));
if(local7 < 1900 || local7 > local6) {
return false;
}
var local8:int = parseInt(param1.substr(10,2));
var local9:int = parseInt(param1.substr(12,2));
if(local8 < 1 || local8 > 12 || local9 < 1 || local9 > 31) {
return false;
}
var local10:int = 0;
var local11:int = local2 - 1;
var local12:int = 0;
while(local12 < local11) {
local10 += KEY[local12] * parseInt(param1.substr(local12,1));
local12++;
}
if(param1.charAt(local11).toLowerCase() != AUTH[local10 % MOD_CHECK_SUM]) {
return false;
}
return true;
}
}
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.items_mini_CENTER.png")]
public dynamic class items_mini_CENTER extends BitmapData {
public function items_mini_CENTER(param1:int = 40, param2:int = 40) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.view.battlelist {
import alternativa.tanks.controllers.battlelist.BattleListItemParams;
import alternativa.tanks.controllers.battlelist.IBattleListViewControllerCallback;
import alternativa.types.Long;
import projects.tanks.client.battleservice.BattleMode;
import projects.tanks.client.battleservice.model.types.BattleSuspicionLevel;
public interface IBattleListView {
function show(param1:BattleMode) : void;
function hide() : void;
function destroy() : void;
function setCallBack(param1:IBattleListViewControllerCallback) : void;
function resetSelectedItem() : void;
function createItem(param1:BattleListItemParams, param2:Boolean) : void;
function removeItem(param1:Long) : void;
function setSelect(param1:Long) : void;
function updateSuspicious(param1:Long, param2:BattleSuspicionLevel) : void;
function updateUsersCount(param1:Long) : void;
function updateBattleName(param1:Long) : void;
function swapTeams(param1:Long) : void;
function updateAccessibleItems() : void;
function resize(param1:Boolean = true) : void;
function sortBattleList() : void;
function getItemIndex(param1:Long) : int;
function unPressFilter(param1:BattleMode) : void;
function lockFilter(param1:BattleMode) : void;
function unLockFilter(param1:BattleMode) : void;
function setBattleButtonEnabled(param1:Boolean) : void;
function setBattleCreationEnabled(param1:Boolean) : void;
}
}
|
package alternativa.tanks.view.battlelist.battleitem {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battlelist.battleitem.BattleItemIcon_ctfNormalClass.png")]
public class BattleItemIcon_ctfNormalClass extends BitmapAsset {
public function BattleItemIcon_ctfNormalClass() {
super();
}
}
}
|
package alternativa.engine3d.animation.keys {
import alternativa.engine3d.alternativa3d;
use namespace alternativa3d;
public class Keyframe {
alternativa3d var _time:Number = 0;
public function Keyframe() {
super();
}
public function get time() : Number {
return this.alternativa3d::_time;
}
public function get value() : Object {
return null;
}
public function set value(param1:Object) : void {
}
alternativa3d function get nextKeyFrame() : Keyframe {
return null;
}
alternativa3d function set nextKeyFrame(param1:Keyframe) : void {
}
public function toString() : String {
return "[Keyframe time = " + this.alternativa3d::_time.toFixed(2) + " value = " + this.value + "]";
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.aim {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.aim.AimShape_halfSquareClass.png")]
public class AimShape_halfSquareClass extends BitmapAsset {
public function AimShape_halfSquareClass() {
super();
}
}
}
|
package alternativa.tanks.gui {
import controls.base.LabelBase;
import flash.display.BitmapData;
import flash.display.Shape;
import flash.display.Sprite;
import flash.geom.Matrix;
public class ModTable extends Sprite {
private static const upgradeSelectionLeftClass:Class = ModTable_upgradeSelectionLeftClass;
private static const upgradeSelectionCenterClass:Class = ModTable_upgradeSelectionCenterClass;
private var _maxCostWidth:int;
public var constWidth:int;
public var rows:Vector.<ModInfoRow>;
public const vSpace:int = 0;
private var selection:Shape;
private var selectedRowIndex:int = -1;
private var _width:int;
public function ModTable(param1:int) {
var local3:ModInfoRow = null;
this.rows = new Vector.<ModInfoRow>();
super();
this._width = param1;
this.selection = new Shape();
addChild(this.selection);
this.selection.x = 3;
var local2:int = 0;
while(local2 < 4) {
local3 = new ModInfoRow(local2,this._width);
addChild(local3);
local3.y = (local3.h + this.vSpace) * local2;
this.rows.push(local3);
local2++;
}
this.resizeSelection(this._width);
}
public function select(param1:int) : void {
var local2:ModInfoRow = null;
if(this.selectedRowIndex != -1) {
local2 = this.rows[this.selectedRowIndex];
local2.unselect();
}
this.selectedRowIndex = param1;
this.selection.y = (ModInfoRow(this.rows[0]).h + this.vSpace) * param1;
this.selection.visible = true;
local2 = this.rows[this.selectedRowIndex];
local2.select();
}
public function resetSelection() : void {
var local1:ModInfoRow = null;
this.selection.visible = false;
if(this.selectedRowIndex != -1) {
local1 = this.rows[this.selectedRowIndex];
local1.unselect();
}
this.selectedRowIndex = -1;
}
private function resizeSelection(param1:int) : void {
var local2:int = param1 - 6;
var local3:BitmapData = new upgradeSelectionLeftClass().bitmapData;
this.selection.graphics.clear();
this.selection.graphics.beginBitmapFill(local3);
this.selection.graphics.drawRect(0,0,local3.width,local3.height);
var local4:BitmapData = new upgradeSelectionCenterClass().bitmapData;
this.selection.graphics.beginBitmapFill(local4);
this.selection.graphics.drawRect(local3.width,0,local2 - local3.width * 2,local4.height);
var local5:Matrix = new Matrix(-1,0,0,1,local2,0);
this.selection.graphics.beginBitmapFill(local3,local5);
this.selection.graphics.drawRect(local2 - local3.width,0,local3.width,local3.height);
this.selection.graphics.endFill();
}
public function correctNonintegralValues() : void {
var local5:int = 0;
var local6:LabelBase = null;
var local7:int = 0;
var local1:Array = new Array();
var local2:ModInfoRow = this.rows[0];
var local3:int = int(local2.labels.length);
var local4:int = 0;
while(local4 < 4) {
local2 = this.rows[local4] as ModInfoRow;
local5 = 0;
while(local5 < local3) {
local6 = local2.labels[local5] as LabelBase;
if(local6.text.indexOf(".") != -1) {
local1.push(local5);
}
local5++;
}
local4++;
}
local4 = 0;
while(local4 < 4) {
local2 = this.rows[local4];
local5 = 0;
while(local5 < local1.length) {
local7 = int(local1[local5]);
local6 = local2.labels[local7] as LabelBase;
if(local6.text.indexOf(".") == -1) {
local6.text += ".0";
}
local5++;
}
local4++;
}
}
public function set maxCostWidth(param1:int) : void {
this._maxCostWidth = param1;
var local2:ModInfoRow = this.rows[0];
this.constWidth = local2.upgradeIndicator.width + local2.rankIcon.width + 3 + local2.crystalIcon.width + this._maxCostWidth + local2.hSpace * 3;
var local3:int = 0;
while(local3 < 4) {
local2 = this.rows[local3] as ModInfoRow;
local2.costWidth = this._maxCostWidth;
local3++;
}
}
}
}
|
package projects.tanks.client.garage.skins {
import platform.client.fp10.core.type.IGameObject;
public class MountedSkinCC {
private var _item:IGameObject;
public function MountedSkinCC(param1:IGameObject = null) {
super();
this._item = param1;
}
public function get item() : IGameObject {
return this._item;
}
public function set item(param1:IGameObject) : void {
this._item = param1;
}
public function toString() : String {
var local1:String = "MountedSkinCC [";
local1 += "item = " + this.item + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.challenge.greenpanel.black
{
import flash.display.BitmapData;
import utils.FlipBitmapDataUtils;
public class BlackPack
{
[Embed(source="1112.png")]
private static const bg:Class;
[Embed(source="1033.png")]
private static const left_botom_corner:Class;
[Embed(source="1053.png")]
private static const left_line:Class;
[Embed(source="817.png")]
private static const left_top:Class;
[Embed(source="1070.png")]
private static const top_line:Class;
public static const _dailyQuestPanelBackground:BitmapData = new bg().bitmapData;
public static const _bottomLeftCorner:BitmapData = new left_botom_corner().bitmapData;
public static const _leftLine:BitmapData = new left_line().bitmapData;
public static const _topLeftCorner:BitmapData = new left_top().bitmapData;
public static const _topCenterLine:BitmapData = new top_line().bitmapData;
public static const _topRightCorner:BitmapData = FlipBitmapDataUtils.flipH(_topLeftCorner);
public static const _bottomCenterLine:BitmapData = FlipBitmapDataUtils.flipW(_topCenterLine);
public static const _dailyQuestPanelRightLine:BitmapData = FlipBitmapDataUtils.flipH(_leftLine);
public static const _bottomRightCorner:BitmapData = FlipBitmapDataUtils.flipH(_bottomLeftCorner);
public function BlackPack()
{
super();
}
}
}
|
package projects.tanks.clients.fp10.TanksLauncher.background {
import flash.display.BitmapData;
import flash.display.Shape;
import flash.events.Event;
public class Background extends Shape {
private static const tileClass:Class = Background_tileClass;
private static const tileBitmapData:BitmapData = new tileClass().bitmapData;
public function Background() {
super();
this.init();
}
private function init() : void {
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
}
private function onAddedToStage(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
stage.addEventListener(Event.RESIZE,this.onResize);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
this.redrawBackground();
}
private function onRemoveFromStage(param1:Event) : void {
removeEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
stage.removeEventListener(Event.RESIZE,this.onResize);
}
private function onResize(param1:Event) : void {
this.redrawBackground();
}
private function redrawBackground() : void {
this.graphics.clear();
this.graphics.beginBitmapFill(tileBitmapData);
this.graphics.drawRect(0,0,stage.stageWidth,stage.stageHeight);
}
}
}
|
package controls.buttons.h30px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h30px.OrangeMediumButtonSkin_middleDownClass.png")]
public class OrangeMediumButtonSkin_middleDownClass extends BitmapAsset {
public function OrangeMediumButtonSkin_middleDownClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.bonus.bonus.notification {
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 BonusNotificationModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BonusNotificationModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_bitmapHealRadius.png")]
public class ItemInfoPanelBitmaps_bitmapHealRadius extends BitmapAsset {
public function ItemInfoPanelBitmaps_bitmapHealRadius() {
super();
}
}
}
|
package alternativa.tanks.models.tank.criticalhit
{
import alternativa.console.ConsoleVarInt;
import alternativa.init.Main;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.sfx.IGraphicEffect;
import alternativa.tanks.vehicles.tanks.Tank;
public class TankCriticalHitGraphicEffect implements IGraphicEffect
{
private static var modelService:IModelService = IModelService(Main.osgi.getService(IModelService));
private static var delay:ConsoleVarInt = new ConsoleVarInt("tankexpl_goffset",110,0,2000);
private var tankData:TankData;
private var time:int;
private var killed:Boolean;
public function TankCriticalHitGraphicEffect(tankData:TankData)
{
super();
this.tankData = tankData;
}
public function destroy() : void
{
this.tankData = null;
}
public function get owner() : ClientObject
{
return null;
}
public function play(millis:int, camera:GameCamera) : Boolean
{
if(this.killed)
{
return false;
}
if(this.time >= delay.value)
{
this.createEffects();
return false;
}
this.time += millis;
return true;
}
public function kill() : void
{
this.killed = true;
}
public function addToContainer(container:Scene3DContainer) : void
{
this.time = 0;
this.killed = false;
}
private function createEffects() : void
{
var tank:Tank = this.tankData.tank;
if(tank.skin.hullMesh.parent == null)
{
return;
}
var explosionModel:TankCriticalHitModel = Main.osgi.getService(ITankCriticalHitModel) as TankCriticalHitModel;
explosionModel.createExplosionEffects(this.tankData.hull,this.tankData);
}
}
}
|
package projects.tanks.client.garage.models.item.itempersonaldiscount {
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 ItemPersonalDiscountModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ItemPersonalDiscountModelServer;
private var client:IItemPersonalDiscountModelBase = IItemPersonalDiscountModelBase(this);
private var modelId:Long = Long.getLong(1297980728,-1710036775);
public function ItemPersonalDiscountModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ItemPersonalDiscountModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ItemPersonalDiscountCC,false)));
}
protected function getInitParam() : ItemPersonalDiscountCC {
return ItemPersonalDiscountCC(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 _codec.projects.tanks.client.battleselect.model.battle {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battleselect.model.battle.BattleInfoCC;
public class VectorCodecBattleInfoCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattleInfoCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BattleInfoCC,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.<BattleInfoCC> = new Vector.<BattleInfoCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattleInfoCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattleInfoCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattleInfoCC> = Vector.<BattleInfoCC>(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.kitoffer.log {
public class KitOfferAction {
public static const BUY_BUTTON_CLICK:KitOfferAction = new KitOfferAction(0,"BUY_BUTTON_CLICK");
public static const PICTURE_CLICK:KitOfferAction = new KitOfferAction(1,"PICTURE_CLICK");
public static const EXIT_BUTTON_CLICK:KitOfferAction = new KitOfferAction(2,"EXIT_BUTTON_CLICK");
private var _value:int;
private var _name:String;
public function KitOfferAction(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<KitOfferAction> {
var local1:Vector.<KitOfferAction> = new Vector.<KitOfferAction>();
local1.push(BUY_BUTTON_CLICK);
local1.push(PICTURE_CLICK);
local1.push(EXIT_BUTTON_CLICK);
return local1;
}
public function toString() : String {
return "KitOfferAction [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package scpacker.gui
{
import alternativa.init.Main;
import assets.scroller.color.ScrollThumbSkinBlue;
import assets.scroller.color.ScrollTrackBlue;
import controls.DefaultButton;
import controls.Label;
import controls.TankWindow;
import controls.TankWindowInner;
import fl.controls.UIScrollBar;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.GlowFilter;
import flash.text.TextFieldAutoSize;
public class AlertBugWindow extends Sprite
{
private var window:TankWindow;
private var windowInner:TankWindowInner;
private var btnOk:DefaultButton;
private var scrollBar:UIScrollBar;
private var errorText:Label;
public function AlertBugWindow()
{
this.window = new TankWindow();
this.windowInner = new TankWindowInner(-1,-1,TankWindowInner.RED);
this.btnOk = new DefaultButton();
this.scrollBar = new UIScrollBar();
this.errorText = new Label();
super();
addChild(this.window);
this.window.addChild(this.windowInner);
this.window.addChild(this.btnOk);
this.window.addChild(this.errorText);
this.window.addChild(this.scrollBar);
this.window.width = 450;
this.window.height = 250;
this.windowInner.width = 430;
this.windowInner.height = 200;
this.windowInner.x = 10;
this.windowInner.y = 10;
this.btnOk.x = this.window.width / 2 - this.btnOk.width / 2;
this.btnOk.y = this.windowInner.height + 12;
this.errorText.x = 20;
this.errorText.y = 15;
this.errorText.wordWrap = true;
this.errorText.autoSize = TextFieldAutoSize.NONE;
this.errorText.selectable = true;
this.errorText.width = 410;
this.errorText.height = 190;
this.scrollBar.setSize(this.errorText.width + 5,this.errorText.y + 5);
this.btnOk.label = "OK";
this.errorText.multiline = true;
this.scrollBar.scrollTarget = this.errorText;
this.scrollBar.move(this.errorText.x + this.errorText.width,this.errorText.y);
this.scrollBar.setSize(this.scrollBar.width,this.errorText.height);
this.scrollBar.setStyle("downArrowUpSkin",ScrollArrowDownBlue);
this.scrollBar.setStyle("downArrowDownSkin",ScrollArrowDownBlue);
this.scrollBar.setStyle("downArrowOverSkin",ScrollArrowDownBlue);
this.scrollBar.setStyle("downArrowDisabledSkin",ScrollArrowDownBlue);
this.scrollBar.setStyle("upArrowUpSkin",ScrollArrowUpBlue);
this.scrollBar.setStyle("upArrowDownSkin",ScrollArrowUpBlue);
this.scrollBar.setStyle("upArrowOverSkin",ScrollArrowUpBlue);
this.scrollBar.setStyle("upArrowDisabledSkin",ScrollArrowUpBlue);
this.scrollBar.setStyle("trackUpSkin",new ScrollTrackBlue());
this.scrollBar.setStyle("trackDownSkin",ScrollTrackBlue);
this.scrollBar.setStyle("trackOverSkin",ScrollTrackBlue);
this.scrollBar.setStyle("trackDisabledSkin",ScrollTrackBlue);
this.scrollBar.setStyle("thumbUpSkin",ScrollThumbSkinBlue);
this.scrollBar.setStyle("thumbDownSkin",ScrollThumbSkinBlue);
this.scrollBar.setStyle("thumbOverSkin",ScrollThumbSkinBlue);
this.scrollBar.setStyle("thumbDisabledSkin",ScrollThumbSkinBlue);
this.errorText.filters = [new GlowFilter(0)];
this.errorText.textColor = 16777215;
this.btnOk.addEventListener(MouseEvent.CLICK,this.remove);
Main.stage.addEventListener(Event.RESIZE,this.resize);
this.resize(null);
}
private function resize(e:Event) : void
{
this.window.x = Main.stage.width / 2 - this.window.width / 2;
this.window.y = Main.stage.height / 2 - this.window.height / 2;
}
private function remove(e:MouseEvent) : void
{
parent.removeChild(this);
}
public function set text(_text:String) : void
{
this.errorText.text = _text;
this.scrollBar.update();
this.scrollBar.setSize(this.scrollBar.width,this.errorText.height);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.friend {
import alternativa.types.Long;
import flash.events.Event;
public class NewFriendRemoveEvent extends Event {
public static const ACCEPTED:String = "NewFriendRemoveEvent.ACCEPTED";
public static const INCOMING:String = "NewFriendRemoveEvent.INCOMING";
public var userId:Long;
public function NewFriendRemoveEvent(param1:String, param2:Long, param3:Boolean = false, param4:Boolean = false) {
this.userId = param2;
super(param1,param3,param4);
}
}
}
|
package alternativa.tanks.models.weapons.shell {
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.collision.CollisionDetector;
import alternativa.physics.collision.IRayCollisionFilter;
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.PhysicsController;
import alternativa.tanks.battle.PhysicsInterpolator;
import alternativa.tanks.battle.scene3d.BattleScene3D;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapons.shell.states.DummyShellStates;
import alternativa.tanks.models.weapons.shell.states.ShellStates;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.utils.EncryptedInt;
import alternativa.tanks.utils.EncryptedIntImpl;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.errors.IllegalOperationError;
public class Shell extends PooledObject implements PhysicsController, Renderer, PhysicsInterpolator, IRayCollisionFilter {
[Inject]
public static var battleService:BattleService;
protected static const thousandth:EncryptedInt = new EncryptedIntImpl(1000);
protected static const _rotationMatrix:Matrix3 = new Matrix3();
protected static const _rayHit:RayHit = new RayHit();
protected static const _hitPoint:Vector3 = new Vector3();
private static const _radialVector:Vector3 = new Vector3();
private static const _barrelDirection:Vector3 = new Vector3();
private const RADIAL_ANGLE_STEP:Number = 2 * Math.PI / this.getNumRadialRays();
private var shotId:int;
protected var isRemoteShot:Boolean;
protected var isFirstTick:Boolean;
protected var shooterBody:Body;
protected var totalDistance:Number = 0;
protected var flightDirection:Vector3 = new Vector3();
protected var currPosition:Vector3 = new Vector3();
protected var prevPosition:Vector3 = new Vector3();
protected var barrelOrigin:Vector3 = new Vector3();
protected var interpolatedPosition:Vector3 = new Vector3();
protected var radialPoints:Vector.<Vector3>;
protected var shellStates:ShellStates;
public function Shell(param1:Pool) {
super(param1);
this.radialPoints = new Vector.<Vector3>(this.getNumRadialRays(),true);
var local2:int = 0;
while(local2 < this.getNumRadialRays()) {
this.radialPoints[local2] = new Vector3();
local2++;
}
}
private static function getRadialVector(param1:Vector3, param2:Vector3) : void {
var local3:int = 0;
var local4:Number = 10000000000;
var local5:Number = param1.x < 0 ? -param1.x : param1.x;
if(local5 < local4) {
local4 = local5;
local3 = 0;
}
local5 = param1.y < 0 ? -param1.y : param1.y;
if(local5 < local4) {
local4 = local5;
local3 = 1;
}
local5 = param1.z < 0 ? -param1.z : param1.z;
if(local5 < local4) {
local3 = 2;
}
if(local3 == 0) {
param2.reset(0,param1.z,-param1.y);
} else if(local3 == 1) {
param2.reset(-param1.z,0,param1.x);
} else if(local3 == 2) {
param2.reset(param1.y,-param1.x,0);
}
}
protected function createShellStates() : ShellStates {
if(this.isRemoteShot) {
return DummyShellStates.INSTANCE;
}
return ShellStates(battleService.getObjectPool().getObject(ShellStates));
}
public function addToGame(param1:AllGlobalGunParams, param2:Vector3, param3:Body, param4:Boolean, param5:int) : void {
this.totalDistance = 0;
this.isFirstTick = true;
this.shotId = param5;
this.isRemoteShot = param4;
this.barrelOrigin.copy(param1.barrelOrigin);
this.currPosition.copy(param1.muzzlePosition);
this.prevPosition.copy(param1.muzzlePosition);
this.flightDirection.copy(param2);
this.shooterBody = param3;
battleService.getBattleRunner().addPhysicsController(this);
battleService.getBattleRunner().addPhysicsInterpolator(this);
battleService.getBattleScene3D().addRenderer(this,0);
this.shellStates = this.createShellStates();
this.shellStates.start(this.currPosition,param2);
}
public function runBeforePhysicsUpdate(param1:Number) : void {
if(this.isFirstTick) {
this.isFirstTick = false;
this.processFirstTick(param1);
} else {
this.update(param1);
}
}
private function processFirstTick(param1:Number) : void {
if(!this.checkIfBarrelIntersectsWithObstacle()) {
this.initRadialPoints(this.currPosition,this.flightDirection);
this.update(param1);
}
}
protected function checkIfBarrelIntersectsWithObstacle() : Boolean {
var local3:Body = null;
var local5:Vector3 = null;
var local1:CollisionDetector = battleService.getBattleRunner().getCollisionDetector();
_barrelDirection.diff(this.currPosition,this.barrelOrigin);
var local2:Number = _barrelDirection.length();
_barrelDirection.normalize();
if(local1.raycast(this.barrelOrigin,_barrelDirection,CollisionGroup.WEAPON,local2,this,_rayHit)) {
local3 = _rayHit.shape.body;
if(local3.tank == null) {
_rayHit.position.subtract(_barrelDirection);
}
this.processHit(local3,_rayHit.position,_barrelDirection,local2);
return true;
}
this.initRadialPoints(this.barrelOrigin,_barrelDirection);
var local4:int = 0;
while(local4 < this.getNumRadialRays()) {
local5 = this.radialPoints[local4];
if(local1.raycast(local5,_barrelDirection,CollisionGroup.WEAPON,local2,this,_rayHit)) {
local3 = _rayHit.shape.body;
if(BattleUtils.isTankBody(local3)) {
_hitPoint.copy(this.barrelOrigin).addScaled(_rayHit.t,_barrelDirection);
this.processHit(local3,_hitPoint,_barrelDirection,local2);
return true;
}
}
local4++;
}
return false;
}
protected function destroy() : void {
battleService.getBattleRunner().removePhysicsController(this);
battleService.getBattleRunner().removePhysicsInterpolator(this);
battleService.getBattleScene3D().removeRenderer(this,0);
this.shellStates.destroy();
recycle();
}
protected function initRadialPoints(param1:Vector3, param2:Vector3) : void {
getRadialVector(param2,_radialVector);
_radialVector.normalize().scale(this.getRadius());
_rotationMatrix.fromAxisAngle(param2,this.RADIAL_ANGLE_STEP);
Vector3(this.radialPoints[0]).sum(param1,_radialVector);
var local3:int = 1;
while(local3 < this.getNumRadialRays()) {
_radialVector.transform3(_rotationMatrix);
Vector3(this.radialPoints[local3]).sum(param1,_radialVector);
local3++;
}
}
public function interpolatePhysicsState(param1:Number, param2:int) : void {
this.interpolatedPosition.interpolate(param1,this.prevPosition,this.currPosition);
}
public function considerBody(param1:Body) : Boolean {
return this.shooterBody != param1;
}
public function getShotId() : int {
return this.shotId;
}
protected function getNumRadialRays() : int {
return 8;
}
protected function update(param1:Number) : void {
throw new IllegalOperationError();
}
protected function processHitImpl(param1:Body, param2:Vector3, param3:Vector3, param4:Number, param5:int) : void {
throw new IllegalOperationError();
}
protected function getTimeMsToHit(param1:Number) : int {
return Math.round(_rayHit.t / param1 * BattleRunner.PHYSICS_STEP_IN_MS);
}
protected function processHit(param1:Body, param2:Vector3, param3:Vector3, param4:Number) : void {
this.processHitImpl(param1,param2,param3,this.totalDistance + _rayHit.t,this.getTimeMsToHit(param4));
}
protected function getRadius() : Number {
throw new IllegalOperationError();
}
public function render(param1:int, param2:int) : void {
throw new IllegalOperationError();
}
protected function objectPool() : ObjectPool {
return battleService.getObjectPool();
}
protected function battleScene() : BattleScene3D {
return battleService.getBattleScene3D();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank12.png")]
public class PremiumRankBitmaps_bitmapSmallRank12 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank12() {
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.ActionOutputLine_rgbPlayerThrewBallIcon.png")]
public class ActionOutputLine_rgbPlayerThrewBallIcon extends BitmapAsset {
public function ActionOutputLine_rgbPlayerThrewBallIcon() {
super();
}
}
}
|
package alternativa.tanks.gui.friends.list.renderer {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.list.renderer.FriendsAcceptedListRenderer_gradientGreenIconClass.png")]
public class FriendsAcceptedListRenderer_gradientGreenIconClass extends BitmapAsset {
public function FriendsAcceptedListRenderer_gradientGreenIconClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.quest.daily.type.map {
public interface IScoreCollectOnMapDailyQuestModelBase {
}
}
|
package platform.client.fp10.core.resource.tara {
import flash.utils.ByteArray;
public class TARAParser {
private var _data:Object;
public function TARAParser(param1:ByteArray) {
super();
if(param1 != null) {
this.parse(param1);
}
}
public function parse(param1:ByteArray) : void {
var local4:int = 0;
var local5:ByteArray = null;
var local6:FileInfo = null;
var local2:int = param1.readInt();
var local3:Vector.<FileInfo> = new Vector.<FileInfo>(local2);
local4 = 0;
while(local4 < local2) {
local3[local4] = new FileInfo(param1.readUTF(),param1.readInt());
local4++;
}
this._data = {};
local4 = 0;
while(local4 < local2) {
local5 = new ByteArray();
local6 = local3[local4];
param1.readBytes(local5,0,local6.size);
this._data[local6.name] = local5;
local4++;
}
}
public function get data() : Object {
return this._data;
}
public function getFileData(param1:String) : ByteArray {
if(this._data == null) {
return null;
}
return ByteArray(this._data[param1]);
}
}
}
class FileInfo {
public var name:String;
public var size:int;
public function FileInfo(param1:String, param2:int) {
super();
this.name = param1;
this.size = param2;
}
}
|
package projects.tanks.client.partners.impl.china.partner2144 {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class Partner2144ModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:Partner2144ModelServer;
private var client:IPartner2144ModelBase = IPartner2144ModelBase(this);
private var modelId:Long = Long.getLong(1460794337,-1064876227);
public function Partner2144ModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new Partner2144ModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.clans.clan.block {
public interface IClanBlockModelBase {
function clanBaned(param1:String) : void;
}
}
|
package projects.tanks.clients.fp10.Prelauncher {
import flash.desktop.NativeApplication;
import flash.display.DisplayObject;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.display.NativeWindow;
import flash.display.NativeWindowInitOptions;
import flash.display.Screen;
import flash.display.Sprite;
import flash.display.StageAlign;
import flash.display.StageDisplayState;
import flash.display.StageQuality;
import flash.display.StageScaleMode;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.MouseEvent;
import flash.events.NativeWindowBoundsEvent;
import flash.events.NativeWindowDisplayStateEvent;
import flash.events.SecurityErrorEvent;
import flash.filesystem.File;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.net.URLLoader;
import flash.net.URLLoaderDataFormat;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import flash.utils.ByteArray;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import projects.tanks.clients.fp10.Prelauncher.controls.LocalizedControl;
import projects.tanks.clients.fp10.Prelauncher.controls.background.Background;
import projects.tanks.clients.fp10.Prelauncher.controls.bottompanel.BottomPanel;
import projects.tanks.clients.fp10.Prelauncher.controls.buttons.ExitButton;
import projects.tanks.clients.fp10.Prelauncher.controls.buttons.StartButton;
import projects.tanks.clients.fp10.Prelauncher.controls.logo.Logo;
import projects.tanks.clients.fp10.Prelauncher.controls.selector.LocaleSelectionEvent;
import projects.tanks.clients.fp10.Prelauncher.controls.selector.LocalizationSelector;
import projects.tanks.clients.fp10.Prelauncher.controls.toppanel.TopPanel;
import projects.tanks.clients.fp10.Prelauncher.locales.Locales;
import projects.tanks.clients.fp10.Prelauncher.serverslist.ServerNode;
import projects.tanks.clients.fp10.Prelauncher.serverslist.ServersListEvent;
import projects.tanks.clients.fp10.Prelauncher.serverslist.ServersListLoader;
import projects.tanks.clients.fp10.Prelauncher.steam.SteamRenderer;
import projects.tanks.clients.fp10.Prelauncher.storage.DisplayState;
import projects.tanks.clients.fp10.Prelauncher.storage.Storage;
[SWF(width="1000",height="600",backgroundColor="#000000",frameRate="40")]
public class Prelauncher extends Sprite {
private var guiLayer:Sprite;
private var tanksLauncherLoader:Loader;
private var selector:LocalizationSelector;
private var steamRenderer:SteamRenderer = new SteamRenderer();
private var airParameters:Object;
protected var swf:String;
protected var defaultLocale:Locale;
protected var canChangeLocale:Boolean = true;
protected var resources:String;
protected var serverPrefix:String;
protected var balancerUrl:String;
protected var configUrl:String;
public var displayStateTimeout:int = 0;
private var battleServer:int;
private var window:NativeWindow;
public function Prelauncher() {
super();
this.defaultLocale = LocalesFactory.getLocale(loaderInfo.parameters["lang"] || Locales.RU);
this.swf = loaderInfo.parameters["swf"] || "http://tankionline.com/AlternativaLoader.swf";
this.configUrl = loaderInfo.parameters["config"] || "cNUMBER.eu.tankionline.com/config.xml";
this.resources = loaderInfo.parameters["resources"] || "s.eu.tankionline.com";
this.balancerUrl = loaderInfo.parameters["balancer"] || "http://tankionline.com/s/status.js";
this.serverPrefix = loaderInfo.parameters["prefix"] || "main.c";
this.canChangeLocale = loaderInfo.parameters["lang"] != Locales.CN;
addEventListener(Event.ADDED_TO_STAGE,this.init);
}
private static function exitPressed(e:MouseEvent) : void {
NativeApplication.nativeApplication.exit();
}
private static function serverNodeByNumber(serversList:Vector.<ServerNode>, number:int) : ServerNode {
var node:ServerNode = null;
for each(node in serversList) {
if(node.serverNumber == number) {
return node;
}
}
return null;
}
private static function getMinElement(serversList:Vector.<ServerNode>) : ServerNode {
var node:ServerNode = null;
var server:ServerNode = serversList[0];
for each(node in serversList) {
if(server.usersOnline > node.usersOnline) {
server = node;
}
}
return server;
}
private static function pointIsVisibleOnScreens(point:Point, screens:Array) : Boolean {
var screen:Screen = null;
for each(screen in screens) {
if(point.x + 100 < screen.bounds.x + screen.bounds.width && point.y + 100 < screen.bounds.y + screen.bounds.height) {
return true;
}
}
return false;
}
private function init(e:Event = null) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.init);
stage.addEventListener(MouseEvent.CLICK,this.mouseClick);
Locale.current = Storage.getLastSessionLocale(this.defaultLocale);
this.configureStage();
this.createGUI();
if(this.isSteamClient()) {
this.addSteamRenderer();
}
this.battleServer = Storage.getLastBattleServer();
if(this.battleServer != -1 && this.configUrl.indexOf("NUMBER") >= 0) {
this.configUrl = this.configUrl.replace("NUMBER",this.battleServer);
}
}
private function addSteamRenderer() : void {
this.guiLayer.addChild(this.steamRenderer);
}
private function setCenterPosition() : void {
var appBounds:Rectangle = stage.nativeWindow.bounds;
var screen:Screen = Screen.getScreensForRectangle(appBounds)[0];
stage.stageWidth = 1000;
stage.stageHeight = 600;
stage.nativeWindow.maxSize = new Point(stage.nativeWindow.width,stage.nativeWindow.height);
stage.nativeWindow.minSize = new Point(stage.nativeWindow.width,stage.nativeWindow.height);
stage.nativeWindow.x = (screen.bounds.width - stage.nativeWindow.width) / 2;
stage.nativeWindow.y = (screen.bounds.height - stage.nativeWindow.height) / 2;
}
private function configureStage() : void {
stage.align = StageAlign.TOP_LEFT;
stage.scaleMode = StageScaleMode.NO_SCALE;
stage.quality = StageQuality.BEST;
stage.displayState = StageDisplayState.NORMAL;
stage.stageWidth = 1000;
stage.stageHeight = 600;
this.setCenterPosition();
}
private function createGUI() : void {
this.guiLayer = new Sprite();
var start:StartButton = new StartButton(this.startPressed);
var exit:ExitButton = new ExitButton(exitPressed);
var logo:Logo = new Logo();
var background:Background = new Background();
var topLine:TopPanel = new TopPanel();
var bottomPanel:BottomPanel = new BottomPanel();
this.selector = new LocalizationSelector();
this.guiLayer.addEventListener(LocaleSelectionEvent.SELECTION,this.switchLocale,false,0,true);
this.guiLayer.addChild(background);
this.guiLayer.addChild(logo);
this.guiLayer.addChild(exit);
this.guiLayer.addChild(start);
this.guiLayer.addChild(topLine);
this.guiLayer.addChild(bottomPanel);
addChild(this.guiLayer);
if(this.canChangeLocale) {
topLine.addAlignRight(this.selector);
}
var ev:LocaleSelectionEvent = new LocaleSelectionEvent(LocaleSelectionEvent.SELECTION,false,false);
ev.locale = Locale.current;
this.switchLocale(ev);
}
private function switchLocale(e:LocaleSelectionEvent) : void {
var child:DisplayObject = null;
Locale.current = e.locale;
for(var i:int = 0; i < this.guiLayer.numChildren; i++) {
child = this.guiLayer.getChildAt(i);
if(child is LocalizedControl) {
(child as LocalizedControl).switchLocale(e.locale);
}
}
}
public function get version() : String {
return "1.0";
}
private function startPressed(e:MouseEvent = null) : void {
stage.nativeWindow.visible = false;
Storage.lastSessionLocale = Locales.list.indexOf(Locale.current.name);
var serversListLoader:ServersListLoader = new ServersListLoader(this.balancerUrl,this.serverPrefix);
serversListLoader.addEventListener(ServersListEvent.ERROR,this.onBalancerConnectError,false,0,true);
serversListLoader.addEventListener(ServersListEvent.LOADED,this.onServersListLoaded,false,0,true);
serversListLoader.loadServersList();
}
private function onServersListLoaded(e:ServersListEvent) : void {
var storedServerNode:ServerNode = null;
var recommendedServerNode:ServerNode = null;
var serverNumber:int = 0;
if(e.serversList.length <= 0) {
this.onBalancerConnectError();
return;
}
var config:String = this.configUrl;
if(config.indexOf("NUMBER") >= 0) {
storedServerNode = serverNodeByNumber(e.serversList,this.battleServer);
recommendedServerNode = getMinElement(e.serversList);
serverNumber = storedServerNode == null ? recommendedServerNode.serverNumber : storedServerNode.serverNumber;
config = config.replace("NUMBER",serverNumber);
}
this.airParameters = {};
this.airParameters["config"] = config;
this.airParameters["resources"] = this.resources;
this.airParameters["lang"] = Locale.current.name;
this.airParameters["debug"] = loaderInfo.parameters["debug"] || "";
this.airParameters["partnerId"] = loaderInfo.parameters["partnerId"] || "";
var urlReq:URLRequest = new URLRequest(this.swf + "?rand=" + Math.random());
var urlLoader:URLLoader = new URLLoader();
urlLoader.dataFormat = URLLoaderDataFormat.BINARY;
urlLoader.addEventListener(Event.COMPLETE,this.byteArrayLoadComplete);
urlLoader.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadingError);
urlLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadingError);
urlLoader.load(urlReq);
}
private function isSteamClient() : Boolean {
return loaderInfo.parameters["partnerId"] == "steam";
}
private function onBalancerConnectError(event:Event = null) : void {
Alert.showMessage("Can not connect to balancer!");
stage.nativeWindow.visible = true;
}
private function onLoadingError(event:Event) : void {
Alert.showMessage("Connection error!");
stage.nativeWindow.visible = true;
}
private function byteArrayLoadComplete(event:Event) : void {
var bytes:ByteArray = URLLoader(event.target).data as ByteArray;
this.tanksLauncherLoader = new Loader();
var loaderContext:LoaderContext = new LoaderContext(false,new ApplicationDomain(ApplicationDomain.currentDomain));
loaderContext.parameters = this.airParameters;
var loaderInfo:LoaderInfo = this.tanksLauncherLoader.contentLoaderInfo;
loaderInfo.addEventListener(Event.COMPLETE,this.onLauncherLoadingComplete,false,0,true);
loaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadingError,false,0,true);
loaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadingError,false,0,true);
loaderContext.allowCodeImport = true;
this.tanksLauncherLoader.loadBytes(bytes,loaderContext);
}
private function mouseClick(e:MouseEvent) : void {
if(this.canChangeLocale && !(e.target == this.selector || e.target.parent != null && e.target.parent == this.selector)) {
this.selector.closeList();
}
}
private function onLauncherLoadingComplete(event:Event) : void {
var options:NativeWindowInitOptions = new NativeWindowInitOptions();
options.renderMode = "direct";
options.maximizable = true;
this.window = new NativeWindow(options);
this.window.minSize = new Point(1024,768);
this.window.maxSize = new Point(4095,2880);
if(this.isSteamClient()) {
this.window.stage.addChild(this.steamRenderer);
}
this.window.stage.addChild(new LauncherContainer(this.tanksLauncherLoader,this));
this.window.stage.stageWidth = 1024;
this.window.stage.stageHeight = 768;
this.window.addEventListener(Event.CLOSING,this.onClosing);
this.window.addEventListener(NativeWindowBoundsEvent.MOVE,this.onWindowMoveOrResize);
this.window.addEventListener(NativeWindowBoundsEvent.RESIZE,this.onWindowMoveOrResize);
this.window.addEventListener(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGE,this.onDisplayStateChange);
this.loadDisplayState();
}
private function onClosing(event:Event) : void {
NativeApplication.nativeApplication.exit();
}
private function onDisplayStateChange(event:NativeWindowDisplayStateEvent) : void {
this.saveDisplayStateDelayed();
}
private function onWindowMoveOrResize(event:NativeWindowBoundsEvent) : void {
this.saveDisplayStateDelayed();
}
private function saveDisplayStateDelayed() : void {
if(this.displayStateTimeout != 0) {
clearTimeout(this.displayStateTimeout);
}
this.displayStateTimeout = setTimeout(this.saveDisplayState,100);
}
private function loadDisplayState() : void {
this.displayStateTimeout = 0;
var displayState:DisplayState = Storage.getDisplayState();
var origin:Point = new Point(displayState.x,displayState.y);
var size:Point = new Point(displayState.width,displayState.height);
var maximized:Boolean = displayState.fullscreen;
if(pointIsVisibleOnScreens(origin,Screen.screens)) {
this.window.y = origin.y;
this.window.x = origin.x;
if(maximized) {
this.setDefaultWindowSize();
this.window.stage.displayState = StageDisplayState.FULL_SCREEN_INTERACTIVE;
} else {
this.window.width = size.x;
this.window.height = size.y;
}
} else {
this.setDefaultWindowSize();
}
this.window.visible = true;
}
private function setDefaultWindowSize() : void {
this.window.x = 100;
this.window.y = 100;
this.window.width = 1024;
this.window.height = 768;
}
private function saveDisplayState() : void {
this.displayStateTimeout = 0;
Storage.setDisplayState(this.window.x,this.window.y,this.window.width,this.window.height,this.window.stage.displayState == StageDisplayState.FULL_SCREEN_INTERACTIVE);
}
public function isUserFromTutorial() : Boolean {
var tutorialFile:File = File.documentsDirectory.resolvePath("tu.dat");
if(tutorialFile.exists) {
return this.deleteTutorialFile(tutorialFile);
}
return false;
}
private function deleteTutorialFile(tutorialFile:File) : Boolean {
try {
tutorialFile.deleteFile();
return true;
}
catch(e:Error) {
}
return false;
}
public function closeLauncher() : void {
NativeApplication.nativeApplication.exit();
}
public function get serverStored() : Boolean {
if(this.battleServer != -1) {
this.battleServer = -1;
return true;
}
return false;
}
}
}
|
package controls {
import assets.window.bitmaps.WindowBGTile;
import assets.window.bitmaps.WindowBottom;
import assets.window.bitmaps.WindowLeft;
import assets.window.bitmaps.WindowRight;
import assets.window.bitmaps.WindowTop;
import assets.window.elemets.WindowBottomLeftCorner;
import assets.window.elemets.WindowBottomRightCorner;
import assets.window.elemets.WindowTopLeftCorner;
import assets.window.elemets.WindowTopRightCorner;
import base.DiscreteSprite;
import flash.display.Shape;
[Embed(source="/_assets/assets.swf", symbol="symbol1139")]
public class TankWindow extends DiscreteSprite {
private var _width:int;
private var _height:int;
private var tl:WindowTopLeftCorner = new WindowTopLeftCorner();
private var tr:WindowTopRightCorner = new WindowTopRightCorner();
private var bl:WindowBottomLeftCorner = new WindowBottomLeftCorner();
private var br:WindowBottomRightCorner = new WindowBottomRightCorner();
private var bgBMP:WindowBGTile = new WindowBGTile(0,0);
private var topBMP:WindowTop = new WindowTop(0,0);
private var bottomBMP:WindowBottom = new WindowBottom(0,0);
private var leftBMP:WindowLeft = new WindowLeft(0,0);
private var rightBMP:WindowRight = new WindowRight(0,0);
private var bg:Shape = new Shape();
private var top:Shape = new Shape();
private var bottom:Shape = new Shape();
private var left:Shape = new Shape();
private var right:Shape = new Shape();
private var mcHeader:TankWindowHeader;
public var headerLang:String = "en";
private var _header:int = 0;
public function TankWindow(param1:int = -1, param2:int = -1) {
super();
this._width = param1;
this._height = param2;
this.ConfigUI();
this.draw();
}
override public function set width(param1:Number) : void {
this._width = int(param1);
this.draw();
}
override public function get width() : Number {
return this._width;
}
override public function set height(param1:Number) : void {
this._height = int(param1);
this.draw();
}
override public function get height() : Number {
return this._height;
}
private function ConfigUI() : void {
this._width = this._width == -1 ? int(scaleX * 100) : this._width;
this._height = this._height == -1 ? int(scaleY * 100) : this._height;
scaleX = 1;
scaleY = 1;
removeChildAt(0);
addChild(this.bg);
addChild(this.top);
addChild(this.bottom);
addChild(this.left);
addChild(this.right);
addChild(this.tl);
addChild(this.tr);
addChild(this.bl);
addChild(this.br);
}
public function set header(param1:int) : void {
this._header = param1;
this.mcHeader = new TankWindowHeader(param1,this.headerLang);
addChild(this.mcHeader);
if(param1 > 23) {
this.mcHeader.x = -13;
} else {
this.mcHeader.y = -13;
}
this.draw();
}
private function draw() : void {
this.bg.graphics.clear();
this.bg.graphics.beginBitmapFill(this.bgBMP);
this.bg.graphics.drawRect(7,7,this._width - 14,this._height - 14);
this.bg.graphics.endFill();
this.top.graphics.clear();
this.top.graphics.beginBitmapFill(this.topBMP);
this.top.graphics.drawRect(0,0,this._width - 22,11);
this.top.graphics.endFill();
this.top.x = 11;
this.bottom.graphics.clear();
this.bottom.graphics.beginBitmapFill(this.bottomBMP);
this.bottom.graphics.drawRect(0,0,this._width - 22,11);
this.bottom.graphics.endFill();
this.bottom.x = 11;
this.bottom.y = this._height - 11;
this.left.graphics.clear();
this.left.graphics.beginBitmapFill(this.leftBMP);
this.left.graphics.drawRect(0,0,11,this._height - 22);
this.left.graphics.endFill();
this.left.x = 0;
this.left.y = 11;
this.right.graphics.clear();
this.right.graphics.beginBitmapFill(this.rightBMP);
this.right.graphics.drawRect(0,0,11,this._height - 22);
this.right.graphics.endFill();
this.right.x = this._width - 11;
this.right.y = 11;
this.tl.x = 0;
this.tl.y = 0;
this.tr.x = this._width - this.tr.width;
this.tr.y = 0;
this.bl.x = 0;
this.bl.y = this._height - this.bl.height;
this.br.x = this._width - this.br.width;
this.br.y = this._height - this.br.height;
if(this.mcHeader != null) {
if(this._header > 23 && this._header < 26) {
this.mcHeader.y = int(this._height / 2);
} else {
this.mcHeader.x = int(this._width / 2);
if(this._header >= 26) {
this.mcHeader.y = -13;
}
}
}
}
}
}
|
package alternativa.protocol.info {
import alternativa.protocol.ICodecInfo;
public class MapCodecInfo extends CodecInfo {
private var _keyCodec:ICodecInfo;
private var _valueCodec:ICodecInfo;
public function MapCodecInfo(param1:ICodecInfo, param2:ICodecInfo, param3:Boolean) {
super(param3);
this._keyCodec = param1;
this._valueCodec = param2;
}
public function get keyCodec() : ICodecInfo {
return this._keyCodec;
}
public function get valueCodec() : ICodecInfo {
return this._valueCodec;
}
}
}
|
package projects.tanks.client.partners.impl.idnet {
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 IdNetLoginModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function IdNetLoginModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_bitmapRailResistance.png")]
public class ResistancesIcons_bitmapRailResistance extends BitmapAsset {
public function ResistancesIcons_bitmapRailResistance() {
super();
}
}
}
|
package projects.tanks.client.garage.models.item.item3d {
public interface IItem3DModelBase {
}
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_SELECTED_BLUE_PIXEL.png")]
public dynamic class bres_SELECTED_BLUE_PIXEL extends BitmapData {
public function bres_SELECTED_BLUE_PIXEL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.service.referrals {
import flash.events.Event;
public class ReferralsServiceEvent extends Event {
public static const UPDATE_DATA_REQUEST:String = "ReferralsServiceEvent.UPDATE_DATA_REQUEST";
public static const DATA_UPDATED:String = "ReferralsServiceEvent.DATA_UPDATED";
public function ReferralsServiceEvent(param1:String) {
super(param1,true);
}
}
}
|
package _codec.projects.tanks.client.battleservice {
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.BattleRoundParameters;
public class VectorCodecBattleRoundParametersLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattleRoundParametersLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BattleRoundParameters,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.<BattleRoundParameters> = new Vector.<BattleRoundParameters>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattleRoundParameters(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattleRoundParameters = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattleRoundParameters> = Vector.<BattleRoundParameters>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.sfx.healing
{
import alternativa.tanks.sfx.ISpecialEffect;
public interface IHealingGunEffectListener
{
function onEffectDestroyed(param1:ISpecialEffect) : void;
}
}
|
package alternativa.tanks.view.battlelist.battleitem.renderer.unavailable {
import controls.cellrenderer.CellRendererDefault;
import flash.display.Bitmap;
import flash.display.BitmapData;
public class CellUnavailableSelected extends CellRendererDefault {
private static const normalLeft:Class = CellUnavailableSelected_normalLeft;
private static const normalLeftData:BitmapData = Bitmap(new normalLeft()).bitmapData;
private static const normalCenter:Class = CellUnavailableSelected_normalCenter;
private static const normalCenterData:BitmapData = Bitmap(new normalCenter()).bitmapData;
private static const normalRight:Class = CellUnavailableSelected_normalRight;
private static const normalRightData:BitmapData = Bitmap(new normalRight()).bitmapData;
public function CellUnavailableSelected() {
super();
bmpLeft = normalLeftData;
bmpCenter = normalCenterData;
bmpRight = normalRightData;
}
}
}
|
package utils
{
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Shape;
import flash.geom.Matrix;
import flash.geom.Rectangle;
import flash.text.TextField;
import flash.text.TextFormat;
public class TextUtils
{
public function TextUtils()
{
super();
}
public static function getTextInCells(tf:TextField, cellWidth:int, cellHeight:int, gridColor:uint = 52224, gridAlpha:Number = 0.5, gridLinThickness:int = 1) : BitmapData
{
var charRect:Rectangle = null;
var shiftX:int = 0;
var shiftY:int = 0;
var format:TextFormat = tf.getTextFormat();
var oldLetterSpacing:Object = format.letterSpacing;
format.letterSpacing = 4;
tf.setTextFormat(format);
var length:int = tf.text.length;
var bd:BitmapData = new BitmapData(cellWidth * length,cellHeight,true,16777215);
var grid:Shape = new Shape();
grid.graphics.lineStyle(gridLinThickness,gridColor,gridAlpha);
grid.graphics.drawRect(0,0,length * cellWidth - gridLinThickness,cellHeight - gridLinThickness);
for(var i:int = 1; i < length; i++)
{
grid.graphics.moveTo(i * cellWidth,0);
grid.graphics.lineTo(i * cellWidth,cellHeight);
}
bd.draw(grid);
var m:Matrix = new Matrix();
for(i = 0; i < length; i++)
{
charRect = tf.getCharBoundaries(i);
charRect.width -= 4;
shiftX = Math.round((cellWidth - charRect.width) * 0.5);
shiftY = Math.round((cellHeight - charRect.height) * 0.5);
m.tx = -charRect.x + i * cellWidth + shiftX;
m.ty = -charRect.y + shiftY;
bd.draw(tf,m,null,BlendMode.NORMAL,new Rectangle(i * cellWidth + shiftX,charRect.y + shiftY,charRect.width + 1,charRect.height),true);
}
format.letterSpacing = oldLetterSpacing;
tf.setTextFormat(format);
return bd;
}
}
}
|
package projects.tanks.client.tanksservices.model.rankloader {
public class RankInfo {
private var _index:int;
private var _name:String;
public function RankInfo(param1:int = 0, param2:String = null) {
super();
this._index = param1;
this._name = param2;
}
public function get index() : int {
return this._index;
}
public function set index(param1:int) : void {
this._index = param1;
}
public function get name() : String {
return this._name;
}
public function set name(param1:String) : void {
this._name = param1;
}
public function toString() : String {
var local1:String = "RankInfo [";
local1 += "index = " + this.index + " ";
local1 += "name = " + this.name + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.item.present {
import platform.client.fp10.core.resource.types.ImageResource;
[ModelInterface]
public interface PresentImage {
function getImage() : ImageResource;
}
}
|
package alternativa.tanks.model.item.premium {
[ModelInterface]
public interface PremiumItem {
function isPremiumItem() : Boolean;
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.aim {
public interface AimWeaponStatus {
function getStatus() : Number;
}
}
|
package projects.tanks.client.battleselect.model.battle.dm {
import projects.tanks.client.battleselect.model.battle.entrance.user.BattleInfoUser;
public class BattleDMInfoCC {
private var _users:Vector.<BattleInfoUser>;
public function BattleDMInfoCC(param1:Vector.<BattleInfoUser> = null) {
super();
this._users = param1;
}
public function get users() : Vector.<BattleInfoUser> {
return this._users;
}
public function set users(param1:Vector.<BattleInfoUser>) : void {
this._users = param1;
}
public function toString() : String {
var local1:String = "BattleDMInfoCC [";
local1 += "users = " + this.users + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.item.drone {
import alternativa.tanks.model.item.info.ItemActionPanel;
import flash.display.DisplayObjectContainer;
import flash.events.IEventDispatcher;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.garage.models.item.drone.DroneModelBase;
import projects.tanks.client.garage.models.item.drone.IDroneModelBase;
[ModelInfo]
public class DroneModel extends DroneModelBase implements IDroneModelBase, ItemActionPanel, ObjectLoadListener {
public function DroneModel() {
super();
}
public function objectLoaded() : void {
putData(DronePanel,new DronePanel());
}
public function handleDoubleClickOnItemPreview() : void {
this.getActionPanel().onDoubleClick();
}
public function updateActionElements(param1:DisplayObjectContainer, param2:IEventDispatcher) : void {
this.getActionPanel().updateActionElements(param1,param2,object);
}
private function getActionPanel() : DronePanel {
return DronePanel(getData(DronePanel));
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.