code
stringlengths 57
237k
|
|---|
package projects.tanks.client.entrance.model.entrance.facebook {
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 FacebookEntranceModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _loginId:Long = Long.getLong(900522240,174529882);
private var _login_idTokenCodec:ICodec;
private var model:IModel;
public function FacebookEntranceModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._login_idTokenCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function login(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._login_idTokenCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._loginId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.services.battlereadiness {
public interface BattleReadinessService {
function reset() : void;
function unlockMap() : void;
function unlockUser() : void;
function isBattleReady() : Boolean;
function isMapReady() : Boolean;
}
}
|
package controls.chat {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.chat.BattleChatInput_bitmapSR.png")]
public class BattleChatInput_bitmapSR extends BitmapAsset {
public function BattleChatInput_bitmapSR() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.railgun {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.types.Vector3d;
public class RailgunModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:RailgunModelServer;
private var client:IRailgunModelBase = IRailgunModelBase(this);
private var modelId:Long = Long.getLong(387277533,1853292335);
private var _fireId:Long = Long.getLong(87545380,-265767482);
private var _fire_shooterCodec:ICodec;
private var _fire_staticHitPointCodec:ICodec;
private var _fire_targetsCodec:ICodec;
private var _fire_targetHitPointsCodec:ICodec;
private var _fireDummyId:Long = Long.getLong(289812713,334160242);
private var _fireDummy_shooterCodec:ICodec;
private var _immediateReloadId:Long = Long.getLong(1438252851,-2076139994);
private var _reconfigureWeaponId:Long = Long.getLong(549412808,-630293643);
private var _reconfigureWeapon_chargingTimeCodec:ICodec;
private var _startChargingId:Long = Long.getLong(498560719,475399825);
private var _startCharging_shooterCodec:ICodec;
public function RailgunModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new RailgunModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(RailgunCC,false)));
this._fire_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._fire_staticHitPointCodec = this._protocol.getCodec(new TypeCodecInfo(Vector3d,true));
this._fire_targetsCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(IGameObject,false),true,1));
this._fire_targetHitPointsCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Vector3d,false),true,1));
this._fireDummy_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._reconfigureWeapon_chargingTimeCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._startCharging_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
}
protected function getInitParam() : RailgunCC {
return RailgunCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._fireId:
this.client.fire(IGameObject(this._fire_shooterCodec.decode(param2)),Vector3d(this._fire_staticHitPointCodec.decode(param2)),this._fire_targetsCodec.decode(param2) as Vector.<IGameObject>,this._fire_targetHitPointsCodec.decode(param2) as Vector.<Vector3d>);
break;
case this._fireDummyId:
this.client.fireDummy(IGameObject(this._fireDummy_shooterCodec.decode(param2)));
break;
case this._immediateReloadId:
this.client.immediateReload();
break;
case this._reconfigureWeaponId:
this.client.reconfigureWeapon(int(this._reconfigureWeapon_chargingTimeCodec.decode(param2)));
break;
case this._startChargingId:
this.client.startCharging(IGameObject(this._startCharging_shooterCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package controls.lifeindicator {
import controls.resultassets.WhiteFrame;
public class LifeIndicator extends WhiteFrame {
private var lineCharge:LineCharge;
private var lineLife:LineLife;
private var _charge:Number = 1;
private var _life:Number = 1;
public function LifeIndicator() {
super();
this.lineCharge = new LineCharge();
this.lineCharge.x = 6;
this.lineCharge.y = 22;
addChild(this.lineCharge);
this.lineLife = new LineLife();
addChild(this.lineLife);
this.lineLife.x = 6;
this.lineLife.y = 6;
}
override public function draw() : void {
super.draw();
this.charge = this._charge;
this.life = this._life;
}
public function set charge(param1:Number) : void {
if(this._charge == param1) {
return;
}
this._charge = param1;
this.lineCharge.setWidth((_width - 12) * this._charge);
}
public function set life(param1:Number) : void {
if(this._life == param1) {
return;
}
this._life = param1;
this.lineLife.setWidth((_width - 12) * this._life);
}
}
}
|
package alternativa.tanks.models.weapon.shotgun.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.battle.objects.tank.tankskin.TankSkin;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.shotgun.ShotgunObject;
import alternativa.tanks.sfx.AnimatedLightEffect;
import alternativa.tanks.sfx.ISound3DEffect;
import alternativa.tanks.sfx.ISoundEffectDestructionListener;
import alternativa.tanks.sfx.MobileSound3DEffect;
import alternativa.tanks.sfx.MuzzlePositionProvider;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.utils.objectpool.ObjectPool;
import flash.media.Sound;
import platform.client.fp10.core.type.AutoClosable;
public class ShotgunEffects implements AutoClosable, ISoundEffectDestructionListener {
[Inject]
public static var battleService:BattleService;
private static const SHOT_VOLUME:Number = 1;
private static const RELOAD_SOUND_SHIFT:int = 500;
private static const MAGAZINE_RELOAD_SOUND_SHIFT:int = 1000;
private var shotgunSFX:ShotgunSFXData;
private var reloadSoundEffect:MobileSound3DEffect;
private var buffed:Boolean = false;
public function ShotgunEffects(param1:ShotgunSFXData) {
super();
this.shotgunSFX = param1;
}
public function createShotEffects(param1:ShotgunObject, param2:AllGlobalGunParams, param3:WeaponPlatform, param4:Vector3) : void {
this.createGraphicEffect(param1,param2,param3,param4);
this.createSoundEffect(param2);
this.createShotLightEffects(param3);
}
private function createSoundEffect(param1:AllGlobalGunParams) : void {
var local2:Sound3D = Sound3D.create(this.shotgunSFX.shotSound,SHOT_VOLUME);
battleService.addSound3DEffect(Sound3DEffect.create(param1.muzzlePosition,local2));
}
private function createGraphicEffect(param1:ShotgunObject, param2:AllGlobalGunParams, param3:WeaponPlatform, param4:Vector3) : void {
var local5:ShotgunShotEffect = ShotgunShotEffect(battleService.getObjectPool().getObject(ShotgunShotEffect));
local5.init(param1,param2,param3,param4,this.shotgunSFX,this.buffed);
battleService.addGraphicEffect(local5);
}
public function createReloadSoundEffect(param1:Object3D, param2:int) : void {
var local3:Sound = this.shotgunSFX.reloadSound;
this.addReloadSound(local3,param2,RELOAD_SOUND_SHIFT,param1);
}
public function createMagazineReloadSoundEffect(param1:Object3D, param2:int) : void {
var local3:Sound = this.shotgunSFX.magazineReloadSound;
this.addReloadSound(local3,param2,MAGAZINE_RELOAD_SOUND_SHIFT,param1);
}
public function stopEffects() : void {
if(this.reloadSoundEffect != null) {
this.reloadSoundEffect.kill();
}
}
private function addReloadSound(param1:Sound, param2:int, param3:int, param4:Object3D) : void {
var local5:Sound3D = Sound3D.create(param1,SHOT_VOLUME);
var local6:ObjectPool = battleService.getObjectPool();
this.reloadSoundEffect = MobileSound3DEffect(local6.getObject(MobileSound3DEffect));
var local7:int = param2 - param1.length + param3;
var local8:int = 0;
if(local7 < 0) {
local8 = -local7;
local7 = 0;
}
this.reloadSoundEffect.init(local5,param4,local7,1,local8,this);
battleService.addSound3DEffect(this.reloadSoundEffect);
}
private function createShotLightEffects(param1:WeaponPlatform) : void {
var local2:TankSkin = param1.getSkin();
var local3:Object3D = local2.getTurret3D();
var local4:Vector3 = param1.getLocalMuzzlePosition();
var local5:AnimatedLightEffect = AnimatedLightEffect(battleService.getObjectPool().getObject(AnimatedLightEffect));
var local6:MuzzlePositionProvider = MuzzlePositionProvider(battleService.getObjectPool().getObject(MuzzlePositionProvider));
local6.init(local3,local4);
local5.init(local6,this.shotgunSFX.shotLightAnimation);
battleService.addGraphicEffect(local5);
}
[Obfuscation(rename="false")]
public function close() : void {
this.shotgunSFX = null;
if(this.reloadSoundEffect != null) {
this.reloadSoundEffect.kill();
}
}
public function onSoundEffectDestroyed(param1:ISound3DEffect) : void {
if(this.reloadSoundEffect == param1) {
this.reloadSoundEffect = null;
}
}
public function setBuffed(param1:Boolean) : void {
this.buffed = param1;
}
}
}
|
package projects.tanks.client.garage.models.item.countable {
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 CountableItemModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function CountableItemModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.gui {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.textinputs.PlaceholderInputText;
import base.DiscreteSprite;
import controls.ValidationIcon;
import controls.base.LabelBase;
import flash.events.Event;
import flash.geom.Point;
import flash.text.TextFormatAlign;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import forms.registration.bubbles.EmailInvalidBubble;
import projects.tanks.clients.flash.commons.services.validate.IValidateService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
public class EmailBlock extends DiscreteSprite {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var userPropertyService:IUserPropertiesService;
[Inject]
public static var validateService:IValidateService;
[Inject]
public static var displayService:IDisplay;
private static const EMAIL_PLACEHOLDER_TEXT:String = "yourname@example.com";
private static const EMAIL_CHECK_DELAY:int = 500;
private var emailInput:PlaceholderInputText;
private var errorEmailInvalidBubble:EmailInvalidBubble;
private var emailCheckIcon:ValidationIcon;
private var timeoutId:int = -1;
public function EmailBlock(param1:int, param2:int) {
super();
var local3:LabelBase = new LabelBase();
local3.htmlText = localeService.getText(TanksLocale.TEXT_SETTINGS_EMAIL_LABEL_TEXT);
local3.x = param2;
local3.y = 7;
addChild(local3);
this.emailInput = new PlaceholderInputText(EMAIL_PLACEHOLDER_TEXT);
this.emailInput.x = int(param2 + local3.width + 5);
this.emailInput.y = 0;
this.emailInput.width = param1 - 2 * param2 - local3.width - 5;
this.emailInput.validValue = true;
this.emailInput.align = TextFormatAlign.LEFT;
this.emailInput.addEventListener(Event.CHANGE,this.validateEmail);
addChild(this.emailInput);
this.emailCheckIcon = new ValidationIcon();
this.emailCheckIcon.x = param1 - param2 - this.emailCheckIcon.width - 10;
this.emailCheckIcon.y = local3.y;
addChild(this.emailCheckIcon);
this.errorEmailInvalidBubble = new EmailInvalidBubble();
this.errorEmailInvalidBubble.visible = false;
displayService.stage.addChild(this.errorEmailInvalidBubble);
displayService.stage.addEventListener(Event.RESIZE,this.alignBubble,false,-1);
}
public function alignBubble(param1:Event = null) : void {
var local2:int = 0;
var local3:int = 0;
if(this.errorEmailInvalidBubble != null && parent != null) {
local2 = this.x + this.emailCheckIcon.x + this.emailCheckIcon.width / 2;
local3 = this.y + this.emailCheckIcon.y + this.emailCheckIcon.height / 2;
this.errorEmailInvalidBubble.targetPoint = parent.localToGlobal(new Point(local2,local3));
this.errorEmailInvalidBubble.align(displayService.stage.stageWidth,displayService.stage.stageHeight);
}
}
public function destroy() : void {
displayService.stage.removeChild(this.errorEmailInvalidBubble);
this.errorEmailInvalidBubble = null;
displayService.stage.removeEventListener(Event.RESIZE,this.alignBubble);
this.resetTimeout();
}
private function validateEmail(param1:Event) : void {
this.resetTimeout();
this.dispatchInvalidEmailEvent();
if(this.emailInput.value == "") {
this.errorEmailInvalidBubble.visible = false;
this.emailInput.validValue = true;
this.emailCheckIcon.turnOff();
} else if(!validateService.isEmailValid(this.emailInput.value)) {
this.errorEmailInvalidBubble.visible = true;
this.errorEmailInvalidBubble.setEmailInvalidText();
this.errorEmailInvalidBubble.redraw();
this.emailCheckIcon.markAsInvalid();
this.emailInput.validValue = false;
this.alignBubble();
} else {
this.errorEmailInvalidBubble.visible = false;
this.emailInput.validValue = true;
this.emailCheckIcon.startProgress();
this.timeoutId = setTimeout(this.sendValidationRequest,EMAIL_CHECK_DELAY);
}
}
private function sendValidationRequest() : void {
this.resetTimeout();
dispatchEvent(new EmailBlockRequestEvent(EmailBlockRequestEvent.SEND_VALIDATE_EMAIL_REQUEST_EVENT,this.emailInput.value));
}
private function dispatchValidEmailEvent() : void {
dispatchEvent(new EmailBlockValidationEvent(EmailBlockValidationEvent.EMAIL_VALIDATED_EVENT,this.emailInput.value,true));
}
private function dispatchInvalidEmailEvent() : void {
dispatchEvent(new EmailBlockValidationEvent(EmailBlockValidationEvent.EMAIL_VALIDATED_EVENT,this.emailInput.value,false));
}
private function resetTimeout() : void {
if(this.timeoutId != -1) {
clearTimeout(this.timeoutId);
this.timeoutId = -1;
}
}
public function showEmailIsBusy(param1:String) : void {
if(this.emailInput.value == param1) {
this.emailInput.validValue = false;
this.emailCheckIcon.markAsInvalid();
this.errorEmailInvalidBubble.setEmailIsNotUniqueText();
this.errorEmailInvalidBubble.visible = true;
this.errorEmailInvalidBubble.redraw();
this.dispatchInvalidEmailEvent();
this.alignBubble();
}
}
public function showEmailIsForbidden(param1:String) : void {
if(this.emailInput.value == param1) {
this.emailInput.validValue = false;
this.emailCheckIcon.markAsInvalid();
this.errorEmailInvalidBubble.setEmailForbiddenText();
this.errorEmailInvalidBubble.visible = true;
this.errorEmailInvalidBubble.redraw();
this.dispatchInvalidEmailEvent();
this.alignBubble();
}
}
public function showEmailIsFree(param1:String) : void {
if(this.emailInput.value == param1) {
this.emailInput.validValue = true;
this.emailCheckIcon.markAsValid();
this.errorEmailInvalidBubble.visible = false;
this.dispatchValidEmailEvent();
}
}
public function get email() : String {
return this.emailInput.value;
}
public function set email(param1:String) : void {
this.emailInput.setValue(param1);
}
}
}
|
package alternativa.tanks.models.weapon.thunder {
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
import flash.display.BlendMode;
internal class Trail extends Mesh {
public function Trail(param1:Number, param2:Material) {
super();
var local3:Number = 4;
var local4:Number = 240 * param1;
var local5:Vertex = this.createVertex(-local3,0,0,0,0);
var local6:Vertex = this.createVertex(local3,0,0,0,1);
var local7:Vertex = this.createVertex(0,local4,0,1,0.5);
this.createFace(local5,local6,local7).material = param2;
this.createFace(local7,local6,local5).material = param2;
calculateFacesNormals(true);
calculateBounds();
blendMode = BlendMode.SCREEN;
alpha = 0.3;
shadowMapAlphaThreshold = 2;
depthMapAlphaThreshold = 2;
useShadowMap = false;
useLight = false;
}
private function createVertex(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number) : Vertex {
var local6:Vertex = new Vertex();
local6.next = vertexList;
vertexList = local6;
local6.x = param1;
local6.y = param2;
local6.z = param3;
local6.u = param4;
local6.v = param5;
return local6;
}
private function createFace(param1:Vertex, param2:Vertex, param3:Vertex) : Face {
var local4:Face = new Face();
local4.next = faceList;
faceList = local4;
local4.wrapper = new Wrapper();
local4.wrapper.vertex = param1;
local4.wrapper.next = new Wrapper();
local4.wrapper.next.vertex = param2;
local4.wrapper.next.next = new Wrapper();
local4.wrapper.next.next.vertex = param3;
return local4;
}
}
}
|
package scpacker.networking
{
import scpacker.networking.commands.Command;
import scpacker.networking.commands.Type;
public class NetworkService
{
private static var listeners:Vector.<INetworkListener>;
public static const DELIM_COMMANDS_SYMBOL:String = "end~";
public static const DELIM_ARGUMENTS_SYMBOL:String = ";";
private var badRequest:String = "";
public function NetworkService()
{
super();
listeners = new Vector.<INetworkListener>();
}
public static function getType(str:String) : Type
{
var type:Type = null;
switch(str)
{
case "auth":
type = Type.AUTH;
break;
case "registration":
type = Type.REGISTRATON;
break;
case "chat":
type = Type.CHAT;
break;
case "lobby":
type = Type.LOBBY;
break;
case "garage":
type = Type.GARAGE;
break;
case "battle":
type = Type.BATTLE;
break;
case "ping":
type = Type.PING;
break;
case "lobby_chat":
type = Type.LOBBY_CHAT;
break;
case "system":
type = Type.SYSTEM;
break;
default:
type = Type.UNKNOWN;
}
return type;
}
public function protocolDecrypt(src:String, network:Network) : void
{
var mass:Array = null;
var tempType:Type = null;
var args:String = null;
var i:int = 0;
var tempCommand:Command = null;
src = this.badRequest + src;
var commands:Array = src.split(DELIM_COMMANDS_SYMBOL);
for(var j:int = 0; j < commands.length - 1; j++)
{
mass = commands[j].split(DELIM_ARGUMENTS_SYMBOL);
tempType = getType(mass[0]);
if(tempType == null || tempType == Type.UNKNOWN)
{
throw new Error("Что то пошло не так " + mass[0]);
}
args = "";
for(i = 1; i < mass.length; i++)
{
args += mass[i] + DELIM_ARGUMENTS_SYMBOL;
}
tempCommand = new Command(tempType,args.split(DELIM_ARGUMENTS_SYMBOL),src);
this.sendRequestToAllListeners(tempCommand);
}
this.badRequest = commands[commands.length - 1];
}
public function endWith(str:String) : Boolean
{
return str.charAt(str.length - 1) == DELIM_COMMANDS_SYMBOL;
}
public function sendRequestToAllListeners(command:Command) : void
{
var listener:INetworkListener = null;
for each(listener in listeners)
{
listener.onData(command);
}
}
public function addListener(listener:INetworkListener) : void
{
listeners.push(listener);
}
public function removeListener(listener:INetworkListener) : void
{
var list:INetworkListener = null;
var index:int = 0;
for each(list in listeners)
{
if(list == listener)
{
break;
}
index++;
}
listeners.removeAt(index);
}
private function getArray(... args) : Array
{
return new Array(args);
}
}
}
|
package services.alertservice {
public class AlertAnswer {
public static var YES:String;
public static var NO:String;
public static var OK:String;
public static var CANCEL:String;
public static var SEND:String;
public static var RETURN:String;
public static var GARAGE:String;
public static var PROCEED:String;
public static var ENTER:String;
public static var DO_NOT_ENTER:String;
public function AlertAnswer() {
super();
}
}
}
|
package alternativa.tanks.help
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
public class ButtonBarHelper extends BubbleHelper
{
public function ButtonBarHelper()
{
super();
var localeService:ILocaleService = ILocaleService(Main.osgi.getService(ILocaleService));
text = localeService.getText(TextConst.HELP_PANEL_BUTTON_BAR_HELPER_TEXT);
arrowLehgth = int(localeService.getText(TextConst.HELP_PANEL_BUTTON_BAR_HELPER_ARROW_LENGTH));
arrowAlign = HelperAlign.TOP_RIGHT;
_showLimit = 3;
_targetPoint.y = 25;
}
}
}
|
package controls.resultassets
{
import assets.resultwindow.bres_BG_GREEN_PIXEL;
import assets.resultwindow.bres_BG_GREEN_TL;
public class ResultWindowGreen extends ResultWindowBase
{
public function ResultWindowGreen()
{
super();
tl = new bres_BG_GREEN_TL(1,1);
px = new bres_BG_GREEN_PIXEL(1,1);
}
}
}
|
package alternativa.tanks.view.battleinfo {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.controllers.battleinfo.TimeStringUtils;
import alternativa.tanks.view.battlelist.modefilter.BattleModeIcons;
import alternativa.tanks.view.icons.BattleParamsBattleInfoIcons;
import alternativa.tanks.view.timeleftindicator.BigWhiteTimeLeftIndicator;
import alternativa.tanks.view.timeleftindicator.TimeLeftIndicator;
import alternativa.types.Long;
import assets.icons.InputCheckIcon;
import base.DiscreteSprite;
import controls.TankWindowInner;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.base.TankInputBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.filters.GlowFilter;
import flash.geom.Rectangle;
import flash.system.System;
import flash.text.TextFieldAutoSize;
import flash.text.TextFieldType;
import forms.ranks.SmallRankIcon;
import forms.registration.CallsignIconStates;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.battleservice.BattleMode;
import projects.tanks.client.battleservice.Range;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.battlelist.UserBattleSelectActionsService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.BattleFormatUtil;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.BattleInfoUtils;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.removeChildrenFrom;
import utils.preview.IImageResource;
import utils.preview.ImageResourceLoadingWrapper;
public class BattleInfoParamsView extends DiscreteSprite implements IImageResource {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var userBattleSelectActionsService:UserBattleSelectActionsService;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var battleFormatUtil:BattleFormatUtil;
private static const MAX_HEIGHT:int = 500;
private static const ICON_VERTICAL_MARGIN:int = 6;
private static const filter:Array = [new GlowFilter(0,1,6,6)];
private static var waitIcon:InputCheckIcon = new InputCheckIcon();
private var _width:int;
private var _height:int;
private var battleLimitsBar:Sprite = new Sprite();
private var proOptionsBar:Sprite = new Sprite();
private var autoBalanceIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.autoBalanceBitmapData);
private var friendlyFireIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.friendlyFireBitmapData);
private var scoreLimitIcon:Bitmap = new Bitmap();
private var suppliesIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.suppliesBitmapData);
private var bonusesIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.bonusesBitmapData);
private var goldBoxesIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.goldBonusesBitmapData);
private var upgradesIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.upgradesBitmapData);
private var devicesIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.devicesBitmapData);
private var proBattleIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.proBitmapData);
private var formatBattleIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.formatBattleBitmapData);
private var reArmorIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.rearmorBitmapData);
private var dependentCooldownIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.dependentCooldownsBitmapData);
private var ultimatesIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.ultimatesBitmapData);
private var clanBattleIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.clanBattleBitmapData);
private var matchmakingStampIcon:Bitmap = new Bitmap(BattleParamsBattleInfoIcons.matchmakingStampBitmapData);
private var scoreLimitLabel:LabelBase = new LabelBase();
private var timeLimitLabel:LabelBase = new LabelBase();
private var timeLeftLabel:LabelBase = new LabelBase();
private var timeLeftIndicator:TimeLeftIndicator = new BigWhiteTimeLeftIndicator();
private var bg:TankWindowInner = new TankWindowInner(100,100,TankWindowInner.TRANSPARENT);
private var nameLabel:LabelBase = new LabelBase();
private var preview:Sprite = new Sprite();
private var stamp:Sprite = new Sprite();
private var rect:Rectangle = new Rectangle(0,0,400,300);
private var urlString:TankInputBase;
private var urlCopyButton:DefaultButtonBase;
private var copyLinkText:String;
private var rangBar:Sprite = new Sprite();
private var rangIconsY:Number;
private var spectatorButton:DefaultButtonBase = new DefaultButtonBase();
private var infoParams:BattleInfoBaseParams;
private var _previewLoadingId:Long;
public function BattleInfoParamsView() {
super();
addChild(this.preview);
addChild(this.bg);
addChild(this.nameLabel);
addChild(this.rangBar);
addChild(this.battleLimitsBar);
addChild(this.proOptionsBar);
addChild(this.spectatorButton);
addChild(this.proBattleIcon);
addChild(this.formatBattleIcon);
addChild(this.stamp);
this.spectatorButton.label = "Spectator";
this.spectatorButton.visible = false;
this.spectatorButton.addEventListener(MouseEvent.CLICK,this.onSpectatorButtonClick);
this.nameLabel.size = 18;
this.nameLabel.height = 25;
this.nameLabel.thickness = 0;
this.nameLabel.autoSize = TextFieldAutoSize.NONE;
this.nameLabel.filters = filter;
this.battleLimitsBar.filters = filter;
this.proOptionsBar.filters = filter;
this.proBattleIcon.filters = filter;
this.formatBattleIcon.filters = filter;
this.proBattleIcon.visible = false;
this.formatBattleIcon.visible = false;
this.preview.scrollRect = this.rect;
this.copyLinkText = localeService.getText(TanksLocale.TEXT_BATTLEINFO_PANEL_COPY_LINK_TEXT);
this.stamp.addChild(this.matchmakingStampIcon);
}
private function onResize() : * {
this.stamp.x = 10;
this.stamp.y = this.bg.height - this.stamp.height;
this.matchmakingStampIcon.visible = this.bg.height > 100;
}
public function setPreview(param1:BitmapData) : void {
if(this.preview.numChildren > 0) {
this.preview.removeChildAt(0);
}
if(param1 == null) {
this.preview.addChild(waitIcon);
waitIcon.gotoAndStop(CallsignIconStates.CALLSIGN_ICON_STATE_PROGRESS);
waitIcon.x = int(375 - waitIcon.width / 2);
waitIcon.y = int(250 - waitIcon.height / 2);
this.preview.scrollRect = this.rect;
} else {
this.preview.addChild(new Bitmap(param1));
this.preview.scrollRect = this.rect;
}
this.width = this._width;
this.height = this._height;
}
public function update(param1:BattleInfoBaseParams) : void {
this.infoParams = param1;
this.updatePreview(param1.previewResource);
this.updateRankRangeBar();
this.updateBattleUrl();
this.updateNameAndFormat();
this.updateBattleLimits();
this.updateOptions();
this.width = this._width;
this.height = this._height;
}
public function updatePreview(param1:ImageResource) : void {
if(param1.isLazy && !param1.isLoaded) {
this._previewLoadingId = param1.id;
param1.loadLazyResource(new ImageResourceLoadingWrapper(this));
}
this.setPreview(param1.data);
}
public function setPreviewResource(param1:ImageResource) : void {
if(this._previewLoadingId == param1.id) {
this.setPreview(param1.data);
}
}
private function updateOptions() : void {
removeChildrenFrom(this.proOptionsBar);
if(this.infoParams.createParams.proBattle) {
this.addIcon(this.bonusesIcon,!this.infoParams.createParams.withoutBonuses);
if(!this.infoParams.createParams.parkourMode) {
this.addIcon(this.goldBoxesIcon,this.infoParams.createParams.goldBoxesEnabled);
}
this.addIcon(this.reArmorIcon,this.infoParams.createParams.reArmorEnabled);
this.addIcon(this.upgradesIcon,!this.infoParams.createParams.withoutUpgrades);
this.addIcon(this.devicesIcon,!this.infoParams.createParams.withoutDevices);
this.addIcon(this.suppliesIcon,!this.infoParams.createParams.withoutSupplies);
if(!this.infoParams.createParams.withoutSupplies) {
this.addIcon(this.dependentCooldownIcon,this.infoParams.createParams.dependentCooldownEnabled);
}
if(this.infoParams.createParams.battleMode != BattleMode.DM) {
this.addIcon(this.friendlyFireIcon,this.infoParams.createParams.friendlyFire);
this.addIcon(this.autoBalanceIcon,this.infoParams.createParams.autoBalance);
}
this.addIcon(this.clanBattleIcon,this.infoParams.createParams.clanBattle);
this.addIcon(this.ultimatesIcon,this.infoParams.createParams.ultimatesEnabled);
}
}
private function updateBattleLimits() : void {
removeChildrenFrom(this.battleLimitsBar);
if(this.infoParams.createParams.limits.timeLimitInSec > 0) {
this.timeLimitLabel.text = int(this.infoParams.createParams.limits.timeLimitInSec / 60).toString();
this.timeLimitLabel.size = 14;
this.battleLimitsBar.addChild(this.timeLimitLabel);
this.battleLimitsBar.addChild(this.timeLeftIndicator);
this.timeLeftIndicator.x = this.timeLimitLabel.textWidth + 11;
this.timeLeftIndicator.y = 2;
this.battleLimitsBar.addChild(this.timeLeftLabel);
this.timeLeftLabel.x = this.timeLeftIndicator.x + this.timeLeftIndicator.width + 5;
this.timeLeftLabel.autoSize = TextFieldAutoSize.NONE;
this.timeLeftLabel.size = 14;
this.timeLeftLabel.width = 50;
this.timeLeftLabel.height = 20;
}
if(this.infoParams.createParams.limits.scoreLimit > 0) {
this.scoreLimitIcon.x = this.battleLimitsBar.numChildren > 0 ? this.battleLimitsBar.width + ICON_VERTICAL_MARGIN : 0;
this.scoreLimitIcon.y = -4;
this.battleLimitsBar.addChild(this.scoreLimitIcon);
switch(this.infoParams.createParams.battleMode) {
case BattleMode.CP:
this.scoreLimitIcon.bitmapData = BattleParamsBattleInfoIcons.cpBitmapData;
break;
case BattleMode.CTF:
this.scoreLimitIcon.bitmapData = BattleParamsBattleInfoIcons.ctfBitmapData;
break;
case BattleMode.AS:
this.scoreLimitIcon.bitmapData = BattleModeIcons.getIcon(BattleMode.AS);
break;
case BattleMode.RUGBY:
this.scoreLimitIcon.bitmapData = BattleModeIcons.getIcon(BattleMode.RUGBY);
break;
default:
this.scoreLimitIcon.bitmapData = BattleParamsBattleInfoIcons.dmBitmapData;
}
this.battleLimitsBar.addChild(this.scoreLimitLabel);
this.scoreLimitLabel.size = 14;
this.scoreLimitLabel.text = String(this.infoParams.createParams.limits.scoreLimit);
this.scoreLimitLabel.x = this.scoreLimitIcon.x + 18;
}
}
public function updateNameAndFormat() : void {
var local1:String = battleFormatUtil.getShortFormatName(this.infoParams.createParams.equipmentConstraintsMode,this.infoParams.createParams.parkourMode);
var local2:Boolean = local1.length > 0;
if(Boolean(this.infoParams.customName)) {
this.nameLabel.text = this.infoParams.customName;
} else {
this.nameLabel.text = this.infoParams.createParams.proBattle ? this.infoParams.mapName : BattleInfoUtils.buildBattleName(this.infoParams.mapName,this.infoParams.createParams.battleMode.name);
if(local2) {
this.nameLabel.text += " " + local1;
}
}
this.proBattleIcon.x = this.nameLabel.x + this.nameLabel.textWidth + 8;
this.proBattleIcon.y = this.nameLabel.y - 1;
this.proBattleIcon.visible = this.infoParams.createParams.proBattle && !local2;
this.formatBattleIcon.x = this.proBattleIcon.x;
this.formatBattleIcon.y = this.proBattleIcon.y;
this.formatBattleIcon.visible = this.infoParams.createParams.proBattle && local2;
this.stamp.visible = this.infoParams.matchmakingMark;
}
private function updateBattleUrl() : void {
if(this.infoParams.battleUrl.length > 0 && this.urlString == null) {
this.urlString = new TankInputBase();
this.urlCopyButton = new DefaultButtonBase();
addChild(this.urlString);
addChild(this.urlCopyButton);
}
if(this.infoParams.battleUrl.length > 0) {
this.urlString.value = this.infoParams.battleUrl;
this.urlString.textField.type = TextFieldType.DYNAMIC;
this.urlCopyButton.width = this.copyLinkText.length * 7;
this.urlCopyButton.label = this.copyLinkText;
this.urlCopyButton.addEventListener(MouseEvent.CLICK,this.copyURL);
}
}
private function updateRankRangeBar() : void {
var local2:SmallRankIcon = null;
var local6:int = 0;
var local1:Range = this.infoParams.createParams.rankRange;
var local3:int = 0;
var local4:int = 0;
removeChildrenFrom(this.rangBar);
var local5:int = 16;
if(local1.min != 0 && local1.max != 0) {
local6 = local1.max;
while(local6 >= local1.min) {
local2 = new SmallRankIcon(local6);
local2.x = local3 * 15;
local2.y = local4 * local5;
this.rangBar.addChild(local2);
local3--;
if(local3 < -15) {
local4--;
local3 = 0;
}
local6--;
}
}
this.rangIconsY = local4 * local5;
}
private function addIcon(param1:Bitmap, param2:Boolean) : void {
var local3:int = this.proOptionsBar.numChildren;
var local4:int = Math.floor(this.width / (param1.width + ICON_VERTICAL_MARGIN));
if(local3 > 0) {
param1.x = this.proOptionsBar.width + ICON_VERTICAL_MARGIN;
} else {
param1.x = 0;
}
if(local3 > local4) {
param1.y = param1.height + ICON_VERTICAL_MARGIN;
param1.x = (param1.width + ICON_VERTICAL_MARGIN) * (local3 - (local4 - 1));
}
param1.alpha = param2 ? 1 : 0.5;
this.proOptionsBar.addChild(param1);
}
private function copyURL(param1:MouseEvent) : void {
userBattleSelectActionsService.copyBattleLink(this.infoParams.createParams.battleMode,this.infoParams.battleId);
System.setClipboard(this.urlString.value);
}
override public function set width(param1:Number) : void {
this._width = int(param1);
this.bg.width = this._width;
this.preview.x = 1;
this.rect.x = int(375 - this._width / 2);
this.rect.width = this._width - 2;
this.preview.scrollRect = this.rect;
this.rangBar.x = this._width - 23;
this.nameLabel.x = 10;
this.nameLabel.width = this._width - 20;
this.battleLimitsBar.x = 12;
this.proOptionsBar.x = 12;
this.spectatorButton.x = this._width - this.spectatorButton.width - 9;
if(this.urlString != null) {
this.urlString.width = this._width - this.urlCopyButton.width - 3;
this.urlCopyButton.x = this._width - this.urlCopyButton.width;
}
this.alignProOptionsIcons();
this.onResize();
}
private function alignProOptionsIcons() : void {
var local1:int = 0;
var local2:int = 0;
var local3:int = 0;
var local4:int = 0;
var local5:DisplayObject = null;
if(this.proOptionsBar.numChildren > 0) {
local1 = this.proOptionsBar.numChildren;
local2 = this.width - 30;
local3 = Math.floor(local2 / (this.proOptionsBar.getChildAt(0).width + ICON_VERTICAL_MARGIN));
if(local1 <= local3) {
return;
}
local4 = 0;
while(local4 < local1) {
local5 = this.proOptionsBar.getChildAt(local4);
if(local4 > local3) {
local5.y = local5.height + ICON_VERTICAL_MARGIN;
local5.x = (local5.width + ICON_VERTICAL_MARGIN) * (local4 - (local3 + 1));
} else {
local5.y = 0;
local5.x = (local5.width + ICON_VERTICAL_MARGIN) * local4;
}
local4++;
}
}
}
override public function set height(param1:Number) : void {
this._height = Math.min(param1,MAX_HEIGHT);
this.bg.height = this.urlString != null ? this._height - this.urlString.height - 3 : this._height;
this.preview.y = 1;
this.rect.y = int(250 - this._height / 2);
this.rect.height = this.bg.height - 2;
this.preview.scrollRect = this.rect;
this.rangBar.y = this.bg.height - 23;
this.nameLabel.y = 10;
this.battleLimitsBar.y = 40;
this.proOptionsBar.y = 70;
this.spectatorButton.y = this.rangBar.y + this.rangIconsY - this.spectatorButton.height - 9;
if(this.urlString != null) {
this.urlString.y = this._height - this.urlCopyButton.height;
this.urlCopyButton.y = this._height - this.urlCopyButton.height;
}
this.onResize();
}
override public function get width() : Number {
return this._width;
}
override public function get height() : Number {
return this._height;
}
private function onSpectatorButtonClick(param1:MouseEvent) : void {
dispatchEvent(new BattleInfoViewEvent(BattleInfoViewEvent.ENTER_SPECTATOR));
}
public function updateSpectatorButton() : void {
this.spectatorButton.visible = Boolean(userPropertiesService.hasSpectatorPermissions()) && !this.isSpectatorInSelectedBattle();
}
private function isSpectatorInSelectedBattle() : Boolean {
return Boolean(battleInfoService.isSpectatorMode()) && battleInfoService.currentBattleId == this.infoParams.battleId;
}
public function destroy() : void {
this.spectatorButton.removeEventListener(MouseEvent.CLICK,this.onSpectatorButtonClick);
}
public function setTimeAndPercentLeft(param1:int) : void {
this.timeLeftLabel.text = TimeStringUtils.getTimeStr(param1);
this.timeLeftIndicator.setPercentLeft(this.getPercentLeft(param1));
}
private function getPercentLeft(param1:int) : Number {
if(param1 == 0) {
return 1;
}
return param1 / this.infoParams.createParams.limits.timeLimitInSec;
}
public function setMatchmakingMark(param1:Boolean) : void {
this.stamp.visible = param1;
}
}
}
|
package com.lorentz.SVG.display.base
{
public class SVGContainer extends SVGElement
{
private var _invalidElements:Boolean = false;
private var _elements:Vector.<SVGElement> = new Vector.<SVGElement>();
public function SVGContainer(tagName:String)
{
super(tagName);
}
protected function invalidateElements():void {
if(!_invalidElements)
{
_invalidElements = true;
invalidateProperties();
}
}
override protected function commitProperties():void {
super.commitProperties();
if(_invalidElements){
_invalidElements = false;
while(content.numChildren > 0)
content.removeChildAt(0);
for each(var element:SVGElement in _elements){
content.addChild(element);
}
}
}
public function addElement(element:SVGElement):void {
addElementAt(element, numElements);
}
public function addElementAt(element:SVGElement, index:int):void {
if(_elements.indexOf(element) == -1){
_elements.splice(index, 0, element);
invalidateElements();
attachElement(element);
}
}
public function getElementAt(index:int):SVGElement {
return _elements[index];
}
public function get numElements():int {
return _elements.length;
}
public function removeElement(element:SVGElement):void {
removeElementAt(_elements.indexOf(element));
}
public function removeElementAt(index:int):void {
if(index >= 0 && index < numElements){
var element:SVGElement = _elements.splice(index, 1)[0];
invalidateElements();
detachElement(element);
}
}
override public function clone():Object {
var c:SVGContainer = super.clone() as SVGContainer;
for(var i:int = 0; i < numElements; i++){
c.addElement(getElementAt(i).clone() as SVGElement);
}
return c;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.shotgun {
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;
import projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.aiming.ShotGunAimingCC;
public class ShotgunHittingModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ShotgunHittingModelServer;
private var client:IShotgunHittingModelBase = IShotgunHittingModelBase(this);
private var modelId:Long = Long.getLong(1519945329,-715940911);
public function ShotgunHittingModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ShotgunHittingModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ShotGunAimingCC,false)));
}
protected function getInitParam() : ShotGunAimingCC {
return ShotGunAimingCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p2 extends BitmapAsset
{
public function RangsIcon_p2()
{
super();
}
}
}
|
package alternativa.tanks.view {
import alternativa.tanks.controller.events.CaptchaAnswerIsIncorrectEvent;
import alternativa.tanks.controller.events.CaptchaUpdatedEvent;
import alternativa.tanks.controller.events.CheckCaptchaAnswerEvent;
import alternativa.tanks.controller.events.GetNewCaptchaEvent;
import alternativa.tanks.controller.events.NavigationEvent;
import alternativa.tanks.controller.events.PasswordRestoreCaptchaEvent;
import alternativa.tanks.controller.events.PasswordRestoreResultEvent;
import alternativa.tanks.view.events.SendRestoreEmailMessageEvent;
import alternativa.tanks.view.forms.PasswordRestoreForm;
import org.robotlegs.mvcs.Mediator;
import projects.tanks.client.commons.models.captcha.CaptchaLocation;
import projects.tanks.clients.flash.commons.models.captcha.RefreshCaptchaClickedEvent;
public class PasswordRestoreFormMediator extends Mediator {
[Inject]
public var view:PasswordRestoreForm;
public function PasswordRestoreFormMediator() {
super();
}
override public function onRegister() : void {
addViewListener(PasswordRestoreCaptchaEvent.CAPTCHA,this.onPasswordRestoreCaptcha,PasswordRestoreCaptchaEvent);
addViewListener(NavigationEvent.GO_TO_LOGIN_FORM,dispatch,NavigationEvent);
addViewListener(RefreshCaptchaClickedEvent.CLICKED,this.onRefreshCaptchaClicked,RefreshCaptchaClickedEvent);
addContextListener(PasswordRestoreResultEvent.EMAIL_DOES_NOT_EXISTS,this.onEmailDoesNotExists,PasswordRestoreResultEvent);
addContextListener(PasswordRestoreResultEvent.RESTORE_MESSAGE_HAVE_BEEN_SENT,this.onMessageHaveBeenSent,PasswordRestoreResultEvent);
addContextListener(CaptchaUpdatedEvent.RESTORE_PASSWORD_FORM_CAPTCHA_UPDATED,this.onCaptchaUpdated,CaptchaUpdatedEvent);
addContextListener(CaptchaAnswerIsIncorrectEvent.EVENT_TYPE,this.onCaptchaFailed);
}
private function onPasswordRestoreCaptcha(param1:PasswordRestoreCaptchaEvent) : void {
var local2:SendRestoreEmailMessageEvent = new SendRestoreEmailMessageEvent(param1.getEmail());
dispatch(new CheckCaptchaAnswerEvent(param1.getCaptchaAnswer(),CaptchaLocation.RESTORE_PASSWORD_FORM,local2));
}
private function onMessageHaveBeenSent(param1:PasswordRestoreResultEvent) : void {
this.view.statusOkRestoreEmail();
}
private function onEmailDoesNotExists(param1:PasswordRestoreResultEvent) : void {
this.view.statusMailNotFoundRestoreEmail();
this.view.captchaFailed();
}
private function onCaptchaFailed(param1:CaptchaAnswerIsIncorrectEvent) : void {
this.view.captchaFailed();
}
private function onRefreshCaptchaClicked(param1:RefreshCaptchaClickedEvent) : void {
dispatch(new GetNewCaptchaEvent(CaptchaLocation.RESTORE_PASSWORD_FORM));
}
private function onCaptchaUpdated(param1:CaptchaUpdatedEvent) : void {
this.view.captchaImage = param1.image;
}
}
}
|
package com.alternativaplatform.projects.tanks.client.models.battlefield.mine
{
public interface IBattleMinesModelBase
{
}
}
|
package controls.windowinner {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.windowinner.WindowInner_topRightClass.png")]
public class WindowInner_topRightClass extends BitmapAsset {
public function WindowInner_topRightClass() {
super();
}
}
}
|
package alternativa.tanks.model.usercountry {
import alternativa.tanks.gui.selectcountry.SelectCountryAlert;
import alternativa.tanks.service.country.CountryService;
import alternativa.tanks.service.country.event.ChooseCountryForPaymentEvent;
import alternativa.tanks.service.country.event.UserPaymentCountryChangedEvent;
import alternativa.tanks.service.payment.IPaymentService;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.panel.model.usercountry.IUserCountryModelBase;
import projects.tanks.client.panel.model.usercountry.UserCountryCC;
import projects.tanks.client.panel.model.usercountry.UserCountryModelBase;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.paymentactions.UserPaymentActionsService;
[ModelInfo]
public class UserCountryModel extends UserCountryModelBase implements IUserCountryModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var countryService:CountryService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var paymentDisplayService:PaymentDisplayService;
[Inject]
public static var userPaymentActionService:UserPaymentActionsService;
[Inject]
public static var paymentService:IPaymentService;
public function UserCountryModel() {
super();
}
public function showPaymentWindow() : void {
this.showPayment();
}
private function onChooseCountry(param1:ChooseCountryForPaymentEvent = null) : void {
if(paymentService.shouldChooseLocation()) {
server.checkUserPaymentCountry();
} else {
this.showPayment();
}
}
private function setCurrentPaymentCountry(param1:String) : void {
userPaymentActionService.selectCountry(param1);
countryService.setDefaultCountryCode(param1);
server.setCurrentPaymentCountry(param1);
this.showPayment();
}
private function showPayment() : void {
paymentDisplayService.loadPayment();
}
public function requestUserCountry(param1:String) : void {
countryService.setDefaultCountryCode(param1);
new SelectCountryAlert(getFunctionWrapper(this.setCurrentPaymentCountry));
}
public function objectLoaded() : void {
var local1:UserCountryCC = getInitParam();
countryService.initService(local1);
paymentService.setShouldChooseLocation(local1.locationCheckEnabled);
this.addEventListeners();
}
public function objectUnloaded() : void {
this.removeEventListeners();
}
private function addEventListeners() : void {
countryService.addEventListener(ChooseCountryForPaymentEvent.EVENT_TYPE,getFunctionWrapper(this.onChooseCountry));
countryService.addEventListener(UserPaymentCountryChangedEvent.USER_PAYMENT_COUNTRY_CHANGED,getFunctionWrapper(this.setUserPaymentCountry));
}
private function removeEventListeners() : void {
countryService.removeEventListener(ChooseCountryForPaymentEvent.EVENT_TYPE,getFunctionWrapper(this.onChooseCountry));
countryService.removeEventListener(UserPaymentCountryChangedEvent.USER_PAYMENT_COUNTRY_CHANGED,getFunctionWrapper(this.setUserPaymentCountry));
}
private function setUserPaymentCountry(param1:UserPaymentCountryChangedEvent) : void {
server.setCurrentPaymentCountry(param1.countryCode);
userPaymentActionService.selectCountry(param1.countryCode);
}
}
}
|
package alternativa.tanks.display.usertitle {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.display.usertitle.ProgressBarSkin_hpRightBgDmCls.png")]
public class ProgressBarSkin_hpRightBgDmCls extends BitmapAsset {
public function ProgressBarSkin_hpRightBgDmCls() {
super();
}
}
}
|
package projects.tanks.client.commons.types {
public class ShopAbonementBonusTypeEnum {
public static const BONUS:ShopAbonementBonusTypeEnum = new ShopAbonementBonusTypeEnum(0,"BONUS");
public static const DISCOUNT:ShopAbonementBonusTypeEnum = new ShopAbonementBonusTypeEnum(1,"DISCOUNT");
private var _value:int;
private var _name:String;
public function ShopAbonementBonusTypeEnum(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<ShopAbonementBonusTypeEnum> {
var local1:Vector.<ShopAbonementBonusTypeEnum> = new Vector.<ShopAbonementBonusTypeEnum>();
local1.push(BONUS);
local1.push(DISCOUNT);
return local1;
}
public function toString() : String {
return "ShopAbonementBonusTypeEnum [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_red_UP_LEFT.png")]
public dynamic class button_red_UP_LEFT extends BitmapData {
public function button_red_UP_LEFT(param1:int = 7, param2:int = 30) {
super(param1,param2);
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.cp {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import alternativa.types.Long;
import projects.tanks.client.battlefield.models.battle.cp.ClientPointData;
import projects.tanks.client.battlefield.models.battle.cp.ControlPointState;
import projects.tanks.client.battlefield.types.Vector3d;
public class CodecClientPointData implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_id:ICodec;
private var codec_name:ICodec;
private var codec_position:ICodec;
private var codec_score:ICodec;
private var codec_scoreChangeRate:ICodec;
private var codec_state:ICodec;
private var codec_tankIds:ICodec;
public function CodecClientPointData() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_id = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_position = param1.getCodec(new TypeCodecInfo(Vector3d,false));
this.codec_score = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_scoreChangeRate = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_state = param1.getCodec(new EnumCodecInfo(ControlPointState,false));
this.codec_tankIds = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Long,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ClientPointData = new ClientPointData();
local2.id = this.codec_id.decode(param1) as int;
local2.name = this.codec_name.decode(param1) as String;
local2.position = this.codec_position.decode(param1) as Vector3d;
local2.score = this.codec_score.decode(param1) as Number;
local2.scoreChangeRate = this.codec_scoreChangeRate.decode(param1) as Number;
local2.state = this.codec_state.decode(param1) as ControlPointState;
local2.tankIds = this.codec_tankIds.decode(param1) as Vector.<Long>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ClientPointData = ClientPointData(param2);
this.codec_id.encode(param1,local3.id);
this.codec_name.encode(param1,local3.name);
this.codec_position.encode(param1,local3.position);
this.codec_score.encode(param1,local3.score);
this.codec_scoreChangeRate.encode(param1,local3.scoreChangeRate);
this.codec_state.encode(param1,local3.state);
this.codec_tankIds.encode(param1,local3.tankIds);
}
}
}
|
package alternativa.tanks.camera
{
public class CameraBookmarks
{
private var bookmarks:Vector.<CameraBookmark>;
public function CameraBookmarks(param1:int)
{
super();
this.bookmarks = new Vector.<CameraBookmark>(param1);
}
public function getBookmark(param1:uint) : CameraBookmark
{
if(param1 < this.bookmarks.length)
{
return this.bookmarks[param1];
}
return null;
}
public function saveCurrentPositionCameraToBookmark(param1:uint) : void
{
if(param1 < this.bookmarks.length)
{
this.getOrCreateBookmark(param1).saveCurrentPossitionCamera();
}
}
private function getOrCreateBookmark(param1:uint) : CameraBookmark
{
if(this.bookmarks[param1] == null)
{
this.bookmarks[param1] = new CameraBookmark();
}
return this.bookmarks[param1];
}
}
}
|
package alternativa.tanks.model.garage.temperature {
public interface TemperatureConfig {
function get temperatureAutoDecrement() : Number;
}
}
|
package scpacker.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksI_coldload16 extends BitmapAsset
{
public function GTanksI_coldload16()
{
super();
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup
{
import alternativa.engine3d.core.MipMapping;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.physics.RayHit;
import alternativa.tanks.engine3d.MaterialType;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.battlefield.effects.levelup.levelup.LightBeamEffect;
import alternativa.tanks.models.battlefield.effects.levelup.levelup.LightWaveEffect;
import alternativa.tanks.models.battlefield.effects.levelup.levelup.SparkEffect;
import alternativa.tanks.models.battlefield.effects.levelup.rangs.BigRangIcon;
import alternativa.tanks.services.materialregistry.IMaterialRegistry;
import alternativa.tanks.vehicles.tanks.Tank;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
public class LevelUpEffect
{
[Embed(source="1146.png")]
private static const BeamTexture:Class;
private static const beamBitmapData:BitmapData = new BeamTexture().bitmapData;
[Embed(source="759.png")]
private static const SparkTexture:Class;
private static const sparkBitmapData:BitmapData = new SparkTexture().bitmapData;
[Embed(source="1189.png")]
private static const WaveTexture:Class;
private static const waveBitmapData:BitmapData = new WaveTexture().bitmapData;
private static const origin:Vector3 = new Vector3();
private static const upDirection:Vector3 = new Vector3(0,0,1);
private static const rayHit:RayHit = new RayHit();
private static var materialRegistry:IMaterialRegistry;
private var battlefield:BattlefieldModel;
public function LevelUpEffect()
{
super();
this.battlefield = Main.osgi.getService(IBattleField) as BattlefieldModel;
materialRegistry = IMaterialRegistry(Main.osgi.getService(IMaterialRegistry));
}
private static function getAvailableHeight(param1:Number, param2:Number, param3:Number, param4:Number) : Number
{
return 2000;
}
public function createEffect(param1:Tank, param2:int) : void
{
var _loc3_:Object3D = param1.skin.turretMesh;
var _loc4_:Number = this.getEffectHeight(_loc3_.x,_loc3_.y,_loc3_.z);
this.createLightBeams(_loc4_,_loc3_);
this.createLabel(param1.id,_loc4_,param2,_loc3_);
this.createSparks(_loc4_,_loc3_);
this.createWave(_loc3_);
}
private function getEffectHeight(param1:Number, param2:Number, param3:Number) : Number
{
var _loc6_:Number = getAvailableHeight(param1,param2,param3,2000);
return Math.max(500,_loc6_);
}
private function createLightBeams(param1:Number, param2:Object3D) : void
{
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:LightBeamEffect = null;
var _loc5_:Number = 0;
var _loc6_:Number = Math.PI * 2 / 6;
var _loc7_:TextureMaterial = materialRegistry.textureMaterialRegistry.getMaterial(MaterialType.EFFECT,beamBitmapData,beamBitmapData.height / beamBitmapData.width,false);
var _loc8_:int = 0;
while(_loc8_ < 6)
{
_loc9_ = Math.sin(_loc5_) * 90;
_loc10_ = Math.cos(_loc5_) * 90;
_loc11_ = LightBeamEffect(this.battlefield.getObjectPool().getObject(LightBeamEffect));
_loc11_.init(500,200,30,param1,0.8,0.5,_loc9_,_loc10_,-50,param2,_loc7_);
this.battlefield.addGraphicEffect(_loc11_);
_loc5_ += _loc6_;
_loc8_++;
}
}
private function createLabel(param1:int, param2:Number, param3:int, param4:Object3D) : void
{
var rangBitmap:Bitmap = new Bitmap(BigRangIcon.getRangIcon(param3));
var _loc8_:BitmapData = new BitmapData(rangBitmap.width,rangBitmap.height,true,0);
_loc8_.draw(rangBitmap);
var _loc9_:TextureMaterial = new TextureMaterial(_loc8_,false,true,MipMapping.PER_PIXEL,1);
var _loc10_:SparkEffect = SparkEffect(this.battlefield.getObjectPool().getObject(SparkEffect));
_loc10_.init(500,270,270,0,param2 * 0.8,param2 * 0.15,0.35,0,0,50,param4,_loc9_,BlendMode.NORMAL);
this.battlefield.addGraphicEffect(_loc10_);
}
private function createSparks(param1:Number, param2:Object3D) : void
{
var _loc3_:int = 0;
var _loc4_:Number = NaN;
var _loc5_:TextureMaterial = null;
var _loc6_:int = 0;
var _loc7_:Number = NaN;
var _loc8_:Number = NaN;
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:SparkEffect = null;
_loc3_ = 15;
_loc4_ = 100;
_loc5_ = materialRegistry.textureMaterialRegistry.getMaterial(MaterialType.EFFECT,sparkBitmapData,sparkBitmapData.height / sparkBitmapData.width,false);
_loc6_ = 0;
while(_loc6_ < _loc3_)
{
_loc7_ = Math.PI * 2 * Math.random();
_loc8_ = Math.sin(_loc7_) * _loc4_;
_loc9_ = Math.cos(_loc7_) * _loc4_;
_loc10_ = -110 * _loc6_ - 50;
_loc11_ = SparkEffect(this.battlefield.getObjectPool().getObject(SparkEffect));
_loc11_.init(400,150,150,_loc7_,param1 * 0.7,param1 * 0.15,0.7,_loc8_,_loc9_,_loc10_,param2,_loc5_,BlendMode.ADD);
this.battlefield.addGraphicEffect(_loc11_);
_loc6_++;
}
}
private function createWave(param1:Object3D) : void
{
var _loc2_:TextureMaterial = materialRegistry.textureMaterialRegistry.getMaterial(MaterialType.EFFECT,waveBitmapData,waveBitmapData.height / waveBitmapData.width,false);
var _loc3_:LightWaveEffect = LightWaveEffect(this.battlefield.getObjectPool().getObject(LightWaveEffect));
_loc3_.init(900,220,3,true,param1,_loc2_);
this.battlefield.addGraphicEffect(_loc3_);
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_def_OVER_LEFT.png")]
public dynamic class button_def_OVER_LEFT extends BitmapData {
public function button_def_OVER_LEFT(param1:int = 7, param2:int = 30) {
super(param1,param2);
}
}
}
|
package projects.tanks.client.battlefield.models.continuebattle {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.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;
import projects.tanks.client.battleselect.model.matchmaking.queue.MatchmakingMode;
public class MatchmakingContinueBattleModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _continueBattleId:Long = Long.getLong(1252922053,-184218977);
private var _continueBattle_modeCodec:ICodec;
private var model:IModel;
public function MatchmakingContinueBattleModelServer(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._continueBattle_modeCodec = this.protocol.getCodec(new EnumCodecInfo(MatchmakingMode,false));
}
public function continueBattle(param1:MatchmakingMode) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._continueBattle_modeCodec.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._continueBattleId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.common.discrete {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.weapons.common.discrete.TargetHit;
public class VectorCodecTargetHitLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTargetHitLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TargetHit,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.<TargetHit> = new Vector.<TargetHit>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TargetHit(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TargetHit = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TargetHit> = Vector.<TargetHit>(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.battlefield.gui.statistics.table
{
public class StatisticsData
{
public var label:Object = null;
public var icon:Object = null;
public var id:Object;
public var playerRank:int = 0;
public var playerName:String = "";
public var kills:int = 0;
public var deaths:int = 0;
public var score:int = 0;
public var reward:int = -1;
public var type:int;
public var self:Boolean;
public function StatisticsData()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.user.tank.commands {
import projects.tanks.client.battlefield.types.Vector3d;
public class MoveCommand {
private var _angularVelocity:Vector3d;
private var _control:int;
private var _linearVelocity:Vector3d;
private var _orientation:Vector3d;
private var _position:Vector3d;
private var _turnSpeedNumber:int;
public function MoveCommand(param1:Vector3d = null, param2:int = 0, param3:Vector3d = null, param4:Vector3d = null, param5:Vector3d = null, param6:int = 0) {
super();
this._angularVelocity = param1;
this._control = param2;
this._linearVelocity = param3;
this._orientation = param4;
this._position = param5;
this._turnSpeedNumber = param6;
}
public function get angularVelocity() : Vector3d {
return this._angularVelocity;
}
public function set angularVelocity(param1:Vector3d) : void {
this._angularVelocity = param1;
}
public function get control() : int {
return this._control;
}
public function set control(param1:int) : void {
this._control = param1;
}
public function get linearVelocity() : Vector3d {
return this._linearVelocity;
}
public function set linearVelocity(param1:Vector3d) : void {
this._linearVelocity = param1;
}
public function get orientation() : Vector3d {
return this._orientation;
}
public function set orientation(param1:Vector3d) : void {
this._orientation = param1;
}
public function get position() : Vector3d {
return this._position;
}
public function set position(param1:Vector3d) : void {
this._position = param1;
}
public function get turnSpeedNumber() : int {
return this._turnSpeedNumber;
}
public function set turnSpeedNumber(param1:int) : void {
this._turnSpeedNumber = param1;
}
public function toString() : String {
var local1:String = "MoveCommand [";
local1 += "angularVelocity = " + this.angularVelocity + " ";
local1 += "control = " + this.control + " ";
local1 += "linearVelocity = " + this.linearVelocity + " ";
local1 += "orientation = " + this.orientation + " ";
local1 += "position = " + this.position + " ";
local1 += "turnSpeedNumber = " + this.turnSpeedNumber + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.antiaddiction {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IAntiAddictionAlertAdapt implements IAntiAddictionAlert {
private var object:IGameObject;
private var impl:IAntiAddictionAlert;
public function IAntiAddictionAlertAdapt(param1:IGameObject, param2:IAntiAddictionAlert) {
super();
this.object = param1;
this.impl = param2;
}
public function setIdNumberAndRealName(param1:String, param2:String) : void {
var realName:String = param1;
var idNumber:String = param2;
try {
Model.object = this.object;
this.impl.setIdNumberAndRealName(realName,idNumber);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.tank.pause {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ITankPauseEvents implements ITankPause {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ITankPauseEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function enablePause() : void {
var i:int = 0;
var m:ITankPause = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ITankPause(this.impl[i]);
m.enablePause();
i++;
}
}
finally {
Model.popObject();
}
}
public function disablePause() : void {
var i:int = 0;
var m:ITankPause = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ITankPause(this.impl[i]);
m.disablePause();
i++;
}
}
finally {
Model.popObject();
}
}
public function resetIdleKickTime() : void {
var i:int = 0;
var m:ITankPause = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ITankPause(this.impl[i]);
m.resetIdleKickTime();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.panel.model.quest.common.specification {
public class QuestLevel {
public static const EASY:QuestLevel = new QuestLevel(0,"EASY");
public static const NORMAL:QuestLevel = new QuestLevel(1,"NORMAL");
public static const HARD:QuestLevel = new QuestLevel(2,"HARD");
private var _value:int;
private var _name:String;
public function QuestLevel(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<QuestLevel> {
var local1:Vector.<QuestLevel> = new Vector.<QuestLevel>();
local1.push(EASY);
local1.push(NORMAL);
local1.push(HARD);
return local1;
}
public function toString() : String {
return "QuestLevel [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.models.drones {
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.tankskin.TankSkin;
import alternativa.tanks.service.settings.ISettingsService;
public class DroneDeactivationRenderer extends AbstractDroneRenderer {
private const EFFECT_DURATION_MS:* = 2000;
private var initLocalPosition:* = new Vector3();
private var localPosition:* = new Vector3();
public function DroneDeactivationRenderer(param1:Boolean, param2:TankSkin, param3:Drone, param4:BattleService, param5:ISettingsService) {
super(param1,param2,param3,param4,param5);
}
override public function render(param1:int, param2:int) : void {
var local3:* = undefined;
local3 = 1 - (param1 - startTime) / this.EFFECT_DURATION_MS;
if(local3 <= 0) {
this.stop();
return;
}
targetAlpha = local3;
this.localPosition.copy(basePosition);
this.localPosition.x *= local3;
this.localPosition.y *= local3;
this.localPosition.z *= local3;
getTurretMatrix().transformVector(this.localPosition,drone.getPosition());
setPositionAndRotation(param1,param2);
updateVisibility();
}
override public function start() : void {
super.start();
getTurretMatrix().invert().transformVector(drone.getPosition(),this.initLocalPosition);
}
override public function stop() : void {
super.stop();
drone.getObject3D().visible = false;
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.item3d {
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.item3d.Item3DCC;
public class VectorCodecItem3DCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecItem3DCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(Item3DCC,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.<Item3DCC> = new Vector.<Item3DCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = Item3DCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:Item3DCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<Item3DCC> = Vector.<Item3DCC>(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.sfx {
import alternativa.math.Vector3;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class AnimatedPlaneEffect extends PooledObject implements GraphicEffect {
private static const BASE_SIZE:Number = 100;
private var scaleSpeed:Number;
protected var scale:Number;
protected var baseScale:Number;
protected var plane:SquareAnimatedPlane;
private var currentTime:int;
private var maxTime:int;
private var container:Scene3DContainer;
public function AnimatedPlaneEffect(param1:Pool) {
super(param1);
this.plane = new SquareAnimatedPlane(BASE_SIZE);
this.plane.useShadowMap = false;
this.plane.useLight = false;
this.plane.shadowMapAlphaThreshold = 2;
this.plane.depthMapAlphaThreshold = 2;
this.plane.softAttenuation = 0;
}
public function init(param1:Number, param2:Vector3, param3:Vector3, param4:TextureAnimation, param5:Number) : void {
this.plane.init(param4,0.001 * param4.fps);
this.maxTime = this.plane.getOneLoopTime();
this.currentTime = 0;
this.scaleSpeed = 0.001 * param5;
this.baseScale = param1 / BASE_SIZE;
this.scale = this.baseScale;
this.plane.x = param2.x;
this.plane.y = param2.y;
this.plane.z = param2.z;
this.plane.rotationX = param3.x;
this.plane.rotationY = param3.y;
this.plane.rotationZ = param3.z;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.plane);
}
public function play(param1:int, param2:GameCamera) : Boolean {
if(this.currentTime >= this.maxTime) {
return false;
}
this.plane.setTime(this.currentTime);
this.currentTime += param1;
this.plane.scaleX = this.scale;
this.plane.scaleY = this.scale;
this.scale = this.baseScale + this.baseScale * this.scaleSpeed * this.currentTime;
return true;
}
public function destroy() : void {
this.container.removeChild(this.plane);
this.container = null;
this.plane.clear();
recycle();
}
public function kill() : void {
this.currentTime = this.maxTime;
}
}
}
|
package alternativa.tanks.models.weapon.gauss {
[ModelInterface]
public interface GaussSkin {
function getSkin() : GaussTurretSkin;
}
}
|
package alternativa.tanks.model.useremailandpassword {
[ModelInterface]
public interface IUserEmailAndPassword {
function changeEmail(param1:String) : void;
function getEmail() : String;
function sendChangeInstruction() : void;
}
}
|
package alternativa.tanks.models.weapon.shaft.states {
import alternativa.tanks.models.weapon.shaft.ShaftEventType;
import alternativa.tanks.models.weapon.shaft.ShaftWeapon;
public class ReadyToShootState implements IShaftState {
private var weapon:ShaftWeapon;
private var timeThreshold:int;
private var switchTime:int;
public function ReadyToShootState(param1:ShaftWeapon, param2:int) {
super();
this.weapon = param1;
this.timeThreshold = param2;
}
public function enter(param1:int) : void {
this.switchTime = param1 + this.timeThreshold;
}
public function update(param1:int, param2:int) : void {
if(this.weapon.isBarrelOriginInsideStaticGeometry()) {
this.weapon.processEvent(ShaftEventType.STOP);
} else if(this.weapon.isAimedModeLocked() && this.weapon.canShoot()) {
this.weapon.processEvent(ShaftEventType.TRIGGER_RELEASE);
} else if(param1 >= this.switchTime && this.weapon.getEnergy() == this.weapon.getMaxEnergy() && !this.weapon.isAimedModeLocked()) {
this.weapon.processEvent(ShaftEventType.SWITCH);
}
}
public function exit() : void {
}
public function processEvent(param1:ShaftEventType, param2:*) : void {
switch(param1) {
case ShaftEventType.TRIGGER_RELEASE:
this.weapon.processEvent(ShaftEventType.TRIGGER_RELEASE);
}
}
}
}
|
package _codec.projects.tanks.client.battleselect.model.battle.dm {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battleselect.model.battle.dm.BattleDMInfoCC;
public class VectorCodecBattleDMInfoCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattleDMInfoCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BattleDMInfoCC,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.<BattleDMInfoCC> = new Vector.<BattleDMInfoCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattleDMInfoCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattleDMInfoCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattleDMInfoCC> = Vector.<BattleDMInfoCC>(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.inventory
{
public interface IInventory
{
function lockItem(param1:int, param2:int, param3:Boolean) : void;
function lockItems(param1:int, param2:Boolean) : void;
}
}
|
package alternativa.tanks.battle.hidablegraphicobjects {
import alternativa.math.Vector3;
public interface HidableGraphicObject {
function readPosition(param1:Vector3) : void;
function setAlphaMultiplier(param1:Number) : void;
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_ratingsActiveIconMakeUp.png")]
public class MakeUp_ratingsActiveIconMakeUp extends BitmapAsset {
public function MakeUp_ratingsActiveIconMakeUp() {
super();
}
}
}
|
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.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.garage.availableupgrades.AvailableUpgradeItem;
import projects.tanks.client.panel.model.garage.availableupgrades.AvailableUpgradesCC;
public class CodecAvailableUpgradesCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_availableUpgradeItems:ICodec;
public function CodecAvailableUpgradesCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_availableUpgradeItems = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(AvailableUpgradeItem,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:AvailableUpgradesCC = new AvailableUpgradesCC();
local2.availableUpgradeItems = this.codec_availableUpgradeItems.decode(param1) as Vector.<AvailableUpgradeItem>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:AvailableUpgradesCC = AvailableUpgradesCC(param2);
this.codec_availableUpgradeItems.encode(param1,local3.availableUpgradeItems);
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.clientlayoutkit {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.shop.clientlayoutkit.CCBundleText;
public class CodecCCBundleText implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_color:ICodec;
private var codec_fontPercentSize:ICodec;
private var codec_positionPercentX:ICodec;
private var codec_positionPercentY:ICodec;
private var codec_text:ICodec;
public function CodecCCBundleText() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_color = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_fontPercentSize = param1.getCodec(new TypeCodecInfo(int,true));
this.codec_positionPercentX = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_positionPercentY = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_text = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:CCBundleText = new CCBundleText();
local2.color = this.codec_color.decode(param1) as int;
local2.fontPercentSize = this.codec_fontPercentSize.decode(param1) as int;
local2.positionPercentX = this.codec_positionPercentX.decode(param1) as int;
local2.positionPercentY = this.codec_positionPercentY.decode(param1) as int;
local2.text = this.codec_text.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:CCBundleText = CCBundleText(param2);
this.codec_color.encode(param1,local3.color);
this.codec_fontPercentSize.encode(param1,local3.fontPercentSize);
this.codec_positionPercentX.encode(param1,local3.positionPercentX);
this.codec_positionPercentY.encode(param1,local3.positionPercentY);
this.codec_text.encode(param1,local3.text);
}
}
}
|
package projects.tanks.client.garage.models.item.container {
import platform.client.fp10.core.resource.types.ImageResource;
public class ContainerGivenItem {
private var _category:ContainerItemCategory;
private var _count:int;
private var _image:ImageResource;
private var _name:String;
public function ContainerGivenItem(param1:ContainerItemCategory = null, param2:int = 0, param3:ImageResource = null, param4:String = null) {
super();
this._category = param1;
this._count = param2;
this._image = param3;
this._name = param4;
}
public function get category() : ContainerItemCategory {
return this._category;
}
public function set category(param1:ContainerItemCategory) : void {
this._category = param1;
}
public function get count() : int {
return this._count;
}
public function set count(param1:int) : void {
this._count = param1;
}
public function get image() : ImageResource {
return this._image;
}
public function set image(param1:ImageResource) : void {
this._image = param1;
}
public function get name() : String {
return this._name;
}
public function set name(param1:String) : void {
this._name = param1;
}
public function toString() : String {
var local1:String = "ContainerGivenItem [";
local1 += "category = " + this.category + " ";
local1 += "count = " + this.count + " ";
local1 += "image = " + this.image + " ";
local1 += "name = " + this.name + " ";
return local1 + "]";
}
}
}
|
package com.lorentz.processing
{
public class Process implements IProcess
{
public static const CONTINUE:int = 0;
public static const SKIP_FRAME:int = 1;
public static const COMPLETE:int = 2;
public function Process(startFunction:Function, loopFunction:Function, completeFunction:Function = null)
{
_startFunction = startFunction;
_loopFunction = loopFunction;
_completeFunction = completeFunction;
}
private var _loopFunction:Function;
public function get loopFunction():Function {
return _loopFunction;
}
private var _completeFunction:Function;
public function get completeFunction():Function {
return _completeFunction;
}
private var _startFunction:Function;
public function get startFunction():Function {
return _startFunction;
}
internal var _isComplete:Boolean = false;
public function get isComplete():Boolean {
return _isComplete;
}
internal var _isRunning:Boolean = false;
public function get isRunning():Boolean {
return _isRunning;
}
public function start():void {
if(_isRunning)
throw new Error("This process is already running.");
if(_isComplete)
throw new Error("This process is complete.");
_isRunning = true;
if(startFunction != null)
startFunction();
ProcessExecutor.instance.addProcess(this);
}
public function execute(): void {
if(startFunction != null)
startFunction();
while(loopFunction() != COMPLETE)
{}
complete();
}
public function stop():void {
_isRunning = false;
ProcessExecutor.instance.removeProcess(this);
}
public function complete():void {
_isRunning = false;
_isComplete = true;
if(completeFunction != null)
completeFunction();
ProcessExecutor.instance.removeProcess(this);
}
public function reset():void {
if(_isRunning)
stop();
_isComplete = false;
}
public function executeLoop():Boolean {
var r:* = loopFunction();
if(r == COMPLETE)
complete();
return r;
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _0426f701766dc3f7d9a0887a37f2146a664310fd42877b7da9c1e53555523bdf_flash_display_Sprite extends Sprite {
public function _0426f701766dc3f7d9a0887a37f2146a664310fd42877b7da9c1e53555523bdf_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package alternativa.tanks.models.battlefield.gui.statistics.messages
{
import alternativa.tanks.models.battlefield.common.MessageContainer;
import alternativa.tanks.models.battlefield.common.MessageLine;
import alternativa.tanks.models.battlefield.event.ChatOutputLineEvent;
public class BattleMessagesOutput extends MessageContainer
{
public var maxMessages:int = 10;
public function BattleMessagesOutput()
{
super();
}
public function addLine(line:UserActionOutputLine) : void
{
var msg:MessageLine = null;
pushMessage(line);
if(container.numChildren > this.maxMessages)
{
msg = shiftMessages();
if(msg != null)
{
msg.removeEventListener(ChatOutputLineEvent.KILL_ME,this.onKillLine);
}
}
line.addEventListener(ChatOutputLineEvent.KILL_ME,this.onKillLine);
line.x = -line.width - 10;
}
private function onKillLine(e:ChatOutputLineEvent) : void
{
if(container.contains(e.line))
{
shiftMessages();
}
e.line.removeEventListener(ChatOutputLineEvent.KILL_ME,this.onKillLine);
}
}
}
|
package alternativa.tanks.gui
{
import flash.events.Event;
public class GarageWindowEvent extends Event
{
public static const WAREHOUSE_ITEM_SELECTED:String = "GarageWindowEventWirehouseItemSelected";
public static const STORE_ITEM_SELECTED:String = "GarageWindowEventStoreItemSelected";
public static const BUY_ITEM:String = "GarageWindowEventBuyItem";
public static const SETUP_ITEM:String = "GarageWindowEventSetupItem";
public static const UPGRADE_ITEM:String = "GarageWindowEventUpgradeItem";
public static const PROCESS_SKIN:String = "GarageWindowEventSkin";
public static const ADD_CRYSTALS:String = "GarageWindowEventAddCrystals";
public static const OPEN_ITEM:String = "GarageWindowEventOpenGift";
public var itemId:String;
public function GarageWindowEvent(type:String, itemId:String)
{
super(type,true,false);
this.itemId = itemId;
}
}
}
|
package alternativa.tanks.battle.scene3d {
public class RotationState {
public static const WITHOUT_ROTATION:RotationState = new RotationState("without_rotation");
public static const USE_RANDOM_ROTATION:RotationState = new RotationState("use_random_rotation");
private var _state:String;
public function RotationState(param1:String) {
super();
this._state = param1;
}
public function get state() : String {
return this._state;
}
public function toString() : String {
return "RotationState{_state=" + String(this._state) + "}";
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.pointbased.rugby {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.SoundResource;
import projects.tanks.client.battlefield.models.battle.pointbased.rugby.RugbySoundFX;
public class CodecRugbySoundFX implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_ballDropNegativeSound:ICodec;
private var codec_ballDropPositiveSound:ICodec;
private var codec_ballFaceOffSound:ICodec;
private var codec_ballTakeNegativeSound:ICodec;
private var codec_ballTakePositiveSound:ICodec;
private var codec_goalNegativeSound:ICodec;
private var codec_goalPositiveSound:ICodec;
public function CodecRugbySoundFX() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_ballDropNegativeSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_ballDropPositiveSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_ballFaceOffSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_ballTakeNegativeSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_ballTakePositiveSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_goalNegativeSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_goalPositiveSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:RugbySoundFX = new RugbySoundFX();
local2.ballDropNegativeSound = this.codec_ballDropNegativeSound.decode(param1) as SoundResource;
local2.ballDropPositiveSound = this.codec_ballDropPositiveSound.decode(param1) as SoundResource;
local2.ballFaceOffSound = this.codec_ballFaceOffSound.decode(param1) as SoundResource;
local2.ballTakeNegativeSound = this.codec_ballTakeNegativeSound.decode(param1) as SoundResource;
local2.ballTakePositiveSound = this.codec_ballTakePositiveSound.decode(param1) as SoundResource;
local2.goalNegativeSound = this.codec_goalNegativeSound.decode(param1) as SoundResource;
local2.goalPositiveSound = this.codec_goalPositiveSound.decode(param1) as SoundResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:RugbySoundFX = RugbySoundFX(param2);
this.codec_ballDropNegativeSound.encode(param1,local3.ballDropNegativeSound);
this.codec_ballDropPositiveSound.encode(param1,local3.ballDropPositiveSound);
this.codec_ballFaceOffSound.encode(param1,local3.ballFaceOffSound);
this.codec_ballTakeNegativeSound.encode(param1,local3.ballTakeNegativeSound);
this.codec_ballTakePositiveSound.encode(param1,local3.ballTakePositiveSound);
this.codec_goalNegativeSound.encode(param1,local3.goalNegativeSound);
this.codec_goalPositiveSound.encode(param1,local3.goalPositiveSound);
}
}
}
|
package projects.tanks.client.battleselect.model.matchmaking.spectator {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.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;
import projects.tanks.client.battleselect.model.matchmaking.queue.MatchmakingMode;
public class MatchmakingSpectatorEntranceModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _enterId:Long = Long.getLong(323483368,-617179503);
private var _enter_modeCodec:ICodec;
private var model:IModel;
public function MatchmakingSpectatorEntranceModelServer(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._enter_modeCodec = this.protocol.getCodec(new EnumCodecInfo(MatchmakingMode,false));
}
public function enter(param1:MatchmakingMode) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._enter_modeCodec.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._enterId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_blue_OVER_LEFT.png")]
public dynamic class button_blue_OVER_LEFT extends BitmapData {
public function button_blue_OVER_LEFT(param1:int = 7, param2:int = 30) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.models.effects.common.bonuscommon
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.lights.OmniLight;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.physics.BodyState;
import alternativa.physics.PhysicsScene;
import alternativa.physics.altphysics;
import alternativa.physics.collision.CollisionPrimitive;
import alternativa.physics.collision.ICollisionPredicate;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.tanks.bonuses.BonusState;
import alternativa.tanks.bonuses.IBonus;
import alternativa.tanks.bonuses.IBonusListener;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.battlefield.hidableobjects.HidableObject3DWrapper;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import alternativa.tanks.vehicles.tanks.Tank;
import flash.geom.ColorTransform;
import flash.utils.Dictionary;
use namespace altphysics;
public class ParaBonus implements IBonus, ICollisionPredicate
{
private static const BIG_VALUE:Number = 10000000000;
private static const BOX_MASS:Number = 20;
private static const BOX_HALF_SIZE:Number = 75;
private static const PARACHUTE_MASS:Number = 10;
private static const PARACHUTE_RADIUS:Number = 180;
private static const CORDS_LENGTH:Number = 400;
private static const TAKEN_ANIMATION_TIME:int = 2000;
private static const FLASH_DURATION:int = 300;
private static const ALPHA_DURATION:int = TAKEN_ANIMATION_TIME - FLASH_DURATION;
private static const MAX_ADDITIVE_VALUE:int = 204;
private static const ADDITIVE_SPEED_UP:Number = Number(MAX_ADDITIVE_VALUE) / FLASH_DURATION;
private static const ADDITIVE_SPEED_DOWN:Number = Number(MAX_ADDITIVE_VALUE) / (TAKEN_ANIMATION_TIME - FLASH_DURATION);
private static const UP_SPEED:Number = 300;
private static const ANGLE_SPEED:Number = 2;
private static const PHYSICS_STATE_FULL:int = 1;
private static const PHYSICS_STATE_PARABOX:int = 2;
private static const PHYSICS_STATE_BOX:int = 3;
private static const WARNING_TIME:int = 8000;
private static const PARACHUTE_REMOVAL_TIME:int = 2000;
private static const BLINK_INTERVAL:int = 500;
private static const DELTA_ALPHA:Number = 0.5;
private static const MIN_ALPHA:Number = 1 - DELTA_ALPHA;
private static const COEFF:Number = 10;
private static const defaultState:BodyState = new BodyState();
private static var pools:Dictionary = new Dictionary();
private static var _v:Vector3 = new Vector3();
private static const _rayHit:RayIntersection = new RayIntersection();
private static const N:Vector3 = new Vector3();
private static const P:Vector3 = new Vector3();
private static const P1:Vector3 = new Vector3();
private static const X:Vector3 = new Vector3();
private static const Y:Vector3 = new Vector3();
private static const Y1:Vector3 = new Vector3();
private static const origin:Vector3 = new Vector3();
private var _bonusId:String;
private var bonusState:int;
private var bonusListener:IBonusListener;
public var parachute:Parachute;
public var cordsMesh:Cords;
private var timeToLive:int;
private var currBlinkInterval:int;
private var visibilitySwitchTime:int;
private var takenAnimationTime:int;
private var parachuteTimeLeft:int;
private var additiveValue:int;
private var alphaSpeed:Number;
private var physicsState:int;
private var pool:Pool;
public var skin:BonusMesh;
public var light:OmniLight;
private var hidabbleWrapper:HidableObject3DWrapper;
private var _boxMesh:Mesh;
private var _parachuteMesh:Mesh;
private var _parachuteInnerMesh:Mesh;
private var _cordMaterial:Material;
private var fallSpeed:Number = 200;
private var fallPrecision:int = 3;
private var landingPrecision:int = 3;
private var fallController:FallController;
private var landingController:LandingController;
private var landingControllerInited:Boolean;
public var trigger:BonusTrigger;
public function ParaBonus(pool:Pool, boxMesh:Mesh, parachuteMesh:Mesh, parachuteInnerMesh:Mesh, cordMaterial:Material)
{
super();
this.pool = pool;
this._boxMesh = boxMesh;
this._parachuteMesh = parachuteMesh;
this._parachuteInnerMesh = parachuteInnerMesh;
this._cordMaterial = cordMaterial;
this.fallController = new FallController(this);
this.landingController = new LandingController(this);
this.trigger = new BonusTrigger(this);
}
public static function create(bonusData:BonusCommonData) : ParaBonus
{
var pool:Pool = pools[bonusData];
if(pool == null)
{
pool = new Pool();
pools[bonusData] = pool;
}
if(pool.numObjects == 0)
{
return new ParaBonus(pool,bonusData.boxMesh,bonusData.parachuteMesh,bonusData.parachuteInnerMesh,bonusData.cordMaterial);
}
var bonus:ParaBonus = pool.objects[--pool.numObjects];
pool.objects[pool.numObjects] = null;
return bonus;
}
public static function deletePool(bonusData:BonusCommonData) : void
{
delete pools[bonusData];
}
private static function isFlatSurface(groundNormal:Vector3) : Boolean
{
return groundNormal.z > BonusConst.COS_ONE_DEGREE;
}
public function init(bonusId:String, timeToLive:int, isFalling:Boolean) : void
{
this._bonusId = bonusId;
if(BonusCache.isBonusMeshCacheEmpty(this.bonusId))
{
this.skin = new BonusMesh(this._bonusId,this._boxMesh);
}
else
{
this.skin = BonusCache.getBonusMesh(this._bonusId);
}
var colorLight:uint = 16745512;
if(bonusId.indexOf("health") >= 0)
{
colorLight = 65280;
}
if(bonusId.indexOf("armor") >= 0)
{
colorLight = 16777215;
}
if(bonusId.indexOf("damage") >= 0)
{
colorLight = 65535;
}
if(bonusId.indexOf("nitro") >= 0)
{
colorLight = 16711680;
}
if(bonusId.indexOf("crystall") >= 0)
{
colorLight = 8454143;
}
if(bonusId.indexOf("gold") >= 0)
{
colorLight = 16777088;
}
this.light = new OmniLight(colorLight,150,500);
this.hidabbleWrapper = new HidableObject3DWrapper(this.skin);
this.createParachuteAndCords(this._parachuteMesh,this._parachuteInnerMesh,this._cordMaterial);
this.timeToLive = timeToLive < 0 ? int(int(int.MAX_VALUE)) : int(int(timeToLive));
this.bonusState = !!isFalling ? int(int(BonusState.FALLING)) : int(int(BonusState.RESTING));
this.skin.alpha = 1;
var colorTransform:ColorTransform = this.skin.colorTransform;
if(colorTransform != null)
{
colorTransform.redOffset = 0;
colorTransform.greenOffset = 0;
colorTransform.blueOffset = 0;
}
this.additiveValue = 0;
this.cordsMesh.alpha = 1;
this.visibilitySwitchTime = 0;
this.takenAnimationTime = TAKEN_ANIMATION_TIME;
this.parachuteTimeLeft = PARACHUTE_REMOVAL_TIME;
this.currBlinkInterval = BLINK_INTERVAL;
}
private function getGroundPointAndNormal(spawnPosition:Vector3, point:Vector3, normal:Vector3) : void
{
var collisionDetector:TanksCollisionDetector = BattlefieldModel(Main.osgi.getService(IBattleField)).bfData.collisionDetector;
if(collisionDetector.raycastStatic(spawnPosition,Vector3.DOWN,CollisionGroup.STATIC,BIG_VALUE,_rayHit))
{
normal.vCopy(_rayHit.normal);
point.vCopy(_rayHit.pos);
}
else
{
normal.vCopy(Vector3.Z_AXIS);
point.vCopy(spawnPosition);
point.z -= 1000;
}
}
public function get bonusId() : String
{
return this._bonusId;
}
public function isFalling() : Boolean
{
return this.bonusState == BonusState.FALLING;
}
public function readBonusPosition(result:Vector3) : void
{
result.x = this.skin.x;
result.y = this.skin.y;
result.z = this.skin.z;
}
public function setBonusPosition(x:Number, y:Number, z:Number) : void
{
this.skin.x = x;
this.skin.y = y;
this.skin.z = z;
}
public function setRestingState(x:Number, y:Number, z:Number) : void
{
this.setBonusPosition(x,y,z);
if(this.bonusState != BonusState.RESTING)
{
this.bonusState = BonusState.RESTING;
this.detachParachute();
}
}
public function setTakenState() : void
{
this.takenAnimationTime = TAKEN_ANIMATION_TIME;
this.skin.setAlpha(1);
if(this.bonusState == BonusState.FALLING)
{
this.detachParachute();
}
this.bonusState = BonusState.TAKEN;
}
public function setRemovedState() : void
{
this.bonusState = BonusState.REMOVING;
}
public function attach(pos:Vector3, rigidWorld:PhysicsScene, container:Scene3DContainer, listener:IBonusListener) : void
{
var fallTime:Number = NaN;
var minPivotZ:Number = NaN;
var startingAngleZ:Number = NaN;
this.light.x = pos.x;
this.light.y = pos.y;
this.light.z = pos.z - 400;
if(container != null)
{
container.addChild(this.skin);
BattlefieldModel(Main.osgi.getService(IBattleField)).hidableObjects.add(this.hidabbleWrapper);
}
if(this.bonusState == BonusState.FALLING)
{
this.parachute.x = pos.x;
this.parachute.y = pos.y;
this.parachute.z = pos.z + 0.5 * CORDS_LENGTH;
container.addChild(this.parachute);
container.addChild(this.cordsMesh);
this.physicsState = PHYSICS_STATE_FULL;
}
else
{
this.physicsState = PHYSICS_STATE_BOX;
}
this.bonusListener = listener;
this.getGroundPointAndNormal(pos,P,N);
if(this.bonusState == BonusState.FALLING)
{
if(isFlatSurface(N))
{
fallTime = this.calculateFallTime(pos,P);
P1.vCopy(P);
}
else
{
X.vCross2(N,Vector3.Z_AXIS);
X.vNormalize();
Y.vCross2(N,X);
Y1.vCross2(Vector3.Z_AXIS,X);
origin.vCopy(pos);
origin.vAddScaled(-BonusConst.BONUS_HALF_SIZE,Y1);
P1.vCopy(P);
P1.vAddScaled(-BonusConst.BONUS_HALF_SIZE / N.z,Y);
if(BattlefieldModel(Main.osgi.getService(IBattleField)).bfData.collisionDetector.raycastStatic(origin,Vector3.DOWN,CollisionGroup.STATIC,BIG_VALUE,_rayHit))
{
if(P.z < _rayHit.pos.z && _rayHit.pos.z < P1.z)
{
P1.vAddScaled(BonusConst.BONUS_HALF_SIZE / N.z * (P1.z - _rayHit.pos.z) / (P1.z - P.z),Y);
}
}
fallTime = this.calculateFallTime(pos,P1);
this.landingController.init(P1,N);
this.landingControllerInited = true;
}
minPivotZ = P1.z + BonusConst.BONUS_HALF_SIZE + BonusConst.BONUS_OFFSET_Z;
startingAngleZ = this.getStartingAngleZ();
this.skin.x = pos.x;
this.skin.y = pos.y;
this.skin.z = pos.z;
this.skin.rotationX = 0;
this.skin.rotationY = 0;
this.skin.rotationZ = startingAngleZ;
this.updateTriggerFromMesh();
this.fallController.init(pos,this.fallSpeed,minPivotZ,-fallTime,0,startingAngleZ);
}
this.trigger.activate(BattlefieldModel(Main.osgi.getService(IBattleField)));
}
private function updateTriggerFromMesh() : void
{
this.trigger.update(this.skin.x,this.skin.y,this.skin.z,this.skin.rotationX,this.skin.rotationY,this.skin.rotationZ);
}
public function onLandingComplete() : void
{
this.landingControllerInited = false;
}
private function getStartingAngleZ() : Number
{
return Math.PI * 10 * parseInt(this.bonusId.split("_")[1]) / 180;
}
private function calculateFallTime(spawnPosition:Vector3, groundTouchPoint:Vector3) : Number
{
return (spawnPosition.z - groundTouchPoint.z - BonusConst.BONUS_HALF_SIZE) / this.fallSpeed;
}
public function update(param1:int, param2:int, param3:Number) : Boolean
{
var _loc4_:int = 0;
this.timeToLive -= param2;
this.light.x = this.skin.x;
this.light.y = this.skin.y;
this.light.z = this.skin.z;
if(this.bonusState == BonusState.FALLING)
{
for(_loc4_ = 0; _loc4_ < this.fallPrecision; _loc4_++)
{
this.fallController.runBeforePhysicsUpdate(param2 / this.fallPrecision);
this.fallController.interpolatePhysicsState(param3);
this.fallController.render();
}
return true;
}
if(this.bonusState == BonusState.TAKEN)
{
if(this.takenAnimationTime < 0)
{
return false;
}
this.playTakenAnimation(param2);
}
if(this.bonusState == BonusState.RESTING && this.landingControllerInited)
{
for(_loc4_ = 0; _loc4_ < this.landingPrecision; _loc4_++)
{
this.landingController.runBeforePhysicsUpdate(param2 / this.landingPrecision);
this.landingController.interpolatePhysicsState(param3);
this.landingController.render();
}
}
if(this.parachuteTimeLeft > 0)
{
this.parachuteTimeLeft -= param2;
if(this.parachuteTimeLeft <= 0)
{
this.removeParachuteGraphics();
this.removeParachutePhysics();
}
else
{
this.cordsMesh.setAlpha(this.parachuteTimeLeft / PARACHUTE_REMOVAL_TIME);
this.parachute.setAlpha(this.parachuteTimeLeft / PARACHUTE_REMOVAL_TIME);
this.parachute.z -= this.fallSpeed / 2000 * param2;
this.cordsMesh.updateVertices();
}
}
if((this.bonusState == BonusState.RESTING || this.bonusState == BonusState.REMOVING) && this.timeToLive < WARNING_TIME)
{
this.playWarningAnimation(param1,param2);
}
if(this.bonusState == BonusState.REMOVING && this.timeToLive > WARNING_TIME)
{
return false;
}
return this.bonusState != BonusState.REMOVED;
}
public function destroy() : void
{
this.skin.alternativa3d::removeFromParent();
this.skin.recycle();
this.skin = null;
BattlefieldModel(Main.osgi.getService(IBattleField)).hidableObjects.remove(this.hidabbleWrapper);
if(this.skin != null)
{
this.skin = null;
}
this.removeParachuteGraphics();
this.removeParachutePhysics();
var _loc1_:* = this.pool.numObjects++;
this.pool.objects[_loc1_] = this;
this.trigger.deactivate();
}
public function considerCollision(primitive:CollisionPrimitive) : Boolean
{
if(primitive.body is Tank)
{
this.onTankCollision();
}
return false;
}
public function onTriggerActivated() : void
{
this.onTankCollision();
this.setTakenState();
this.trigger.deactivate();
}
public function onStaticCollision() : void
{
this.bonusState = BonusState.RESTING;
this.detachParachute();
if(this.bonusListener != null)
{
this.bonusListener.onBonusDropped(this);
}
if(this.landingControllerInited)
{
this.landingController.start();
}
}
private function detachParachute() : void
{
this.startParachuteDissolving();
}
private function startParachuteDissolving() : void
{
this.parachuteTimeLeft = PARACHUTE_REMOVAL_TIME;
}
private function onTankCollision() : void
{
this.bonusListener.onTankCollision(this);
}
private function createParachuteAndCords(parachuteMesh:Mesh, parachuteInnerMesh:Mesh, cordsMaterial:Material) : void
{
if(BonusCache.isParachuteCacheEmpty())
{
this.parachute = new Parachute(parachuteMesh,parachuteInnerMesh);
}
else
{
this.parachute = BonusCache.getParachute();
}
if(BonusCache.isCordsCacheEmpty())
{
this.cordsMesh = new Cords(Parachute.RADIUS,BOX_HALF_SIZE,Parachute.NUM_STRAPS,cordsMaterial);
}
else
{
this.cordsMesh = BonusCache.getCords();
}
this.cordsMesh.init(this.skin,this.parachute);
}
private function removeParachuteGraphics() : void
{
if(this.parachute != null)
{
this.parachute.alternativa3d::removeFromParent();
this.parachute.recycle();
this.parachute = null;
}
if(this.cordsMesh != null)
{
this.cordsMesh.alternativa3d::removeFromParent();
this.cordsMesh.recycle();
this.cordsMesh = null;
}
}
private function removeParachutePhysics() : void
{
if(this.physicsState == PHYSICS_STATE_PARABOX)
{
if(this.parachute != null)
{
this.parachute = null;
}
this.physicsState = PHYSICS_STATE_BOX;
}
}
private function playWarningAnimation(time:int, deltaMsec:Number) : void
{
if(this.skin == null)
{
return;
}
if(this.visibilitySwitchTime == 0)
{
this.alphaSpeed = -COEFF * DELTA_ALPHA / this.currBlinkInterval;
this.visibilitySwitchTime = time + this.currBlinkInterval;
}
else
{
this.skin.alpha += this.alphaSpeed * deltaMsec;
if(this.bonusState == BonusState.REMOVING && this.alphaSpeed < 0)
{
if(this.skin.alpha <= 0)
{
this.bonusState = BonusState.REMOVED;
}
}
else
{
if(this.skin.alpha < MIN_ALPHA)
{
this.skin.alpha = MIN_ALPHA;
}
if(time >= this.visibilitySwitchTime)
{
if(this.currBlinkInterval > 22)
{
this.currBlinkInterval -= 12;
}
this.visibilitySwitchTime += this.currBlinkInterval;
if(this.alphaSpeed < 0)
{
this.alphaSpeed = COEFF * DELTA_ALPHA / this.currBlinkInterval;
this.skin.alpha = MIN_ALPHA;
}
else
{
this.alphaSpeed = -COEFF * DELTA_ALPHA / this.currBlinkInterval;
this.skin.alpha = 1;
}
}
}
}
if(this.currBlinkInterval < 22)
{
this.skin.alpha = 0;
}
}
private function playTakenAnimation(millis:int) : void
{
var dt:Number = millis * 0.001;
this.skin.z += (UP_SPEED * this.takenAnimationTime / TAKEN_ANIMATION_TIME + UP_SPEED * 0.1) * dt;
this.skin.rotationZ += (ANGLE_SPEED * this.takenAnimationTime / TAKEN_ANIMATION_TIME + ANGLE_SPEED * 0.1) * dt;
if(this.takenAnimationTime > TAKEN_ANIMATION_TIME - FLASH_DURATION)
{
this.additiveValue += ADDITIVE_SPEED_UP * millis;
if(this.additiveValue > MAX_ADDITIVE_VALUE)
{
this.additiveValue = MAX_ADDITIVE_VALUE;
}
}
else
{
this.additiveValue -= ADDITIVE_SPEED_DOWN * millis;
if(this.additiveValue < 0)
{
this.additiveValue = 0;
}
}
var colorTransform:ColorTransform = this.skin.colorTransform;
if(colorTransform == null)
{
colorTransform = new ColorTransform();
this.skin.colorTransform = colorTransform;
}
colorTransform.redOffset = this.additiveValue;
colorTransform.blueOffset = this.additiveValue;
colorTransform.greenOffset = this.additiveValue;
if(this.takenAnimationTime < ALPHA_DURATION)
{
this.skin.alpha = this.takenAnimationTime / ALPHA_DURATION;
}
this.takenAnimationTime -= millis;
}
}
}
import alternativa.tanks.models.effects.common.bonuscommon.ParaBonus;
class Pool
{
public var objects:Vector.<ParaBonus>;
public var numObjects:int;
function Pool()
{
this.objects = new Vector.<ParaBonus>();
super();
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.cp {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import projects.tanks.client.battlefield.models.battle.cp.ClientPointData;
import projects.tanks.client.battlefield.models.battle.cp.ControlPointsCC;
import projects.tanks.client.battlefield.models.battle.cp.resources.DominationResources;
import projects.tanks.client.battlefield.models.battle.cp.resources.DominationSounds;
public class CodecControlPointsCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_keypointTriggerRadius:ICodec;
private var codec_keypointVisorHeight:ICodec;
private var codec_minesRestrictionRadius:ICodec;
private var codec_points:ICodec;
private var codec_resources:ICodec;
private var codec_sounds:ICodec;
public function CodecControlPointsCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_keypointTriggerRadius = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_keypointVisorHeight = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_minesRestrictionRadius = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_points = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(ClientPointData,false),false,1));
this.codec_resources = param1.getCodec(new TypeCodecInfo(DominationResources,false));
this.codec_sounds = param1.getCodec(new TypeCodecInfo(DominationSounds,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ControlPointsCC = new ControlPointsCC();
local2.keypointTriggerRadius = this.codec_keypointTriggerRadius.decode(param1) as Number;
local2.keypointVisorHeight = this.codec_keypointVisorHeight.decode(param1) as Number;
local2.minesRestrictionRadius = this.codec_minesRestrictionRadius.decode(param1) as Number;
local2.points = this.codec_points.decode(param1) as Vector.<ClientPointData>;
local2.resources = this.codec_resources.decode(param1) as DominationResources;
local2.sounds = this.codec_sounds.decode(param1) as DominationSounds;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ControlPointsCC = ControlPointsCC(param2);
this.codec_keypointTriggerRadius.encode(param1,local3.keypointTriggerRadius);
this.codec_keypointVisorHeight.encode(param1,local3.keypointVisorHeight);
this.codec_minesRestrictionRadius.encode(param1,local3.minesRestrictionRadius);
this.codec_points.encode(param1,local3.points);
this.codec_resources.encode(param1,local3.resources);
this.codec_sounds.encode(param1,local3.sounds);
}
}
}
|
package alternativa.service
{
import alternativa.register.SpaceInfo;
import alternativa.types.Long;
import flash.utils.Dictionary;
public interface ISpaceService
{
function addSpace(param1:SpaceInfo) : void;
function removeSpace(param1:SpaceInfo) : void;
function get spaces() : Dictionary;
function get spaceList() : Array;
function getSpaceByObjectId(param1:String) : SpaceInfo;
function setIdForSpace(param1:SpaceInfo, param2:Long) : void;
}
}
|
package alternativa.tanks.gui.tankpreview {
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import flash.display.Stage;
import flash.events.MouseEvent;
import flash.utils.getTimer;
public class ManualRotationState implements TankPreviewState {
private var stateMachine:TankPreviewStateMachine;
private var stage:Stage;
private var context:TankPreviewContext;
private var camera:Camera3D;
private var startingRotatonZ:Number;
private var startingMouseX:Number;
private var times:Vector.<int> = new Vector.<int>(2);
private var rotations:Vector.<Number> = new Vector.<Number>(2);
private var cameraContainer:Object3D;
public function ManualRotationState(param1:TankPreviewStateMachine, param2:Stage, param3:TankPreviewContext, param4:Camera3D, param5:Object3D) {
super();
this.stateMachine = param1;
this.stage = param2;
this.context = param3;
this.camera = param4;
this.cameraContainer = param5;
}
public function enter() : void {
this.stage.addEventListener(MouseEvent.MOUSE_UP,this.onStageMouseUp);
this.startingRotatonZ = this.cameraContainer.rotationZ;
this.startingMouseX = this.stage.mouseX;
this.times[0] = getTimer();
this.times[1] = this.times[0];
this.rotations[0] = this.cameraContainer.rotationZ;
this.rotations[1] = this.rotations[0];
}
public function update() : void {
this.cameraContainer.rotationZ = this.getRotationZ();
this.times[1] = this.times[0];
this.times[0] = getTimer();
this.rotations[1] = this.rotations[0];
this.rotations[0] = this.cameraContainer.rotationZ;
}
public function exit() : void {
this.stage.removeEventListener(MouseEvent.MOUSE_UP,this.onStageMouseUp);
}
private function onStageMouseUp(param1:MouseEvent) : void {
this.cameraContainer.rotationZ = this.getRotationZ();
var local2:Number = (getTimer() - this.times[1]) / 1000;
if(local2 == 0) {
local2 = 0.1;
}
this.context.angularSpeed = (this.cameraContainer.rotationZ - this.rotations[1]) / local2;
this.stateMachine.handleEvent(this,TankPreviewEvent.STOP_MANUAL_ROTATION);
}
private function getRotationZ() : Number {
var local1:Number = 2 * Math.PI / this.camera.view.width;
return this.startingRotatonZ + (this.startingMouseX - this.stage.mouseX) * local1;
}
}
}
|
package alternativa.tanks.models.weapon {
import alternativa.tanks.models.weapon.angles.verticals.autoaiming.VerticalAutoAiming;
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapon.shared.shot.IShotModel;
import alternativa.tanks.models.weapon.weakening.DistanceWeakening;
import alternativa.tanks.models.weapon.weakening.IWeaponWeakeningModel;
import flash.events.EventDispatcher;
import platform.client.fp10.core.type.IGameObject;
public class WeaponObject extends EventDispatcher {
protected var remote:Boolean = false;
protected var object:IGameObject;
public function WeaponObject(param1:IGameObject) {
super();
this.object = param1;
}
public function verticalAutoAiming() : VerticalAutoAiming {
return VerticalAutoAiming(this.object.adapt(VerticalAutoAiming));
}
public function getReloadTimeMS() : int {
var local1:IShotModel = IShotModel(this.object.adapt(IShotModel));
return local1.getReloadMS();
}
public function commonData() : WeaponCommonData {
return this.weaponCommon().getCommonData();
}
public function weaponCommon() : IWeaponCommonModel {
return IWeaponCommonModel(this.object.adapt(IWeaponCommonModel));
}
public function distanceWeakening() : DistanceWeakening {
var local1:IWeaponWeakeningModel = IWeaponWeakeningModel(this.object.adapt(IWeaponWeakeningModel));
return local1.getDistanceWeakening();
}
public function setObject(param1:IGameObject) : void {
this.object = param1;
}
public function getObject() : IGameObject {
return this.object;
}
public function isAlive() : Boolean {
return this.object.space != null;
}
public function isLocal() : Boolean {
return !this.remote;
}
public function markAsRemote() : void {
this.remote = true;
}
}
}
|
package alternativa.tanks.gui.settings.tabs.control {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.settings.SettingsWindow;
import alternativa.tanks.gui.settings.tabs.SettingsTabView;
import alternativa.tanks.service.settings.keybinding.GameActionEnum;
import alternativa.tanks.service.settings.keybinding.KeysBindingService;
import base.DiscreteSprite;
import controls.base.DefaultButtonBase;
import controls.containers.StackPanel;
import controls.containers.VerticalStackPanel;
import flash.events.MouseEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class KeyBindingsPanel extends DiscreteSprite {
[Inject]
public static var keysBindingService:KeysBindingService;
[Inject]
public static var localeService:ILocaleService;
private var keyBindingsPanel:VerticalStackPanel = new VerticalStackPanel();
private var keyBindingVisualElements:Vector.<KeyBinding> = new Vector.<KeyBinding>();
private var restoreDefaultBindingsButton:DefaultButtonBase = new DefaultButtonBase();
public function KeyBindingsPanel() {
super();
this.restoreDefaultBindingsButton.label = localeService.getText(TanksLocale.TEXT_BUTTON_LABEL_RESTORE_DEFAULT_BUTTONS);
this.restoreDefaultBindingsButton.width = 250;
this.restoreDefaultBindingsButton.addEventListener(MouseEvent.CLICK,this.restoreDefaultBindings);
addChild(this.restoreDefaultBindingsButton);
this.keyBindingsPanel.setMargin(SettingsTabView.MARGIN * 2);
this.keyBindingsPanel.addItem(this.createTurretActionsPanel());
this.keyBindingsPanel.addItem(this.createChassisActionsPanel());
this.keyBindingsPanel.addItem(this.createInventoryActionsPanel());
this.keyBindingsPanel.addItem(this.createBattleActionsPanel());
this.keyBindingsPanel.addItem(this.createWindowActionsPanel());
this.keyBindingsPanel.addItem(this.createCameraActionsPanel());
this.keyBindingsPanel.y = SettingsTabView.MARGIN + this.restoreDefaultBindingsButton.height;
addChild(this.keyBindingsPanel);
}
private function restoreDefaultBindings(param1:MouseEvent) : void {
var local2:KeyBinding = null;
keysBindingService.restoreDefaultBindings();
for each(local2 in this.keyBindingVisualElements) {
local2.restoreDefaultBinding();
}
}
private function createTurretActionsPanel() : StackPanel {
var local1:StackPanel = new VerticalStackPanel();
local1.addItem(this.createKeyBinding(GameActionEnum.ROTATE_TURRET_LEFT,localeService.getText(TanksLocale.TEXT_GAME_ACTION_TURRET_TURN_LEFT)));
local1.addItem(this.createKeyBinding(GameActionEnum.ROTATE_TURRET_RIGHT,localeService.getText(TanksLocale.TEXT_GAME_ACTION_TURRET_TURN_RIGHT)));
local1.addItem(this.createKeyBinding(GameActionEnum.CENTER_TURRET,localeService.getText(TanksLocale.TEXT_GAME_ACTION_TURRET_CENTER)));
local1.addItem(this.createKeyBinding(GameActionEnum.SHOT,localeService.getText(TanksLocale.TEXT_GAME_ACTION_SHOOT)));
return local1;
}
private function createChassisActionsPanel() : StackPanel {
var local1:StackPanel = new VerticalStackPanel();
local1.addItem(this.createKeyBinding(GameActionEnum.CHASSIS_LEFT_MOVEMENT,localeService.getText(TanksLocale.TEXT_GAME_ACTION_TANK_TURN_LEFT)));
local1.addItem(this.createKeyBinding(GameActionEnum.CHASSIS_FORWARD_MOVEMENT,localeService.getText(TanksLocale.TEXT_GAME_ACTION_TANK_MOVE_FORWARD)));
local1.addItem(this.createKeyBinding(GameActionEnum.CHASSIS_RIGHT_MOVEMENT,localeService.getText(TanksLocale.TEXT_GAME_ACTION_TANK_TURN_RIGHT)));
local1.addItem(this.createKeyBinding(GameActionEnum.CHASSIS_BACKWARD_MOVEMENT,localeService.getText(TanksLocale.TEXT_GAME_ACTION_TANK_MOVE_BACKWARD)));
return local1;
}
private function createInventoryActionsPanel() : StackPanel {
var local1:StackPanel = new VerticalStackPanel();
local1.addItem(this.createKeyBinding(GameActionEnum.USE_FIRS_AID,localeService.getText(TanksLocale.TEXT_GAME_ACTION_USE_FIRST_AID)));
local1.addItem(this.createKeyBinding(GameActionEnum.USE_DOUBLE_ARMOR,localeService.getText(TanksLocale.TEXT_GAME_ACTION_USE_DOUBLE_ARMOR)));
local1.addItem(this.createKeyBinding(GameActionEnum.USE_DOUBLE_DAMAGE,localeService.getText(TanksLocale.TEXT_GAME_ACTION_USE_DOBLE_DAMAGE)));
local1.addItem(this.createKeyBinding(GameActionEnum.USE_NITRO,localeService.getText(TanksLocale.TEXT_GAME_ACTION_USE_NITRO)));
local1.addItem(this.createKeyBinding(GameActionEnum.USE_MINE,localeService.getText(TanksLocale.TEXT_GAME_ACTION_USE_MINE)));
local1.addItem(this.createKeyBinding(GameActionEnum.DROP_GOLD_BOX,localeService.getText(TanksLocale.TEXT_GAME_ACTION_DROP_GOLD_BOX)));
local1.addItem(this.createKeyBinding(GameActionEnum.ULTIMATE,localeService.getText(TanksLocale.TEXT_ULTIMATES)));
return local1;
}
private function createWindowActionsPanel() : StackPanel {
var local1:StackPanel = new VerticalStackPanel();
local1.addItem(this.createKeyBinding(GameActionEnum.BATTLE_VIEW_INCREASE,localeService.getText(TanksLocale.TEXT_GAME_ACTION_SCREEN_SIZE_INCREASE)));
local1.addItem(this.createKeyBinding(GameActionEnum.BATTLE_VIEW_DECREASE,localeService.getText(TanksLocale.TEXT_GAME_ACTION_SCREEN_SIZE_DECREASE)));
local1.addItem(this.createKeyBinding(GameActionEnum.FULL_SCREEN,localeService.getText(TanksLocale.TEXT_GAME_ACTION_FULL_SCREEN)));
local1.addItem(this.createKeyBinding(GameActionEnum.OPEN_GARAGE,localeService.getText(TanksLocale.TEXT_OPEN_GARAGE)));
return local1;
}
private function createBattleActionsPanel() : StackPanel {
var local1:StackPanel = new VerticalStackPanel();
local1.addItem(this.createKeyBinding(GameActionEnum.DROP_FLAG,localeService.getText(TanksLocale.TEXT_GAME_ACTION_DROP_FLAG)));
local1.addItem(this.createKeyBinding(GameActionEnum.BATTLE_PAUSE,localeService.getText(TanksLocale.TEXT_GAME_ACTION_PAUSE)));
local1.addItem(this.createKeyBinding(GameActionEnum.SHOW_TANK_PARAMETERS,localeService.getText(TanksLocale.TEXT_GAME_ACTION_SHOW_TANK_STATS)));
return local1;
}
private function createCameraActionsPanel() : StackPanel {
var local1:StackPanel = new VerticalStackPanel();
local1.addItem(this.createKeyBinding(GameActionEnum.FOLLOW_CAMERA_UP,localeService.getText(TanksLocale.TEXT_GAME_ACTION_CAMERA_UP)));
local1.addItem(this.createKeyBinding(GameActionEnum.FOLLOW_CAMERA_DOWN,localeService.getText(TanksLocale.TEXT_GAME_ACTION_CAMERA_DOWN)));
return local1;
}
private function createKeyBinding(param1:GameActionEnum, param2:String) : KeyBinding {
var local3:KeyBinding = new KeyBinding(param1,param2,SettingsTabView.MARGIN,SettingsWindow.TAB_VIEW_MAX_WIDTH);
this.keyBindingVisualElements.push(local3);
return local3;
}
public function destroy() : void {
var local1:KeyBinding = null;
this.restoreDefaultBindingsButton.removeEventListener(MouseEvent.CLICK,this.restoreDefaultBindings);
for each(local1 in this.keyBindingVisualElements) {
local1.destroy();
}
this.keyBindingsPanel = null;
this.keyBindingVisualElements = null;
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_bitmapPropertiesLeft.png")]
public class ItemInfoPanelBitmaps_bitmapPropertiesLeft extends BitmapAsset {
public function ItemInfoPanelBitmaps_bitmapPropertiesLeft() {
super();
}
}
}
|
package alternativa.tanks.model
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.object.ClientObject;
import com.alternativaplatform.client.models.core.users.model.timechecker.ITimeCheckerModelBase;
import com.alternativaplatform.client.models.core.users.model.timechecker.TimeCheckerModelBase;
import flash.events.TimerEvent;
import flash.utils.Timer;
import forms.Alert;
import forms.AlertAnswer;
public class TimeCheckerModel extends TimeCheckerModelBase implements ITimeCheckerModelBase
{
private var clientObject:ClientObject;
private var timer:Timer;
public function TimeCheckerModel()
{
super();
_interfaces.push(IModel);
_interfaces.push(ITimeCheckerModelBase);
this.timer = new Timer(15000,1);
this.timer.addEventListener(TimerEvent.TIMER,this.sendPong);
}
public function ping(clientObject:ClientObject) : void
{
this.clientObject = clientObject;
this.timer.reset();
this.timer.start();
}
public function showKickMessage(clientObject:ClientObject, message:String) : void
{
var alert:Alert = new Alert();
alert.showAlert(message,[AlertAnswer.OK]);
Main.contentUILayer.addChild(alert);
}
private function sendPong(e:TimerEvent) : void
{
}
}
}
|
package alternativa.tanks.models.battle.gui.markers {
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.osgi.service.console.variables.ConsoleVarFloat;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleView;
import alternativa.tanks.battle.scene3d.Renderer;
import flash.display.Bitmap;
import flash.display.BitmapData;
public class PointMarker implements Renderer {
[Inject]
public static var battleService:BattleService;
private static const CON_HIDE_SCALE:ConsoleVarFloat = new ConsoleVarFloat("ph_scale",0.12,0.00001,10);
private static const CON_FULL_HIDE_SCALE:ConsoleVarFloat = new ConsoleVarFloat("pfh_scale",0.1,0.00001,10);
private static const m:Matrix4 = new Matrix4();
private static const m1:Matrix4 = new Matrix4();
private static const v:Vector3 = new Vector3();
private static const pointPosition:Vector3 = new Vector3();
private static const cameraPosition:Vector3 = new Vector3();
private static const direction:Vector3 = new Vector3();
private var camera:Camera3D;
private var marker:PointHudIndicator;
private var infiniteVisible:Boolean;
public function PointMarker(param1:Camera3D, param2:BitmapData, param3:PointIndicatorStateProvider, param4:Boolean = false) {
super();
this.camera = param1;
this.infiniteVisible = param4;
this.marker = new PointHudIndicator(new Bitmap(param2),param3);
this.marker.visible = false;
battleService.getBattleView().addOverlayObject(this.marker);
}
private static function getPerspectiveScale(param1:Camera3D, param2:Vector3) : Number {
var local3:Number = Math.cos(param1.rotationX);
var local4:Number = Math.sin(param1.rotationX);
var local5:Number = Math.cos(param1.rotationY);
var local6:Number = Math.sin(param1.rotationY);
var local7:Number = Math.cos(param1.rotationZ);
var local8:Number = Math.sin(param1.rotationZ);
var local9:Number = local7 * local6 * local3 + local8 * local4;
var local10:Number = -local7 * local4 + local6 * local8 * local3;
var local11:Number = local5 * local3;
var local12:Number = -local9 * param1.x - local10 * param1.y - local11 * param1.z;
var local13:Number = param1.view.width * 0.5;
var local14:Number = param1.view.height * 0.5;
var local15:Number = Math.sqrt(local13 * local13 + local14 * local14) / Math.tan(param1.fov * 0.5);
var local16:Number = local9 * param2.x + local10 * param2.y + local11 * param2.z + local12;
return local15 / local16;
}
private static function composeObject3DMatrix(param1:Object3D) : Matrix4 {
var local2:Number = Math.cos(param1.rotationX);
var local3:Number = Math.sin(param1.rotationX);
var local4:Number = Math.cos(param1.rotationY);
var local5:Number = Math.sin(param1.rotationY);
var local6:Number = Math.cos(param1.rotationZ);
var local7:Number = Math.sin(param1.rotationZ);
var local8:Number = local6 * local5;
var local9:Number = local7 * local5;
var local10:Number = local4 * param1.scaleX;
var local11:Number = local3 * param1.scaleY;
var local12:Number = local2 * param1.scaleY;
var local13:Number = local2 * param1.scaleZ;
var local14:Number = local3 * param1.scaleZ;
m1.m00 = local6 * local10;
m1.m01 = local8 * local11 - local7 * local12;
m1.m02 = local8 * local13 + local7 * local14;
m1.m03 = param1.x;
m1.m10 = local7 * local10;
m1.m11 = local9 * local11 + local6 * local12;
m1.m12 = local9 * local13 - local6 * local14;
m1.m13 = param1.y;
m1.m20 = -local5 * param1.scaleX;
m1.m21 = local4 * local11;
m1.m22 = local4 * local13;
m1.m23 = param1.z;
return m1;
}
public function show() : void {
this.marker.visible = true;
}
public function render(param1:int, param2:int) : void {
var local3:Matrix4 = this.calculateProjectionMatrix();
this.updateMarker(local3);
}
private function updateMarker(param1:Matrix4) : void {
var local6:Number = NaN;
if(!this.marker.isActive(this.camera)) {
this.marker.visible = false;
return;
}
this.marker.readPosition3D(v);
v.transform4(param1);
this.projectToView(v);
var local2:Number = 15;
var local3:Number = this.getMarginY();
var local4:Boolean = this.isPointInsideViewport(v.x,v.y,local2,local3);
if(v.z > 0 && local4) {
local6 = this.getPointAlpha();
if(local6 == 0) {
this.marker.visible = false;
this.marker.alpha = 0;
} else {
this.marker.visible = true;
this.marker.alpha = local6;
}
} else {
this.marker.alpha = 1;
this.marker.visible = false;
}
var local5:BattleView = battleService.getBattleView();
this.marker.x = int(v.x + local5.getWidth() / 2 - 12);
this.marker.y = int(v.y + local5.getHeight() / 2 - 12);
}
private function getPointAlpha() : Number {
var local2:Number = NaN;
var local3:Number = NaN;
var local4:RayIntersectionData = null;
this.marker.readPosition3D(pointPosition);
var local1:Number = getPerspectiveScale(this.camera,pointPosition);
if(local1 < CON_FULL_HIDE_SCALE.value) {
return 1;
}
cameraPosition.reset(this.camera.x,this.camera.y,this.camera.z);
direction.diff(pointPosition,cameraPosition);
local3 = direction.length();
direction.normalize();
local4 = battleService.getBattleScene3D().raycast(cameraPosition,direction,battleService.getExcludedObjects3D());
if(local4 != null && local4.time < local3) {
local2 = 1;
} else if(local1 > CON_HIDE_SCALE.value) {
local2 = 0;
} else if(this.infiniteVisible) {
local2 = 1;
} else {
local2 = (CON_HIDE_SCALE.value - local1) / (CON_HIDE_SCALE.value - CON_FULL_HIDE_SCALE.value);
}
return local2;
}
private function projectToView(param1:Vector3) : void {
var local2:Number = NaN;
var local3:Number = NaN;
if(param1.z > 0.001) {
param1.x = param1.x * this.camera.viewSizeX / param1.z;
param1.y = param1.y * this.camera.viewSizeY / param1.z;
} else if(param1.z < -0.001) {
param1.x = -param1.x * this.camera.viewSizeX / param1.z;
param1.y = -param1.y * this.camera.viewSizeY / param1.z;
} else {
local2 = Number(battleService.getBattleView().getDiagonalSquared());
local3 = Math.sqrt(param1.x * param1.x + param1.y * param1.y);
param1.x *= local2 / local3;
param1.y *= local2 / local3;
}
}
private function getMarginY() : int {
switch(battleService.getBattleView().getScreenSize()) {
case BattleView.MAX_SCREEN_SIZE:
return 70;
case BattleView.MAX_SCREEN_SIZE - 1:
return 40;
default:
return 15;
}
}
private function isPointInsideViewport(param1:Number, param2:Number, param3:Number, param4:Number) : Boolean {
var local5:BattleView = battleService.getBattleView();
var local6:Number = local5.getWidth() / 2 - param3;
var local7:Number = local5.getHeight() / 2 - param4;
return param1 >= -local6 && param1 <= local6 && param2 >= -local7 && param2 <= local7;
}
private function calculateProjectionMatrix() : Matrix4 {
var local2:Number = NaN;
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local1:Number = this.camera.viewSizeX / this.camera.focalLength;
local2 = this.camera.viewSizeY / this.camera.focalLength;
var local3:Number = Math.cos(this.camera.rotationX);
var local4:Number = Math.sin(this.camera.rotationX);
local5 = Math.cos(this.camera.rotationY);
local6 = Math.sin(this.camera.rotationY);
local7 = Math.cos(this.camera.rotationZ);
var local8:Number = Math.sin(this.camera.rotationZ);
var local9:Number = local7 * local6;
var local10:Number = local8 * local6;
var local11:Number = local5 * this.camera.scaleX;
var local12:Number = local4 * this.camera.scaleY;
var local13:Number = local3 * this.camera.scaleY;
local14 = local3 * this.camera.scaleZ;
local15 = local4 * this.camera.scaleZ;
m.m00 = local7 * local11 * local1;
m.m01 = (local9 * local12 - local8 * local13) * local2;
m.m02 = local9 * local14 + local8 * local15;
m.m03 = this.camera.x;
m.m10 = local8 * local11 * local1;
m.m11 = (local10 * local12 + local7 * local13) * local2;
m.m12 = local10 * local14 - local7 * local15;
m.m13 = this.camera.y;
m.m20 = -local6 * this.camera.scaleX * local1;
m.m21 = local5 * local12 * local2;
m.m22 = local5 * local14;
m.m23 = this.camera.z;
var local16:Object3D = this.camera;
while(local16._parent != null) {
local16 = local16._parent;
m.append(composeObject3DMatrix(local16));
}
m.invert();
return m;
}
}
}
|
package alternativa.tanks.gui.communication.tabs.chat {
import flash.events.IEventDispatcher;
public interface IChatTabView extends IEventDispatcher {
function getChatTab() : ChatTab;
function setChatTab(param1:ChatTab) : void;
function clear() : void;
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.utils {
public class FormatUtils {
public function FormatUtils() {
super();
}
public static function valueToString(param1:Number, param2:int, param3:Boolean) : String {
if(param3) {
param1 = Math.ceil(param1);
}
var local4:String = param1.toFixed(param2);
var local5:String = "";
if(param2 > 0) {
local5 = local4.substr(local4.length - param2 - 1);
if(local5 == ".00") {
local5 = "";
}
local4 = local4.substr(0,local4.length - param2 - 1);
}
while(local4.length > 3) {
local5 = " " + local4.substr(local4.length - 3,3) + local5;
local4 = local4.substr(0,local4.length - 3);
}
return local4 + local5;
}
}
}
|
package projects.tanks.client.panel.model.garage.availableupgrades {
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 AvailableUpgradesModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function AvailableUpgradesModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.gui.payment.forms.platbox {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.payment.controls.ProceedButton;
import alternativa.tanks.gui.payment.forms.mobile.PhoneNumberEvent;
import alternativa.tanks.gui.payment.forms.mobile.PhoneNumberInput;
import alternativa.tanks.gui.payment.forms.mobile.PhoneNumberValidationEvent;
import base.DiscreteSprite;
import controls.Label;
import controls.labels.MouseDisabledLabel;
import flash.events.MouseEvent;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.model.payment.PayModeProceed;
public class PlatboxPhoneNumberForm extends DiscreteSprite {
[Inject]
public static var localeService:ILocaleService;
private static const PROCEED_BUTTON_WIDTH:int = 100;
private static const LABEL_GAP:int = 7;
private static const PHONE_CHECK_DELAY:int = 500;
private var payMode:IGameObject;
private var phoneInput:PhoneNumberInput;
private var phoneLabel:Label;
private var proceedButton:ProceedButton;
private var timeout:int = -1;
public function PlatboxPhoneNumberForm(param1:IGameObject) {
super();
this.payMode = param1;
this.addPhoneLabel();
this.addPhoneInput();
this.addProceedButton();
this.render();
}
private function addPhoneLabel() : void {
this.phoneLabel = new MouseDisabledLabel();
this.phoneLabel.text = "Номер телефона:";
addChild(this.phoneLabel);
}
private function addPhoneInput() : void {
this.phoneInput = new PhoneNumberInput();
this.phoneInput.addEventListener(PhoneNumberEvent.CHANGED,this.onNumberChanged);
addChild(this.phoneInput);
}
private function addProceedButton() : void {
this.proceedButton = new ProceedButton();
this.proceedButton.label = localeService.getText(TanksLocale.TEXT_PAYMENT_BUTTON_PROCEED_TEXT);
this.proceedButton.addEventListener(MouseEvent.CLICK,this.onProceedClick);
this.proceedButton.width = PROCEED_BUTTON_WIDTH;
this.proceedButton.visible = false;
addChild(this.proceedButton);
}
private function onNumberChanged(param1:PhoneNumberEvent) : void {
this.resetTimeout();
if(param1.isCorrectLength()) {
this.phoneInput.waiting();
this.timeout = setTimeout(this.sendValidationRequest,PHONE_CHECK_DELAY);
} else {
this.phoneInput.onInvalidNumber();
this.proceedButton.visible = false;
}
}
private function sendValidationRequest() : void {
this.resetTimeout();
dispatchEvent(new PhoneNumberValidationEvent(this.phoneInput.value));
}
private function resetTimeout() : void {
if(this.timeout != -1) {
clearTimeout(this.timeout);
this.timeout = -1;
}
}
private function onProceedClick(param1:MouseEvent) : void {
PayModeProceed(this.payMode.adapt(PayModeProceed)).proceedPayment();
dispatchEvent(new ProceedPaymentEvent());
}
public function reset() : void {
this.phoneInput.reset();
this.proceedButton.visible = false;
}
public function get phoneNumber() : String {
return this.phoneInput.getPhoneNumber();
}
private function render() : void {
var local1:int = this.phoneInput.width + this.phoneLabel.width + LABEL_GAP;
this.phoneLabel.x = PlatBoxForm.WIDTH - local1 >> 1;
this.phoneInput.x = this.phoneLabel.x + this.phoneLabel.width + LABEL_GAP;
this.phoneLabel.y = this.phoneInput.height - this.phoneLabel.height >> 1;
this.proceedButton.x = PlatBoxForm.WIDTH - this.proceedButton.width >> 1;
this.proceedButton.y = PlatBoxForm.HEIGHT - this.proceedButton.height;
}
public function showPhoneIsInvalid(param1:String) : void {
if(this.phoneInput.value == param1) {
this.phoneInput.onInvalidNumber();
}
}
public function showPhoneIsValid(param1:String) : void {
if(this.phoneInput.value == param1) {
this.phoneInput.onValidNumber();
this.proceedButton.visible = true;
}
}
}
}
|
package alternativa.osgi.service.display {
import flash.display.DisplayObjectContainer;
import flash.display.Stage;
public interface IDisplay {
function get stage() : Stage;
function get mainContainer() : DisplayObjectContainer;
function get backgroundLayer() : DisplayObjectContainer;
function get contentLayer() : DisplayObjectContainer;
function get contentUILayer() : DisplayObjectContainer;
function get systemLayer() : DisplayObjectContainer;
function get systemUILayer() : DisplayObjectContainer;
function get dialogsLayer() : DisplayObjectContainer;
function get loaderLayer() : DisplayObjectContainer;
function get noticesLayer() : DisplayObjectContainer;
function get cursorLayer() : DisplayObjectContainer;
}
}
|
package projects.tanks.client.garage.models.item.properties {
public class ItemPropertiesCC {
private var _properties:Vector.<ItemGaragePropertyData>;
public function ItemPropertiesCC(param1:Vector.<ItemGaragePropertyData> = null) {
super();
this._properties = param1;
}
public function get properties() : Vector.<ItemGaragePropertyData> {
return this._properties;
}
public function set properties(param1:Vector.<ItemGaragePropertyData>) : void {
this._properties = param1;
}
public function toString() : String {
var local1:String = "ItemPropertiesCC [";
local1 += "properties = " + this.properties + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.quest.challenge.rewarding {
import alternativa.tanks.model.challenge.battlepass.notifier.BattlePassPurchaseEvent;
import alternativa.tanks.model.challenge.battlepass.notifier.BattlePassPurchaseService;
import alternativa.tanks.model.quest.challenge.ChallengeEvents;
import alternativa.tanks.model.quest.challenge.ChallengesViewService;
import alternativa.tanks.model.quest.challenge.stars.StarsChangedEvent;
import alternativa.tanks.model.quest.challenge.stars.StarsInfoService;
import alternativa.tanks.model.quest.common.MissionsWindowsService;
import flash.events.Event;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.panel.model.challenge.rewarding.ChallengesRewardingModelBase;
import projects.tanks.client.panel.model.challenge.rewarding.IChallengesRewardingModelBase;
import projects.tanks.client.panel.model.challenge.rewarding.Tier;
[ModelInfo]
public class ChallengesRewardingModel extends ChallengesRewardingModelBase implements IChallengesRewardingModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var challengeService:ChallengesViewService;
[Inject]
public static var starsInfoService:StarsInfoService;
[Inject]
public static var missionsWindowService:MissionsWindowsService;
[Inject]
public static var battlePassPurchaseService:BattlePassPurchaseService;
public function ChallengesRewardingModel() {
super();
}
public function objectLoaded() : void {
challengeService.changeTiersInfo(getInitParam().tiers);
challengeService.addEventListener(ChallengeEvents.REQUEST_DATA,getFunctionWrapper(this.requestTiersInfo));
var local1:Function = getFunctionWrapper(this.conditionRequestTiersInfo);
battlePassPurchaseService.addEventListener(BattlePassPurchaseEvent.PURCHASE,local1);
starsInfoService.addEventListener(StarsChangedEvent.STARS_CHANGED,local1);
}
private function requestTiersInfo(param1:Event = null) : void {
server.requestTiersInfo();
}
private function conditionRequestTiersInfo(param1:Event) : void {
if(missionsWindowService.isWindowOpen()) {
this.requestTiersInfo();
}
}
public function sendTiersInfo(param1:Vector.<Tier>) : void {
challengeService.changeTiersInfo(param1);
}
public function objectUnloaded() : void {
challengeService.removeEventListener(ChallengeEvents.REQUEST_DATA,getFunctionWrapper(this.requestTiersInfo));
var local1:Function = getFunctionWrapper(this.conditionRequestTiersInfo);
battlePassPurchaseService.removeEventListener(BattlePassPurchaseEvent.PURCHASE,local1);
starsInfoService.removeEventListener(StarsChangedEvent.STARS_CHANGED,local1);
missionsWindowService.closeWindow();
}
}
}
|
package alternativa.tanks.models.weapon.shotgun.sfx {
[ModelInterface]
public interface ShotgunSFX {
function getEffects() : ShotgunEffects;
}
}
|
package alternativa.tanks.display.usertitle
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ProgressBarSkin_barShadowLeftCls extends BitmapAsset
{
public function ProgressBarSkin_barShadowLeftCls()
{
super();
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ItemInfoPanel_bitmapPlasmaResistance extends BitmapAsset
{
public function ItemInfoPanel_bitmapPlasmaResistance()
{
super();
}
}
}
|
package alternativa.tanks.models.battle.battlefield.mine {
public class UserMinesList {
public var head:ProximityMine;
public var tail:ProximityMine;
public function UserMinesList() {
super();
}
public function addMine(param1:ProximityMine) : void {
if(this.head == null) {
this.head = this.tail = param1;
} else {
this.tail.next = param1;
param1.prev = this.tail;
this.tail = param1;
}
}
public function removeMine(param1:ProximityMine) : void {
if(this.head == null) {
return;
}
if(param1 == this.head) {
if(param1 == this.tail) {
this.head = this.tail = null;
} else {
this.head = this.head.next;
this.head.prev = null;
}
} else if(param1 == this.tail) {
this.tail = this.tail.prev;
this.tail.next = null;
} else {
param1.prev.next = param1.next;
param1.next.prev = param1.prev;
}
param1.dispose();
}
public function clearMines() : void {
while(this.head != null) {
this.removeMine(this.head);
}
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIcon_p26 extends BitmapAsset
{
public function RangIcon_p26()
{
super();
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ItemInfoPanel_bitmapUpgradeTableRight extends BitmapAsset
{
public function ItemInfoPanel_bitmapUpgradeTableRight()
{
super();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service {
import alternativa.osgi.service.logging.LogService;
import alternativa.types.Long;
import flash.utils.Dictionary;
import flash.utils.clearInterval;
import flash.utils.setInterval;
public class TimeOutTruncateConsumers {
[Inject]
public static var logService:LogService;
private const TRUNCATE_PERIOD:int = 300000;
private var _intervalId:uint;
private var _consumersLastAccessTime:Dictionary = new Dictionary();
private var _consumers:Dictionary;
private var _truncateFunction:Function;
public function TimeOutTruncateConsumers() {
super();
this._intervalId = setInterval(this.truncateOutdatedConsumers,this.TRUNCATE_PERIOD);
}
public function get truncateFunction() : Function {
return this._truncateFunction;
}
public function set truncateFunction(param1:Function) : void {
this._truncateFunction = param1;
}
private function truncateOutdatedConsumers() : void {
var local3:* = undefined;
var local4:IInfoLabelUpdater = null;
if(this.truncateFunction == null) {
return;
}
var local1:Vector.<Long> = new Vector.<Long>();
var local2:Number = new Date().time - this.TRUNCATE_PERIOD;
for(local3 in this._consumers) {
local4 = this._consumers[local3];
if(local4.lastAccessTime < local2 && local4.visibleLabelsCounter == 0) {
local1.push(local3);
}
}
if(local1.length > 0) {
this.truncateFunction(local1);
}
}
public function updateLastAccessTime(param1:Long) : void {
this._consumersLastAccessTime[param1] = new Date().time;
}
public function set consumers(param1:Dictionary) : void {
this._consumers = param1;
}
public function stop() : void {
clearInterval(this._intervalId);
}
}
}
|
package alternativa.tanks.model.profile
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GiftUserInfo_emeraldBitmap extends BitmapAsset
{
public function GiftUserInfo_emeraldBitmap()
{
super();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p30 extends BitmapAsset
{
public function RangIconNormal_p30()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.price {
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 ShopItemModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ShopItemModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.types {
public class HitTraceData {
private var _armorPreEffectDamage:Number;
private var _colorResistDamage:Number;
private var _hullResistDamage:Number;
private var _killerTurretName:String;
private var _origDamage:Number;
private var _postHealth:Number;
private var _targetHealth:Number;
private var _targetHullName:String;
private var _weaponEffectsDamage:Number;
public function HitTraceData(param1:Number = 0, param2:Number = 0, param3:Number = 0, param4:String = null, param5:Number = 0, param6:Number = 0, param7:Number = 0, param8:String = null, param9:Number = 0) {
super();
this._armorPreEffectDamage = param1;
this._colorResistDamage = param2;
this._hullResistDamage = param3;
this._killerTurretName = param4;
this._origDamage = param5;
this._postHealth = param6;
this._targetHealth = param7;
this._targetHullName = param8;
this._weaponEffectsDamage = param9;
}
public function get armorPreEffectDamage() : Number {
return this._armorPreEffectDamage;
}
public function set armorPreEffectDamage(param1:Number) : void {
this._armorPreEffectDamage = param1;
}
public function get colorResistDamage() : Number {
return this._colorResistDamage;
}
public function set colorResistDamage(param1:Number) : void {
this._colorResistDamage = param1;
}
public function get hullResistDamage() : Number {
return this._hullResistDamage;
}
public function set hullResistDamage(param1:Number) : void {
this._hullResistDamage = param1;
}
public function get killerTurretName() : String {
return this._killerTurretName;
}
public function set killerTurretName(param1:String) : void {
this._killerTurretName = param1;
}
public function get origDamage() : Number {
return this._origDamage;
}
public function set origDamage(param1:Number) : void {
this._origDamage = param1;
}
public function get postHealth() : Number {
return this._postHealth;
}
public function set postHealth(param1:Number) : void {
this._postHealth = param1;
}
public function get targetHealth() : Number {
return this._targetHealth;
}
public function set targetHealth(param1:Number) : void {
this._targetHealth = param1;
}
public function get targetHullName() : String {
return this._targetHullName;
}
public function set targetHullName(param1:String) : void {
this._targetHullName = param1;
}
public function get weaponEffectsDamage() : Number {
return this._weaponEffectsDamage;
}
public function set weaponEffectsDamage(param1:Number) : void {
this._weaponEffectsDamage = param1;
}
public function toString() : String {
var local1:String = "HitTraceData [";
local1 += "armorPreEffectDamage = " + this.armorPreEffectDamage + " ";
local1 += "colorResistDamage = " + this.colorResistDamage + " ";
local1 += "hullResistDamage = " + this.hullResistDamage + " ";
local1 += "killerTurretName = " + this.killerTurretName + " ";
local1 += "origDamage = " + this.origDamage + " ";
local1 += "postHealth = " + this.postHealth + " ";
local1 += "targetHealth = " + this.targetHealth + " ";
local1 += "targetHullName = " + this.targetHullName + " ";
local1 += "weaponEffectsDamage = " + this.weaponEffectsDamage + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.weapon.streamweapon {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class StreamWeaponReconfiguredListenerAdapt implements StreamWeaponReconfiguredListener {
private var object:IGameObject;
private var impl:StreamWeaponReconfiguredListener;
public function StreamWeaponReconfiguredListenerAdapt(param1:IGameObject, param2:StreamWeaponReconfiguredListener) {
super();
this.object = param1;
this.impl = param2;
}
public function streamWeaponReconfigured(param1:IGameObject, param2:Number) : void {
var user:IGameObject = param1;
var dischargeRate:Number = param2;
try {
Model.object = this.object;
this.impl.streamWeaponReconfigured(user,dischargeRate);
}
finally {
Model.popObject();
}
}
public function streamWeaponDistanceChanged(param1:IGameObject, param2:Number) : void {
var user:IGameObject = param1;
var newDistance:Number = param2;
try {
Model.object = this.object;
this.impl.streamWeaponDistanceChanged(user,newDistance);
}
finally {
Model.popObject();
}
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_red_OVER_RIGHT.png")]
public dynamic class button_red_OVER_RIGHT extends BitmapData {
public function button_red_OVER_RIGHT(param1:int = 7, param2:int = 30) {
super(param1,param2);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.utils {
import flash.ui.Keyboard;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenStateService;
public class AlertUtils {
[Inject]
public static var fullscreenStateService:FullscreenStateService;
public function AlertUtils() {
super();
}
public static function isConfirmationKey(param1:uint) : Boolean {
return param1 == Keyboard.ENTER;
}
public static function isCancelKey(param1:uint) : Boolean {
return param1 == Keyboard.ESCAPE && !fullscreenStateService.isFullscreen();
}
}
}
|
package alternativa.osgi.service.loader
{
public interface ILoadingProgressListener
{
function processStarted(param1:Object) : void;
function processStoped(param1:Object) : void;
function changeStatus(param1:Object, param2:String) : void;
function changeProgress(param1:Object, param2:Number) : void;
}
}
|
package alternativa.tanks.models.battlefield
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ViewportBorder_bmpClassCorner1 extends BitmapAsset
{
public function ViewportBorder_bmpClassCorner1()
{
super();
}
}
}
|
package com.reygazu.anticheat.variables
{
import com.reygazu.anticheat.managers.CheatManager;
public class SecureInt
{
private var secureData:SecureObject;
private var fake:int;
public function SecureInt(name:String = "Unnamed SecureInt", _fake:int = 0)
{
super();
this.fake = _fake;
this.secureData = new SecureObject(name,_fake);
}
public function set value(data:int) : void
{
if(this.fake != this.secureData.objectValue)
{
CheatManager.getInstance().detectCheat(this.secureData.name,this.fake,this.secureData.objectValue);
}
this.secureData.objectValue = data;
this.fake = data;
}
public function get value() : int
{
return this.secureData.objectValue as int;
}
}
}
|
package alternativa.types {
public class UByte {
public function UByte() {
super();
}
}
}
|
package forms.stat
{
import alternativa.init.Main;
import assets.scroller.color.ScrollThumbSkinGreen;
import assets.scroller.color.ScrollTrackGreen;
import controls.statassets.ReferalStatLineBackgroundNormal;
import controls.statassets.ReferalStatLineBackgroundSelected;
import controls.statassets.ReferralStatHeader;
import controls.statassets.StatLineBase;
import controls.statassets.StatLineNormal;
import controls.statassets.StatLineNormalActive;
import controls.statassets.StatLineSelected;
import controls.statassets.StatLineSelectedActive;
import fl.controls.List;
import fl.data.DataProvider;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.utils.Timer;
import forms.events.StatListEvent;
public class ReferralStatList extends Sprite
{
private var header:ReferralStatHeader;
protected var list:List;
protected var dp:DataProvider;
protected var currentSort:int = 1;
protected var nr:DisplayObject;
protected var sl:DisplayObject;
protected var timer:Timer = null;
protected var _width:int = 100;
private var _height:int = 100;
public function ReferralStatList()
{
this.header = new ReferralStatHeader();
this.list = new List();
this.dp = new DataProvider();
super();
addEventListener(Event.ADDED_TO_STAGE,this.ConfigUI);
}
public static function setBackground(_width:int, currentSort:int, _selected:Boolean) : BitmapData
{
var cont:Sprite = null;
var cell:StatLineBase = null;
cont = new Sprite();
var cells:Array = [0,_width - 120,_width - 1];
var i:int = 0;
var data:BitmapData = new BitmapData(_width,20,true,0);
for(i = 0; i < 2; i++)
{
if(currentSort == i)
{
if(_selected)
{
cell = new StatLineSelectedActive();
}
else
{
cell = new StatLineNormalActive();
}
}
else if(_selected)
{
cell = new StatLineSelected();
}
else
{
cell = new StatLineNormal();
}
cell.width = cells[i + 1] - cells[i] - 2;
cell.height = 18;
cell.x = cells[i];
cont.addChild(cell);
}
data.draw(cont);
return data;
}
protected function ConfigUI(e:Event) : void
{
removeEventListener(Event.ADDED_TO_STAGE,this.ConfigUI);
this.currentSort = 1;
this.list.rowHeight = 20;
this.list.setStyle("cellRenderer",ReferralStatListRenderer);
this.list.dataProvider = this.dp;
this.confSkin();
addChild(this.header);
addChild(this.list);
this.list.y = 20;
this.header.addEventListener(StatListEvent.UPDATE_SORT,this.changeSort);
}
override public function set height(value:Number) : void
{
this._height = int(value);
this.list.height = this._height - 20;
}
public function clear() : void
{
var item:Object = new Object();
for(var i:int = 0; i < this.dp.length; i++)
{
item = this.dp.getItemAt(i);
item.sort = this.currentSort;
this.dp.replaceItemAt(item,i);
}
this.sort();
}
public function addReferrals(referrals:Array) : void
{
var item:Object = null;
var i:Object = null;
for each(i in referrals)
{
item = new Object();
item.rank = i.rank;
item.callsign = i.callsign;
item.income = i.income;
item.sort = this.currentSort;
Main.writeVarsToConsoleChannel("REFERALS MODEL","name = %1, income=%2",item.callsign,item.income);
this.dp.addItem(item);
}
this.sort();
}
private function sort() : void
{
if(this.currentSort == 0)
{
this.dp.sortOn("callsign");
}
else
{
this.dp.sortOn("income",Array.NUMERIC | Array.DESCENDING);
}
this.dp.invalidate();
}
override public function set width(value:Number) : void
{
this._width = int(value);
var scrollOn:Boolean = this.list.maxVerticalScrollPosition > 0;
var _listWidth:int = !!scrollOn ? int(int(this._width + 6)) : int(int(this._width));
this.list.width = _listWidth;
this.header.width = !!scrollOn ? Number(Number(_listWidth - 15)) : Number(Number(_listWidth));
ReferalStatLineBackgroundNormal.bg = new Bitmap(setBackground(!!scrollOn ? int(int(_listWidth - 15)) : int(int(_listWidth)),this.currentSort,false));
ReferalStatLineBackgroundSelected.bg = new Bitmap(setBackground(!!scrollOn ? int(int(_listWidth - 15)) : int(int(_listWidth)),this.currentSort,true));
this.dp.invalidate();
}
protected function changeSort(e:StatListEvent) : void
{
this.currentSort = e.sortField;
this.clear();
this.width = this._width;
}
protected function confSkin() : void
{
this.list.setStyle("downArrowUpSkin",ScrollArrowDownGreen);
this.list.setStyle("downArrowDownSkin",ScrollArrowDownGreen);
this.list.setStyle("downArrowOverSkin",ScrollArrowDownGreen);
this.list.setStyle("downArrowDisabledSkin",ScrollArrowDownGreen);
this.list.setStyle("upArrowUpSkin",ScrollArrowUpGreen);
this.list.setStyle("upArrowDownSkin",ScrollArrowUpGreen);
this.list.setStyle("upArrowOverSkin",ScrollArrowUpGreen);
this.list.setStyle("upArrowDisabledSkin",ScrollArrowUpGreen);
this.list.setStyle("trackUpSkin",ScrollTrackGreen);
this.list.setStyle("trackDownSkin",ScrollTrackGreen);
this.list.setStyle("trackOverSkin",ScrollTrackGreen);
this.list.setStyle("trackDisabledSkin",ScrollTrackGreen);
this.list.setStyle("thumbUpSkin",ScrollThumbSkinGreen);
this.list.setStyle("thumbDownSkin",ScrollThumbSkinGreen);
this.list.setStyle("thumbOverSkin",ScrollThumbSkinGreen);
this.list.setStyle("thumbDisabledSkin",ScrollThumbSkinGreen);
}
}
}
|
package alternativa.tanks.gui.friends {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.FriendsWindowStateSmallButton_pressedStateClass.png")]
public class FriendsWindowStateSmallButton_pressedStateClass extends BitmapAsset {
public function FriendsWindowStateSmallButton_pressedStateClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.quest.daily.type.goal {
public interface ICaptureGoalDailyQuestModelBase {
}
}
|
package projects.tanks.client.panel.model.battlepass.purchasenotifier {
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 BattlePassPurchaseNotifierModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BattlePassPurchaseNotifierModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.partners.impl.miniclip {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class MiniclipLoginModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:MiniclipLoginModelServer;
private var client:IMiniclipLoginModelBase = IMiniclipLoginModelBase(this);
private var modelId:Long = Long.getLong(819736117,596240975);
public function MiniclipLoginModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new MiniclipLoginModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.specialkit {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.shop.specialkit.ShopKitText;
public class CodecShopKitText implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_color:ICodec;
private var codec_size:ICodec;
private var codec_text:ICodec;
private var codec_x:ICodec;
private var codec_y:ICodec;
public function CodecShopKitText() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_color = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_size = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_text = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_x = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_y = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ShopKitText = new ShopKitText();
local2.color = this.codec_color.decode(param1) as int;
local2.size = this.codec_size.decode(param1) as int;
local2.text = this.codec_text.decode(param1) as String;
local2.x = this.codec_x.decode(param1) as int;
local2.y = this.codec_y.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ShopKitText = ShopKitText(param2);
this.codec_color.encode(param1,local3.color);
this.codec_size.encode(param1,local3.size);
this.codec_text.encode(param1,local3.text);
this.codec_x.encode(param1,local3.x);
this.codec_y.encode(param1,local3.y);
}
}
}
|
package alternativa.tanks.view.battleinfo {
import alternativa.types.Long;
import flash.utils.Dictionary;
import projects.tanks.client.battleselect.model.battle.entrance.user.BattleInfoUser;
public class UserToInfoMap {
private var dictionary:* = new Dictionary();
public function UserToInfoMap() {
super();
}
public function put(param1:BattleInfoUser) : void {
this.dictionary[param1.user] = param1;
}
public function get(param1:Long) : BattleInfoUser {
return BattleInfoUser(this.dictionary[param1]);
}
public function remove(param1:Long) : void {
delete this.dictionary[param1];
}
public function resetScore() : * {
var local1:BattleInfoUser = null;
for each(local1 in this.dictionary) {
local1.score = 0;
}
}
}
}
|
package alternativa.tanks.battle {
import flash.utils.getTimer;
public class FPSCounter {
private var framesToAverage:int;
private var lastTime:int;
private var frameCounter:int;
private var fps:Number = 0;
public function FPSCounter(param1:int) {
super();
this.framesToAverage = param1;
this.lastTime = getTimer();
}
public function update() : void {
var local1:int = 0;
var local2:int = 0;
if(++this.frameCounter >= this.framesToAverage) {
local1 = getTimer();
local2 = local1 - this.lastTime;
this.lastTime = local1;
this.fps = 1000 * this.frameCounter / local2;
this.frameCounter = 0;
}
}
public function getFPS() : Number {
return this.fps;
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.