code
stringlengths 57
237k
|
|---|
package alternativa.gfx.core {
import alternativa.gfx.alternativagfx;
import flash.display3D.Context3D;
import flash.display3D.Context3DTextureFormat;
use namespace alternativagfx;
public class RenderTargetTextureResource extends TextureResource {
private var _width:int;
private var _height:int;
private var _available:Boolean = true;
public function RenderTargetTextureResource(param1:int, param2:int) {
super();
this._width = param1;
this._height = param2;
}
public function get width() : int {
return this._width;
}
public function get height() : int {
return this._height;
}
override public function dispose() : void {
super.dispose();
this._available = false;
}
override public function get available() : Boolean {
return this._available;
}
override alternativagfx function create(param1:Context3D) : void {
super.alternativagfx::create(param1);
texture = param1.createTexture(this._width,this._height,Context3DTextureFormat.BGRA,true);
}
}
}
|
package alternativa.utils.filters {
public class AdjustColor {
private static var s_arrayOfDeltaIndex:Array = [0,0.01,0.02,0.04,0.05,0.06,0.07,0.08,0.1,0.11,0.12,0.14,0.15,0.16,0.17,0.18,0.2,0.21,0.22,0.24,0.25,0.27,0.28,0.3,0.32,0.34,0.36,0.38,0.4,0.42,0.44,0.46,0.48,0.5,0.53,0.56,0.59,0.62,0.65,0.68,0.71,0.74,0.77,0.8,0.83,0.86,0.89,0.92,0.95,0.98,1,1.06,1.12,1.18,1.24,1.3,1.36,1.42,1.48,1.54,1.6,1.66,1.72,1.78,1.84,1.9,1.96,2,2.12,2.25,2.37,2.5,2.62,2.75,2.87,3,3.2,3.4,3.6,3.8,4,4.3,4.7,4.9,5,5.5,6,6.5,6.8,7,7.3,7.5,7.8,8,8.4,8.7,9,9.4,9.6,9.8,10];
private var m_brightnessMatrix:ColorMatrix;
private var m_contrastMatrix:ColorMatrix;
private var m_saturationMatrix:ColorMatrix;
private var m_hueMatrix:ColorMatrix;
private var m_finalMatrix:ColorMatrix;
public function AdjustColor() {
super();
}
public function set brightness(param1:Number) : void {
if(this.m_brightnessMatrix == null) {
this.m_brightnessMatrix = new ColorMatrix();
}
if(param1 != 0) {
this.m_brightnessMatrix.SetBrightnessMatrix(param1);
}
}
public function set contrast(param1:Number) : void {
var local2:Number = param1;
if(param1 == 0) {
local2 = 127;
} else if(param1 > 0) {
local2 = s_arrayOfDeltaIndex[int(param1)] * 127 + 127;
} else {
local2 = param1 / 100 * 127 + 127;
}
if(this.m_contrastMatrix == null) {
this.m_contrastMatrix = new ColorMatrix();
}
this.m_contrastMatrix.SetContrastMatrix(local2);
}
public function set saturation(param1:Number) : void {
var local2:Number = param1;
if(param1 == 0) {
local2 = 1;
} else if(param1 > 0) {
local2 = 1 + 3 * param1 / 100;
} else {
local2 = param1 / 100 + 1;
}
if(this.m_saturationMatrix == null) {
this.m_saturationMatrix = new ColorMatrix();
}
this.m_saturationMatrix.SetSaturationMatrix(local2);
}
public function set hue(param1:Number) : void {
if(this.m_hueMatrix == null) {
this.m_hueMatrix = new ColorMatrix();
}
if(param1 != 0) {
this.m_hueMatrix.SetHueMatrix(param1 * Math.PI / 180);
}
}
public function AllValuesAreSet() : Boolean {
return Boolean(this.m_brightnessMatrix) && Boolean(this.m_contrastMatrix) && Boolean(this.m_saturationMatrix) && Boolean(this.m_hueMatrix);
}
public function CalculateFinalFlatArray() : Array {
if(this.CalculateFinalMatrix()) {
return this.m_finalMatrix.GetFlatArray();
}
return null;
}
private function CalculateFinalMatrix() : Boolean {
if(!this.AllValuesAreSet()) {
return false;
}
this.m_finalMatrix = new ColorMatrix();
this.m_finalMatrix.Multiply(this.m_brightnessMatrix);
this.m_finalMatrix.Multiply(this.m_contrastMatrix);
this.m_finalMatrix.Multiply(this.m_saturationMatrix);
this.m_finalMatrix.Multiply(this.m_hueMatrix);
return true;
}
}
}
|
package alternativa.osgi.service.command {
public interface CommandService {
function registerCommand(param1:String, param2:String, param3:String, param4:Array, param5:Function) : void;
function removeCommand(param1:String, param2:String, param3:Array) : void;
function execute(param1:String, param2:FormattedOutput) : void;
}
}
|
package projects.tanks.client.panel.model.socialnetwork.notification {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class SNGroupReminderModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _giveBonusId:Long = Long.getLong(2062690653,-1269347575);
private var model:IModel;
public function SNGroupReminderModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
public function giveBonus() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._giveBonusId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.gate2shop {
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 Gate2ShopPaymentModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _getPaymentUrlId:Long = Long.getLong(803840413,-1558470042);
private var _getPaymentUrl_shopItemIdCodec:ICodec;
private var _registerEmailAndGetPaymentUrlId:Long = Long.getLong(1842867688,985989084);
private var _registerEmailAndGetPaymentUrl_shopItemIdCodec:ICodec;
private var _registerEmailAndGetPaymentUrl_emailCodec:ICodec;
private var _validateEmailId:Long = Long.getLong(1922004257,-611741631);
private var _validateEmail_emailCodec:ICodec;
private var model:IModel;
public function Gate2ShopPaymentModelServer(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._getPaymentUrl_shopItemIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._registerEmailAndGetPaymentUrl_shopItemIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._registerEmailAndGetPaymentUrl_emailCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._validateEmail_emailCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function getPaymentUrl(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._getPaymentUrl_shopItemIdCodec.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._getPaymentUrlId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function registerEmailAndGetPaymentUrl(param1:Long, param2:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._registerEmailAndGetPaymentUrl_shopItemIdCodec.encode(this.protocolBuffer,param1);
this._registerEmailAndGetPaymentUrl_emailCodec.encode(this.protocolBuffer,param2);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local3:SpaceCommand = new SpaceCommand(Model.object.id,this._registerEmailAndGetPaymentUrlId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function validateEmail(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._validateEmail_emailCodec.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._validateEmailId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package forms.buttons
{
import flash.display.Bitmap;
public class MainPanelSocialNetsButton extends MainPanelWideButton
{
[Embed(source="1017.png")]
private static const iconN:Class;
[Embed(source="1045.png")]
private static const overBtn:Class;
[Embed(source="778.png")]
private static const normalBtn:Class;
public function MainPanelSocialNetsButton()
{
super(new Bitmap(new iconN().bitmapData),3,3,new Bitmap(new overBtn().bitmapData),new Bitmap(new normalBtn().bitmapData));
}
}
}
|
package projects.tanks.client.panel.model.shop.androidspecialoffer.banner {
public interface IAndroidBannerModelBase {
}
}
|
package projects.tanks.client.panel.model.alerts.entrancealert {
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 EntranceAlertModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function EntranceAlertModelServer(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.upgrade {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.ItemInfoPanelBitmaps;
import alternativa.tanks.model.item.upgradable.UpgradableItemParams;
import alternativa.tanks.model.item.upgradable.UpgradableItemPropertyValue;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParams;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParamsService;
import base.DiscreteSprite;
import controls.labels.MouseDisabledLabel;
import flash.display.Bitmap;
import flash.display.DisplayObject;
import flash.display.Sprite;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.removeDisplayObject;
public class UpgradeInfoForm extends DiscreteSprite {
[Inject]
public static var propertyService:ItemPropertyParamsService;
[Inject]
public static var localeService:ILocaleService;
private static const arrowClass:Class = UpgradeInfoForm_arrowClass;
private static const ICON_X:int = 10;
private static const PROPERTY_NAME_X:int = 47;
private static const CURRENT_VALUE_X:int = 228;
private static const ARROW_X:int = 308;
private static const DELTA_VALUE_X:int = 310;
private static const NEXT_VALUE_X:int = 373;
private static const Y:int = 14;
private var propertyNameLabel:MouseDisabledLabel = new MouseDisabledLabel();
private var propertyValueLabel:MouseDisabledLabel = new MouseDisabledLabel();
private var propertyDeltaLabel:MouseDisabledLabel = new MouseDisabledLabel();
private var propertyNextValueLabel:MouseDisabledLabel = new MouseDisabledLabel();
private var propertyParams:ItemPropertyParams;
private var propertyValue:UpgradableItemPropertyValue;
private var icon:Bitmap;
private var upgradeLayer:Sprite = new DiscreteSprite();
private var upgradableItemParams:UpgradableItemParams;
private var arrow:Bitmap;
private var valueWidth:int;
public function UpgradeInfoForm(param1:UpgradableItemParams, param2:UpgradableItemPropertyValue) {
super();
this.upgradableItemParams = param1;
this.propertyValue = param2;
this.propertyParams = propertyService.getParams(param2.getProperty());
this.icon = this.propertyParams.createBitmap();
var local3:Bitmap = new Bitmap(ItemInfoPanelBitmaps.backIcon);
local3.x = ICON_X;
local3.y = 1;
this.putOnLine(local3,Y);
this.icon.x = (local3.width - this.icon.width >> 1) + local3.x + 1;
this.icon.y = (local3.height - this.icon.height >> 1) + local3.y + 1;
addChild(local3);
addChild(this.icon);
addChild(this.propertyNameLabel);
this.propertyNameLabel.text = this.propertyParams.name + ":";
this.propertyNameLabel.x = PROPERTY_NAME_X;
this.putOnLine(this.propertyNameLabel,Y);
addChild(this.propertyValueLabel);
this.propertyValueLabel.x = CURRENT_VALUE_X;
addChild(this.upgradeLayer);
if(param2.isUpgradable()) {
this.arrow = new arrowClass();
this.putOnLine(this.arrow,Y);
this.arrow.x = ARROW_X;
this.upgradeLayer.addChild(this.arrow);
this.upgradeLayer.addChild(this.propertyDeltaLabel);
this.propertyDeltaLabel.x = DELTA_VALUE_X;
}
this.upgradeLayer.addChild(this.propertyNextValueLabel);
this.propertyNextValueLabel.x = NEXT_VALUE_X;
this.updateForm();
}
public function getPropertyNameWidth() : int {
return this.propertyNameLabel.width;
}
public function getValueMaxWidth() : int {
this.propertyValueLabel.text = this.propertyValue.getValue(0);
var local1:int = int(this.propertyValueLabel.width);
this.propertyValueLabel.text = this.propertyValue.getValue(this.upgradableItemParams.getLevelsCount());
return Math.max(local1,this.propertyValueLabel.width);
}
public function getWidth() : int {
if(this.upgradableItemParams.isFullUpgraded()) {
return this.propertyValueLabel.x + this.valueWidth + 10;
}
return this.propertyNextValueLabel.x + this.valueWidth + 10;
}
public function align(param1:int, param2:int) : void {
this.propertyValueLabel.x = this.propertyNameLabel.x + param1 + 20;
var local3:int = this.propertyValueLabel.x + param2 + 20;
this.valueWidth = param2;
if(Boolean(this.arrow)) {
this.arrow.x = local3;
this.propertyDeltaLabel.x = local3 + 2;
}
this.propertyNextValueLabel.x = local3 + 65;
this.updateForm();
}
internal function updateForm() : void {
this.updateColor();
var local1:int = this.upgradableItemParams.getLevel();
this.propertyValueLabel.text = this.propertyValue.getValue(local1);
this.putOnLine(this.propertyValueLabel,Y);
if(this.upgradableItemParams.isFullUpgraded()) {
removeDisplayObject(this.upgradeLayer);
} else {
this.propertyNextValueLabel.text = this.propertyValue.getValue(local1 + 1);
this.putOnLine(this.propertyNextValueLabel,Y);
this.propertyDeltaLabel.text = this.propertyValue.getDelta(local1);
this.putOnLine(this.propertyDeltaLabel,Y);
}
}
private function updateColor() : void {
this.propertyValueLabel.textColor = UpgradeColors.getColor(this.upgradableItemParams,this.propertyValue);
this.propertyNextValueLabel.textColor = UpgradeColors.getNextColor(this.upgradableItemParams,this.propertyValue);
}
protected function putOnLine(param1:DisplayObject, param2:int) : void {
param1.y = int(param2 - param1.height * 0.5);
}
}
}
|
package alternativa.tanks.gui.settings.tabs.control {
import alternativa.tanks.service.settings.keybinding.GameActionEnum;
import alternativa.tanks.service.settings.keybinding.KeyBindingChangeEvent;
import alternativa.tanks.service.settings.keybinding.KeysBindingService;
import alternativa.tanks.service.settings.keybinding.KeysBindingServiceImpl;
import base.DiscreteSprite;
import controls.base.LabelBase;
import controls.base.TankInput;
import controls.containers.HorizontalStackPanel;
import flash.events.KeyboardEvent;
import flash.text.TextFormatAlign;
import flash.ui.Keyboard;
public class KeyBinding extends DiscreteSprite {
[Inject]
public static var keysBindingService:KeysBindingService;
public static const KEY_INPUT_WIDTH:int = 120;
private var keyInputs:Vector.<TankInput> = new Vector.<TankInput>(3,true);
private var action:GameActionEnum;
public function KeyBinding(param1:GameActionEnum, param2:String, param3:int, param4:int) {
super();
this.action = param1;
var local5:int = param4 - 6 * param3 - KEY_INPUT_WIDTH * 3;
var local6:HorizontalStackPanel = new HorizontalStackPanel();
local6.setMargin(param3);
local6.x = local5 + param3;
var local7:int = 0;
while(local7 < 3) {
local6.addItem(this.createKeyInput(local7));
local7++;
}
var local8:LabelBase = new LabelBase();
local8.text = param2;
local8.x = 0;
local8.y = Math.round((this.keyInputs[0].height - local8.textHeight) * 0.5) - 2;
addChild(local8);
addChild(local6);
keysBindingService.addEventListener(KeyBindingChangeEvent.KEY_BINDING_CHANGE + param1.name,this.keyChanged);
}
private function keyChanged(param1:KeyBindingChangeEvent) : void {
var local2:int = 0;
while(local2 < this.keyInputs.length) {
this.keyInputs[local2].value = this.getKeyBindingStringFromService(local2);
local2++;
}
}
private function getKeyBindingStringFromService(param1:uint) : String {
var local2:uint = uint(keysBindingService.getKeyBinding(this.action,param1));
return keysBindingService.getKeyCodeLabel(local2);
}
public function getAction() : GameActionEnum {
return this.action;
}
private function createKeyInput(param1:int) : TankInput {
var local2:TankInput = new TankInput();
local2.addEventListener(KeyboardEvent.KEY_UP,this.onKeyDown);
local2.maxChars = 1;
local2.width = KEY_INPUT_WIDTH;
local2.align = TextFormatAlign.CENTER;
local2.value = this.getKeyBindingStringFromService(param1);
this.keyInputs[param1] = local2;
return local2;
}
private function onKeyDown(param1:KeyboardEvent) : void {
var local4:Boolean = false;
var local2:TankInput = TankInput(param1.currentTarget);
if(param1.keyCode == Keyboard.BACKSPACE || param1.keyCode == Keyboard.DELETE) {
if(keysBindingService.setKeyBinding(this.action,KeysBindingServiceImpl.BINDING_KEY_NOT_DEFINED,this.keyInputs.indexOf(local2))) {
local2.value = "";
} else {
local2.value = this.getKeyBindingStringFromService(this.keyInputs.indexOf(local2));
}
return;
}
var local3:String = keysBindingService.getKeyCodeLabel(param1.keyCode);
if(local3 != "") {
local4 = Boolean(keysBindingService.setKeyBinding(this.action,param1.keyCode,this.keyInputs.indexOf(local2)));
local2.value = local4 ? local3 : "";
} else {
local2.value = this.getKeyBindingStringFromService(this.keyInputs.indexOf(local2));
}
}
public function restoreDefaultBinding() : void {
var local1:Vector.<uint> = keysBindingService.getKeyBindings(this.action);
if(!local1) {
return;
}
var local2:int = 0;
while(local2 < local1.length) {
this.keyInputs[local2].value = keysBindingService.getKeyCodeLabel(local1[local2]);
local2++;
}
}
public function destroy() : void {
var local1:TankInput = null;
for each(local1 in this.keyInputs) {
local1.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
}
this.keyInputs = null;
keysBindingService.removeEventListener(KeyBindingChangeEvent.KEY_BINDING_CHANGE + this.action.name,this.keyChanged);
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.ricochet {
import alternativa.osgi.OSGi;
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 alternativa.types.Short;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import platform.client.fp10.core.type.IGameObject;
public class RicochetModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:RicochetModelServer;
private var client:IRicochetModelBase = IRicochetModelBase(this);
private var modelId:Long = Long.getLong(592429654,1339096271);
private var _addEnergyId:Long = Long.getLong(1470646161,908304539);
private var _addEnergy_energyDeltaCodec:ICodec;
private var _fireId:Long = Long.getLong(1979897371,-1124194266);
private var _fire_shooterCodec:ICodec;
private var _fire_shotDirectionXCodec:ICodec;
private var _fire_shotDirectionYCodec:ICodec;
private var _fire_shotDirectionZCodec:ICodec;
private var _fireDummyId:Long = Long.getLong(1470645133,813558546);
private var _fireDummy_shooterCodec:ICodec;
private var _reconfigureWeaponId:Long = Long.getLong(619928272,961682155);
private var _reconfigureWeapon_maxDistanceCodec:ICodec;
private var _reconfigureWeapon_energyPerShootCodec:ICodec;
public function RicochetModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new RicochetModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(RicochetCC,false)));
this._addEnergy_energyDeltaCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._fire_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._fire_shotDirectionXCodec = this._protocol.getCodec(new TypeCodecInfo(Short,false));
this._fire_shotDirectionYCodec = this._protocol.getCodec(new TypeCodecInfo(Short,false));
this._fire_shotDirectionZCodec = this._protocol.getCodec(new TypeCodecInfo(Short,false));
this._fireDummy_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._reconfigureWeapon_maxDistanceCodec = this._protocol.getCodec(new TypeCodecInfo(Float,false));
this._reconfigureWeapon_energyPerShootCodec = this._protocol.getCodec(new TypeCodecInfo(Float,false));
}
protected function getInitParam() : RicochetCC {
return RicochetCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._addEnergyId:
this.client.addEnergy(int(this._addEnergy_energyDeltaCodec.decode(param2)));
break;
case this._fireId:
this.client.fire(IGameObject(this._fire_shooterCodec.decode(param2)),int(this._fire_shotDirectionXCodec.decode(param2)),int(this._fire_shotDirectionYCodec.decode(param2)),int(this._fire_shotDirectionZCodec.decode(param2)));
break;
case this._fireDummyId:
this.client.fireDummy(IGameObject(this._fireDummy_shooterCodec.decode(param2)));
break;
case this._reconfigureWeaponId:
this.client.reconfigureWeapon(Number(this._reconfigureWeapon_maxDistanceCodec.decode(param2)),Number(this._reconfigureWeapon_energyPerShootCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.payment.modes.paypal {
import platform.client.fp10.core.type.IGameObject;
public class PayPalPaymentAdapt implements PayPalPayment {
private var object:IGameObject;
private var impl:PayPalPayment;
public function PayPalPaymentAdapt(param1:IGameObject, param2:PayPalPayment) {
super();
this.object = param1;
this.impl = param2;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.railgun {
public class RailgunCC {
private var _chargingTimeMsec:int;
private var _weakeningCoeff:Number;
public function RailgunCC(param1:int = 0, param2:Number = 0) {
super();
this._chargingTimeMsec = param1;
this._weakeningCoeff = param2;
}
public function get chargingTimeMsec() : int {
return this._chargingTimeMsec;
}
public function set chargingTimeMsec(param1:int) : void {
this._chargingTimeMsec = param1;
}
public function get weakeningCoeff() : Number {
return this._weakeningCoeff;
}
public function set weakeningCoeff(param1:Number) : void {
this._weakeningCoeff = param1;
}
public function toString() : String {
var local1:String = "RailgunCC [";
local1 += "chargingTimeMsec = " + this.chargingTimeMsec + " ";
local1 += "weakeningCoeff = " + this.weakeningCoeff + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_18 extends BitmapAsset
{
public function BigRangIcon_rang_18()
{
super();
}
}
}
|
package alternativa.tanks.sfx
{
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.events.Event;
import flash.media.SoundChannel;
public class MobileSound3DEffect extends PooledObject implements ISound3DEffect
{
private static var soundPosition:Vector3 = new Vector3();
private var _owner:ClientObject;
private var sound:Sound3D;
private var playbackDelay:int;
private var loops:int;
private var object:Object3D;
private var channel:SoundChannel;
private var _enabled:Boolean;
private var playing:Boolean;
private var terminated:Boolean;
private var time:int;
private var actualVolume:Number;
private var volumeFadeSpeed:Number;
public function MobileSound3DEffect(objectPool:ObjectPool)
{
super(objectPool);
}
public function init(owner:ClientObject, sound:Sound3D, object:Object3D, playbackDelay:int, loops:int) : void
{
this._owner = owner;
this.sound = sound;
this.object = object;
this.playbackDelay = playbackDelay;
this.loops = loops;
this.terminated = false;
this.playing = false;
this._enabled = false;
this.time = 0;
this.actualVolume = sound.volume;
this.volumeFadeSpeed = 0;
}
public function get owner() : ClientObject
{
return this._owner;
}
public function play(millis:int, camera:GameCamera) : Boolean
{
if(!this.playing)
{
if(this.time < this.playbackDelay)
{
this.time += millis;
return this._enabled && !this.terminated;
}
this.playing = true;
this.channel = this.sound.play(0,this.loops);
if(this.channel == null)
{
this._enabled = false;
return false;
}
this.channel.addEventListener(Event.SOUND_COMPLETE,this.onSoundComplete);
}
soundPosition.x = this.object.x;
soundPosition.y = this.object.y;
soundPosition.z = this.object.z;
if(this.volumeFadeSpeed > 0)
{
this.actualVolume -= this.volumeFadeSpeed * millis;
if(this.actualVolume <= 0)
{
this.volumeFadeSpeed = 0;
this.actualVolume = 0;
}
this.sound.volume = this.actualVolume;
}
this.sound.checkVolume(camera.pos,soundPosition,camera.xAxis);
return this._enabled && !this.terminated;
}
public function destroy() : void
{
Sound3D.destroy(this.sound);
if(this.channel != null)
{
this.onSoundComplete(null);
}
this._owner = null;
this.object = null;
this.sound = null;
storeInPool();
}
public function kill() : void
{
this.terminated = true;
}
public function set enabled(value:Boolean) : void
{
if(this._enabled == value)
{
return;
}
if(!(this._enabled = value))
{
this.onSoundComplete(null);
}
}
public function readPosition(result:Vector3) : void
{
result.x = this.object.x;
result.y = this.object.y;
result.z = this.object.z;
}
public function get numSounds() : int
{
return this._enabled && !this.terminated ? int(int(1)) : int(int(0));
}
public function fade(time:int) : void
{
this.volumeFadeSpeed = this.actualVolume / time;
}
override protected function getClass() : Class
{
return MobileSound3DEffect;
}
private function onSoundComplete(e:Event) : void
{
if(this.channel != null)
{
this.channel.removeEventListener(Event.SOUND_COMPLETE,this.onSoundComplete);
this.channel = null;
}
this._enabled = false;
}
}
}
|
package alternativa.tanks.models.dom.hud
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class MarkerBitmaps_letters extends BitmapAsset
{
public function MarkerBitmaps_letters()
{
super();
}
}
}
|
package alternativa.tanks.camera {
import alternativa.engine3d.core.EllipsoidCollider;
import alternativa.engine3d.core.Object3D;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.osgi.service.console.variables.ConsoleVarFloat;
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.service.settings.SettingEnum;
import alternativa.tanks.service.settings.SettingsServiceEvent;
import alternativa.tanks.service.settings.keybinding.GameActionEnum;
import alternativa.tanks.services.battleinput.BattleInputService;
import alternativa.tanks.services.battleinput.GameActionListener;
import alternativa.tanks.services.battleinput.MouseMovementListener;
import alternativa.tanks.services.battleinput.MouseWheelListener;
import alternativa.tanks.utils.MathUtils;
import flash.geom.Point;
import flash.geom.Vector3D;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
public class FollowCameraController implements CameraController, IFollowCameraController, MouseWheelListener, MouseMovementListener, GameActionListener {
[Inject]
public static var settings:ISettingsService;
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var battleInputService:BattleInputService;
public static const CAMERA_FOLLOWS_TURRET:int = 0;
public static const CAMERA_FOLLOWS_MOUSE:int = 1;
private static var followCameraMode:int = 0;
private static var followCameraDirection:Number = 0;
private static const VERTICAL_CAMERA_SPEED:Number = 0.7;
private static const ROTATE_SENS:Number = 0.001;
private static const MIN_CAMERA_ANGLE:Number = 5 * Math.PI / 180;
private static const COLLIDER_RADIUS:Number = 50;
private static const MAX_CAMERA_MOVE_SPEED:Number = 5;
private static const MIN_CAMERA_ROTATE_SPEED:Number = 3;
private static const MAX_CAMERA_ROTATE_SPEED:Number = 9;
private static const collisionPoint:Vector3 = new Vector3();
private static const _v:Vector3 = new Vector3();
private static const rayOrigin3D:Vector3D = new Vector3D();
private static const displacement:Vector3D = new Vector3D();
private static const collisionPoint3D:Vector3D = new Vector3D();
private static const collisionNormal3D:Vector3D = new Vector3D();
private static const rotationMatrix:Matrix3 = new Matrix3();
private static const axis:Vector3 = new Vector3();
private static const rayDirection:Vector3 = new Vector3();
private static var maxCameraMoveSpeed:ConsoleVarFloat = new ConsoleVarFloat("cam_maxmove",MAX_CAMERA_MOVE_SPEED,0,MAX_CAMERA_MOVE_SPEED);
public static var maxPositionError:Number = 10;
public static var maxAngleError:Number = Math.PI / 180;
public static var camSpeedThreshold:Number = 10;
private static const FIXED_PITCH:Number = 10 * Math.PI / 180;
private static const PITCH_CORRECTION_COEFF:Number = 1;
private static const MIN_DISTANCE:Number = 300;
private static const currentPosition:Vector3 = new Vector3();
private static const currentRotation:Vector3 = new Vector3();
private static const rayOrigin:Vector3 = new Vector3();
private static const flatDirection:Vector3 = new Vector3();
private static const positionDelta:Vector3 = new Vector3();
private var pitchCorrectionEnabled:Boolean;
public var inputLocked:Boolean;
private var distanceFromPivotToCamera:Number = 0;
private var locked:Boolean;
private var keyUpPressed:Boolean;
private var keyDownPressed:Boolean;
private var active:Boolean;
private var target:CameraTarget;
private var position:Vector3 = new Vector3();
private var rotation:Vector3 = new Vector3();
private var targetPosition:Vector3 = new Vector3();
private var targetDirection:Vector3 = new Vector3();
private var linearSpeed:Number = 0;
private var pitchSpeed:Number = 0;
private var yawSpeed:Number = 0;
private var cameraPositionData:CameraPositionData = new CameraPositionData();
private var baseElevation:Number;
private var cameraRelativeHeight:Number = 0;
private var cameraPosition:Point = new Point();
private var point0:Point;
private var point1:Point;
private var point2:Point;
private var point3:Point;
private var collider:EllipsoidCollider;
private var collisionObject:Object3D;
private var _mouseWheel:int;
private var mouseLookShift:Number = 0;
public function FollowCameraController() {
super();
this.point0 = new Point(145,545);
this.point1 = new Point(930,1395);
this.point2 = new Point(2245,1565);
this.point3 = new Point(3105,760);
this.collider = new EllipsoidCollider(COLLIDER_RADIUS,COLLIDER_RADIUS,COLLIDER_RADIUS);
var local1:Number = Number(storageService.getStorage().data["cameraT"]);
if(isNaN(local1)) {
local1 = 0.2;
}
this.setCameraRelativeHeight(local1);
}
public static function getFollowCameraMode() : int {
return followCameraMode;
}
public static function setFollowCameraMode(param1:int) : void {
followCameraMode = param1;
}
public static function getFollowCameraDirection() : Number {
return followCameraDirection;
}
public static function setFollowCameraDirection(param1:Number) : void {
followCameraDirection = param1;
}
private static function vector3To3D(param1:Vector3, param2:Vector3D) : void {
param2.x = param1.x;
param2.y = param1.y;
param2.z = param1.z;
}
private static function getLinearSpeed(param1:Number) : Number {
return maxCameraMoveSpeed.value * param1;
}
private static function bezier(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number) : Number {
var local6:Number = 3 * (param3 - param2);
var local7:Number = 3 * param2 - 6 * param3 + 3 * param4;
var local8:Number = -param2 + 3 * param3 - 3 * param4 + param5;
return param2 + param1 * local6 + param1 * param1 * local7 + param1 * param1 * param1 * local8;
}
private function configAlternateCamera(param1:SettingsServiceEvent = null) : void {
if(param1 == null || param1.getSetting() == SettingEnum.ALTERNATE_CAMERA) {
this.pitchCorrectionEnabled = !settings.alternateCamera;
}
}
public function setCollisionObject(param1:Object3D) : void {
this.collisionObject = param1;
}
public function setTarget(param1:CameraTarget) : void {
this.target = param1;
}
public function setCurrentState(param1:Vector3, param2:Vector3) : void {
this.targetPosition.copy(param1);
this.targetDirection.copy(param2);
this.getCameraPositionData(param1,param2,this.cameraPositionData);
this.position.copy(this.cameraPositionData.position);
this.rotation.x = this.getPitchAngle(this.cameraPositionData) - 0.5 * Math.PI;
this.rotation.y = 0;
this.rotation.z = Math.atan2(-param2.x,param2.y);
}
public function activate(param1:GameCamera) : void {
if(!this.active) {
this.active = true;
this.configAlternateCamera();
settings.addEventListener(SettingsServiceEvent.SETTINGS_CHANGED,this.configAlternateCamera);
param1.readPosition(this.position);
param1.readRotation(this.rotation);
battleInputService.addGameActionListener(this);
battleInputService.addMouseMoveListener(this);
battleInputService.addMouseWheelListener(this);
}
}
public function deactivate() : void {
if(this.active) {
this.active = false;
battleInputService.removeGameActionListener(this);
battleInputService.removeMouseMoveListener(this);
battleInputService.removeMouseWheelListener(this);
settings.removeEventListener(SettingsServiceEvent.SETTINGS_CHANGED,this.configAlternateCamera);
storageService.getStorage().data["cameraT"] = this.cameraRelativeHeight;
this.keyUpPressed = false;
this.keyDownPressed = false;
}
}
public function update(param1:GameCamera, param2:int, param3:int) : void {
var local4:Number = param3 * 0.001;
if(local4 > 0.1) {
local4 = 0.1;
}
this.updateCameraHeight(local4);
if(!this.locked && this.target != null) {
this.target.getCameraParams(this.targetPosition,this.targetDirection);
}
this.getCameraPositionData(this.targetPosition,this.targetDirection,this.cameraPositionData);
positionDelta.diff(this.cameraPositionData.position,this.position);
var local5:Number = positionDelta.length();
if(local5 > maxPositionError) {
this.linearSpeed = getLinearSpeed(local5 - maxPositionError);
}
var local6:Number = this.linearSpeed * local4;
if(local6 > local5) {
local6 = local5;
}
positionDelta.normalize().scale(local6);
var local7:Number = this.getPitchAngle(this.cameraPositionData);
var local8:Number = Math.atan2(-this.targetDirection.x,this.targetDirection.y);
var local9:Number = MathUtils.clampAngle(this.rotation.x + 0.5 * Math.PI);
var local10:Number = MathUtils.clampAngle(this.rotation.z);
var local11:Number = MathUtils.clampAngle(local7 - local9);
this.pitchSpeed = this.getAngularSpeed(local11,this.pitchSpeed);
var local12:Number = this.pitchSpeed * local4;
if(local11 > 0 && local12 > local11 || local11 < 0 && local12 < local11) {
local12 = local11;
}
var local13:Number = MathUtils.clampAngle(local8 - local10);
this.yawSpeed = this.getAngularSpeed(local13,this.yawSpeed);
var local14:Number = this.yawSpeed * local4;
if(local13 > 0 && local14 > local13 || local13 < 0 && local14 < local13) {
local14 = local13;
}
this.linearSpeed = MathUtils.snap(this.linearSpeed,0,camSpeedThreshold);
this.pitchSpeed = MathUtils.snap(this.pitchSpeed,0,camSpeedThreshold);
this.yawSpeed = MathUtils.snap(this.yawSpeed,0,camSpeedThreshold);
this.position.add(positionDelta);
this.rotation.x += local12;
this.rotation.y = MathUtils.moveValueTowards(this.rotation.y,0,local4);
this.rotation.z += local14;
currentPosition.copy(this.position);
currentRotation.copy(this.rotation);
param1.setPosition(currentPosition);
param1.setRotation(currentRotation);
}
public function setLocked(param1:Boolean) : void {
this.locked = param1;
if(param1) {
this._mouseWheel = 0;
}
}
private function setCameraRelativeHeight(param1:Number) : void {
this.cameraRelativeHeight = MathUtils.clamp(param1,0,1);
var local2:Number = MathUtils.clamp(this.cameraRelativeHeight + this.mouseLookShift * 0.1,0,1);
this.cameraPosition.x = bezier(local2,this.point0.x,this.point1.x,this.point2.x,this.point3.x);
this.cameraPosition.y = bezier(local2,this.point0.y,this.point1.y,this.point2.y,this.point3.y);
this.baseElevation = Math.atan2(this.cameraPosition.x,this.cameraPosition.y);
this.distanceFromPivotToCamera = this.cameraPosition.length;
}
public function getCameraState(param1:Vector3, param2:Vector3, param3:Vector3, param4:Vector3) : void {
this.getCameraPositionData(param1,param2,this.cameraPositionData);
param4.x = this.getPitchAngle(this.cameraPositionData) - 0.5 * Math.PI;
param4.z = Math.atan2(-param2.x,param2.y);
param3.copy(this.cameraPositionData.position);
}
private function getCameraPositionData(param1:Vector3, param2:Vector3, param3:CameraPositionData) : void {
var local7:Number = NaN;
var local4:Number = this.baseElevation;
var local5:Number = Math.sqrt(param2.x * param2.x + param2.y * param2.y);
if(local5 < 0.00001) {
flatDirection.x = 1;
flatDirection.y = 0;
} else {
flatDirection.x = param2.x / local5;
flatDirection.y = param2.y / local5;
}
param3.extraPitch = 0;
param3.t = 1;
rayOrigin.copy(param1);
axis.x = flatDirection.y;
axis.y = -flatDirection.x;
flatDirection.reverse();
rotationMatrix.fromAxisAngle(axis,-local4);
rotationMatrix.transformVector(flatDirection,rayDirection);
this.getCollisionPoint(rayOrigin,rayDirection,this.distanceFromPivotToCamera,collisionPoint);
var local6:Number = _v.copy(rayOrigin).subtract(collisionPoint).length();
param3.t = local6 / this.distanceFromPivotToCamera;
if(local6 < MIN_DISTANCE) {
rayOrigin.copy(collisionPoint);
local7 = MIN_DISTANCE - local6;
this.getCollisionPoint(rayOrigin,Vector3.Z_AXIS,local7,collisionPoint);
}
param3.position.copy(collisionPoint);
}
private function getCollisionPoint(param1:Vector3, param2:Vector3, param3:Number, param4:Vector3) : void {
var local5:Number = NaN;
vector3To3D(param1,rayOrigin3D);
displacement.x = param3 * param2.x;
displacement.y = param3 * param2.y;
displacement.z = param3 * param2.z;
if(this.collider.getCollision(rayOrigin3D,displacement,collisionPoint3D,collisionNormal3D,this.collisionObject)) {
local5 = COLLIDER_RADIUS + 0.1;
param4.x = collisionPoint3D.x + local5 * collisionNormal3D.x;
param4.y = collisionPoint3D.y + local5 * collisionNormal3D.y;
param4.z = collisionPoint3D.z + local5 * collisionNormal3D.z;
} else {
param4.copy(param1).addScaled(param3,param2);
}
}
private function updateCameraHeight(param1:Number) : void {
var local2:int = 0;
if(this._mouseWheel < 0) {
this.keyUpPressed = true;
this.keyDownPressed = false;
++this._mouseWheel;
if(this._mouseWheel == 0) {
this.keyUpPressed = false;
}
} else if(this._mouseWheel > 0) {
this.keyUpPressed = false;
this.keyDownPressed = true;
--this._mouseWheel;
if(this._mouseWheel == 0) {
this.keyDownPressed = false;
}
}
if(!this.inputLocked && this.keyUpPressed != this.keyDownPressed) {
local2 = this.keyUpPressed ? 1 : -1;
this.setCameraRelativeHeight(this.cameraRelativeHeight + local2 * VERTICAL_CAMERA_SPEED * param1);
} else {
this.setCameraRelativeHeight(this.cameraRelativeHeight);
}
}
private function getAngularSpeed(param1:Number, param2:Number) : Number {
var local3:Number = followCameraMode == CAMERA_FOLLOWS_TURRET ? MIN_CAMERA_ROTATE_SPEED : MAX_CAMERA_ROTATE_SPEED;
if(param1 < -maxAngleError) {
return local3 * (param1 + maxAngleError);
}
if(param1 > maxAngleError) {
return local3 * (param1 - maxAngleError);
}
return param2;
}
private function getPitchAngle(param1:CameraPositionData) : Number {
var local2:Number = this.baseElevation - FIXED_PITCH;
if(local2 < 0) {
local2 = 0;
}
var local3:Number = param1.t;
if(local3 >= 1 || local2 < MIN_CAMERA_ANGLE || !this.pitchCorrectionEnabled) {
return param1.extraPitch - local2;
}
var local4:Number = this.cameraPosition.x;
return param1.extraPitch - Math.atan2(local3 * local4,PITCH_CORRECTION_COEFF * local4 * (1 / Math.tan(local2) - (1 - local3) / Math.tan(this.baseElevation)));
}
public function onMouseRelativeMovement(param1:Number, param2:Number) : void {
if(!this.locked) {
this.mouseLookShift += param2 * ROTATE_SENS * this.getMouseMoveMultiplier();
this.mouseLookShift = MathUtils.clamp(this.mouseLookShift,-1,1);
}
}
public function onMouseWheel(param1:int) : void {
var local2:Boolean = false;
param1 *= this.getMouseMoveMultiplier();
if(!this.locked) {
local2 = false;
if(param1 > 1) {
if(this._mouseWheel < 0) {
this._mouseWheel = 0;
}
local2 = true;
}
if(param1 < 1) {
if(this._mouseWheel > 0) {
this._mouseWheel = 0;
}
local2 = true;
}
if(local2) {
this._mouseWheel = param1 * 2;
}
}
}
public function onGameAction(param1:GameActionEnum, param2:Boolean) : void {
switch(param1) {
case GameActionEnum.FOLLOW_CAMERA_UP:
this.keyUpPressed = param2;
break;
case GameActionEnum.FOLLOW_CAMERA_DOWN:
this.keyDownPressed = param2;
}
}
private function getMouseMoveMultiplier() : int {
return !!settings.mouseYInverse ? -1 : 1;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.logging.garage {
import alternativa.tanks.tracker.ITrackerService;
import flash.events.EventDispatcher;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.tanksservices.model.logging.garage.GarageAction;
public class UserGarageActionsServiceImpl extends EventDispatcher implements UserGarageActionsService {
[Inject]
public static var trackerService:ITrackerService;
public function UserGarageActionsServiceImpl() {
super();
}
public function selectItem(param1:IGameObject) : void {
dispatchEvent(new UserGarageActionEvent(GarageAction.SELECT_ITEM,param1));
}
public function equipItem(param1:IGameObject) : void {
dispatchEvent(new UserGarageActionEvent(GarageAction.EQUIP_ITEM,param1));
}
public function buyItem(param1:IGameObject) : void {
dispatchEvent(new UserGarageActionEvent(GarageAction.BUY_ITEM,param1));
}
public function buyItemModification(param1:IGameObject) : void {
dispatchEvent(new UserGarageActionEvent(GarageAction.BUY_MODIFICATION,param1));
}
public function upgradeItem(param1:IGameObject) : void {
dispatchEvent(new UserGarageActionEvent(GarageAction.UPGRADE_ITEM,param1));
}
public function chooseItemCount(param1:IGameObject) : void {
dispatchEvent(new UserGarageActionEvent(GarageAction.CHOOSE_COUNT,param1));
}
public function notEnoughCrystalsForBuying(param1:IGameObject) : void {
dispatchEvent(new UserGarageActionEvent(GarageAction.SHOW_BUY_CRYSTALS_WINDOW,param1));
}
public function purchaseAccepted(param1:IGameObject) : void {
dispatchEvent(new UserGarageActionEvent(GarageAction.PURCHASE_ACCEPTED,param1));
}
public function purchaseDeclined(param1:IGameObject) : void {
dispatchEvent(new UserGarageActionEvent(GarageAction.PURCHASE_DECLINED,param1));
}
public function unmountItem(param1:IGameObject) : void {
dispatchEvent(new UserGarageActionEvent(GarageAction.UNMOUNT_ITEM,param1));
}
}
}
|
package assets.combo {
public class ComboUpButton extends ComboButtonState {
public function ComboUpButton() {
super();
bmpLeft = new combo_UP_LEFT(1,1);
bmpCenter = new combo_UP_CENTER(1,1);
bmpRight = new combo_UP_RIGHT(1,1);
draw();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.shaft {
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 alternativa.types.Short;
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;
import projects.tanks.client.battlefield.types.Vector3d;
public class ShaftModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _activateManualTargetingCommandId:Long = Long.getLong(1850967873,1410393465);
private var _aimedShotCommandId:Long = Long.getLong(665718601,863056095);
private var _aimedShotCommand_timeCodec:ICodec;
private var _aimedShotCommand_staticHitPointCodec:ICodec;
private var _aimedShotCommand_targetCodec:ICodec;
private var _aimedShotCommand_targetHitPointCodec:ICodec;
private var _aimedShotCommand_targetIncarnationCodec:ICodec;
private var _aimedShotCommand_targetPositionCodec:ICodec;
private var _aimedShotCommand_hitPointWorldCodec:ICodec;
private var _beginEnergyDrainCommandId:Long = Long.getLong(384666897,-1041026192);
private var _beginEnergyDrainCommand_timeCodec:ICodec;
private var _quickShotCommandId:Long = Long.getLong(1060379432,313263560);
private var _quickShotCommand_timeCodec:ICodec;
private var _quickShotCommand_staticHitPointCodec:ICodec;
private var _quickShotCommand_targetCodec:ICodec;
private var _quickShotCommand_targetHitPointCodec:ICodec;
private var _quickShotCommand_targetIncarnationCodec:ICodec;
private var _quickShotCommand_targetPositionCodec:ICodec;
private var _quickShotCommand_hitPointWorldCodec:ICodec;
private var _stopManualTargetingCommandId:Long = Long.getLong(717480200,-1898093994);
private var model:IModel;
public function ShaftModelServer(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._aimedShotCommand_timeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._aimedShotCommand_staticHitPointCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,true));
this._aimedShotCommand_targetCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,true));
this._aimedShotCommand_targetHitPointCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,true));
this._aimedShotCommand_targetIncarnationCodec = this.protocol.getCodec(new TypeCodecInfo(Short,false));
this._aimedShotCommand_targetPositionCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,true));
this._aimedShotCommand_hitPointWorldCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,true));
this._beginEnergyDrainCommand_timeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._quickShotCommand_timeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._quickShotCommand_staticHitPointCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,true));
this._quickShotCommand_targetCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,true));
this._quickShotCommand_targetHitPointCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,true));
this._quickShotCommand_targetIncarnationCodec = this.protocol.getCodec(new TypeCodecInfo(Short,false));
this._quickShotCommand_targetPositionCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,true));
this._quickShotCommand_hitPointWorldCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,true));
}
public function activateManualTargetingCommand() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._activateManualTargetingCommandId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
public function aimedShotCommand(param1:int, param2:Vector3d, param3:IGameObject, param4:Vector3d, param5:int, param6:Vector3d, param7:Vector3d) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._aimedShotCommand_timeCodec.encode(this.protocolBuffer,param1);
this._aimedShotCommand_staticHitPointCodec.encode(this.protocolBuffer,param2);
this._aimedShotCommand_targetCodec.encode(this.protocolBuffer,param3);
this._aimedShotCommand_targetHitPointCodec.encode(this.protocolBuffer,param4);
this._aimedShotCommand_targetIncarnationCodec.encode(this.protocolBuffer,param5);
this._aimedShotCommand_targetPositionCodec.encode(this.protocolBuffer,param6);
this._aimedShotCommand_hitPointWorldCodec.encode(this.protocolBuffer,param7);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local8:SpaceCommand = new SpaceCommand(Model.object.id,this._aimedShotCommandId,this.protocolBuffer);
var local9:IGameObject = Model.object;
var local10:ISpace = local9.space;
local10.commandSender.sendCommand(local8);
this.protocolBuffer.optionalMap.clear();
}
public function beginEnergyDrainCommand(param1:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._beginEnergyDrainCommand_timeCodec.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._beginEnergyDrainCommandId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function quickShotCommand(param1:int, param2:Vector3d, param3:IGameObject, param4:Vector3d, param5:int, param6:Vector3d, param7:Vector3d) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._quickShotCommand_timeCodec.encode(this.protocolBuffer,param1);
this._quickShotCommand_staticHitPointCodec.encode(this.protocolBuffer,param2);
this._quickShotCommand_targetCodec.encode(this.protocolBuffer,param3);
this._quickShotCommand_targetHitPointCodec.encode(this.protocolBuffer,param4);
this._quickShotCommand_targetIncarnationCodec.encode(this.protocolBuffer,param5);
this._quickShotCommand_targetPositionCodec.encode(this.protocolBuffer,param6);
this._quickShotCommand_hitPointWorldCodec.encode(this.protocolBuffer,param7);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local8:SpaceCommand = new SpaceCommand(Model.object.id,this._quickShotCommandId,this.protocolBuffer);
var local9:IGameObject = Model.object;
var local10:ISpace = local9.space;
local10.commandSender.sendCommand(local8);
this.protocolBuffer.optionalMap.clear();
}
public function stopManualTargetingCommand() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._stopManualTargetingCommandId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.physics.collision.colliders {
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.physics.ShapeContact;
import alternativa.physics.collision.Collider;
import alternativa.physics.collision.CollisionShape;
import alternativa.physics.collision.primitives.CollisionBox;
import alternativa.physics.collision.primitives.CollisionRect;
public class BoxRectCollider implements Collider {
private static const boxFaceVertices:Vector.<Vertex> = Vector.<Vertex>([new Vertex(),new Vertex(),new Vertex(),new Vertex()]);
private static const rectFaceVertices:Vector.<Vertex> = Vector.<Vertex>([new Vertex(),new Vertex(),new Vertex(),new Vertex()]);
private static const _basisMatrix:Matrix4 = new Matrix4();
private const _vectorToBox:Vector3 = new Vector3();
private const _axis:Vector3 = new Vector3();
private const axis10:Vector3 = new Vector3();
private const axis11:Vector3 = new Vector3();
private const axis12:Vector3 = new Vector3();
private const axis20:Vector3 = new Vector3();
private const axis21:Vector3 = new Vector3();
private const axis22:Vector3 = new Vector3();
private const minOverlapAxis:Vector3 = new Vector3();
private var minOverlap:Number;
private var epsilon:Number;
public function BoxRectCollider(param1:Number) {
super();
this.epsilon = param1;
}
public function getContacts(param1:CollisionShape, param2:CollisionShape, param3:Vector.<ShapeContact>) : void {
var local4:CollisionRect = null;
var local5:CollisionBox = null;
if(this.haveCollision(param1,param2)) {
if(param1 is CollisionRect) {
local4 = CollisionRect(param1);
local5 = CollisionBox(param2);
} else {
local4 = CollisionRect(param2);
local5 = CollisionBox(param1);
}
this.findContacts(local5,local4,this.minOverlapAxis,param3);
}
}
public function haveCollision(param1:CollisionShape, param2:CollisionShape) : Boolean {
var local3:CollisionBox = null;
var local4:CollisionRect = null;
this.minOverlap = 10000000000;
if(param1 is CollisionBox) {
local3 = CollisionBox(param1);
local4 = CollisionRect(param2);
} else {
local3 = CollisionBox(param2);
local4 = CollisionRect(param1);
}
var local5:Matrix4 = local3.transform;
var local6:Matrix4 = local4.transform;
this._vectorToBox.x = local5.m03 - local6.m03;
this._vectorToBox.y = local5.m13 - local6.m13;
this._vectorToBox.z = local5.m23 - local6.m23;
this.axis22.x = local6.m02;
this.axis22.y = local6.m12;
this.axis22.z = local6.m22;
if(!this.testMainAxis(local3,local4,this.axis22,this._vectorToBox)) {
return false;
}
this.axis10.x = local5.m00;
this.axis10.y = local5.m10;
this.axis10.z = local5.m20;
if(!this.testMainAxis(local3,local4,this.axis10,this._vectorToBox)) {
return false;
}
this.axis11.x = local5.m01;
this.axis11.y = local5.m11;
this.axis11.z = local5.m21;
if(!this.testMainAxis(local3,local4,this.axis11,this._vectorToBox)) {
return false;
}
this.axis12.x = local5.m02;
this.axis12.y = local5.m12;
this.axis12.z = local5.m22;
if(!this.testMainAxis(local3,local4,this.axis12,this._vectorToBox)) {
return false;
}
this.axis20.x = local6.m00;
this.axis20.y = local6.m10;
this.axis20.z = local6.m20;
this.axis21.x = local6.m01;
this.axis21.y = local6.m11;
this.axis21.z = local6.m21;
if(!this.testDerivedAxis(local3,local4,this.axis10,this.axis20,this._vectorToBox)) {
return false;
}
if(!this.testDerivedAxis(local3,local4,this.axis10,this.axis21,this._vectorToBox)) {
return false;
}
if(!this.testDerivedAxis(local3,local4,this.axis11,this.axis20,this._vectorToBox)) {
return false;
}
if(!this.testDerivedAxis(local3,local4,this.axis11,this.axis21,this._vectorToBox)) {
return false;
}
if(!this.testDerivedAxis(local3,local4,this.axis12,this.axis20,this._vectorToBox)) {
return false;
}
if(!this.testDerivedAxis(local3,local4,this.axis12,this.axis21,this._vectorToBox)) {
return false;
}
return true;
}
private function testMainAxis(param1:CollisionBox, param2:CollisionRect, param3:Vector3, param4:Vector3) : Boolean {
var local5:Number = this.getOverlapOnAxis(param1,param2,param3,param4);
return this.registerOverlap(local5,param3);
}
private function testDerivedAxis(param1:CollisionBox, param2:CollisionRect, param3:Vector3, param4:Vector3, param5:Vector3) : Boolean {
var local7:Number = NaN;
this._axis.x = param3.y * param4.z - param3.z * param4.y;
this._axis.y = param3.z * param4.x - param3.x * param4.z;
this._axis.z = param3.x * param4.y - param3.y * param4.x;
var local6:Number = this._axis.x * this._axis.x + this._axis.y * this._axis.y + this._axis.z * this._axis.z;
if(local6 < 1e-10) {
return true;
}
local7 = 1 / Math.sqrt(local6);
this._axis.x *= local7;
this._axis.y *= local7;
this._axis.z *= local7;
var local8:Number = this.getOverlapOnAxis(param1,param2,this._axis,param5);
return this.registerOverlap(local8,this._axis);
}
private function getOverlapOnAxis(param1:CollisionBox, param2:CollisionRect, param3:Vector3, param4:Vector3) : Number {
var local5:Matrix4 = param1.transform;
var local6:Number = (local5.m00 * param3.x + local5.m10 * param3.y + local5.m20 * param3.z) * param1.hs.x;
if(local6 < 0) {
local6 = -local6;
}
var local7:Number = local6;
local6 = (local5.m01 * param3.x + local5.m11 * param3.y + local5.m21 * param3.z) * param1.hs.y;
if(local6 < 0) {
local6 = -local6;
}
local7 += local6;
local6 = (local5.m02 * param3.x + local5.m12 * param3.y + local5.m22 * param3.z) * param1.hs.z;
if(local6 < 0) {
local6 = -local6;
}
local7 += local6;
local5 = param2.transform;
local6 = (local5.m00 * param3.x + local5.m10 * param3.y + local5.m20 * param3.z) * param2.hs.x;
if(local6 < 0) {
local6 = -local6;
}
local7 += local6;
local6 = (local5.m01 * param3.x + local5.m11 * param3.y + local5.m21 * param3.z) * param2.hs.y;
if(local6 < 0) {
local6 = -local6;
}
local7 += local6;
local6 = param4.x * param3.x + param4.y * param3.y + param4.z * param3.z;
if(local6 < 0) {
local6 = -local6;
}
return local7 - local6;
}
private function registerOverlap(param1:Number, param2:Vector3) : Boolean {
if(param1 < this.epsilon) {
return false;
}
if(param1 + this.epsilon < this.minOverlap) {
this.minOverlap = param1;
this.minOverlapAxis.x = param2.x;
this.minOverlapAxis.y = param2.y;
this.minOverlapAxis.z = param2.z;
}
return true;
}
private function findContacts(param1:CollisionBox, param2:CollisionRect, param3:Vector3, param4:Vector.<ShapeContact>) : void {
var local5:Matrix4 = null;
var local12:ShapeContact = null;
var local13:Vector3 = null;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
local5 = param1.transform;
var local6:Matrix4 = param2.transform;
var local7:Vector3 = this._vectorToBox;
local7.x = local5.m03 - local6.m03;
local7.y = local5.m13 - local6.m13;
local7.z = local5.m23 - local6.m23;
if(param3.x * local7.x + param3.y * local7.y + param3.z * local7.z < 0) {
param3.x = -param3.x;
param3.y = -param3.y;
param3.z = -param3.z;
}
var local8:Matrix4 = _basisMatrix;
ColliderUtils.buildContactBasis(param3,local5,local6,local8);
ColliderUtils.getBoxFaceVerticesInCCWOrder(param1,param3,FaceSide.BACK,boxFaceVertices);
ColliderUtils.getRectFaceInCCWOrder(param2,param3,rectFaceVertices);
ColliderUtils.transformFaceToReferenceSpace(local8,local5,boxFaceVertices,4);
ColliderUtils.transformFaceToReferenceSpace(local8,local6,rectFaceVertices,4);
var local9:int = int(param4.length);
PolygonsIntersectionUtils.findContacts(param1,boxFaceVertices,4,param2,rectFaceVertices,4,local8,param4);
var local10:int = int(param4.length);
var local11:int = local9;
while(local11 < local10) {
local12 = param4[local11];
local13 = local12.normal;
local14 = local6.m02;
local15 = local6.m12;
local16 = local6.m22;
if(local13.x * local14 + local13.y * local15 + local13.z * local16 < 0) {
local12.dispose();
local10--;
param4[local11] = param4[local10];
param4[local10] = null;
local11--;
} else if(Math.abs(local6.m22) > 0.999) {
local13.x = local14;
local13.y = local15;
local13.z = local16;
}
local11++;
}
if(local10 < param4.length) {
param4.length = local10;
}
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item {
import alternativa.tanks.gui.shop.shopitems.item.base.ShopItemButton;
import alternativa.tanks.gui.shop.shopitems.item.base.ShopItemSkins;
import controls.base.LabelBase;
import flash.text.TextFieldAutoSize;
import forms.ColorConstants;
import platform.client.fp10.core.type.IGameObject;
public class LeftPictureAndTextPackageButton extends ShopItemButton {
private static const LEFT_PADDING:int = 18;
protected var nameLabel:LabelBase;
public function LeftPictureAndTextPackageButton(param1:IGameObject) {
super(param1,ShopItemSkins.GREY);
}
override protected function initLabels() : void {
this.nameLabel = new LabelBase();
this.nameLabel.text = this.getText();
this.nameLabel.color = ColorConstants.SHOP_ITEM_NAME_LABEL_COLOR;
this.nameLabel.autoSize = TextFieldAutoSize.LEFT;
this.nameLabel.size = this.getNameLabelFontSize();
this.nameLabel.bold = true;
this.nameLabel.mouseEnabled = false;
addChild(this.nameLabel);
addPriceLabel();
}
protected function getText() : String {
return "";
}
override protected function align() : void {
if(preview != null) {
preview.x = this.getPreviewLeftPadding();
preview.y = HEIGHT - preview.height >> 1;
this.nameLabel.x = preview.x + preview.width - 15;
priceLabel.x = this.nameLabel.x;
} else {
this.nameLabel.x = COMMON_LEFT_MARGIN;
priceLabel.x = this.nameLabel.x;
}
this.nameLabel.y = int(HEIGHT / 2) - this.nameLabel.height;
priceLabel.y = int(HEIGHT / 2);
if(hasDiscount()) {
this.nameLabel.y -= 5;
priceLabel.y -= 10;
oldPriceSprite.x = priceLabel.x;
oldPriceSprite.y = priceLabel.y + priceLabel.height - 5;
}
}
protected function getPreviewLeftPadding() : int {
return LEFT_PADDING - 5;
}
protected function getNameLabelFontSize() : int {
return 30;
}
}
}
|
package alternativa.tanks.service.temporaryitemnotify {
import platform.client.fp10.core.type.IGameObject;
public class TemporaryItemNotifyService implements ITemporaryItemNotifyService {
private var listeners:Vector.<ITemporaryItemNotifyServiceListener>;
public function TemporaryItemNotifyService() {
super();
this.listeners = new Vector.<ITemporaryItemNotifyServiceListener>();
}
public function addListener(param1:ITemporaryItemNotifyServiceListener) : void {
if(this.listeners.indexOf(param1) == -1) {
this.listeners.push(param1);
}
}
public function removeListener(param1:ITemporaryItemNotifyServiceListener) : void {
var local2:Number = Number(this.listeners.indexOf(param1));
if(local2 >= 0) {
this.listeners.splice(local2,1);
}
}
public function notifyTimeIsUp(param1:IGameObject) : void {
var local2:int = 0;
while(local2 < this.listeners.length) {
this.listeners[local2].temporaryItemTimeIsUp(param1);
local2++;
}
}
}
}
|
package alternativa.tanks.gui.panel.buttons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.panel.buttons.MainPanelGrayWideButton_buttonOver.png")]
public class MainPanelGrayWideButton_buttonOver extends BitmapAsset {
public function MainPanelGrayWideButton_buttonOver() {
super();
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.FontAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_myriadProFont.ttf",
fontName="Embedded Myriad Pro",
fontFamily="Myriad Pro",
mimeType="application/x-font",
fontWeight="normal",
fontStyle="normal",
unicodeRange="U+0020-007E,U+00A0-017E,U+0192-0192,U+01A0-01A1,U+01AF-01B0,U+01FA-01FF,U+0218-021D,U+0232-0233,U+02C6-02C7,U+02C9-02C9,U+02D8-02DD,U+037E-037E,U+0384-038A,U+038C-038C,U+038E-03A1,U+03A3-03CE,U+0401-040C,U+040E-044F,U+0451-045C,U+045E-045F,U+0490-0491,U+04D9-04D9,U+1E80-1E85,U+1EA0-1EF9,U+2010-2010,U+2013-2014,U+2018-201A,U+201C-201E,U+2020-2022,U+2026-2026,U+2030-2030,U+2039-203A,U+2044-2044,U+2070-2070,U+2074-2079,U+207D-207E,U+2080-2089,U+208D-208E,U+20AB-20AC,U+2113-2113,U+2116-2116,U+2122-2122,U+2126-2126,U+212E-212E,U+2202-2202,U+2206-2206,U+220F-220F,U+2211-2212,U+2215-2215,U+2219-221A,U+221E-221E,U+222B-222B,U+2248-2248,U+2260-2260,U+2264-2265,U+25CA-25CA,U+E000-E008,U+E184-E184,U+E300-E309,U+E310-E319,U+E320-E321,U+EFED-EFEE,U+EFF1-EFF3,U+EFF5-EFF5,U+EFF7-EFF7,U+F629-F634,U+F638-F64C,U+F64E-F66C,U+F6AE-F6BD,U+F6C1-F6C3,U+F6C9-F6D8,U+F6DC-F6DC,U+F6DF-F6E8,U+F730-F739,U+FB00-FB04",
advancedAntiAliasing="true",
embedAsCFF="false"
)]
public class MakeUp_myriadProFont extends FontAsset {
public function MakeUp_myriadProFont() {
super();
}
}
}
|
package alternativa.tanks.models.battle.commonflag {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.battle.pointbased.ClientTeamPoint;
import projects.tanks.client.battlefield.models.battle.pointbased.flag.ClientFlag;
public class IFlagModeInitilizerEvents implements IFlagModeInitilizer {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IFlagModeInitilizerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function init(param1:Vector.<ClientFlag>, param2:Vector.<ClientTeamPoint>) : void {
var i:int = 0;
var m:IFlagModeInitilizer = null;
var flags:Vector.<ClientFlag> = param1;
var points:Vector.<ClientTeamPoint> = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IFlagModeInitilizer(this.impl[i]);
m.init(flags,points);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.debug.dump
{
import alternativa.init.Main;
import alternativa.osgi.service.dump.dumper.IDumper;
import alternativa.register.ClientClass;
import alternativa.service.IClassService;
public class ClassDumper implements IDumper
{
public function ClassDumper()
{
super();
}
public function dump(params:Vector.<String>) : String
{
var result:String = "\n";
var classes:Array = IClassService(Main.osgi.getService(IClassService)).classList;
for(var i:int = 0; i < classes.length; i++)
{
result += ClientClass(classes[i]).toString();
}
return result + "\n";
}
public function get dumperName() : String
{
return "class";
}
}
}
|
package alternativa.tanks.model.quest.challenge.gui {
import controls.TankWindowInner;
import fl.controls.ScrollBarDirection;
import fl.controls.TileList;
import fl.data.DataProvider;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.Rectangle;
import flash.system.Capabilities;
import flash.utils.Timer;
import flash.utils.getTimer;
import forms.Styles;
import projects.tanks.client.panel.model.challenge.rewarding.Tier;
import utils.ScrollStyleUtils;
public class TierList extends TankWindowInner {
public static const STATE_DEFAULT:int = 0;
public static const STATE_CURRENT:int = 1;
public static const STATE_DONE:int = 2;
private static const MIN_POSSIBLE_SPEED:Number = 70;
private static const MAX_DELTA_FOR_SELECT:Number = 7;
private static const ADDITIONAL_SCROLL_AREA_HEIGHT:Number = 3;
private var list:TileList = new TileList();
private var previousPositionX:Number;
private var currentPositionX:Number;
private var sumDragWay:Number;
private var lastItemIndex:int;
private var previousTime:int;
private var currentTime:int;
private var scrollSpeed:Number = 0;
private var blinkTimer:Timer;
public function TierList() {
super(0,0,GREEN);
this.list.x = 3;
this.list.y = 3;
this.list.rowCount = 1;
this.list.rowHeight = 323;
this.list.columnWidth = 196;
this.list.focusEnabled = false;
this.list.horizontalScrollBar.focusEnabled = false;
this.list.direction = ScrollBarDirection.HORIZONTAL;
this.list.setStyle(Styles.CELL_RENDERER,TierRenderer);
this.list.dataProvider = new DataProvider();
ScrollStyleUtils.setGreenStyle(this.list);
addChild(this.list);
addEventListener(Event.ADDED_TO_STAGE,this.addListeners);
addEventListener(Event.REMOVED_FROM_STAGE,this.removeListeners);
}
override public function set width(param1:Number) : void {
super.width = Math.ceil(param1);
this.list.width = width - 5;
}
override public function set height(param1:Number) : void {
super.height = Math.ceil(param1);
this.list.height = height + 2;
}
public function setTiers(param1:Vector.<Tier>, param2:int, param3:int) : void {
var local5:Object = null;
this.list.dataProvider.removeAll();
var local4:int = 0;
while(local4 < param1.length) {
local5 = new Object();
local5.number = local4 + 1;
local5.tier = param1[local4];
if(local4 < param2) {
local5.state = STATE_DONE;
} else if(local4 == param2) {
local5.state = STATE_CURRENT;
local5.progress = param3;
this.stopTimer();
this.blinkTimer = new Timer(800);
local5.timer = this.blinkTimer;
} else {
local5.state = STATE_DEFAULT;
}
this.list.dataProvider.addItem(local5);
local4++;
}
this.list.scrollToIndex(Math.min(param2,param1.length - 1));
}
private function stopTimer() : * {
if(this.blinkTimer != null) {
this.blinkTimer.stop();
this.blinkTimer = null;
}
}
private function scrollList(param1:MouseEvent) : void {
this.list.horizontalScrollPosition -= param1.delta * (Boolean(Capabilities.os.search("Linux") != -1) ? 50 : 10);
}
private function onMouseDown(param1:MouseEvent) : void {
this.scrollSpeed = 0;
var local2:Rectangle = this.list.horizontalScrollBar.getBounds(stage);
local2.top -= ADDITIONAL_SCROLL_AREA_HEIGHT;
if(!local2.contains(param1.stageX,param1.stageY)) {
this.sumDragWay = 0;
this.previousPositionX = this.currentPositionX = param1.stageX;
this.currentTime = this.previousTime = getTimer();
this.lastItemIndex = this.list.selectedIndex;
stage.addEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
stage.addEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
}
}
private function onMouseUp(param1:MouseEvent) : void {
stage.removeEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
stage.removeEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
var local2:Number = (getTimer() - this.previousTime) / 1000;
if(local2 == 0) {
local2 = 0.1;
}
var local3:Number = param1.stageX - this.previousPositionX;
this.scrollSpeed = local3 / local2;
this.previousTime = this.currentTime;
this.currentTime = getTimer();
addEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
private function onEnterFrame(param1:Event) : void {
this.previousTime = this.currentTime;
this.currentTime = getTimer();
var local2:Number = (this.currentTime - this.previousTime) / 1000;
this.list.horizontalScrollPosition -= this.scrollSpeed * local2;
var local3:Number = this.list.horizontalScrollPosition;
var local4:Number = this.list.maxHorizontalScrollPosition;
if(Math.abs(this.scrollSpeed) > MIN_POSSIBLE_SPEED && 0 < local3 && local3 < local4) {
this.scrollSpeed *= Math.exp(-1.5 * local2);
} else {
this.scrollSpeed = 0;
removeEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
}
private function onMouseMove(param1:MouseEvent) : void {
this.previousPositionX = this.currentPositionX;
this.currentPositionX = param1.stageX;
this.previousTime = this.currentTime;
this.currentTime = getTimer();
var local2:Number = this.currentPositionX - this.previousPositionX;
this.sumDragWay += Math.abs(local2);
if(this.sumDragWay > MAX_DELTA_FOR_SELECT) {
this.list.horizontalScrollPosition -= local2;
}
param1.updateAfterEvent();
}
private function addListeners(param1:Event) : void {
addEventListener(MouseEvent.MOUSE_WHEEL,this.scrollList);
addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
}
private function removeListeners(param1:Event) : void {
removeEventListener(MouseEvent.MOUSE_WHEEL,this.scrollList);
removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
removeEventListener(Event.ENTER_FRAME,this.onEnterFrame);
stage.removeEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
stage.removeEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
}
public function destroy() : void {
this.stopTimer();
}
}
}
|
package _codec.projects.tanks.client.panel.model.garage.availableupgrades {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import projects.tanks.client.commons.types.ItemViewCategoryEnum;
import projects.tanks.client.panel.model.garage.availableupgrades.AvailableUpgradeItem;
public class CodecAvailableUpgradeItem implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_available:ICodec;
private var codec_category:ICodec;
private var codec_timeToEndUpgradeInSec:ICodec;
public function CodecAvailableUpgradeItem() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_available = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_category = param1.getCodec(new EnumCodecInfo(ItemViewCategoryEnum,false));
this.codec_timeToEndUpgradeInSec = param1.getCodec(new TypeCodecInfo(Long,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:AvailableUpgradeItem = new AvailableUpgradeItem();
local2.available = this.codec_available.decode(param1) as Boolean;
local2.category = this.codec_category.decode(param1) as ItemViewCategoryEnum;
local2.timeToEndUpgradeInSec = this.codec_timeToEndUpgradeInSec.decode(param1) as Long;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:AvailableUpgradeItem = AvailableUpgradeItem(param2);
this.codec_available.encode(param1,local3.available);
this.codec_category.encode(param1,local3.category);
this.codec_timeToEndUpgradeInSec.encode(param1,local3.timeToEndUpgradeInSec);
}
}
}
|
package alternativa.tanks.models.tank.spawn {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ITankSpawnerEvents implements ITankSpawner {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ITankSpawnerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getIncarnationId() : int {
var result:int = 0;
var i:int = 0;
var m:ITankSpawner = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ITankSpawner(this.impl[i]);
result = int(m.getIncarnationId());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function readyToSpawn() : void {
var i:int = 0;
var m:ITankSpawner = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ITankSpawner(this.impl[i]);
m.readyToSpawn();
i++;
}
}
finally {
Model.popObject();
}
}
public function setLocal() : void {
var i:int = 0;
var m:ITankSpawner = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ITankSpawner(this.impl[i]);
m.setLocal();
i++;
}
}
finally {
Model.popObject();
}
}
public function setRemote() : void {
var i:int = 0;
var m:ITankSpawner = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ITankSpawner(this.impl[i]);
m.setRemote();
i++;
}
}
finally {
Model.popObject();
}
}
public function setReadyToPlace() : void {
var i:int = 0;
var m:ITankSpawner = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ITankSpawner(this.impl[i]);
m.setReadyToPlace();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.model.challenge
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChallengeCongratulationWindow_mineBitmap extends BitmapAsset
{
public function ChallengeCongratulationWindow_mineBitmap()
{
super();
}
}
}
|
package _codec.projects.tanks.client.battleselect.model.map {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import alternativa.types.Short;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.battleselect.model.map.MapInfoCC;
import projects.tanks.client.battleservice.BattleMode;
import projects.tanks.client.battleservice.Range;
import projects.tanks.client.battleservice.model.map.params.MapTheme;
public class CodecMapInfoCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_defaultTheme:ICodec;
private var codec_enabled:ICodec;
private var codec_mapId:ICodec;
private var codec_mapName:ICodec;
private var codec_matchmakingMark:ICodec;
private var codec_maxPeople:ICodec;
private var codec_preview:ICodec;
private var codec_rankLimit:ICodec;
private var codec_supportedModes:ICodec;
private var codec_theme:ICodec;
public function CodecMapInfoCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_defaultTheme = param1.getCodec(new EnumCodecInfo(MapTheme,false));
this.codec_enabled = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_mapId = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_mapName = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_matchmakingMark = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_maxPeople = param1.getCodec(new TypeCodecInfo(Short,false));
this.codec_preview = param1.getCodec(new TypeCodecInfo(ImageResource,false));
this.codec_rankLimit = param1.getCodec(new TypeCodecInfo(Range,false));
this.codec_supportedModes = param1.getCodec(new CollectionCodecInfo(new EnumCodecInfo(BattleMode,false),false,1));
this.codec_theme = param1.getCodec(new EnumCodecInfo(MapTheme,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:MapInfoCC = new MapInfoCC();
local2.defaultTheme = this.codec_defaultTheme.decode(param1) as MapTheme;
local2.enabled = this.codec_enabled.decode(param1) as Boolean;
local2.mapId = this.codec_mapId.decode(param1) as Long;
local2.mapName = this.codec_mapName.decode(param1) as String;
local2.matchmakingMark = this.codec_matchmakingMark.decode(param1) as Boolean;
local2.maxPeople = this.codec_maxPeople.decode(param1) as int;
local2.preview = this.codec_preview.decode(param1) as ImageResource;
local2.rankLimit = this.codec_rankLimit.decode(param1) as Range;
local2.supportedModes = this.codec_supportedModes.decode(param1) as Vector.<BattleMode>;
local2.theme = this.codec_theme.decode(param1) as MapTheme;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:MapInfoCC = MapInfoCC(param2);
this.codec_defaultTheme.encode(param1,local3.defaultTheme);
this.codec_enabled.encode(param1,local3.enabled);
this.codec_mapId.encode(param1,local3.mapId);
this.codec_mapName.encode(param1,local3.mapName);
this.codec_matchmakingMark.encode(param1,local3.matchmakingMark);
this.codec_maxPeople.encode(param1,local3.maxPeople);
this.codec_preview.encode(param1,local3.preview);
this.codec_rankLimit.encode(param1,local3.rankLimit);
this.codec_supportedModes.encode(param1,local3.supportedModes);
this.codec_theme.encode(param1,local3.theme);
}
}
}
|
package alternativa.engine3d.materials {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import alternativa.gfx.core.IndexBufferResource;
import alternativa.gfx.core.VertexBufferResource;
import flash.utils.getQualifiedClassName;
use namespace alternativa3d;
public class Material {
public var name:String;
public var alphaTestThreshold:Number = 0;
public var zOffset:Boolean = false;
public var uploadEveryFrame:Boolean = false;
alternativa3d var drawId:uint = 0;
alternativa3d var useVerticesNormals:Boolean = true;
private var isTransparent:Boolean;
public function Material() {
super();
}
alternativa3d function get transparent() : Boolean {
return this.isTransparent;
}
alternativa3d function set transparent(param1:Boolean) : void {
this.isTransparent = param1;
}
public function clone() : Material {
var local1:Material = new Material();
local1.clonePropertiesFrom(this);
return local1;
}
protected function clonePropertiesFrom(param1:Material) : void {
this.name = param1.name;
this.alphaTestThreshold = param1.alphaTestThreshold;
this.alternativa3d::useVerticesNormals = param1.alternativa3d::useVerticesNormals;
}
public function toString() : String {
var local1:String = getQualifiedClassName(this);
return "[" + local1.substr(local1.indexOf("::") + 2) + " " + this.name + "]";
}
alternativa3d function drawOpaque(param1:Camera3D, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D) : void {
}
alternativa3d function drawTransparent(param1:Camera3D, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D, param7:Boolean = false) : void {
}
public function dispose() : void {
}
}
}
|
package com.lorentz.SVG.data.filters
{
import com.lorentz.SVG.utils.ICloneable;
import flash.filters.BitmapFilter;
public interface ISVGFilter extends ICloneable
{
function getFlashFilter():BitmapFilter;
}
}
|
package controls.scroller.red
{
public class ScrollSkinRed
{
[Embed(source="993.png")]
public static const thumbTop:Class;
[Embed(source="1027.png")]
public static const thumbMiddle:Class;
[Embed(source="1073.png")]
public static const track:Class;
[Embed(source="1109.png")]
public static const trackTop:Class;
[Embed(source="805.png")]
public static const trackBottom:Class;
public function ScrollSkinRed()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.shaft {
public class ShaftState {
public static const IDLE:ShaftState = new ShaftState(1);
public static const READY_TO_SHOOT:ShaftState = new ShaftState(2);
public static const MANUAL_TARGETING_ACTIVATION:ShaftState = new ShaftState(3);
public static const MANUAL_TARGETING:ShaftState = new ShaftState(4);
private var value:int;
public function ShaftState(param1:int) {
super();
this.value = param1;
}
[Obfuscation(rename="false")]
public function toString() : String {
return this.value.toString();
}
}
}
|
package projects.tanks.clients.flash.commons.services.fullscreen {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.launcherparams.ILauncherParams;
import flash.display.StageDisplayState;
import flash.external.ExternalInterface;
import flash.system.Capabilities;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenService;
public class FullscreenServiceImpl implements FullscreenService {
private static const STANDALONE:String = "StandAlone";
private static const DESKTOP:String = "Desktop";
private static const BROWSER_BLACK_LIST:Array = [{
"browser":"Chrome",
"os":"Windows"
},{
"browser":"Chrome",
"os":"Mac"
},{
"browser":"Safari",
"os":"Windows"
},{
"browser":"Safari",
"os":"Mac"
},{
"browser":"Yandex",
"os":"Windows"
},{
"browser":"Yandex",
"os":"Mac"
}];
private var _display:IDisplay;
private var launcherParams:ILauncherParams;
private var mouseLockEnabled:Boolean;
private var standalone:Boolean;
public function FullscreenServiceImpl(param1:IDisplay, param2:ILauncherParams) {
super();
this._display = param1;
this.launcherParams = param2;
this.standalone = Capabilities.playerType == STANDALONE || Capabilities.playerType == DESKTOP;
this.mouseLockEnabled = this.checkIfMouseLockEnabled();
}
public function switchFullscreen() : void {
if(this._display.stage.displayState == StageDisplayState.NORMAL) {
this.activate();
} else {
this.deactivate();
}
}
private function activate() : void {
if(this.isAvailable()) {
this._display.stage.displayState = StageDisplayState.FULL_SCREEN_INTERACTIVE;
}
}
private function deactivate() : void {
this._display.stage.displayState = StageDisplayState.NORMAL;
}
public function isAvailable() : Boolean {
if(this.launcherParams.getParameter(StageDisplayState.FULL_SCREEN_INTERACTIVE,"true") != "true") {
return false;
}
var local1:Array = this.getFlashVersion();
return int(local1[0]) == 11 && int(local1[1]) >= 3 || int(local1[0]) > 11;
}
public function isFullScreenNow() : Boolean {
return this._display.stage.displayState == StageDisplayState.FULL_SCREEN_INTERACTIVE || this._display.stage.displayState == StageDisplayState.FULL_SCREEN;
}
public function isMouseLockEnabled() : Boolean {
return this.mouseLockEnabled;
}
private function checkIfMouseLockEnabled() : Boolean {
var local4:Object = null;
if(this.standalone) {
return true;
}
var local1:String = this.getBrowserName();
var local2:String = Capabilities.os;
var local3:int = 0;
while(local3 < BROWSER_BLACK_LIST.length) {
local4 = BROWSER_BLACK_LIST[local3];
if(local1.indexOf(local4.browser) > -1 && local2.indexOf(local4.os) > -1) {
return false;
}
local3++;
}
return true;
}
private function getBrowserName() : String {
var userAgent:String = null;
var browser:String = null;
try {
userAgent = ExternalInterface.call("window.navigator.userAgent.toString");
browser = "[Unknown Browser]";
if(userAgent.indexOf("Safari") != -1) {
browser = "Safari";
}
if(userAgent.indexOf("Firefox") != -1) {
browser = "Firefox";
}
if(userAgent.indexOf("Chrome") != -1) {
browser = "Chrome";
}
if(userAgent.indexOf("MSIE") != -1) {
browser = "IE";
}
if(userAgent.indexOf("Opera") != -1) {
browser = "Opera";
}
if(userAgent.indexOf("YaBrowser") != -1) {
browser = "Yandex";
}
}
catch(e:Error) {
return "[No ExternalInterface]";
}
return browser;
}
private function getFlashVersion() : Array {
return Capabilities.version.substr(Capabilities.version.indexOf(" ") + 1).split(",");
}
}
}
|
package alternativa.tanks.view.matchmaking.group.invite {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.types.Long;
import controls.base.LabelBase;
import forms.ColorConstants;
import forms.userlabel.UserLabel;
import projects.tanks.clients.flash.commons.services.notification.Notification;
public class ResponseGroupInviteNotification extends Notification {
[Inject]
public static var localeService:ILocaleService;
private var messageLabel:LabelBase;
private var userLabel:UserLabel;
public function ResponseGroupInviteNotification(param1:Long, param2:String) {
super(param1,localeService.getText(param2));
}
override protected function init() : void {
super.init();
this.userLabel = new UserLabel(userId);
addChild(this.userLabel);
this.messageLabel = new LabelBase();
this.messageLabel.mouseEnabled = false;
addChild(this.messageLabel);
this.messageLabel.color = ColorConstants.GREEN_LABEL;
this.messageLabel.text = message;
}
override protected function resize() : void {
this.userLabel.x = GAP + 7;
this.userLabel.y = GAP + 5;
this.messageLabel.x = GAP + 9;
this.messageLabel.y = this.userLabel.y + this.userLabel.height - 1;
_innerHeight = this.messageLabel.y + this.messageLabel.height - 3;
var local1:int = this.messageLabel.x + this.messageLabel.width + GAP * 2;
if(local1 > _width) {
_width = local1;
}
_height = _innerHeight + GAP * 2 + 1;
super.resize();
}
}
}
|
package services.alertservice {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import flash.display.Sprite;
import flash.events.EventDispatcher;
import forms.events.AlertEvent;
import platform.client.fp10.core.network.connection.ConnectionCloseStatus;
import platform.client.fp10.core.network.handler.OnConnectionClosedServiceListener;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.AlertServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.blur.IBlurService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogwindowdispatcher.DialogWindowsDispatcherServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogwindowdispatcher.IDialogWindowsDispatcherService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.removeDisplayObject;
public class AlertService extends EventDispatcher implements IAlertService, OnConnectionClosedServiceListener {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var blurService:IBlurService;
[Inject]
public static var dialogWindowsDispatcherService:IDialogWindowsDispatcherService;
private var _alert:Alert;
private var _queue:Vector.<Alert>;
public function AlertService() {
super();
this.init();
}
private function init() : void {
this._alert = new Alert();
this._alert = null;
this._queue = new Vector.<Alert>();
}
public function showAlert(param1:String, param2:Vector.<String>) : void {
var local3:Alert = null;
if(this.isClose()) {
this._alert = new Alert();
this._alert.showAlert(param1,param2);
this.addAlert();
} else {
local3 = new Alert();
local3.showAlert(param1,param2);
this._queue.push(local3);
}
}
public function showAlertWithCustomButtons(param1:String, param2:Vector.<String>, param3:Vector.<Sprite>) : void {
var local4:Alert = null;
if(this.isClose()) {
this._alert = new Alert();
this._alert.showAlertWithCustomButtons(param1,param2,param3);
this.addAlert();
} else {
local4 = new Alert();
local4.showAlertWithCustomButtons(param1,param2,param3);
this._queue.push(local4);
}
}
public function showOkAlert(param1:String) : void {
this.showAlert(param1,Vector.<String>([localeService.getText(AlertAnswer.OK)]));
}
private function addAlert() : void {
dialogWindowsDispatcherService.open();
blurService.blurDialogContent();
display.noticesLayer.addChild(this._alert);
this._alert.addEventListener(AlertEvent.ALERT_BUTTON_PRESSED,this.onAlertButtonPressed);
dialogWindowsDispatcherService.addEventListener(DialogWindowsDispatcherServiceEvent.FORCIBLY_CLOSE,this.onForciblyCloseDialogs);
}
public function showAlertById(param1:int) : void {
if(this.isClose()) {
this._alert = new Alert(param1);
this.addAlert();
} else {
this._queue.push(new Alert(param1));
}
}
private function onAlertButtonPressed(param1:AlertEvent) : void {
this.removeAlert();
dispatchEvent(new AlertServiceEvent(AlertServiceEvent.ALERT_BUTTON_PRESSED,param1.typeButton));
}
private function removeAlert() : void {
dialogWindowsDispatcherService.removeEventListener(DialogWindowsDispatcherServiceEvent.FORCIBLY_CLOSE,this.onForciblyCloseDialogs);
this._alert.removeEventListener(AlertEvent.ALERT_BUTTON_PRESSED,this.onAlertButtonPressed);
this._alert = null;
if(this._queue.length > 0) {
this._alert = this._queue.shift();
this.addAlert();
} else {
dialogWindowsDispatcherService.close();
blurService.unblurDialogContent();
}
}
private function onForciblyCloseDialogs(param1:DialogWindowsDispatcherServiceEvent) : void {
this._alert.simulatePressedCancel();
}
public function onConnectionClosed(param1:ConnectionCloseStatus) : void {
this._queue.length = 0;
if(Boolean(this._alert)) {
removeDisplayObject(this._alert);
this.removeAlert();
}
}
private function isClose() : Boolean {
return this._alert == null;
}
}
}
|
package alternativa.tanks.camera
{
import alternativa.math.Vector3;
import alternativa.tanks.utils.MathUtils;
public class FlyCameraController extends CameraControllerBase implements ICameraController
{
private static const FLY_HEIGHT:Number = 3000;
private static const cameraPosition:Vector3 = new Vector3();
private var p1:Vector3;
private var p2:Vector3;
private var p3:Vector3;
private var p4:Vector3;
private var totalDistance:Number;
private var distance:Number;
private var acceleration:Number;
private var speed:Number;
private var angleValuesX:AngleValues;
private var angleValuesZ:AngleValues;
public function FlyCameraController(camera:GameCamera)
{
this.p1 = new Vector3();
this.p2 = new Vector3();
this.p3 = new Vector3();
this.p4 = new Vector3();
this.angleValuesX = new AngleValues();
this.angleValuesZ = new AngleValues();
super(camera);
}
public function init(targetPosition:Vector3, targetAngles:Vector3, travelTime:int) : void
{
this.p1.vCopy(camera.pos);
this.p2.vCopy(this.p1);
this.p4.vCopy(targetPosition);
this.p3.vCopy(this.p4);
this.p2.z = this.p3.z = (this.p1.z > this.p4.z ? this.p1.z : this.p4.z) + FLY_HEIGHT;
var k:Number = 4000000 / (travelTime * travelTime);
this.angleValuesX.init(MathUtils.clampAngle(camera.rotationX),targetAngles.x,k);
this.angleValuesZ.init(MathUtils.clampAngle(camera.rotationZ),targetAngles.z,k);
this.totalDistance = new Vector3().vDiff(this.p4,this.p1).vLength();
this.acceleration = this.totalDistance * k;
this.distance = 0;
this.speed = 0;
}
public function update(time:int, deltaMsec:int) : void
{
if(this.speed < 0)
{
return;
}
if(this.distance > 0.5 * this.totalDistance && this.acceleration > 0)
{
this.acceleration = -this.acceleration;
this.angleValuesX.reverseAcceleration();
this.angleValuesZ.reverseAcceleration();
}
var dt:Number = 0.001 * deltaMsec;
var dv:Number = this.acceleration * dt;
this.distance += (this.speed + 0.5 * dv) * dt;
this.speed += dv;
if(this.distance > this.totalDistance)
{
this.distance = this.totalDistance;
}
this.bezier(this.distance / this.totalDistance,this.p1,this.p2,this.p3,this.p4,cameraPosition);
setPosition(cameraPosition);
rotateBy(this.angleValuesX.update(dt),0,this.angleValuesZ.update(dt));
}
private function bezier(t:Number, p1:Vector3, p2:Vector3, p3:Vector3, p4:Vector3, result:Vector3) : void
{
var a:Number = NaN;
var d:Number = NaN;
var b:Number = NaN;
var c:Number = NaN;
a = NaN;
d = NaN;
var t1:Number = 1 - t;
a = t1 * t1;
b = 3 * t * a;
a *= t1;
d = t * t;
c = 3 * d * t1;
d *= t;
result.x = a * p1.x + b * p2.x + c * p3.x + d * p4.x;
result.y = a * p1.y + b * p2.y + c * p3.y + d * p4.y;
result.z = a * p1.z + b * p2.z + c * p3.z + d * p4.z;
}
}
}
class AngleValues
{
private var currentAngle:Number;
private var totalAngle:Number;
private var angularAcceleration:Number;
private var angularSpeed:Number;
private var angleDirection:Number;
function AngleValues()
{
super();
}
public function init(startAngle:Number, targetAngle:Number, accelerationCoeff:Number) : void
{
this.totalAngle = targetAngle - startAngle;
if(this.totalAngle < 0)
{
this.totalAngle = -this.totalAngle;
this.angleDirection = -1;
}
else
{
this.angleDirection = 1;
}
if(this.totalAngle > Math.PI)
{
this.angleDirection = -this.angleDirection;
this.totalAngle = 2 * Math.PI - this.totalAngle;
}
this.angularAcceleration = accelerationCoeff * this.totalAngle;
this.angularSpeed = 0;
this.currentAngle = 0;
}
public function reverseAcceleration() : void
{
this.angularAcceleration = -this.angularAcceleration;
}
public function update(dt:Number) : Number
{
var dv:Number = NaN;
var delta:Number = NaN;
var da:Number = NaN;
if(this.currentAngle < this.totalAngle)
{
dv = this.angularAcceleration * dt;
delta = (this.angularSpeed + 0.5 * dv) * dt;
this.angularSpeed += dv;
da = this.totalAngle - this.currentAngle;
if(da < delta)
{
delta = da;
}
this.currentAngle += delta;
return delta * this.angleDirection;
}
return 0;
}
}
|
package alternativa.engine3d.loaders.collada {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.animation.AnimationClip;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.objects.Joint;
import alternativa.engine3d.objects.Skin;
import alternativa.engine3d.objects.VertexBinding;
import flash.utils.Dictionary;
use namespace alternativa3d;
use namespace collada;
public class DaeController extends DaeElement {
private var jointsBindMatrices:Vector.<Vector.<Number>>;
private var vcounts:Array;
private var indices:Array;
private var jointsInput:DaeInput;
private var weightsInput:DaeInput;
private var inputsStride:int;
public function DaeController(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
override protected function parseImplementation() : Boolean {
var local1:XML = data.skin.vertex_weights[0];
if(local1 == null) {
return false;
}
var local2:XML = local1.vcount[0];
if(local2 == null) {
return false;
}
this.vcounts = parseIntsArray(local2);
var local3:XML = local1.v[0];
if(local3 == null) {
return false;
}
this.indices = parseIntsArray(local3);
this.parseInputs();
this.parseJointsBindMatrices();
return true;
}
private function parseInputs() : void {
var local5:DaeInput = null;
var local6:String = null;
var local7:int = 0;
var local1:XMLList = data.skin.vertex_weights.input;
var local2:int = 0;
var local3:int = 0;
var local4:int = int(local1.length());
for(; local3 < local4; local7 = local5.offset,local2 = local7 > local2 ? local7 : local2,local3++) {
local5 = new DaeInput(local1[local3],document);
local6 = local5.semantic;
if(local6 == null) {
continue;
}
switch(local6) {
case "JOINT":
if(this.jointsInput == null) {
this.jointsInput = local5;
}
break;
case "WEIGHT":
if(this.weightsInput == null) {
this.weightsInput = local5;
}
break;
}
}
this.inputsStride = local2 + 1;
}
private function parseJointsBindMatrices() : void {
var jointsXML:XML = null;
var jointsSource:DaeSource = null;
var stride:int = 0;
var count:int = 0;
var i:int = 0;
var index:int = 0;
var matrix:Vector.<Number> = null;
var j:int = 0;
jointsXML = data.skin.joints.input.(@semantic == "INV_BIND_MATRIX")[0];
if(jointsXML != null) {
jointsSource = document.findSource(jointsXML.@source[0]);
if(jointsSource != null) {
if(jointsSource.parse() && jointsSource.numbers != null && jointsSource.stride >= 16) {
stride = jointsSource.stride;
count = jointsSource.numbers.length / stride;
this.jointsBindMatrices = new Vector.<Vector.<Number>>(count);
i = 0;
while(i < count) {
index = stride * i;
matrix = new Vector.<Number>(16);
this.jointsBindMatrices[i] = matrix;
j = 0;
while(j < 16) {
matrix[j] = jointsSource.numbers[int(index + j)];
j++;
}
i++;
}
}
} else {
document.logger.logNotFoundError(jointsXML.@source[0]);
}
}
}
private function get geometry() : DaeGeometry {
var local1:DaeGeometry = document.findGeometry(data.skin.@source[0]);
if(local1 == null) {
document.logger.logNotFoundError(data.@source[0]);
}
return local1;
}
public function parseSkin(param1:Object, param2:Vector.<DaeNode>, param3:Vector.<DaeNode>) : DaeObject {
var local5:Skin = null;
var local6:DaeGeometry = null;
var local7:Vector.<Vertex> = null;
var local8:Vector.<DaeObject> = null;
var local4:XML = data.skin[0];
if(local4 != null) {
local5 = new Skin();
local6 = this.geometry;
if(local6 != null) {
local6.parse();
local7 = local6.fillInMesh(local5,param1);
this.applyBindShapeMatrix(local5);
local8 = this.addJointsToSkin(local5,param2,this.findNodes(param3));
this.setJointsBindMatrices(local8);
this.linkVerticesToJoints(local8,local7);
local5.normalizeWeights();
local6.cleanVertices(local5);
local5.calculateFacesNormals(true);
local5.calculateBounds();
return new DaeObject(local5,this.mergeJointsClips(local5,local8));
}
local5.calculateFacesNormals(true);
local5.calculateBounds();
return new DaeObject(local5);
}
return null;
}
private function mergeJointsClips(param1:Skin, param2:Vector.<DaeObject>) : AnimationClip {
var local7:DaeObject = null;
var local8:AnimationClip = null;
var local9:Object3D = null;
var local10:int = 0;
if(!this.hasJointsAnimation(param2)) {
return null;
}
var local3:AnimationClip = new AnimationClip();
var local4:Array = [param1];
var local5:int = 0;
var local6:int = int(param2.length);
while(local5 < local6) {
local7 = param2[local5];
local8 = local7.animation;
if(local8 != null) {
local10 = 0;
while(local10 < local8.numTracks) {
local3.addTrack(local8.getTrackAt(local10));
local10++;
}
} else {
local3.addTrack(local7.jointNode.createStaticTransformTrack());
}
local9 = local7.object;
local9.name = local7.jointNode.animName;
local4.push(local9);
local5++;
}
local3.alternativa3d::_objects = local4;
return local3;
}
private function hasJointsAnimation(param1:Vector.<DaeObject>) : Boolean {
var local4:DaeObject = null;
var local2:int = 0;
var local3:int = int(param1.length);
while(local2 < local3) {
local4 = param1[local2];
if(local4.animation != null) {
return true;
}
local2++;
}
return false;
}
private function setJointsBindMatrices(param1:Vector.<DaeObject>) : void {
var local4:DaeObject = null;
var local5:Vector.<Number> = null;
var local6:Joint = null;
var local2:int = 0;
var local3:int = int(this.jointsBindMatrices.length);
while(local2 < local3) {
local4 = param1[local2];
local5 = this.jointsBindMatrices[local2];
local6 = local4.object as Joint;
local6.alternativa3d::bma = local5[0];
local6.alternativa3d::bmb = local5[1];
local6.alternativa3d::bmc = local5[2];
local6.alternativa3d::bmd = local5[3];
local6.alternativa3d::bme = local5[4];
local6.alternativa3d::bmf = local5[5];
local6.alternativa3d::bmg = local5[6];
local6.alternativa3d::bmh = local5[7];
local6.alternativa3d::bmi = local5[8];
local6.alternativa3d::bmj = local5[9];
local6.alternativa3d::bmk = local5[10];
local6.alternativa3d::bml = local5[11];
local2++;
}
}
private function linkVertexToJoint(param1:Joint, param2:Vertex, param3:Number) : void {
var local4:VertexBinding = new VertexBinding();
local4.alternativa3d::next = param1.alternativa3d::vertexBindingList;
param1.alternativa3d::vertexBindingList = local4;
local4.alternativa3d::vertex = param2;
local4.alternativa3d::weight = param3;
while(true) {
param2 = param2.alternativa3d::value;
if(param2 == null) {
break;
}
local4 = new VertexBinding();
local4.alternativa3d::next = param1.alternativa3d::vertexBindingList;
param1.alternativa3d::vertexBindingList = local4;
local4.alternativa3d::vertex = param2;
local4.alternativa3d::weight = param3;
}
}
private function linkVerticesToJoints(param1:Vector.<DaeObject>, param2:Vector.<Vertex>) : void {
var local11:Vertex = null;
var local12:int = 0;
var local13:int = 0;
var local14:int = 0;
var local15:int = 0;
var local16:int = 0;
var local17:Number = NaN;
var local3:int = this.jointsInput.offset;
var local4:int = this.weightsInput.offset;
var local5:DaeSource = this.weightsInput.prepareSource(1);
var local6:Vector.<Number> = local5.numbers;
var local7:int = local5.stride;
var local8:int = 0;
var local9:int = 0;
var local10:int = int(param2.length);
while(local9 < local10) {
local11 = param2[local9];
local12 = int(this.vcounts[local9]);
local13 = 0;
while(local13 < local12) {
local14 = this.inputsStride * (local8 + local13);
local15 = int(this.indices[int(local14 + local3)]);
if(local15 >= 0) {
local16 = int(this.indices[int(local14 + local4)]);
local17 = local6[int(local7 * local16)];
this.linkVertexToJoint(Joint(param1[local15].object),local11,local17);
}
local13++;
}
local8 += local12;
local9++;
}
}
private function addJointsToSkin(param1:Skin, param2:Vector.<DaeNode>, param3:Vector.<DaeNode>) : Vector.<DaeObject> {
var local6:int = 0;
var local9:DaeNode = null;
var local10:DaeObject = null;
var local4:Dictionary = new Dictionary();
var local5:int = int(param3.length);
local6 = 0;
while(local6 < local5) {
local4[param3[local6]] = local6;
local6++;
}
var local7:Vector.<DaeObject> = new Vector.<DaeObject>(local5);
var local8:int = int(param2.length);
local6 = 0;
while(local6 < local8) {
local9 = param2[local6];
local10 = this.addRootJointToSkin(param1,local9,local7,local4);
this.addJointChildren(Joint(local10.object),local7,local9,local4);
local6++;
}
return local7;
}
private function addRootJointToSkin(param1:Skin, param2:DaeNode, param3:Vector.<DaeObject>, param4:Dictionary) : DaeObject {
var local5:Joint = new Joint();
local5.name = param2.name;
param1.addJoint(local5);
var local6:DaeObject = param2.applyAnimation(param2.applyTransformations(local5));
local6.jointNode = param2;
if(param2 in param4) {
param3[param4[param2]] = local6;
} else {
param3.push(local6);
}
return local6;
}
private function addJointChildren(param1:Joint, param2:Vector.<DaeObject>, param3:DaeNode, param4:Dictionary) : void {
var local5:DaeObject = null;
var local9:DaeNode = null;
var local10:Joint = null;
var local6:Vector.<DaeNode> = param3.nodes;
var local7:int = 0;
var local8:int = int(local6.length);
while(local7 < local8) {
local9 = local6[local7];
if(local9 in param4) {
local10 = new Joint();
local10.name = local9.name;
local5 = local9.applyAnimation(local9.applyTransformations(local10));
local5.jointNode = local9;
param2[param4[local9]] = local5;
param1.addChild(local10);
this.addJointChildren(local10,param2,local9,param4);
} else if(this.hasJointInDescendants(local9,param4)) {
local10 = new Joint();
local10.name = local9.name;
local5 = local9.applyAnimation(local9.applyTransformations(local10));
local5.jointNode = local9;
param2.push(local5);
param1.addChild(local10);
this.addJointChildren(local10,param2,local9,param4);
}
local7++;
}
}
private function hasJointInDescendants(param1:DaeNode, param2:Dictionary) : Boolean {
var local6:DaeNode = null;
var local3:Vector.<DaeNode> = param1.nodes;
var local4:int = 0;
var local5:int = int(local3.length);
while(local4 < local5) {
local6 = local3[local4];
if(local6 in param2 || this.hasJointInDescendants(local6,param2)) {
return true;
}
local4++;
}
return false;
}
private function applyBindShapeMatrix(param1:Skin) : void {
var local3:Array = null;
var local4:Number = NaN;
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Vertex = null;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local2:XML = data.skin.bind_shape_matrix[0];
if(local2 != null) {
local3 = parseNumbersArray(local2);
if(local3.length >= 16) {
local4 = Number(local3[0]);
local5 = Number(local3[1]);
local6 = Number(local3[2]);
local7 = Number(local3[3]);
local8 = Number(local3[4]);
local9 = Number(local3[5]);
local10 = Number(local3[6]);
local11 = Number(local3[7]);
local12 = Number(local3[8]);
local13 = Number(local3[9]);
local14 = Number(local3[10]);
local15 = Number(local3[11]);
local16 = param1.alternativa3d::vertexList;
while(local16 != null) {
local17 = local16.x;
local18 = local16.y;
local19 = local16.z;
local16.x = local4 * local17 + local5 * local18 + local6 * local19 + local7;
local16.y = local8 * local17 + local9 * local18 + local10 * local19 + local11;
local16.z = local12 * local17 + local13 * local18 + local14 * local19 + local15;
local16 = local16.alternativa3d::next;
}
}
}
}
private function isRootJointNode(param1:DaeNode, param2:Dictionary) : Boolean {
var local3:DaeNode = param1.parent;
while(local3 != null) {
if(local3 in param2) {
return false;
}
local3 = local3.parent;
}
return true;
}
public function findRootJointNodes(param1:Vector.<DaeNode>) : Vector.<DaeNode> {
var local5:Dictionary = null;
var local6:Vector.<DaeNode> = null;
var local7:DaeNode = null;
var local2:Vector.<DaeNode> = this.findNodes(param1);
var local3:int = 0;
var local4:int = int(local2.length);
if(local4 > 0) {
local5 = new Dictionary();
local3 = 0;
while(local3 < local4) {
local5[local2[local3]] = local3;
local3++;
}
local6 = new Vector.<DaeNode>();
local3 = 0;
while(local3 < local4) {
local7 = local2[local3];
if(this.isRootJointNode(local7,local5)) {
local6.push(local7);
}
local3++;
}
return local6;
}
return null;
}
private function findNode(param1:String, param2:Vector.<DaeNode>) : DaeNode {
var local5:DaeNode = null;
var local3:int = int(param2.length);
var local4:int = 0;
while(local4 < local3) {
local5 = param2[local4].getNodeBySid(param1);
if(local5 != null) {
return local5;
}
local4++;
}
return null;
}
private function findNodes(param1:Vector.<DaeNode>) : Vector.<DaeNode> {
var jointsXML:XML = null;
var jointsSource:DaeSource = null;
var stride:int = 0;
var count:int = 0;
var nodes:Vector.<DaeNode> = null;
var i:int = 0;
var node:DaeNode = null;
var skeletons:Vector.<DaeNode> = param1;
jointsXML = data.skin.joints.input.(@semantic == "JOINT")[0];
if(jointsXML != null) {
jointsSource = document.findSource(jointsXML.@source[0]);
if(jointsSource != null) {
if(jointsSource.parse() && jointsSource.names != null) {
stride = jointsSource.stride;
count = jointsSource.names.length / stride;
nodes = new Vector.<DaeNode>(count);
i = 0;
while(i < count) {
node = this.findNode(jointsSource.names[int(stride * i)],skeletons);
if(node == null) {
}
nodes[i] = node;
i++;
}
return nodes;
}
} else {
document.logger.logNotFoundError(jointsXML.@source[0]);
}
}
return null;
}
}
}
|
package alternativa.tanks.controller.commands {
import alternativa.osgi.service.launcherparams.ILauncherParams;
import alternativa.tanks.controller.events.NavigationEvent;
import alternativa.tanks.model.EntranceUrlParamsModel;
import flash.utils.Dictionary;
import org.robotlegs.mvcs.Command;
import platform.client.fp10.core.service.address.AddressService;
public class ParseUrlParamsCommand extends Command {
[Inject]
public var paramsModel:EntranceUrlParamsModel;
[Inject]
public var launcherParams:ILauncherParams;
[Inject]
public var addressService:AddressService;
public function ParseUrlParamsCommand() {
super();
}
override public function execute() : void {
this.paramsModel.entranceHash = this.parseEntranceHash();
this.paramsModel.singleUseHash = this.parseSingleUseHash();
this.paramsModel.domain = this.addressService != null ? this.addressService.getBaseURL() : "";
this.paramsModel.passedCallsign = this.launcherParams.getParameter("user");
this.paramsModel.passedPassword = this.launcherParams.getParameter("password");
this.paramsModel.emailConfirmHash = this.parseEmailConfirmHash();
this.paramsModel.emailChangeHash = this.parseEmailChangeHash();
this.paramsModel.email = this.parseEmail();
this.paramsModel.referralHash = this.parseReferralHash();
this.paramsModel.tutorialHash = this.parseTutorialHash();
this.paramsModel.changeUidHash = this.parseChangeUidHash();
dispatch(new NavigationEvent(NavigationEvent.GO_TO_STAND_ALONE_CAPTCHA));
}
private function parseChangeUidHash() : String {
var local1:String = this.getAddressParams()["changeUidHash"];
if(local1 == null) {
local1 = this.launcherParams.getParameter("changeUidHash");
}
return local1;
}
private function parseTutorialHash() : String {
var local1:String = this.getAddressParams()["tutorial"];
if(local1 == null) {
local1 = this.launcherParams.getParameter("tutorial");
}
return local1;
}
private function parseReferralHash() : String {
var local1:String = this.getAddressParams()["friend"];
if(local1 == null) {
local1 = this.launcherParams.getParameter("friend");
}
return local1;
}
private function parseEmail() : String {
var local1:String = this.getAddressParams()["userEmail"];
if(local1 == null) {
local1 = this.launcherParams.getParameter("userEmail");
}
return local1;
}
private function parseEntranceHash() : String {
var local1:String = this.getAddressParams()["hash"];
if(local1 == null) {
local1 = this.launcherParams.getParameter("hash");
}
return local1;
}
private function parseSingleUseHash() : String {
var local1:String = this.getAddressParams()["singleUseHash"];
if(local1 == null) {
local1 = this.launcherParams.getParameter("singleUseHash");
}
return local1;
}
private function parseEmailConfirmHash() : String {
var local1:String = this.getAddressParams()["emailConfirmHash"];
if(local1 == null) {
local1 = this.launcherParams.getParameter("emailConfirmHash");
}
return local1;
}
private function parseEmailChangeHash() : String {
var local1:String = this.getAddressParams()["emailChangeHash"];
if(local1 == null) {
local1 = this.launcherParams.getParameter("emailChangeHash");
}
return local1;
}
private function getAddressParams() : Dictionary {
var local2:String = null;
var local3:Array = null;
var local4:int = 0;
var local5:Array = null;
var local1:Dictionary = new Dictionary();
if(this.addressService != null) {
local2 = this.addressService.getValue();
if(local2 != null) {
local3 = local2.split("&");
local4 = 0;
while(local4 < local3.length) {
local5 = (local3[local4] as String).split("=");
local1[local5[0]] = local5[1];
local4++;
}
}
}
return local1;
}
}
}
|
package alternativa
{
import flash.display.MovieClip;
public class Alternativa3D extends MovieClip
{
public static const version:String = "7.8.0";
public function Alternativa3D()
{
super();
}
}
}
|
package projects.tanks.client.battleservice {
import alternativa.types.Long;
import projects.tanks.client.battleservice.model.createparams.BattleLimits;
import projects.tanks.client.battleservice.model.map.params.MapTheme;
public class BattleCreateParameters {
private var _autoBalance:Boolean;
private var _battleMode:BattleMode;
private var _clanBattle:Boolean;
private var _dependentCooldownEnabled:Boolean;
private var _equipmentConstraintsMode:String;
private var _friendlyFire:Boolean;
private var _goldBoxesEnabled:Boolean;
private var _limits:BattleLimits;
private var _mapId:Long;
private var _maxPeopleCount:int;
private var _name:String;
private var _parkourMode:Boolean;
private var _privateBattle:Boolean;
private var _proBattle:Boolean;
private var _rankRange:Range;
private var _reArmorEnabled:Boolean;
private var _theme:MapTheme;
private var _ultimatesEnabled:Boolean;
private var _uniqueUsersBattle:Boolean;
private var _withoutBonuses:Boolean;
private var _withoutDevices:Boolean;
private var _withoutDrones:Boolean;
private var _withoutSupplies:Boolean;
private var _withoutUpgrades:Boolean;
public function BattleCreateParameters(param1:Boolean = false, param2:BattleMode = null, param3:Boolean = false, param4:Boolean = false, param5:String = null, param6:Boolean = false, param7:Boolean = false, param8:BattleLimits = null, param9:Long = null, param10:int = 0, param11:String = null, param12:Boolean = false, param13:Boolean = false, param14:Boolean = false, param15:Range = null, param16:Boolean = false, param17:MapTheme = null, param18:Boolean = false, param19:Boolean = false, param20:Boolean = false, param21:Boolean = false, param22:Boolean = false, param23:Boolean = false, param24:Boolean = false) {
super();
this._autoBalance = param1;
this._battleMode = param2;
this._clanBattle = param3;
this._dependentCooldownEnabled = param4;
this._equipmentConstraintsMode = param5;
this._friendlyFire = param6;
this._goldBoxesEnabled = param7;
this._limits = param8;
this._mapId = param9;
this._maxPeopleCount = param10;
this._name = param11;
this._parkourMode = param12;
this._privateBattle = param13;
this._proBattle = param14;
this._rankRange = param15;
this._reArmorEnabled = param16;
this._theme = param17;
this._ultimatesEnabled = param18;
this._uniqueUsersBattle = param19;
this._withoutBonuses = param20;
this._withoutDevices = param21;
this._withoutDrones = param22;
this._withoutSupplies = param23;
this._withoutUpgrades = param24;
}
public function get autoBalance() : Boolean {
return this._autoBalance;
}
public function set autoBalance(param1:Boolean) : void {
this._autoBalance = param1;
}
public function get battleMode() : BattleMode {
return this._battleMode;
}
public function set battleMode(param1:BattleMode) : void {
this._battleMode = param1;
}
public function get clanBattle() : Boolean {
return this._clanBattle;
}
public function set clanBattle(param1:Boolean) : void {
this._clanBattle = param1;
}
public function get dependentCooldownEnabled() : Boolean {
return this._dependentCooldownEnabled;
}
public function set dependentCooldownEnabled(param1:Boolean) : void {
this._dependentCooldownEnabled = param1;
}
public function get equipmentConstraintsMode() : String {
return this._equipmentConstraintsMode;
}
public function set equipmentConstraintsMode(param1:String) : void {
this._equipmentConstraintsMode = param1;
}
public function get friendlyFire() : Boolean {
return this._friendlyFire;
}
public function set friendlyFire(param1:Boolean) : void {
this._friendlyFire = param1;
}
public function get goldBoxesEnabled() : Boolean {
return this._goldBoxesEnabled;
}
public function set goldBoxesEnabled(param1:Boolean) : void {
this._goldBoxesEnabled = param1;
}
public function get limits() : BattleLimits {
return this._limits;
}
public function set limits(param1:BattleLimits) : void {
this._limits = param1;
}
public function get mapId() : Long {
return this._mapId;
}
public function set mapId(param1:Long) : void {
this._mapId = param1;
}
public function get maxPeopleCount() : int {
return this._maxPeopleCount;
}
public function set maxPeopleCount(param1:int) : void {
this._maxPeopleCount = param1;
}
public function get name() : String {
return this._name;
}
public function set name(param1:String) : void {
this._name = param1;
}
public function get parkourMode() : Boolean {
return this._parkourMode;
}
public function set parkourMode(param1:Boolean) : void {
this._parkourMode = param1;
}
public function get privateBattle() : Boolean {
return this._privateBattle;
}
public function set privateBattle(param1:Boolean) : void {
this._privateBattle = param1;
}
public function get proBattle() : Boolean {
return this._proBattle;
}
public function set proBattle(param1:Boolean) : void {
this._proBattle = param1;
}
public function get rankRange() : Range {
return this._rankRange;
}
public function set rankRange(param1:Range) : void {
this._rankRange = param1;
}
public function get reArmorEnabled() : Boolean {
return this._reArmorEnabled;
}
public function set reArmorEnabled(param1:Boolean) : void {
this._reArmorEnabled = param1;
}
public function get theme() : MapTheme {
return this._theme;
}
public function set theme(param1:MapTheme) : void {
this._theme = param1;
}
public function get ultimatesEnabled() : Boolean {
return this._ultimatesEnabled;
}
public function set ultimatesEnabled(param1:Boolean) : void {
this._ultimatesEnabled = param1;
}
public function get uniqueUsersBattle() : Boolean {
return this._uniqueUsersBattle;
}
public function set uniqueUsersBattle(param1:Boolean) : void {
this._uniqueUsersBattle = param1;
}
public function get withoutBonuses() : Boolean {
return this._withoutBonuses;
}
public function set withoutBonuses(param1:Boolean) : void {
this._withoutBonuses = param1;
}
public function get withoutDevices() : Boolean {
return this._withoutDevices;
}
public function set withoutDevices(param1:Boolean) : void {
this._withoutDevices = param1;
}
public function get withoutDrones() : Boolean {
return this._withoutDrones;
}
public function set withoutDrones(param1:Boolean) : void {
this._withoutDrones = param1;
}
public function get withoutSupplies() : Boolean {
return this._withoutSupplies;
}
public function set withoutSupplies(param1:Boolean) : void {
this._withoutSupplies = param1;
}
public function get withoutUpgrades() : Boolean {
return this._withoutUpgrades;
}
public function set withoutUpgrades(param1:Boolean) : void {
this._withoutUpgrades = param1;
}
public function toString() : String {
var local1:String = "BattleCreateParameters [";
local1 += "autoBalance = " + this.autoBalance + " ";
local1 += "battleMode = " + this.battleMode + " ";
local1 += "clanBattle = " + this.clanBattle + " ";
local1 += "dependentCooldownEnabled = " + this.dependentCooldownEnabled + " ";
local1 += "equipmentConstraintsMode = " + this.equipmentConstraintsMode + " ";
local1 += "friendlyFire = " + this.friendlyFire + " ";
local1 += "goldBoxesEnabled = " + this.goldBoxesEnabled + " ";
local1 += "limits = " + this.limits + " ";
local1 += "mapId = " + this.mapId + " ";
local1 += "maxPeopleCount = " + this.maxPeopleCount + " ";
local1 += "name = " + this.name + " ";
local1 += "parkourMode = " + this.parkourMode + " ";
local1 += "privateBattle = " + this.privateBattle + " ";
local1 += "proBattle = " + this.proBattle + " ";
local1 += "rankRange = " + this.rankRange + " ";
local1 += "reArmorEnabled = " + this.reArmorEnabled + " ";
local1 += "theme = " + this.theme + " ";
local1 += "ultimatesEnabled = " + this.ultimatesEnabled + " ";
local1 += "uniqueUsersBattle = " + this.uniqueUsersBattle + " ";
local1 += "withoutBonuses = " + this.withoutBonuses + " ";
local1 += "withoutDevices = " + this.withoutDevices + " ";
local1 += "withoutDrones = " + this.withoutDrones + " ";
local1 += "withoutSupplies = " + this.withoutSupplies + " ";
local1 += "withoutUpgrades = " + this.withoutUpgrades + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.gui.present.give {
import controls.base.LabelBase;
import flash.events.FocusEvent;
import flash.text.TextField;
import forms.ColorConstants;
public class TypingHintLabel extends LabelBase {
private var input:TextField;
public function TypingHintLabel(param1:TextField) {
super();
this.input = param1;
param1.addEventListener(FocusEvent.FOCUS_IN,this.onFocusIn);
param1.addEventListener(FocusEvent.FOCUS_OUT,this.onFocusOut);
mouseEnabled = false;
color = ColorConstants.LIST_LABEL_HINT;
}
private function onFocusIn(param1:FocusEvent) : void {
visible = false;
}
private function onFocusOut(param1:FocusEvent) : void {
if(this.input.text.length == 0) {
visible = true;
}
}
}
}
|
package controls.base {
import assets.button.button_OFF_CENTER;
import assets.button.button_OFF_LEFT;
import assets.button.button_OFF_RIGHT;
import assets.button.button_blue_DOWN_CENTER;
import assets.button.button_blue_DOWN_LEFT;
import assets.button.button_blue_DOWN_RIGHT;
import assets.button.button_blue_OVER_CENTER;
import assets.button.button_blue_OVER_LEFT;
import assets.button.button_blue_OVER_RIGHT;
import assets.button.button_blue_UP_CENTER;
import assets.button.button_blue_UP_LEFT;
import assets.button.button_blue_UP_RIGHT;
import assets.button.button_def_DOWN_CENTER;
import assets.button.button_def_DOWN_LEFT;
import assets.button.button_def_DOWN_RIGHT;
import assets.button.button_def_OVER_CENTER;
import assets.button.button_def_OVER_LEFT;
import assets.button.button_def_OVER_RIGHT;
import assets.button.button_def_UP_CENTER;
import assets.button.button_def_UP_LEFT;
import assets.button.button_def_UP_RIGHT;
import assets.button.button_red_DOWN_CENTER;
import assets.button.button_red_DOWN_LEFT;
import assets.button.button_red_DOWN_RIGHT;
import assets.button.button_red_OVER_CENTER;
import assets.button.button_red_OVER_LEFT;
import assets.button.button_red_OVER_RIGHT;
import assets.button.button_red_UP_CENTER;
import assets.button.button_red_UP_LEFT;
import assets.button.button_red_UP_RIGHT;
import base.DiscreteMovieClip;
import controls.ButtonState;
import controls.Hint;
import controls.Label;
import flash.display.BitmapData;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.DropShadowFilter;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.text.TextFormatAlign;
import fonts.TanksFontService;
public class TankColorButton extends DiscreteMovieClip {
public static const DEFAULT:String = "def";
public static const RED:String = "red";
public static const BLUE:String = "blue";
public var stateUP:ButtonState = new ButtonState();
public var stateOVER:ButtonState = new ButtonState();
public var stateDOWN:ButtonState = new ButtonState();
public var stateOFF:ButtonState = new ButtonState();
protected var _label:Label = new Label();
protected var _hint:Hint;
public var labelColor:uint = 16777215;
private var format:TextFormat = TanksFontService.getTextFormat(12);
private var _enable:Boolean = true;
private var _width:int;
private var _height:int;
public function TankColorButton() {
super();
this.configUI();
this.enable = true;
tabEnabled = false;
}
public function get label() : String {
return this._label.text;
}
public function set label(param1:String) : void {
this._label.text = param1;
}
public function set hint(param1:String) : void {
if(this._hint != null) {
this._hint.text = param1;
return;
}
this._hint = new Hint();
this._hint.text = param1;
addChild(this._hint);
this._hint.visible = false;
this._hint.y = -this._hint.height;
addEventListener(MouseEvent.MOUSE_OVER,this.showHint);
addEventListener(MouseEvent.MOUSE_OUT,this.hideHint);
}
private function showHint(param1:Event) : void {
this._hint.visible = true;
}
private function hideHint(param1:Event) : void {
this._hint.visible = false;
}
public function set enable(param1:Boolean) : void {
this._enable = param1;
if(this._enable) {
this.addListeners();
} else {
this.removeListeners();
}
}
public function get enable() : Boolean {
return this._enable;
}
override public function set width(param1:Number) : void {
this._width = int(param1);
this.stateDOWN.width = this.stateOFF.width = this.stateOVER.width = this.stateUP.width = this._width;
this._label.width = this._width - 4;
}
override public function get width() : Number {
return this._width;
}
override public function get height() : Number {
return this._height;
}
override public function set height(param1:Number) : void {
this._height = param1;
}
public function configUI() : void {
addChild(this.stateOFF);
addChild(this.stateDOWN);
addChild(this.stateOVER);
addChild(this.stateUP);
addChild(this._label);
this.format.align = TextFormatAlign.CENTER;
this.format.color = this.labelColor;
this._label.embedFonts = TanksFontService.isEmbedFonts();
this._label.align = TextFormatAlign.CENTER;
this._label.autoSize = TextFieldAutoSize.NONE;
this._label.selectable = false;
this._label.x = 2;
this._label.y = 6;
this._label.width = 92;
this._label.height = 22;
this._label.mouseEnabled = false;
this._label.filters = [new DropShadowFilter(1,45,0,0.7,1,1,1)];
}
protected function addListeners() : void {
this.setState(1);
buttonMode = true;
mouseEnabled = true;
mouseChildren = true;
addEventListener(MouseEvent.MOUSE_OVER,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_OUT,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_UP,this.onMouseEvent);
}
protected function removeListeners() : void {
this.setState(0);
buttonMode = false;
mouseEnabled = false;
mouseChildren = false;
removeEventListener(MouseEvent.MOUSE_OVER,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_OUT,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_UP,this.onMouseEvent);
}
protected function onMouseEvent(param1:MouseEvent) : void {
if(this._enable) {
switch(param1.type) {
case MouseEvent.MOUSE_OVER:
this.setState(2);
this._label.y = 6;
break;
case MouseEvent.MOUSE_OUT:
this.setState(1);
this._label.y = 6;
break;
case MouseEvent.MOUSE_DOWN:
this.setState(3);
this._label.y = 7;
break;
case MouseEvent.MOUSE_UP:
this.setState(1);
this._label.y = 6;
}
}
}
protected function setState(param1:int = 0) : void {
switch(param1) {
case 0:
this.stateOFF.alpha = 1;
this.stateUP.alpha = 0;
this.stateOVER.alpha = 0;
this.stateDOWN.alpha = 0;
break;
case 1:
this.stateOFF.alpha = 0;
this.stateUP.alpha = 1;
this.stateOVER.alpha = 0;
this.stateDOWN.alpha = 0;
break;
case 2:
this.stateOFF.alpha = 0;
this.stateUP.alpha = 0;
this.stateOVER.alpha = 1;
this.stateDOWN.alpha = 0;
break;
case 3:
this.stateOFF.alpha = 0;
this.stateUP.alpha = 0;
this.stateOVER.alpha = 0;
this.stateDOWN.alpha = 1;
}
}
public function setStyle(param1:String = "def") : void {
var local3:String = null;
var local2:String = "button_" + param1 + "_";
local3 = "UP";
this.stateUP.bmpLeft = this.getBitmapByName(local2 + local3 + "_LEFT");
this.stateUP.bmpCenter = this.getBitmapByName(local2 + local3 + "_CENTER");
this.stateUP.bmpRight = this.getBitmapByName(local2 + local3 + "_RIGHT");
local3 = "OVER";
this.stateOVER.bmpLeft = this.getBitmapByName(local2 + local3 + "_LEFT");
this.stateOVER.bmpCenter = this.getBitmapByName(local2 + local3 + "_CENTER");
this.stateOVER.bmpRight = this.getBitmapByName(local2 + local3 + "_RIGHT");
local3 = "DOWN";
this.stateDOWN.bmpLeft = this.getBitmapByName(local2 + local3 + "_LEFT");
this.stateDOWN.bmpCenter = this.getBitmapByName(local2 + local3 + "_CENTER");
this.stateDOWN.bmpRight = this.getBitmapByName(local2 + local3 + "_RIGHT");
local3 = "OFF";
local2 = "button_";
this.stateOFF.bmpLeft = this.getBitmapByName(local2 + local3 + "_LEFT");
this.stateOFF.bmpCenter = this.getBitmapByName(local2 + local3 + "_CENTER");
this.stateOFF.bmpRight = this.getBitmapByName(local2 + local3 + "_RIGHT");
this.width = 96;
}
private function getBitmapByName(param1:String) : BitmapData {
var local2:BitmapData = new BitmapData(1,1);
switch(param1) {
case "button_def_UP_LEFT":
local2 = new button_def_UP_LEFT(1,1);
break;
case "button_def_UP_CENTER":
local2 = new button_def_UP_CENTER(1,1);
break;
case "button_def_UP_RIGHT":
local2 = new button_def_UP_RIGHT(1,1);
break;
case "button_def_OVER_LEFT":
local2 = new button_def_OVER_LEFT(1,1);
break;
case "button_def_OVER_CENTER":
local2 = new button_def_OVER_CENTER(1,1);
break;
case "button_def_OVER_RIGHT":
local2 = new button_def_OVER_RIGHT(1,1);
break;
case "button_def_DOWN_LEFT":
local2 = new button_def_DOWN_LEFT(1,1);
break;
case "button_def_DOWN_CENTER":
local2 = new button_def_DOWN_CENTER(1,1);
break;
case "button_def_DOWN_RIGHT":
local2 = new button_def_DOWN_RIGHT(1,1);
break;
case "button_red_UP_LEFT":
local2 = new button_red_UP_LEFT(1,1);
break;
case "button_red_UP_CENTER":
local2 = new button_red_UP_CENTER(1,1);
break;
case "button_red_UP_RIGHT":
local2 = new button_red_UP_RIGHT(1,1);
break;
case "button_red_OVER_LEFT":
local2 = new button_red_OVER_LEFT(1,1);
break;
case "button_red_OVER_CENTER":
local2 = new button_red_OVER_CENTER(1,1);
break;
case "button_red_OVER_RIGHT":
local2 = new button_red_OVER_RIGHT(1,1);
break;
case "button_red_DOWN_LEFT":
local2 = new button_red_DOWN_LEFT(1,1);
break;
case "button_red_DOWN_CENTER":
local2 = new button_red_DOWN_CENTER(1,1);
break;
case "button_red_DOWN_RIGHT":
local2 = new button_red_DOWN_RIGHT(1,1);
break;
case "button_blue_UP_LEFT":
local2 = new button_blue_UP_LEFT(1,1);
break;
case "button_blue_UP_CENTER":
local2 = new button_blue_UP_CENTER(1,1);
break;
case "button_blue_UP_RIGHT":
local2 = new button_blue_UP_RIGHT(1,1);
break;
case "button_blue_OVER_LEFT":
local2 = new button_blue_OVER_LEFT(1,1);
break;
case "button_blue_OVER_CENTER":
local2 = new button_blue_OVER_CENTER(1,1);
break;
case "button_blue_OVER_RIGHT":
local2 = new button_blue_OVER_RIGHT(1,1);
break;
case "button_blue_DOWN_LEFT":
local2 = new button_blue_DOWN_LEFT(1,1);
break;
case "button_blue_DOWN_CENTER":
local2 = new button_blue_DOWN_CENTER(1,1);
break;
case "button_blue_DOWN_RIGHT":
local2 = new button_blue_DOWN_RIGHT(1,1);
break;
case "button_OFF_LEFT":
local2 = new button_OFF_LEFT(1,1);
break;
case "button_OFF_CENTER":
local2 = new button_OFF_CENTER(1,1);
break;
case "button_OFF_RIGHT":
local2 = new button_OFF_RIGHT(1,1);
}
return local2;
}
}
}
|
package alternativa.tanks.battle.triggers {
import alternativa.tanks.battle.DeferredAction;
import alternativa.tanks.battle.Trigger;
public class DeferredTriggerAddition implements DeferredAction {
private var triggers:Triggers;
private var trigger:Trigger;
public function DeferredTriggerAddition(param1:Triggers, param2:Trigger) {
super();
this.triggers = param1;
this.trigger = param2;
}
public function execute() : void {
this.triggers.add(this.trigger);
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _a525350bdeb0ac85606c3f1b5024cec954d64a9584cdf6315fc200a9b6e54f76_flash_display_Sprite extends Sprite {
public function _a525350bdeb0ac85606c3f1b5024cec954d64a9584cdf6315fc200a9b6e54f76_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.model.friends.loader {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.gui.friends.FriendsWindow;
import alternativa.tanks.gui.friends.FriendsWindowState;
import forms.events.MainButtonBarEvents;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.panel.model.friends.FriendsLoaderModelBase;
import projects.tanks.client.panel.model.friends.IFriendsLoaderModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.model.IFriends;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendInfoService;
import services.buttonbar.IButtonBarService;
[ModelInfo]
public class FriendsLoaderModel extends FriendsLoaderModelBase implements IFriendsLoaderModelBase, ObjectLoadPostListener, ObjectUnloadListener {
[Inject]
public static var display:IDisplay;
[Inject]
public static var friendInfoService:IFriendInfoService;
[Inject]
public static var buttonBarService:IButtonBarService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
private var friendsWindow:FriendsWindow;
public function FriendsLoaderModel() {
super();
}
public function objectLoadedPost() : void {
if(!IFriends(object.adapt(IFriends)).isLocal()) {
return;
}
if(this.friendsWindow == null) {
this.friendsWindow = new FriendsWindow();
}
clanUserInfoService.updateFriendsClanButtonFunction = this.friendsWindow.updateClanButton;
buttonBarService.addEventListener(MainButtonBarEvents.PANEL_BUTTON_PRESSED,getFunctionWrapper(this.onButtonBarButtonClick));
}
private function onButtonBarButtonClick(param1:MainButtonBarEvents) : void {
if(param1.typeButton == MainButtonBarEvents.FRIENDS) {
server.show();
}
}
public function objectUnloaded() : void {
if(!IFriends(object.adapt(IFriends)).isLocal()) {
return;
}
if(this.friendsWindow != null) {
this.friendsWindow.destroy();
this.friendsWindow = null;
}
buttonBarService.removeEventListener(MainButtonBarEvents.PANEL_BUTTON_PRESSED,getFunctionWrapper(this.onButtonBarButtonClick));
}
public function onUsersLoaded() : void {
if(friendInfoService.newIncomingFriendsLength > 0) {
this.friendsWindow.show(FriendsWindowState.INCOMING);
} else {
this.friendsWindow.show(FriendsWindowState.ACCEPTED);
}
}
}
}
|
package alternativa.tanks.utils {
import alternativa.tanks.utils.thirdparty.URI;
public class LinksInterceptor {
private var _linkRegexp:RegExp = /(https?:\/\/|www\.)((([\w-\.]+)\.([a-z]{2,6}\.?))|(([а-я-\.]+)\.(рф\.?)))(\/[\w\.]*)*\/?([^\s\n]+)?/gi;
private var _linkRegexpExtra:RegExp = new RegExp(this._linkRegexp);
private var _linkRegexpAddon:RegExp = /[\[\]\{\}\|\*\(\)\@\$\^\'`~+№!]/gi;
private var _allowedDomains:Vector.<String>;
public var htmlFlag:Boolean = false;
public function LinksInterceptor(param1:Vector.<String>) {
super();
this._allowedDomains = param1;
}
public function checkLinks(param1:String) : String {
var local5:String = null;
var local6:URI = null;
this._linkRegexp.lastIndex = 0;
var local2:String = "";
var local3:Array = this._linkRegexp.exec(param1);
var local4:int = 0;
this.htmlFlag = false;
while(local3 != null) {
local2 += param1.substr(local4,local3.index - local4);
local5 = param1.substr(local3.index,this._linkRegexp.lastIndex - local3.index);
local6 = this.createUri(local5);
if(!this.existsUrlInQuery(local6) && local5.indexOf("*") == -1) {
local2 += " <u><a href=\'event:" + local6 + "\'>" + local5 + "</a></u> ";
this.htmlFlag = true;
} else {
local2 += local5;
}
local4 = this._linkRegexp.lastIndex;
local3 = this._linkRegexp.exec(param1);
}
return local2 + param1.substr(this._linkRegexp.lastIndex == 0 ? local4 : this._linkRegexp.lastIndex);
}
public function isInWhiteList(param1:String) : Boolean {
var local2:URI = this.createUri(param1);
var local3:String = local2.authority;
return this._allowedDomains.indexOf(local3) != -1 && !this.existsUrlInQuery(local2);
}
private function createUri(param1:String) : URI {
return new URI(param1.search(/^https?:\/\//i) == -1 ? "http://" + param1 : param1);
}
private function existsUrlInQuery(param1:URI) : Boolean {
this._linkRegexpExtra.lastIndex = 0;
if(this._linkRegexpExtra.exec(param1.queryRaw) != null) {
return true;
}
this._linkRegexpAddon.lastIndex = 0;
if(this._linkRegexpAddon.exec(param1.path) != null) {
return true;
}
this._linkRegexpAddon.lastIndex = 0;
if(this._linkRegexpAddon.exec(param1.fragment) != null) {
return true;
}
return false;
}
}
}
|
package alternativa.tanks.models.weapon.smoky {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.WeaponForces;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class RemoteSmokyWeapon implements Weapon {
private static const gunParams:AllGlobalGunParams = new AllGlobalGunParams();
private var weaponForces:WeaponForces;
private var effects:ISmokyEffects;
private var weaponPlatform:WeaponPlatform;
public function RemoteSmokyWeapon(param1:WeaponForces, param2:ISmokyEffects) {
super();
this.weaponForces = param1;
this.effects = param2;
}
public function init(param1:WeaponPlatform) : void {
this.weaponPlatform = param1;
}
public function destroy() : void {
}
public function activate() : void {
}
public function deactivate() : void {
}
public function enable() : void {
}
public function disable(param1:Boolean) : void {
}
public function reset() : void {
}
public function getStatus() : Number {
return 0;
}
public function simulateShot() : void {
this.weaponPlatform.getAllGunParams(gunParams);
this.createShotEffects(gunParams);
}
public function simulateStaticShot(param1:Vector3) : void {
this.weaponPlatform.getAllGunParams(gunParams);
this.createShotEffects(gunParams);
this.effects.createExplosionMark(gunParams.barrelOrigin,param1);
this.effects.createExplosionEffects(param1);
}
public function simulateTargetShot(param1:Tank, param2:Vector3, param3:Number, param4:Boolean) : void {
this.weaponPlatform.getAllGunParams(gunParams);
this.createShotEffects(gunParams);
var local5:Vector3 = param2.clone().subtract(gunParams.muzzlePosition).normalize();
param1.applyWeaponHit(param2,local5,param3 * this.weaponForces.getImpactForce());
this.effects.createExplosionEffects(param2);
if(param4) {
this.effects.createCriticalHitEffects(param1.getBody().state.position);
}
}
private function createShotEffects(param1:AllGlobalGunParams) : void {
this.weaponPlatform.getBody().addWorldForceScaled(param1.muzzlePosition,param1.direction,-this.weaponForces.getRecoilForce());
this.weaponPlatform.addDust();
this.effects.createShotEffects(this.weaponPlatform.getLocalMuzzlePosition(),this.weaponPlatform.getTurret3D());
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.SMOKY_RESISTANCE;
}
public function updateRecoilForce(param1:Number) : void {
this.weaponForces.setRecoilForce(param1);
}
public function fullyRecharge() : void {
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
}
public function stun() : void {
}
public function calm(param1:int) : void {
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.facilities.facillity {
public class FacilitySphericalZoneCC {
private var _centerOffsetZ:Number;
private var _radius:Number;
public function FacilitySphericalZoneCC(param1:Number = 0, param2:Number = 0) {
super();
this._centerOffsetZ = param1;
this._radius = param2;
}
public function get centerOffsetZ() : Number {
return this._centerOffsetZ;
}
public function set centerOffsetZ(param1:Number) : void {
this._centerOffsetZ = param1;
}
public function get radius() : Number {
return this._radius;
}
public function set radius(param1:Number) : void {
this._radius = param1;
}
public function toString() : String {
var local1:String = "FacilitySphericalZoneCC [";
local1 += "centerOffsetZ = " + this.centerOffsetZ + " ";
local1 += "radius = " + this.radius + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.clients.flash.commons.services.stagequality {
public interface IStageQualityService {
}
}
|
package alternativa.tanks.gui.selectcountry {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.service.country.CountryService;
import controls.TankWindow;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.dropdownlist.DropDownList;
import flash.events.MouseEvent;
import projects.tanks.client.panel.model.usercountry.CountryInfo;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.IDialogsService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
public class SelectCountryAlert extends DialogWindow {
[Inject]
public static var countryService:CountryService;
[Inject]
public static var dialogService:IDialogsService;
[Inject]
public static var localeService:ILocaleService;
private const TOP_PADDING:int = 20;
private var okButton:DefaultButtonBase;
private var chooseCountryComboBox:DropDownList;
private var countrySelectedCallback:Function;
public function SelectCountryAlert(param1:Function) {
var local4:LabelBase = null;
super();
this.countrySelectedCallback = param1;
var local2:TankWindow = new TankWindow(340,140);
addChild(local2);
this.okButton = new DefaultButtonBase();
this.okButton.label = localeService.getText(TanksLocale.TEXT_ALERT_ANSWER_OK);
this.okButton.x = (width - this.okButton.width) / 2;
this.okButton.y = local2.height - this.okButton.height - 20;
this.okButton.addEventListener(MouseEvent.CLICK,this.onClick);
addChild(this.okButton);
var local3:LabelBase = new LabelBase();
local3.text = localeService.getText(TanksLocale.TEXT_CHECK_YOU_LOCATION_TEXT);
local3.x = this.TOP_PADDING;
local3.y = this.TOP_PADDING + 5;
addChild(local3);
local4 = new LabelBase();
local4.text = localeService.getText(TanksLocale.TEXT_YOURE_LOCATION_TEXT);
local4.x = this.TOP_PADDING;
local4.y = 55;
local4.width = 300;
local4.wordWrap = true;
addChild(local4);
this.chooseCountryComboBox = new DropDownList();
this.chooseCountryComboBox.width = local2.width - 45 - local3.width;
this.chooseCountryComboBox.y = this.TOP_PADDING;
this.initCountries();
addChild(this.chooseCountryComboBox);
this.chooseCountryComboBox.x = local3.x + local3.width + 5;
dialogService.addDialog(this);
}
private function initCountries() : void {
var local1:Vector.<CountryInfo> = countryService.getRegisteredCountries();
var local2:int = 0;
while(local2 < local1.length) {
this.chooseCountryComboBox.addItem({
"rang":0,
"index":local2,
"id":local2,
"gameName":local1[local2].countryName,
"code":local1[local2].countryCode
});
local2++;
}
this.chooseCountryComboBox.sortOn("gameName");
if(Boolean(countryService.getDefaultCountryCode())) {
this.chooseCountryComboBox.selectItemByField("code",countryService.getDefaultCountryCode());
} else {
this.chooseCountryComboBox.selectItemByField("id",0);
}
}
private function onClick(param1:MouseEvent) : void {
dialogService.removeDialog(this);
this.countrySelectedCallback(this.chooseCountryComboBox.selectedItem["code"]);
this.destroyWindow();
}
private function destroyWindow() : void {
this.okButton.removeEventListener(MouseEvent.CLICK,this.onClick);
this.countrySelectedCallback = null;
this.okButton = null;
this.chooseCountryComboBox = null;
}
}
}
|
package alternativa.tanks.servermodels {
public interface IEntranceStateSwitcher {
function goToRegistarationState(param1:ILeavableEntranceState) : void;
function goToLoginByHashState() : void;
function goToLoginState(param1:ILeavableEntranceState) : void;
}
}
|
package projects.tanks.clients.flash.commons.services.externalauth {
import flash.utils.Dictionary;
public class ExternalAuthParamsServiceImpl implements ExternalAuthParamsService {
private static const params:* = new Dictionary();
public function ExternalAuthParamsServiceImpl() {
super();
}
public function setParam(param1:String, param2:String) : * {
params[param1] = param2;
}
}
}
|
package projects.tanks.client.battleselect.model.matchmaking.grouplifecycle.invite {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class MatchmakingGroupInviteModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:MatchmakingGroupInviteModelServer;
private var client:IMatchmakingGroupInviteModelBase = IMatchmakingGroupInviteModelBase(this);
private var modelId:Long = Long.getLong(1554280211,1562501796);
private var _acceptedId:Long = Long.getLong(1122035593,599020768);
private var _accepted_userCodec:ICodec;
private var _rejectInvitationToGroupDisabledId:Long = Long.getLong(490134730,1080398833);
private var _rejectInvitationToGroupDisabled_userCodec:ICodec;
private var _rejectUserAlreadyInGroupId:Long = Long.getLong(473112343,1371826939);
private var _rejectUserAlreadyInGroup_userCodec:ICodec;
private var _rejectUserOfflineId:Long = Long.getLong(374808837,1597389024);
private var _rejectUserOffline_userCodec:ICodec;
private var _rejectedId:Long = Long.getLong(1122035483,-939007991);
private var _rejected_userCodec:ICodec;
private var _sendInviteId:Long = Long.getLong(239302436,-1286419946);
private var _sendInvite_leaderCodec:ICodec;
public function MatchmakingGroupInviteModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new MatchmakingGroupInviteModelServer(IModel(this));
this._accepted_userCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._rejectInvitationToGroupDisabled_userCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._rejectUserAlreadyInGroup_userCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._rejectUserOffline_userCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._rejected_userCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._sendInvite_leaderCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._acceptedId:
this.client.accepted(Long(this._accepted_userCodec.decode(param2)));
break;
case this._rejectInvitationToGroupDisabledId:
this.client.rejectInvitationToGroupDisabled(Long(this._rejectInvitationToGroupDisabled_userCodec.decode(param2)));
break;
case this._rejectUserAlreadyInGroupId:
this.client.rejectUserAlreadyInGroup(Long(this._rejectUserAlreadyInGroup_userCodec.decode(param2)));
break;
case this._rejectUserOfflineId:
this.client.rejectUserOffline(Long(this._rejectUserOffline_userCodec.decode(param2)));
break;
case this._rejectedId:
this.client.rejected(Long(this._rejected_userCodec.decode(param2)));
break;
case this._sendInviteId:
this.client.sendInvite(Long(this._sendInvite_leaderCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.panel.model.quest.daily {
public class DailyQuestShowingCC {
private var _hasNewQuests:Boolean;
private var _timeToNextQuest:int;
public function DailyQuestShowingCC(param1:Boolean = false, param2:int = 0) {
super();
this._hasNewQuests = param1;
this._timeToNextQuest = param2;
}
public function get hasNewQuests() : Boolean {
return this._hasNewQuests;
}
public function set hasNewQuests(param1:Boolean) : void {
this._hasNewQuests = param1;
}
public function get timeToNextQuest() : int {
return this._timeToNextQuest;
}
public function set timeToNextQuest(param1:int) : void {
this._timeToNextQuest = param1;
}
public function toString() : String {
var local1:String = "DailyQuestShowingCC [";
local1 += "hasNewQuests = " + this.hasNewQuests + " ";
local1 += "timeToNextQuest = " + this.timeToNextQuest + " ";
return local1 + "]";
}
}
}
|
package _codec.projects.tanks.client.panel.model.videoads {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.videoads.VideoAdsModelCC;
public class CodecVideoAdsModelCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_enable:ICodec;
public function CodecVideoAdsModelCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_enable = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:VideoAdsModelCC = new VideoAdsModelCC();
local2.enable = this.codec_enable.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:VideoAdsModelCC = VideoAdsModelCC(param2);
this.codec_enable.encode(param1,local3.enable);
}
}
}
|
package alternativa.tanks.model.item.countable {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ICountableItemEvents implements ICountableItem {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ICountableItemEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getCount() : int {
var result:int = 0;
var i:int = 0;
var m:ICountableItem = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ICountableItem(this.impl[i]);
result = int(m.getCount());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function setCount(param1:int) : void {
var i:int = 0;
var m:ICountableItem = null;
var value:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ICountableItem(this.impl[i]);
m.setCount(value);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.model.item.upgradable.calculators {
import alternativa.tanks.service.itempropertyparams.ItemPropertyParams;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParamsService;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
import projects.tanks.client.garage.models.item.upgradeable.types.GaragePropertyParams;
import projects.tanks.client.garage.models.item.upgradeable.types.PropertyData;
public class CriticalChanceCalculator extends BasePropertyCalculator implements PropertyCalculator, PropertyValueCalculator {
[Inject]
public static var propertyParamsService:ItemPropertyParamsService;
private var afterCrit:LinearPropertyValueCalculator;
private var deltaCrit:LinearPropertyValueCalculator;
private var maxCrit:LinearPropertyValueCalculator;
private var data:GaragePropertyParams;
private var multiplier:Number;
public function CriticalChanceCalculator(param1:int, param2:GaragePropertyParams) {
this.data = param2;
var local3:ItemPropertyParams = propertyParamsService.getParams(param2.property);
this.multiplier = local3.getMultiplier();
this.afterCrit = this.createPropertyCalculator(ItemProperty.AFTER_CRIT_CRITICAL_HIT_CHANCE,param1);
this.deltaCrit = this.createPropertyCalculator(ItemProperty.CRITICAL_CHANCE_DELTA,param1);
this.maxCrit = this.createPropertyCalculator(ItemProperty.MAX_CRITICAL_HIT_CHANCE,param1);
super(param2.precision,this);
}
override public function getNumberValue(param1:int) : Number {
return this.calculate(param1);
}
private function calculate(param1:int) : Number {
var local8:Number = NaN;
var local9:Number = NaN;
var local2:Number = this.afterCrit.getNumberValue(param1);
var local3:Number = this.deltaCrit.getNumberValue(param1);
var local4:Number = this.maxCrit.getNumberValue(param1);
var local5:Number = 0;
var local6:Number = 1;
var local7:int = 1;
while(true) {
if(local2 > local4) {
local5 += local6 * (local7 - 1 + 1 / local4);
break;
}
local9 = Math.max(local2,0);
local5 += local6 * local9 * local7;
local6 *= 1 - local9;
local2 += local3;
local7++;
}
local8 = 1 / local5;
return local8 * this.multiplier;
}
private function createPropertyCalculator(param1:ItemProperty, param2:int) : LinearPropertyValueCalculator {
var local3:PropertyData = this.getPropertyData(param1);
return new LinearPropertyValueCalculator(local3.initialValue,local3.finalValue,param2);
}
private function getPropertyData(param1:ItemProperty) : PropertyData {
var local2:PropertyData = null;
for each(local2 in this.data.properties) {
if(local2.property == param1) {
return local2;
}
}
throw new PropertyNotFoundError(param1);
}
}
}
|
package alternativa.tanks.models.weapon.healing {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IHealingGunSFXModelEvents implements IHealingGunSFXModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IHealingGunSFXModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getHealingGunEffects() : HealingGunEffects {
var result:HealingGunEffects = null;
var i:int = 0;
var m:IHealingGunSFXModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IHealingGunSFXModel(this.impl[i]);
result = m.getHealingGunEffects();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.shoot.shaft {
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 ShaftShootSFXModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ShaftShootSFXModelServer;
private var client:IShaftShootSFXModelBase = IShaftShootSFXModelBase(this);
private var modelId:Long = Long.getLong(2117558336,-406639565);
public function ShaftShootSFXModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ShaftShootSFXModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ShaftShootSFXCC,false)));
}
protected function getInitParam() : ShaftShootSFXCC {
return ShaftShootSFXCC(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 assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_def_ACTIVE_CENTER.png")]
public dynamic class button_def_ACTIVE_CENTER extends BitmapData {
public function button_def_ACTIVE_CENTER(param1:int = 18, param2:int = 29) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.display.usertitle {
import flash.display.Graphics;
import flash.display.Shape;
import flash.display.Sprite;
import flash.filters.BitmapFilterQuality;
import flash.filters.GlowFilter;
public class RadialBar extends Sprite {
private const SEGMENTS_COUNT:int = 45;
private var canvas:Shape = new Shape();
private var value:Number;
private var color:uint;
private var backColor:uint;
private var radius:int;
private var thickness:Number;
private var mirrored:Boolean;
public function RadialBar(param1:uint, param2:uint, param3:int, param4:Number, param5:Boolean = false) {
super();
this.color = param1;
this.backColor = param2;
this.radius = param3;
this.thickness = param4;
this.mirrored = param5;
this.canvas.filters = [new GlowFilter(0,0.6,3,3,2,BitmapFilterQuality.HIGH)];
addChild(this.canvas);
}
public function setValue(param1:Number) : void {
this.value = Math.max(0,Math.min(1,param1));
this.draw();
}
public function draw() : void {
var local3:int = 0;
var local4:Number = NaN;
var local1:Graphics = this.canvas.graphics;
local1.clear();
local1.moveTo(0,0 - this.radius);
var local2:int = this.SEGMENTS_COUNT * this.value;
local1.moveTo(0,0 - this.radius);
local1.lineStyle(this.thickness,this.backColor);
local3 = this.SEGMENTS_COUNT;
while(local3 >= 0) {
local4 = local3 * 2 * Math.PI / 180;
if(local3 == local2 - 1) {
local1.lineStyle(this.thickness,this.color);
}
local1.lineTo(0 - Math.cos(local4) * this.radius * (this.mirrored ? -1 : 1),0 - Math.sin(local4) * this.radius);
local3--;
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.presents {
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.presents.PresentsSettingsCC;
public class VectorCodecPresentsSettingsCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecPresentsSettingsCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(PresentsSettingsCC,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.<PresentsSettingsCC> = new Vector.<PresentsSettingsCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = PresentsSettingsCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:PresentsSettingsCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<PresentsSettingsCC> = Vector.<PresentsSettingsCC>(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.tank.rankup {
[ModelInterface]
public interface ITankRankUpEffectModel {
function showRankUpEffect(param1:int) : void;
}
}
|
package forms.buttons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class MainPanelSocialNetsButton_normalBtn extends BitmapAsset
{
public function MainPanelSocialNetsButton_normalBtn()
{
super();
}
}
}
|
package projects.tanks.clients.tankslauncershared.dishonestprogressbar {
import mx.core.BitmapAsset;
[Embed(source="/_assets/projects.tanks.clients.tankslauncershared.dishonestprogressbar.DishonestProgressBar_progressLineClass.jpg")]
public class DishonestProgressBar_progressLineClass extends BitmapAsset {
public function DishonestProgressBar_progressLineClass() {
super();
}
}
}
|
package mx.core
{
import flash.utils.ByteArray;
use namespace mx_internal;
public class ByteArrayAsset extends ByteArray implements IFlexAsset
{
mx_internal static const VERSION:String = "4.6.0.23201";
public function ByteArrayAsset()
{
super();
}
}
}
|
package projects.tanks.client.garage.models.item.item {
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 ItemModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ItemModelServer;
private var client:IItemModelBase = IItemModelBase(this);
private var modelId:Long = Long.getLong(800589377,840038407);
public function ItemModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ItemModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ItemModelCC,false)));
}
protected function getInitParam() : ItemModelCC {
return ItemModelCC(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 forms
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
import controls.Label;
import controls.statassets.BlackRoundRect;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.text.TextFormatAlign;
import flash.utils.Timer;
public class ChangeTeamAlert extends Sprite
{
public static const RED:int = 0;
public static const BLUE:int = 1;
private const PADDING:int = 15;
private var bg:BlackRoundRect;
private var label:Label;
private var countDown:int = 0;
private var countDownTimer:Timer;
public function ChangeTeamAlert(time:int, team:int = 0)
{
this.bg = new BlackRoundRect();
this.label = new Label();
super();
var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
var colorName:String = team == RED ? localeService.getText(TextConst.BATTLE_TEAM_RED) : localeService.getText(TextConst.BATTLE_TEAM_BLUE);
this.label.align = TextFormatAlign.CENTER;
this.label.size = 14;
this.label.bold = true;
this.label.htmlText = "<font color=" + (team == RED ? "\"#ff9999\">" : "\"#99ccff\">") + localeService.getText(TextConst.BATTLE_TEAM_ALERT,colorName) + "</font>";
addChild(this.bg);
addChild(this.label);
this.label.x = this.PADDING;
this.label.y = this.PADDING;
this.bg.width = this.label.width + this.PADDING * 2;
this.bg.height = this.label.height + this.PADDING * 2;
this.countDown = time;
this.showCountDown();
addEventListener(MouseEvent.CLICK,this.hide);
}
public function hide(e:Event = null) : void
{
if(this.parent != null)
{
this.parent.removeChild(this);
removeEventListener(MouseEvent.CLICK,this.hide);
}
}
private function showCountDown() : void
{
this.countDownTimer = new Timer(1000);
this.countDownTimer.addEventListener(TimerEvent.TIMER,this.showCountDownTick);
this.countDownTimer.start();
this.showCountDownTick();
}
private function showCountDownTick(e:TimerEvent = null) : void
{
--this.countDown;
if(this.countDown < 0)
{
this.countDownTimer.removeEventListener(TimerEvent.TIMER,this.showCountDownTick);
this.countDownTimer.stop();
this.hide();
}
}
}
}
|
package alternativa.tanks.utils {
public class IntUtil {
private static var hexChars:String = "0123456789abcdef";
public function IntUtil() {
super();
}
public static function rol(param1:int, param2:int) : int {
return param1 << param2 | param1 >>> 32 - param2;
}
public static function ror(param1:int, param2:int) : uint {
var local3:int = 32 - param2;
return param1 << local3 | param1 >>> 32 - local3;
}
public static function toHex(param1:int, param2:Boolean = false) : String {
var local4:int = 0;
var local5:int = 0;
var local3:String = "";
if(param2) {
local4 = 0;
while(local4 < 4) {
local3 += hexChars.charAt(param1 >> (3 - local4) * 8 + 4 & 0x0F) + hexChars.charAt(param1 >> (3 - local4) * 8 & 0x0F);
local4++;
}
} else {
local5 = 0;
while(local5 < 4) {
local3 += hexChars.charAt(param1 >> local5 * 8 + 4 & 0x0F) + hexChars.charAt(param1 >> local5 * 8 & 0x0F);
local5++;
}
}
return local3;
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.bigbutton_OVER_LEFT.png")]
public dynamic class bigbutton_OVER_LEFT extends BitmapData {
public function bigbutton_OVER_LEFT(param1:int = 7, param2:int = 50) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.display.usertitle {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.display.usertitle.EffectIndicator_iconArmorCls.png")]
public class EffectIndicator_iconArmorCls extends BitmapAsset {
public function EffectIndicator_iconArmorCls() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.terminator.state {
import alternativa.tanks.models.weapon.rocketlauncher.weapon.RocketLauncherWeaponState;
import alternativa.tanks.models.weapon.terminator.ITerminatorWeapon;
import flash.utils.getTimer;
public class PrimaryShotState implements RocketLauncherWeaponState {
private static const SWITCH_INTERVAL:int = 200;
private var weapon:ITerminatorWeapon;
private var switchStateTime:int;
private var reloadTime:int;
private var chargeTime:int;
private var chargingTrigger:Boolean = false;
public function PrimaryShotState(param1:ITerminatorWeapon, param2:int, param3:int) {
super();
this.weapon = param1;
this.reloadTime = param2;
this.chargeTime = param3;
}
public function getStatus() : Number {
if(this.chargingTrigger) {
return (this.weapon.getPrimaryNextChargeTime() - getTimer()) / this.chargeTime;
}
return 1 - (this.weapon.getPrimaryNextShotTime() - this.chargeTime - getTimer()) / this.reloadTime;
}
public function update(param1:int) : void {
if(Boolean(this.weapon.isShooting()) && param1 >= this.weapon.getPrimaryNextShotTime() && param1 >= this.switchStateTime) {
this.weapon.switchToSecondaryState(param1);
}
if(this.chargingTrigger && param1 >= this.weapon.getPrimaryNextChargeTime()) {
this.weapon.shootPrimary(param1);
this.chargingTrigger = false;
}
}
public function start(param1:int) : void {
this.switchStateTime = param1 + SWITCH_INTERVAL;
}
public function stop(param1:int) : void {
if(!this.chargingTrigger && param1 >= this.weapon.getPrimaryNextShotTime() - this.chargeTime && param1 < this.switchStateTime) {
this.chargingTrigger = true;
this.weapon.startCharging(param1);
}
}
[Obfuscation(rename="false")]
public function close() : void {
this.weapon = null;
}
public function getReloadTime() : int {
return 0;
}
public function stopCharging() : void {
this.chargingTrigger = false;
}
public function resetNextShotTime() : void {
this.weapon.resetPrimaryNextShotTime();
}
public function weaponStunned(param1:int) : void {
}
public function isCharging() : Boolean {
return this.chargingTrigger;
}
}
}
|
package alternativa.tanks.model.coin {
import flash.events.EventDispatcher;
public class CoinInfoServiceImpl extends EventDispatcher implements CoinInfoService {
private var coins:int;
private var _enabled:Boolean;
public function CoinInfoServiceImpl() {
super();
}
public function getCoins() : int {
return this.coins;
}
public function setCoins(param1:int) : void {
if(this.coins != param1) {
this.coins = param1;
dispatchEvent(new CoinsChangedEvent(param1));
}
}
public function changeBy(param1:int) : void {
var local2:int = Math.max(this.coins + param1,0);
this.setCoins(local2);
}
public function get enabled() : Boolean {
return this._enabled;
}
public function set enabled(param1:Boolean) : void {
this._enabled = param1;
}
}
}
|
package alternativa.tanks.model.item3d {
import platform.client.fp10.core.registry.ResourceRegistry;
import projects.tanks.client.garage.models.item.object3ds.IObject3DSModelBase;
import projects.tanks.client.garage.models.item.object3ds.Object3DSModelBase;
import projects.tanks.clients.flash.resources.object3ds.IObject3DS;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
[ModelInfo]
public class Object3DSModel extends Object3DSModelBase implements IObject3DSModelBase, IObject3DS {
[Inject]
public static var resourceRegistry:ResourceRegistry;
public function Object3DSModel() {
super();
}
public function getResource3DS() : Tanks3DSResource {
return Tanks3DSResource(resourceRegistry.getResource(getInitParam().resourceId));
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_blue_UP_RIGHT.png")]
public dynamic class button_blue_UP_RIGHT extends BitmapData {
public function button_blue_UP_RIGHT(param1:int = 7, param2:int = 30) {
super(param1,param2);
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.drone {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.drone.HasBatteriesNotifyCC;
public class VectorCodecHasBatteriesNotifyCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecHasBatteriesNotifyCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(HasBatteriesNotifyCC,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = int(LengthCodecHelper.decodeLength(param1));
var local3:Vector.<HasBatteriesNotifyCC> = new Vector.<HasBatteriesNotifyCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = HasBatteriesNotifyCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:HasBatteriesNotifyCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<HasBatteriesNotifyCC> = Vector.<HasBatteriesNotifyCC>(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.display.usertitle {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.display.usertitle.ProgressBarSkin_weaponLeftCls.png")]
public class ProgressBarSkin_weaponLeftCls extends BitmapAsset {
public function ProgressBarSkin_weaponLeftCls() {
super();
}
}
}
|
package alternativa.gfx.agal {
public class SamplerMipMap extends SamplerOption {
private static const SAMPLER_MIPMAP_SHIFT:uint = 24;
public static const NONE:SamplerMipMap = new SamplerMipMap(0);
public static const NEAREST:SamplerMipMap = new SamplerMipMap(1);
public static const LINEAR:SamplerMipMap = new SamplerMipMap(2);
public function SamplerMipMap(param1:uint) {
super(param1,SAMPLER_MIPMAP_SHIFT);
}
}
}
|
package alternativa.tanks.gui.settings.tabs {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.gui.settings.SettingsWindow;
import alternativa.tanks.service.settings.SettingEnum;
import controls.Slider;
import controls.TankWindowInner;
import controls.base.LabelBase;
import controls.checkbox.CheckBoxBase;
import forms.events.SliderEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.LocaleServiceLangValues;
public class SoundSettingsTab extends SettingsTabView {
[Inject]
public static var display:IDisplay;
private var volumeLevel:Slider;
private var bgSound:CheckBoxBase;
public function SoundSettingsTab() {
super();
var local1:TankWindowInner = new TankWindowInner(SettingsWindow.TAB_VIEW_MAX_WIDTH,0,TankWindowInner.TRANSPARENT);
var local2:LabelBase = new LabelBase();
local1.addChild(local2);
local2.text = localeService.getText(TanksLocale.TEXT_SETTINGS_SOUND_VOLUME_LABEL_TEXT);
local2.x = MARGIN;
this.volumeLevel = new Slider();
this.volumeLevel.maxValue = 100;
this.volumeLevel.minValue = 0;
this.volumeLevel.tickInterval = 5;
this.volumeLevel.x = local2.x + local2.textWidth + MARGIN;
this.volumeLevel.y = MARGIN;
this.volumeLevel.width = SettingsWindow.TAB_VIEW_MAX_WIDTH - 2 * MARGIN - local2.width - 1;
if(localeService.language == LocaleServiceLangValues.CN) {
this.volumeLevel.width -= 4;
}
this.volume = settingsService.soundVolume;
this.volumeLevel.addEventListener(SliderEvent.CHANGE_VALUE,this.onChangeVolume);
local1.addChild(this.volumeLevel);
this.bgSound = createCheckBox(SettingEnum.BG_SOUND,localeService.getText(TanksLocale.TEXT_SETTINGS_BACKGROUND_SOUND_CHECKBOX_LABEL_TEXT),settingsService.bgSound,MARGIN,0);
this.bgSound.x = MARGIN;
this.bgSound.y = MARGIN + this.volumeLevel.y + this.volumeLevel.height;
local1.addChild(this.bgSound);
local1.height = MARGIN + this.bgSound.y + this.bgSound.height;
local2.y = this.volumeLevel.y + Math.round((this.volumeLevel.height - local2.textHeight) * 0.5) - 2;
addChild(local1);
}
private function onChangeVolume(param1:SliderEvent) : void {
settingsService.soundVolume = this.volume;
}
override public function hide() : void {
super.hide();
}
public function getBgSound() : Boolean {
return this.bgSound.checked;
}
public function setBgSound(param1:Boolean) : void {
this.bgSound.checked = param1;
}
public function get volume() : Number {
return this.volumeLevel.value / 100;
}
public function set volume(param1:Number) : void {
this.volumeLevel.value = int(param1 * 100);
}
override public function destroy() : void {
this.volumeLevel.removeEventListener(SliderEvent.CHANGE_VALUE,this.onChangeVolume);
super.destroy();
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.billboard {
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 BillboardsModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BillboardsModelServer;
private var client:IBillboardsModelBase = IBillboardsModelBase(this);
private var modelId:Long = Long.getLong(489200536,-1856903338);
public function BillboardsModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BillboardsModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(BillboardCC,false)));
}
protected function getInitParam() : BillboardCC {
return BillboardCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.facilities.facillity {
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 CommonFacilityModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:CommonFacilityModelServer;
private var client:ICommonFacilityModelBase = ICommonFacilityModelBase(this);
private var modelId:Long = Long.getLong(1779789989,953701943);
private var _markAsDispelledId:Long = Long.getLong(1287147105,1273566171);
public function CommonFacilityModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new CommonFacilityModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(CommonFacilityCC,false)));
}
protected function getInitParam() : CommonFacilityCC {
return CommonFacilityCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._markAsDispelledId:
this.client.markAsDispelled();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.payment.modes.terminal {
import platform.client.fp10.core.type.IGameObject;
public class TerminalPayModeAdapt implements TerminalPayMode {
private var object:IGameObject;
private var impl:TerminalPayMode;
public function TerminalPayModeAdapt(param1:IGameObject, param2:TerminalPayMode) {
super();
this.object = param1;
this.impl = param2;
}
}
}
|
package resources.windowheaders.background
{
import flash.display.BitmapData;
public class BackgroundHeader
{
[Embed(source="1032.png")]
private static const shortBackgroundHeaderClass:Class;
public static const shortBackgroundHeader:BitmapData = new shortBackgroundHeaderClass().bitmapData;
[Embed(source="870.png")]
private static const longBackgroundHeaderClass:Class;
public static const longBackgroundHeader:BitmapData = new longBackgroundHeaderClass().bitmapData;
[Embed(source="847.png")]
private static const verticalBackgroundHeaderClass:Class;
public static const verticalBackgroundHeader:BitmapData = new verticalBackgroundHeaderClass().bitmapData;
public function BackgroundHeader()
{
super();
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.common
{
public interface IWeaponCommonModelBase
{
}
}
|
package alternativa.tanks.model.payment.shop.onetimepurchase {
[ModelInterface]
public interface ShopItemOneTimePurchase {
function isOneTimePurchase() : Boolean;
function isTriedToBuy() : Boolean;
}
}
|
package alternativa.tanks.models.battlefield.logic
{
import flash.utils.Dictionary;
public class BattleLogicUnits
{
private var units:Dictionary;
public function BattleLogicUnits()
{
this.units = new Dictionary();
super();
}
public function addLogicUnit(unit:LogicUnit) : void
{
this.units[unit] = true;
}
public function removeLogicUnit(unit:LogicUnit) : void
{
this.units[unit] = false;
delete this.units[unit];
}
public function update(deltaMsec:int, deltaSec:int) : void
{
var unit:* = undefined;
var logicUnit:LogicUnit = null;
for(unit in this.units)
{
logicUnit = unit as LogicUnit;
logicUnit.runLogic(deltaMsec,deltaSec);
}
}
}
}
|
package alternativa.tanks.models.battle.gui.indicators {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.services.battlegui.BattleGUIService;
import alternativa.utils.removeDisplayObject;
import controls.base.LabelBase;
import controls.statassets.BlackRoundRect;
import flash.display.Bitmap;
import flash.events.Event;
import flash.text.TextFieldAutoSize;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class ReloaderIndicator extends BlackRoundRect {
[Inject]
public static var display:IDisplay;
[Inject]
public static var battleGUIService:BattleGUIService;
[Inject]
public static var localeService:ILocaleService;
private static const reArmorIconClass:Class = ReloaderIndicator_reArmorIconClass;
private static const TIME_REPLACE_PATTERN:String = "{time}";
private var _timeLabel:LabelBase;
private var _throughText:String;
private var _seconds:int;
private var _isShow:Boolean;
public function ReloaderIndicator() {
super();
this.init();
}
private function init() : void {
var local6:int = 0;
this._throughText = localeService.getText(TanksLocale.TEXT_REARM_SELFDISTRUCTION);
var local1:int = 33;
var local2:int = 33;
var local3:int = 5;
var local4:int = 16;
var local5:Bitmap = new Bitmap(new reArmorIconClass().bitmapData);
addChild(local5);
local5.y = local1 - 5;
local6 = local5.y + local5.height + 2 * local3;
var local7:LabelBase = new LabelBase();
local7.size = local4;
local7.text = localeService.getText(TanksLocale.TEXT_REARM_APPLY);
local7.y = local6;
addChild(local7);
width = local7.textWidth;
local6 += local7.height;
this._timeLabel = new LabelBase();
this._timeLabel.size = local4;
this._timeLabel.autoSize = TextFieldAutoSize.LEFT;
this._timeLabel.text = this._throughText.replace(TIME_REPLACE_PATTERN," 99:99");
this._timeLabel.y = local6;
addChild(this._timeLabel);
if(width < this._timeLabel.textWidth) {
width = this._timeLabel.textWidth;
}
width += 2 * local2;
local5.x = width - local5.width >> 1;
local7.x = width - local7.width >> 1;
height = local6 + this._timeLabel.height + local1 - 5;
}
public function set seconds(param1:int) : void {
if(this._seconds == param1) {
return;
}
this._seconds = param1;
var local2:int = this._seconds / 60;
this._seconds -= local2 * 60;
var local3:String = this._seconds < 10 ? "0" + this._seconds : this._seconds.toString();
this._timeLabel.text = this._throughText.replace(TIME_REPLACE_PATTERN,local2 + ":" + local3);
this._timeLabel.x = width - this._timeLabel.width >> 1;
}
public function show(param1:int) : void {
if(this._isShow) {
return;
}
this._isShow = true;
this.seconds = param1;
battleGUIService.getViewportContainer().addChild(this);
this.onResize();
display.stage.addEventListener(Event.RESIZE,this.onResize);
}
private function onResize(param1:Event = null) : void {
this.x = display.stage.stageWidth - this.width >> 1;
this.y = display.stage.stageHeight - this.height >> 1;
}
public function hide() : void {
if(!this._isShow) {
return;
}
this._isShow = false;
removeDisplayObject(this);
display.stage.removeEventListener(Event.RESIZE,this.onResize);
}
public function destroy() : void {
this.hide();
this._timeLabel = null;
}
}
}
|
package alternativa.engine3d.loaders.collada {
use namespace collada;
public class DaeInstanceMaterial extends DaeElement {
public function DaeInstanceMaterial(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
public function get symbol() : String {
var local1:XML = data.@symbol[0];
return local1 == null ? null : local1.toString();
}
private function get target() : XML {
return data.@target[0];
}
public function get material() : DaeMaterial {
var local1:DaeMaterial = document.findMaterial(this.target);
if(local1 == null) {
document.logger.logNotFoundError(this.target);
}
return local1;
}
public function getBindVertexInputSetNum(param1:String) : int {
var bindVertexInputXML:XML = null;
var setNumXML:XML = null;
var semantic:String = param1;
bindVertexInputXML = data.bind_vertex_input.(@semantic == semantic)[0];
if(bindVertexInputXML == null) {
return 0;
}
setNumXML = bindVertexInputXML.@input_set[0];
return setNumXML == null ? 0 : int(parseInt(setNumXML.toString(),10));
}
}
}
|
package controls.resultassets
{
import assets.resultwindow.bres_SELECTED_RED_PIXEL;
import assets.resultwindow.bres_SELECTED_RED_TL;
import controls.statassets.StatLineBase;
public class ResultWindowRedSelected extends StatLineBase
{
public function ResultWindowRedSelected()
{
super();
tl = new bres_SELECTED_RED_TL(1,1);
px = new bres_SELECTED_RED_PIXEL(1,1);
frameColor = 16673333;
}
}
}
|
package controls.buttons.h71px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h71px.GreyHugeButtonSkin_rightOffClass.png")]
public class GreyHugeButtonSkin_rightOffClass extends BitmapAsset {
public function GreyHugeButtonSkin_rightOffClass() {
super();
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ItemInfoPanel_bitmapEnergyConsumption extends BitmapAsset
{
public function ItemInfoPanel_bitmapEnergyConsumption()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.pricerange {
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 PriceRangeModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:PriceRangeModelServer;
private var client:IPriceRangeModelBase = IPriceRangeModelBase(this);
private var modelId:Long = Long.getLong(1510900807,1636785662);
public function PriceRangeModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new PriceRangeModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(PriceRangeCC,false)));
}
protected function getInitParam() : PriceRangeCC {
return PriceRangeCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.battle.events.suicide {
public class SuicideDeactivationEvent {
public function SuicideDeactivationEvent() {
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.score.ctf {
import alternativa.tanks.models.battle.gui.gui.statistics.field.score.TeamScoreIndicator;
public class CTFScoreIndicator extends ComplexTeamScoreIndicator implements TeamScoreIndicator {
private static var flagBlueClass:Class = CTFScoreIndicator_flagBlueClass;
private static var flagRedClass:Class = CTFScoreIndicator_flagRedClass;
private static var flagBlueLostClass:Class = CTFScoreIndicator_flagBlueLostClass;
private static var flagRedLostClass:Class = CTFScoreIndicator_flagRedLostClass;
private static var flagFlashClass:Class = CTFScoreIndicator_flagFlashClass;
public function CTFScoreIndicator() {
super(new flagBlueClass(),new flagBlueLostClass(),new flagFlashClass(),new flagRedClass(),new flagRedLostClass(),new flagFlashClass());
}
}
}
|
package projects.tanks.client.panel.model.shop.kitpackage.view {
public interface IKitPackageViewModelBase {
}
}
|
package alternativa.tanks.models.weapon.laser {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.objects.Sprite3D;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.scene3d.Object3DNames;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.sfx.MuzzlePositionProvider;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.Colorizer;
import alternativa.tanks.utils.SetControllerForTemporaryItems;
import alternativa.tanks.utils.objectpool.ObjectPool;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.utils.Dictionary;
import platform.client.fp10.core.type.AutoClosable;
public class LaserPointerEffect implements GraphicEffect, AutoClosable {
[Inject]
public static var battleService:BattleService;
private static const EmbedLaserSpot:Class = LaserPointerEffect_EmbedLaserSpot;
public static var spotTexture:BitmapData = new EmbedLaserSpot().bitmapData;
private static const colorizedSpotTextures:Dictionary = new Dictionary();
private static const STATE_OFF:int = 0;
private static const STATE_FADEIN:int = 1;
private static const STATE_SHOW:int = 2;
private static const STATE_FADEOUT:int = 3;
private static const STATE_DEAD:int = 4;
private static const FADE_OUT_TIME:int = 200;
private static const MAX_BEAM_LENGTH:Number = 100000;
private static const MIN_BEAM_LENGTH:Number = 200;
private static const CURVE:Number = 2.2;
private static const LERP_FACTOR:Number = 0.333;
private static const SPOT_SIZE:Number = 30;
private static const RAYCAST_SHIFT:Number = 10;
private static const DIRECTION_ACCURACY:Number = 0.001;
private static const LOCAL_POINT_ACCURACY:Number = 1;
private const startPosition:Vector3 = new Vector3();
private const endPosition:Vector3 = new Vector3();
private const direction:Vector3 = new Vector3();
private var visible:Boolean;
private var state:int;
private var time:int;
private var fadeInTimeMs:int;
private var turret:Object3D;
private var laser:Laser;
private var container:Scene3DContainer;
private var sourcePositionProvider:MuzzlePositionProvider;
private var spot:Sprite3D;
private var targetUpCoord:Number;
private var currentUpCoord:Number;
private var currentForwardCoord:Number;
private var targetTank:Tank;
private var localPointOnTarget:Vector3 = new Vector3();
private var exclusionSetController:SetControllerForTemporaryItems;
private var excludedObjects:Dictionary;
public function LaserPointerEffect(param1:int, param2:Tank) {
super();
this.fadeInTimeMs = param1;
this.reset(param2);
}
public function show(param1:uint) : void {
this.visible = true;
this.state = STATE_OFF;
this.currentUpCoord = 0;
this.currentForwardCoord = 1;
this.laser.alpha = 0;
this.laser.visible = false;
this.laser.init(param1);
this.spot.alpha = 0;
this.spot.visible = false;
this.spot.material = Colorizer.getColorizedMaterial(colorizedSpotTextures,param1,spotTexture);
if(this.container == null) {
battleService.addGraphicEffect(this);
}
}
public function reset(param1:Tank) : void {
this.laser = new Laser();
this.spot = new Sprite3D(SPOT_SIZE,SPOT_SIZE);
this.spot.useShadowMap = false;
this.spot.useLight = false;
this.spot.blendMode = BlendMode.ADD;
this.spot.sorting = Sorting.DYNAMIC_BSP;
this.spot.shadowMapAlphaThreshold = 2;
this.spot.depthMapAlphaThreshold = 2;
this.turret = param1.getTurret3D();
var local2:ObjectPool = battleService.getObjectPool();
this.sourcePositionProvider = MuzzlePositionProvider(local2.getObject(MuzzlePositionProvider));
this.sourcePositionProvider.init(this.turret,param1.getLaserLocalPosition());
this.excludedObjects = battleService.getBattleScene3D().getExcludedObjects();
this.exclusionSetController = new SetControllerForTemporaryItems(this.excludedObjects);
}
public function markAsVisible() : void {
this.visible = true;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.laser);
param1.addChild(this.spot);
}
public function updateDirection(param1:Number) : Boolean {
if(this.state == STATE_OFF || this.targetTank != null || Math.abs(this.targetUpCoord - param1) > DIRECTION_ACCURACY) {
this.changeStateIfWasOff();
this.targetUpCoord = param1;
this.targetTank = null;
return true;
}
return false;
}
public function aimAtTank(param1:Tank, param2:Vector3) : Boolean {
this.changeStateIfWasOff();
if(this.targetTank != param1 || param2.distanceToSquared(this.localPointOnTarget) > LOCAL_POINT_ACCURACY) {
this.targetTank = param1;
this.localPointOnTarget.copy(param2);
return true;
}
return false;
}
private function changeStateIfWasOff() : void {
if(this.state == STATE_OFF) {
this.time = 0;
this.state = STATE_FADEIN;
}
}
public function play(param1:int, param2:GameCamera) : Boolean {
var local3:Number = NaN;
this.updateState(param1);
if(this.state == STATE_DEAD) {
return false;
}
if(this.state == STATE_OFF) {
this.laser.alpha = 0;
this.laser.visible = false;
this.spot.alpha = 0;
this.spot.visible = false;
return true;
}
this.sourcePositionProvider.updateObjectPosition(this.laser,param2,param1);
this.startPosition.x = this.laser.x;
this.startPosition.y = this.laser.y;
this.startPosition.z = this.laser.z;
this.calculateDirectionAndEndPoint();
local3 = Vector3.distanceBetween(this.startPosition,this.endPosition);
this.laser.update(param1,local3);
this.laser.visible = local3 >= MIN_BEAM_LENGTH;
this.spot.x = this.endPosition.x;
this.spot.y = this.endPosition.y;
this.spot.z = this.endPosition.z;
this.spot.visible = local3 < MAX_BEAM_LENGTH;
SFXUtils.alignObjectPlaneToView(this.laser,this.startPosition,this.direction,param2.position);
return true;
}
private function calculateDirectionAndEndPoint() : void {
var local1:Matrix3 = BattleUtils.tmpMatrix3;
local1.setRotationMatrixForObject3D(this.turret);
var local2:Vector3 = BattleUtils.tmpVector;
local1.getUp(local2);
if(this.targetTank != null && this.targetTank.getBody() != null) {
this.endPosition.copy(this.localPointOnTarget);
BattleUtils.localToGlobal(this.targetTank.getBody(),this.endPosition);
this.direction.diff(this.endPosition,this.startPosition).normalize();
this.targetUpCoord = local2.dot(this.direction);
}
if(Math.abs(this.targetUpCoord - this.currentUpCoord) > DIRECTION_ACCURACY) {
this.currentUpCoord += LERP_FACTOR * (this.targetUpCoord - this.currentUpCoord);
this.currentForwardCoord = Math.sqrt(1 - this.currentUpCoord * this.currentUpCoord);
}
this.direction.copy(local2);
this.direction.scale(this.currentUpCoord);
local1.getForward(local2);
this.direction.addScaled(this.currentForwardCoord,local2);
this.calculateEndPoint();
}
private function updateState(param1:int) : void {
var local2:Number = 0;
switch(this.state) {
case STATE_FADEIN:
local2 = this.updateStateTimer(param1,STATE_SHOW,this.fadeInTimeMs);
break;
case STATE_FADEOUT:
local2 = 1 - this.updateStateTimer(param1,STATE_DEAD,FADE_OUT_TIME);
break;
default:
return;
}
var local3:Number = Math.pow(local2,CURVE);
this.laser.alpha = local3;
this.spot.alpha = local3;
}
private function updateStateTimer(param1:int, param2:int, param3:int) : Number {
this.time += param1;
if(this.time >= param3) {
this.state = param2;
this.time = param3;
}
return this.time / param3;
}
private function calculateEndPoint() : void {
var local1:RayIntersectionData = null;
var local2:Object3D = null;
this.exclusionSetController.addTemporaryItem(this.turret);
while(true) {
local1 = battleService.getBattleScene3D().raycast(this.startPosition,this.direction,this.excludedObjects);
if(local1 == null) {
break;
}
local2 = local1.object;
if(local2.name == Object3DNames.STATIC || local2.name == Object3DNames.TANK_PART) {
this.endPosition.copy(this.startPosition);
this.endPosition.addScaled(local1.time - RAYCAST_SHIFT,this.direction);
this.exclusionSetController.deleteAllTemporaryItems();
return;
}
this.exclusionSetController.addTemporaryItem(local1.object);
}
this.exclusionSetController.deleteAllTemporaryItems();
this.endPosition.copy(this.startPosition);
this.endPosition.addScaled(MAX_BEAM_LENGTH,this.direction);
}
public function hide() : void {
this.visible = false;
if(Boolean(this.container)) {
this.state = STATE_FADEOUT;
this.time = 0;
} else {
this.kill();
}
}
public function isVisible() : Boolean {
return this.visible;
}
public function destroy() : void {
this.kill();
}
[Obfuscation(rename="false")]
public function close() : void {
this.kill();
this.sourcePositionProvider.destroy();
this.sourcePositionProvider = null;
this.turret = null;
this.laser = null;
this.spot = null;
this.excludedObjects = null;
this.exclusionSetController = null;
}
public function kill() : void {
if(Boolean(this.container)) {
this.container.removeChild(this.laser);
this.container.removeChild(this.spot);
this.container = null;
this.laser.close();
this.spot.material = null;
this.state = STATE_DEAD;
} else {
this.state = STATE_OFF;
}
this.targetTank = null;
this.localPointOnTarget.reset();
this.targetUpCoord = 0;
this.currentUpCoord = 0;
this.currentForwardCoord = 1;
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.