code
stringlengths 57
237k
|
|---|
package alternativa.tanks.controllers.battleinfo {
public class TimeStringUtils {
public function TimeStringUtils() {
super();
}
public static function getTimeStr(param1:int) : String {
var local2:String = null;
var local3:int = int(param1 / 60);
var local4:int = param1 - local3 * 60;
return String(local3) + ":" + (local4 > 9 ? String(local4) : "0" + String(local4));
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.loader.ILoaderWindowService;
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.events.Event;
import platform.client.fp10.core.network.connection.ConnectionCloseStatus;
import platform.client.fp10.core.network.handler.OnConnectionClosedServiceListener;
import projects.tanks.clients.fp10.libraries.tanksservices.service.blur.IBlurService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogwindowdispatcher.DialogWindowsDispatcherServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogwindowdispatcher.IDialogWindowsDispatcherService;
public class DialogsService implements IDialogsService, OnConnectionClosedServiceListener {
[Inject]
public static var display:IDisplay;
[Inject]
public static var blurService:IBlurService;
[Inject]
public static var dialogWindowsDispatcherService:IDialogWindowsDispatcherService;
[Inject]
public static var loaderWindowService:ILoaderWindowService;
private var dialogs:Vector.<DialogWindow> = new Vector.<DialogWindow>();
private var queue:Vector.<DialogWindow> = new Vector.<DialogWindow>();
public function DialogsService() {
super();
}
private static function center(param1:DisplayObject) : void {
param1.x = display.stage.stageWidth - param1.width >> 1;
param1.y = display.stage.stageHeight - param1.height >> 1;
}
public function addDialog(param1:DialogWindow) : void {
if(this.dialogs.indexOf(param1) > -1) {
return;
}
this.dialogs.unshift(param1);
if(this.dialogs.length > 1) {
this.hideDialog(this.dialogs[1],false);
}
this.showDialog(param1,this.dialogs.length == 1);
if(this.dialogs.length == 1) {
display.stage.addEventListener(Event.RESIZE,this.onResize,false,-1);
}
}
public function centerDialog(param1:DialogWindow) : void {
center(param1);
}
public function enqueueDialog(param1:DialogWindow) : void {
if(loaderWindowService.isInProgress()) {
this.queue.unshift(param1);
return;
}
if(this.dialogs.length == 0) {
this.addDialog(param1);
} else {
this.queue.unshift(param1);
}
}
public function removeDialog(param1:DialogWindow) : void {
var local2:int = this.dialogs.indexOf(param1);
if(local2 < 0) {
return;
}
this.dialogs.splice(this.dialogs.indexOf(param1),1);
if(this.dialogs.length == 0 && this.queue.length > 0) {
this.dialogs.push(this.queue.pop());
}
this.hideDialog(param1,this.dialogs.length == 0);
if(this.dialogs.length > 0) {
this.showDialog(this.dialogs[0],false);
} else {
display.stage.removeEventListener(Event.RESIZE,this.onResize);
}
}
private function showDialog(param1:DialogWindow, param2:Boolean) : void {
if(param2) {
blurService.blurGameContent();
}
center(param1);
dialogWindowsDispatcherService.addEventListener(DialogWindowsDispatcherServiceEvent.FORCIBLY_CLOSE,this.onForciblyCloseDialogs);
dialogWindowsDispatcherService.open();
this.dialogsLayer.addChild(param1);
param1.setEventListeners();
}
private function hideDialog(param1:DialogWindow, param2:Boolean) : void {
if(this.dialogsLayer.contains(param1)) {
param1.removeEventListeners();
this.dialogsLayer.removeChild(param1);
dialogWindowsDispatcherService.removeEventListener(DialogWindowsDispatcherServiceEvent.FORCIBLY_CLOSE,this.onForciblyCloseDialogs);
dialogWindowsDispatcherService.close();
}
if(param2) {
blurService.unblurGameContent();
}
}
private function onResize(param1:Event) : void {
if(this.dialogs.length > 0) {
center(this.dialogs[0]);
}
}
private function onForciblyCloseDialogs(param1:DialogWindowsDispatcherServiceEvent) : void {
var local2:DialogWindow = null;
for each(local2 in this.dialogs.concat()) {
local2.forciblyClose();
}
}
private function get dialogsLayer() : DisplayObjectContainer {
return display.dialogsLayer;
}
public function onConnectionClosed(param1:ConnectionCloseStatus) : void {
if(this.dialogs.length > 0) {
this.hideDialog(this.dialogs[0],true);
display.stage.removeEventListener(Event.RESIZE,this.onResize);
}
this.dialogs.length = 0;
this.queue.length = 0;
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes.description {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.panel.model.payment.modes.description.BottomDescriptionCC;
public class CodecBottomDescriptionCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_description:ICodec;
private var codec_images:ICodec;
public function CodecBottomDescriptionCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_description = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_images = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(ImageResource,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BottomDescriptionCC = new BottomDescriptionCC();
local2.description = this.codec_description.decode(param1) as String;
local2.images = this.codec_images.decode(param1) as Vector.<ImageResource>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BottomDescriptionCC = BottomDescriptionCC(param2);
this.codec_description.encode(param1,local3.description);
this.codec_images.encode(param1,local3.images);
}
}
}
|
package alternativa.tanks.camera.controllers.spectator {
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventListener;
import alternativa.tanks.battle.events.TankUnloadedEvent;
import alternativa.tanks.battle.objects.tank.ClientTankState;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.scene3d.BattleScene3D;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.spawn.ITankSpawner;
import alternativa.tanks.services.bonusregion.IBonusRegionService;
import alternativa.tanks.services.tankregistry.TankUsersRegistry;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import services.contextmenu.ContextMenuServiceEvent;
import services.contextmenu.IContextMenuService;
public class PlayerCamera implements KeyboardHandler, BattleEventListener {
[Inject]
public static var tankUsersRegistry:TankUsersRegistry;
[Inject]
public static var battleService:BattleService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var contextMenuService:IContextMenuService;
[Inject]
public static var bonusRegionService:IBonusRegionService;
private var focusedUser:Tank;
private var spectatorController:SpectatorCameraController;
public function PlayerCamera(param1:SpectatorCameraController) {
super();
this.spectatorController = param1;
battleEventDispatcher.addBattleEventListener(TankUnloadedEvent,this);
contextMenuService.addEventListener(ContextMenuServiceEvent.FOCUS_ON_USER,this.onFocusOnUser);
}
private function onFocusOnUser(param1:ContextMenuServiceEvent) : void {
var local2:IGameObject = tankUsersRegistry.getUser(param1.userId);
this.focusOnTank(this.getTank(local2));
}
public function handleBattleEvent(param1:Object) : void {
var local2:Tank = TankUnloadedEvent(param1).tank;
if(this.focusedUser == local2) {
this.unfocus();
}
}
public function handleKeyUp(param1:KeyboardEvent) : void {
}
public function handleKeyDown(param1:KeyboardEvent) : void {
this.onKey(param1);
}
private function onKey(param1:KeyboardEvent) : void {
var local2:Tank = null;
if(param1.ctrlKey) {
switch(param1.keyCode) {
case Keyboard.F:
local2 = this.findNearestUser();
break;
case Keyboard.B:
local2 = this.findNearestUser(BattleTeam.BLUE);
break;
case Keyboard.R:
local2 = this.findNearestUser(BattleTeam.RED);
break;
case Keyboard.U:
this.unfocus();
}
if(Boolean(local2)) {
this.focusOnTank(local2);
}
} else if(Boolean(this.focusedUser)) {
switch(param1.keyCode) {
case Keyboard.RIGHT:
this.nextPlayer();
break;
case Keyboard.LEFT:
this.prevPlayer();
}
}
}
private function findNearestUser(param1:BattleTeam = null) : Tank {
var local6:IGameObject = null;
var local7:Tank = null;
var local8:Number = NaN;
var local2:Tank = null;
var local3:Number = 100000000000000000000;
var local4:GameCamera = this.battleScene().getCamera();
var local5:Vector3 = new Vector3(local4.x,local4.y,local4.z);
for each(local6 in tankUsersRegistry.getUsers()) {
local7 = this.getTank(local6);
if((param1 == null || local7.teamType == param1) && local7.state == ClientTankState.ACTIVE) {
local8 = local7.getBody().state.position.distanceTo(local5);
if(local8 < local3) {
local3 = local8;
local2 = local7;
}
}
}
return local2;
}
private function focusOnTank(param1:Tank) : void {
if(param1 == null) {
return;
}
if(param1.state != ClientTankState.ACTIVE) {
return;
}
this.setRemoteSpawnMode(this.focusedUser);
this.focusedUser = param1;
var local2:ITankSpawner = ITankSpawner(this.focusedUser.user.adapt(ITankSpawner));
local2.setLocal();
battleService.activateFollowCamera();
battleService.setFollowCameraTarget(param1);
bonusRegionService.changeTank(param1);
}
public function unfocus() : void {
if(Boolean(this.focusedUser)) {
this.setRemoteSpawnMode(this.focusedUser);
this.focusedUser = null;
battleService.getBattleScene3D().setCameraController(this.spectatorController);
bonusRegionService.resetTank();
}
}
private function setRemoteSpawnMode(param1:Tank) : void {
var local2:ITankSpawner = null;
if(param1 != null) {
local2 = ITankSpawner(param1.user.adapt(ITankSpawner));
local2.setRemote();
}
}
private function nextPlayer() : void {
this.focusOnTank(this.nextPlayerInDirection(1));
}
private function prevPlayer() : void {
this.focusOnTank(this.nextPlayerInDirection(-1));
}
private function nextPlayerInDirection(param1:int) : Tank {
var local5:Tank = null;
var local2:Vector.<IGameObject> = tankUsersRegistry.getUsers();
var local3:int = int(local2.indexOf(this.focusedUser.user));
if(local3 == -1) {
return null;
}
var local4:int = local3;
while(true) {
local4 += param1;
if(local4 == -1) {
local4 = local2.length - 1;
} else if(local4 == local2.length) {
local4 = 0;
}
local5 = this.getTank(local2[local4]);
if(local5.teamType == this.focusedUser.teamType && local5.state == ClientTankState.ACTIVE) {
break;
}
if(local3 == local4) {
return null;
}
}
return local5;
}
private function getTank(param1:IGameObject) : Tank {
var local2:ITankModel = ITankModel(param1.adapt(ITankModel));
return local2.getTank();
}
private function battleScene() : BattleScene3D {
return battleService.getBattleScene3D();
}
public function close() : void {
battleEventDispatcher.removeBattleEventListener(TankUnloadedEvent,this);
contextMenuService.removeEventListener(ContextMenuServiceEvent.FOCUS_ON_USER,this.onFocusOnUser);
}
}
}
|
package alternativa.tanks.gui.clanmanagement.clanmemberlist.members {
import alternativa.tanks.gui.clanmanagement.clanmemberlist.list.ClanMembersDataProvider;
import alternativa.tanks.models.clan.membersdata.ClanMembersDataService;
import alternativa.types.Long;
import base.DiscreteSprite;
import fl.controls.List;
import flash.events.Event;
import flash.utils.Dictionary;
import forms.Styles;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoService;
import utils.ScrollStyleUtils;
public class ClanMembersList extends DiscreteSprite {
[Inject]
public static var userInfoService:IUserInfoService;
[Inject]
public static var clanMembersData:ClanMembersDataService;
private var dataProvider:ClanMembersDataProvider = new ClanMembersDataProvider();
private var list:List = new List();
protected var viewed:Dictionary = new Dictionary();
private var _width:int;
private var _height:int;
private var header:HeaderClanMemberList = new HeaderClanMemberList();
public function ClanMembersList() {
super();
addChild(this.header);
this.list.y = 20;
this.list.rowHeight = 20;
this.list.setStyle(Styles.CELL_RENDERER,ClanMembersListRenderer);
this.list.focusEnabled = true;
this.list.selectable = false;
ScrollStyleUtils.setGreenStyle(this.list);
this.dataProvider.getItemAtHandler = this.markAsViewed;
this.list.dataProvider = this.dataProvider;
addChild(this.list);
ScrollStyleUtils.setGreenStyle(this.list);
addEventListener(Event.ADDED_TO_STAGE,this.addResizeListener);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
}
private function markAsViewed(param1:Object) : void {
if(!this.isViewed(param1)) {
this.setAsViewed(param1);
}
}
protected function setAsViewed(param1:Object) : void {
this.viewed[param1] = true;
}
protected function isViewed(param1:Object) : Boolean {
return param1 in this.viewed;
}
public function fillData(param1:Vector.<Object>) : void {
var local2:Object = null;
this.dataProvider.removeAll();
for each(local2 in param1) {
this.dataProvider.addItem(local2);
}
this.update();
}
private function sort() : void {
this.dataProvider.sortOn(["permissionIndex","date"],[Array.NUMERIC,Array.NUMERIC | Array.DESCENDING]);
}
public function removeUser(param1:Long) : void {
var local2:int = this.dataProvider.getItemIndexById(param1);
if(local2 >= 0) {
this.dataProvider.removeItemAt(local2);
}
this.update();
}
public function addUser(param1:Object) : void {
this.dataProvider.addItem(param1);
this.update(param1);
}
private function update(param1:Object = null) : void {
if(param1 != null) {
this.markAsViewed(param1);
}
this.sort();
this.onResize();
}
private function addResizeListener(param1:Event) : void {
stage.addEventListener(Event.RESIZE,this.onResize);
this.onResize();
}
private function onResize(param1:Event = null) : void {
this.list.height = this._height - 20;
var local2:Boolean = this.list.maxVerticalScrollPosition > 0;
this.header.width = this._width;
this.list.width = local2 ? this._width + 8 : this._width;
}
private function onRemoveFromStage(param1:Event) : void {
var local3:Object = null;
stage.removeEventListener(Event.RESIZE,this.onResize);
var local2:int = 0;
while(local2 < this.dataProvider.length) {
local3 = this.dataProvider.getItemAt(local2);
local3.isNew = false;
local2++;
}
}
override public function get width() : Number {
return this._width;
}
override public function set width(param1:Number) : void {
this._width = param1;
this.onResize();
}
override public function get height() : Number {
return this._height;
}
override public function set height(param1:Number) : void {
this._height = param1;
this.onResize();
}
}
}
|
package alternativa.engine3d.core {
import alternativa.gfx.agal.VertexShader;
public class ShadowAtlasVertexShader extends VertexShader {
public function ShadowAtlasVertexShader() {
super();
mov(op,va0);
mov(v0,va1);
}
}
}
|
package _codec.projects.tanks.client.battleservice.model.statistics {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import alternativa.types.Short;
import projects.tanks.client.battleservice.model.statistics.UserStat;
public class CodecUserStat implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_deaths:ICodec;
private var codec_kills:ICodec;
private var codec_score:ICodec;
private var codec_user:ICodec;
public function CodecUserStat() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_deaths = param1.getCodec(new TypeCodecInfo(Short,false));
this.codec_kills = param1.getCodec(new TypeCodecInfo(Short,false));
this.codec_score = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_user = param1.getCodec(new TypeCodecInfo(Long,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:UserStat = new UserStat();
local2.deaths = this.codec_deaths.decode(param1) as int;
local2.kills = this.codec_kills.decode(param1) as int;
local2.score = this.codec_score.decode(param1) as int;
local2.user = this.codec_user.decode(param1) as Long;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:UserStat = UserStat(param2);
this.codec_deaths.encode(param1,local3.deaths);
this.codec_kills.encode(param1,local3.kills);
this.codec_score.encode(param1,local3.score);
this.codec_user.encode(param1,local3.user);
}
}
}
|
package alternativa.tanks.gui.payment.controls.exchange {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.payment.controls.exchange.ExchangeGroup_bitmapExchange.png")]
public class ExchangeGroup_bitmapExchange extends BitmapAsset {
public function ExchangeGroup_bitmapExchange() {
super();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p9 extends BitmapAsset
{
public function RangsIcon_p9()
{
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.panel.model.payment.modes.PayModeCC;
public class CodecPayModeCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_customManualDescription:ICodec;
private var codec_description:ICodec;
private var codec_image:ICodec;
private var codec_name:ICodec;
private var codec_order:ICodec;
public function CodecPayModeCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_customManualDescription = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_description = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_image = param1.getCodec(new TypeCodecInfo(ImageResource,true));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_order = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:PayModeCC = new PayModeCC();
local2.customManualDescription = this.codec_customManualDescription.decode(param1) as String;
local2.description = this.codec_description.decode(param1) as String;
local2.image = this.codec_image.decode(param1) as ImageResource;
local2.name = this.codec_name.decode(param1) as String;
local2.order = this.codec_order.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:PayModeCC = PayModeCC(param2);
this.codec_customManualDescription.encode(param1,local3.customManualDescription);
this.codec_description.encode(param1,local3.description);
this.codec_image.encode(param1,local3.image);
this.codec_name.encode(param1,local3.name);
this.codec_order.encode(param1,local3.order);
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_mineResistanceClass.png")]
public class ResistancesIcons_mineResistanceClass extends BitmapAsset {
public function ResistancesIcons_mineResistanceClass() {
super();
}
}
}
|
package projects.tanks.client.garage.models.item.mobilelootbox.deliverylootbox {
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 MobileLootBoxDeliveryModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function MobileLootBoxDeliveryModelServer(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.engine3d.loaders.collada {
use namespace collada;
public class DaeArray extends DaeElement {
public var array:Array;
public function DaeArray(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
public function get type() : String {
return String(data.localName());
}
override protected function parseImplementation() : Boolean {
var local2:int = 0;
this.array = parseStringArray(data);
var local1:XML = data.@count[0];
if(local1 != null) {
local2 = parseInt(local1.toString(),10);
if(this.array.length < local2) {
document.logger.logNotEnoughDataError(data.@count[0]);
return false;
}
this.array.length = local2;
return true;
}
return false;
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_chineseLogoMakeUp.png")]
public class MakeUp_chineseLogoMakeUp extends BitmapAsset {
public function MakeUp_chineseLogoMakeUp() {
super();
}
}
}
|
package alternativa.tanks.gui.tankpreview {
public class TankPreviewContext {
public var angularSpeed:Number = 0;
public function TankPreviewContext() {
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.terminator {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import projects.tanks.client.battlefield.models.tankparts.weapon.railgun.RailgunCC;
import projects.tanks.client.battlefield.models.tankparts.weapon.terminator.TerminatorCC;
import projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher.RocketLauncherCC;
public class CodecTerminatorCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_primaryCC:ICodec;
private var codec_secondaryCC:ICodec;
private var codec_secondaryKickback:ICodec;
public function CodecTerminatorCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_primaryCC = param1.getCodec(new TypeCodecInfo(RailgunCC,false));
this.codec_secondaryCC = param1.getCodec(new TypeCodecInfo(RocketLauncherCC,false));
this.codec_secondaryKickback = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:TerminatorCC = new TerminatorCC();
local2.primaryCC = this.codec_primaryCC.decode(param1) as RailgunCC;
local2.secondaryCC = this.codec_secondaryCC.decode(param1) as RocketLauncherCC;
local2.secondaryKickback = this.codec_secondaryKickback.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:TerminatorCC = TerminatorCC(param2);
this.codec_primaryCC.encode(param1,local3.primaryCC);
this.codec_secondaryCC.encode(param1,local3.secondaryCC);
this.codec_secondaryKickback.encode(param1,local3.secondaryKickback);
}
}
}
|
package alternativa.tanks.model.quest.challenge.gui {
import alternativa.osgi.service.locale.ILocaleService;
import controls.Label;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import forms.ColorConstants;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class TierNumberView extends Sprite {
[Inject]
public static var localeService:ILocaleService;
private static const tierClass:Class = TierNumberView_tierClass;
private static const tierBitmapData:BitmapData = new tierClass().bitmapData;
private var backgroundBitmap:Bitmap = new Bitmap(tierBitmapData);
private var levelLabel:Label = new Label();
private var titleLabel:Label = new Label();
public function TierNumberView() {
super();
addChild(this.backgroundBitmap);
this.initLevelLabel();
this.initTitleLabel();
}
public function set level(param1:int) : * {
this.levelLabel.text = param1.toString();
this.updateLabelPosition();
}
private function initLevelLabel() : void {
this.levelLabel.size = 42;
this.levelLabel.bold = true;
this.levelLabel.color = ColorConstants.GREEN_LABEL;
addChild(this.levelLabel);
}
private function initTitleLabel() : void {
this.titleLabel.size = 15;
this.titleLabel.text = localeService.getText(TanksLocale.TEXT_CHALLENGE_TIER);
this.titleLabel.x = (this.backgroundBitmap.width - this.titleLabel.width) / 2;
this.titleLabel.y = this.backgroundBitmap.height - 30;
this.titleLabel.color = ColorConstants.GREEN_LABEL;
addChild(this.titleLabel);
}
private function updateLabelPosition() : * {
this.levelLabel.x = (this.backgroundBitmap.width - this.levelLabel.width) / 2;
this.levelLabel.y = this.titleLabel.y - 40;
}
}
}
|
package alternativa.tanks.models.effects.durationTime {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IDurationAdapt implements IDuration {
private var object:IGameObject;
private var impl:IDuration;
public function IDurationAdapt(param1:IGameObject, param2:IDuration) {
super();
this.object = param1;
this.impl = param2;
}
public function getDurationTimeInMs() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getDurationTimeInMs());
}
finally {
Model.popObject();
}
return result;
}
public function isInfinite() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.isInfinite());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.physics.collision.primitives
{
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.physics.collision.CollisionPrimitive;
import alternativa.physics.collision.types.BoundBox;
public class CollisionRect extends CollisionPrimitive
{
private static const EPSILON:Number = 0.005;
public var hs:Vector3;
public var twoSided:Boolean = true;
public function CollisionRect(hs:Vector3, collisionGroup:int)
{
this.hs = new Vector3();
super(RECT,collisionGroup);
this.hs.vCopy(hs);
}
override public function calculateAABB() : BoundBox
{
var t:Matrix4 = null;
t = null;
t = transform;
var xx:Number = t.a < 0 ? Number(Number(-t.a)) : Number(Number(t.a));
var yy:Number = t.b < 0 ? Number(Number(-t.b)) : Number(Number(t.b));
var zz:Number = t.c < 0 ? Number(Number(-t.c)) : Number(Number(t.c));
aabb.maxX = this.hs.x * xx + this.hs.y * yy + EPSILON * zz;
aabb.minX = -aabb.maxX;
xx = t.e < 0 ? Number(Number(-t.e)) : Number(Number(t.e));
yy = t.f < 0 ? Number(Number(-t.f)) : Number(Number(t.f));
zz = t.g < 0 ? Number(Number(-t.g)) : Number(Number(t.g));
aabb.maxY = this.hs.x * xx + this.hs.y * yy + EPSILON * zz;
aabb.minY = -aabb.maxY;
xx = t.i < 0 ? Number(Number(-t.i)) : Number(Number(t.i));
yy = t.j < 0 ? Number(Number(-t.j)) : Number(Number(t.j));
zz = t.k < 0 ? Number(Number(-t.k)) : Number(Number(t.k));
aabb.maxZ = this.hs.x * xx + this.hs.y * yy + EPSILON * zz;
aabb.minZ = -aabb.maxZ;
aabb.minX += t.d;
aabb.maxX += t.d;
aabb.minY += t.h;
aabb.maxY += t.h;
aabb.minZ += t.l;
aabb.maxZ += t.l;
return aabb;
}
override public function copyFrom(source:CollisionPrimitive) : CollisionPrimitive
{
var rect:CollisionRect = source as CollisionRect;
if(rect == null)
{
return this;
}
super.copyFrom(rect);
this.hs.vCopy(rect.hs);
return this;
}
override public function toString() : String
{
return "[CollisionRect hs=" + this.hs + "]";
}
override protected function createPrimitive() : CollisionPrimitive
{
return new CollisionRect(this.hs,collisionGroup);
}
override public function getRayIntersection(origin:Vector3, vector:Vector3, threshold:Number, normal:Vector3) : Number
{
var t:Number = NaN;
t = NaN;
var vx:Number = origin.x - transform.d;
var vy:Number = origin.y - transform.h;
var vz:Number = origin.z - transform.l;
var ox:Number = transform.a * vx + transform.e * vy + transform.i * vz;
var oy:Number = transform.b * vx + transform.f * vy + transform.j * vz;
var oz:Number = transform.c * vx + transform.g * vy + transform.k * vz;
vx = transform.a * vector.x + transform.e * vector.y + transform.i * vector.z;
vy = transform.b * vector.x + transform.f * vector.y + transform.j * vector.z;
vz = transform.c * vector.x + transform.g * vector.y + transform.k * vector.z;
if(vz > -threshold && vz < threshold)
{
return -1;
}
t = -oz / vz;
if(t < 0)
{
return -1;
}
ox += vx * t;
oy += vy * t;
oz = 0;
if(ox < -this.hs.x - threshold || ox > this.hs.x + threshold || oy < -this.hs.y - threshold || oy > this.hs.y + threshold)
{
return -1;
}
normal.x = transform.c;
normal.y = transform.g;
normal.z = transform.k;
return t;
}
}
}
|
package alternativa.tanks.models.tank.rankup {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ITankRankUpEffectModelEvents implements ITankRankUpEffectModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ITankRankUpEffectModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function showRankUpEffect(param1:int) : void {
var i:int = 0;
var m:ITankRankUpEffectModel = null;
var rankIndex:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ITankRankUpEffectModel(this.impl[i]);
m.showRankUpEffect(rankIndex);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.panel.model.quest.notifier {
public class QuestNotifierCC {
private var _hasCompletedDailyQuests:Boolean;
private var _hasCompletedWeeklyQuests:Boolean;
private var _hasNewDailyQuests:Boolean;
private var _hasNewWeeklyQuests:Boolean;
private var _hasNotCompletedQuests:Boolean;
public function QuestNotifierCC(param1:Boolean = false, param2:Boolean = false, param3:Boolean = false, param4:Boolean = false, param5:Boolean = false) {
super();
this._hasCompletedDailyQuests = param1;
this._hasCompletedWeeklyQuests = param2;
this._hasNewDailyQuests = param3;
this._hasNewWeeklyQuests = param4;
this._hasNotCompletedQuests = param5;
}
public function get hasCompletedDailyQuests() : Boolean {
return this._hasCompletedDailyQuests;
}
public function set hasCompletedDailyQuests(param1:Boolean) : void {
this._hasCompletedDailyQuests = param1;
}
public function get hasCompletedWeeklyQuests() : Boolean {
return this._hasCompletedWeeklyQuests;
}
public function set hasCompletedWeeklyQuests(param1:Boolean) : void {
this._hasCompletedWeeklyQuests = param1;
}
public function get hasNewDailyQuests() : Boolean {
return this._hasNewDailyQuests;
}
public function set hasNewDailyQuests(param1:Boolean) : void {
this._hasNewDailyQuests = param1;
}
public function get hasNewWeeklyQuests() : Boolean {
return this._hasNewWeeklyQuests;
}
public function set hasNewWeeklyQuests(param1:Boolean) : void {
this._hasNewWeeklyQuests = param1;
}
public function get hasNotCompletedQuests() : Boolean {
return this._hasNotCompletedQuests;
}
public function set hasNotCompletedQuests(param1:Boolean) : void {
this._hasNotCompletedQuests = param1;
}
public function toString() : String {
var local1:String = "QuestNotifierCC [";
local1 += "hasCompletedDailyQuests = " + this.hasCompletedDailyQuests + " ";
local1 += "hasCompletedWeeklyQuests = " + this.hasCompletedWeeklyQuests + " ";
local1 += "hasNewDailyQuests = " + this.hasNewDailyQuests + " ";
local1 += "hasNewWeeklyQuests = " + this.hasNewWeeklyQuests + " ";
local1 += "hasNotCompletedQuests = " + this.hasNotCompletedQuests + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.camera.controllers.spectator {
import alternativa.tanks.services.bonusregion.IBonusRegionService;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
public class SpectatorBonusRegionController implements KeyboardHandler {
[Inject]
public static var bonusRegionService:IBonusRegionService;
public function SpectatorBonusRegionController() {
super();
}
public function handleKeyDown(param1:KeyboardEvent) : void {
if(param1.keyCode == Keyboard.QUOTE) {
bonusRegionService.toggleRegionsVisible();
}
}
public function handleKeyUp(param1:KeyboardEvent) : void {
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.mobilelootbox.deliverylootbox {
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.mobilelootbox.deliverylootbox.MobileLootBoxDeliveryCC;
public class VectorCodecMobileLootBoxDeliveryCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecMobileLootBoxDeliveryCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(MobileLootBoxDeliveryCC,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.<MobileLootBoxDeliveryCC> = new Vector.<MobileLootBoxDeliveryCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = MobileLootBoxDeliveryCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:MobileLootBoxDeliveryCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<MobileLootBoxDeliveryCC> = Vector.<MobileLootBoxDeliveryCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.gui {
import controls.timer.CountDownTimer;
import controls.timer.CountDownTimerOnCompleteBefore;
import platform.client.fp10.core.type.IGameObject;
public class TimerKitCouldBeBoughtContext implements CountDownTimerOnCompleteBefore {
public var item:IGameObject;
public var timer:CountDownTimer;
private var garageWindow:IGarageWindow;
public function TimerKitCouldBeBoughtContext(param1:IGameObject, param2:CountDownTimer, param3:IGarageWindow) {
super();
this.item = param1;
this.timer = param2;
this.garageWindow = param3;
this.timer.addListener(CountDownTimerOnCompleteBefore,this);
}
public function onCompleteBefore(param1:CountDownTimer, param2:Boolean) : void {
this.garageWindow.removeItemFromStore(this.item);
}
public function removeListener() : void {
this.timer.removeListener(CountDownTimerOnCompleteBefore,this);
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.KillMessageOutputLine_shaftIconClass.png")]
public class KillMessageOutputLine_shaftIconClass extends BitmapAsset {
public function KillMessageOutputLine_shaftIconClass() {
super();
}
}
}
|
package alternativa.tanks.gui.friends {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.FriendsWindowStateBigButton_ButtonRight.png")]
public class FriendsWindowStateBigButton_ButtonRight extends BitmapAsset {
public function FriendsWindowStateBigButton_ButtonRight() {
super();
}
}
}
|
package alternativa.engine3d.animation.keys {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.animation.AnimationState;
use namespace alternativa3d;
public class NumberTrack extends Track {
private static var temp:NumberKey = new NumberKey();
alternativa3d var keyList:NumberKey;
public var property:String;
public function NumberTrack(param1:String, param2:String) {
super();
this.property = param2;
this.object = param1;
}
override alternativa3d function get keyFramesList() : Keyframe {
return this.alternativa3d::keyList;
}
override alternativa3d function set keyFramesList(param1:Keyframe) : void {
this.alternativa3d::keyList = NumberKey(param1);
}
public function addKey(param1:Number, param2:Number = 0) : Keyframe {
var local3:NumberKey = new NumberKey();
local3.alternativa3d::_time = param1;
local3.value = param2;
alternativa3d::addKeyToList(local3);
return local3;
}
override alternativa3d function blend(param1:Number, param2:Number, param3:AnimationState) : void {
var local4:NumberKey = null;
if(this.property == null) {
return;
}
var local5:NumberKey = this.alternativa3d::keyList;
while(local5 != null && local5.alternativa3d::_time < param1) {
local4 = local5;
local5 = local5.alternativa3d::next;
}
if(local4 != null) {
if(local5 != null) {
temp.interpolate(local4,local5,(param1 - local4.alternativa3d::_time) / (local5.alternativa3d::_time - local4.alternativa3d::_time));
param3.addWeightedNumber(this.property,temp.alternativa3d::_value,param2);
} else {
param3.addWeightedNumber(this.property,local4.alternativa3d::_value,param2);
}
} else if(local5 != null) {
param3.addWeightedNumber(this.property,local5.alternativa3d::_value,param2);
}
}
override alternativa3d function createKeyFrame() : Keyframe {
return new NumberKey();
}
override alternativa3d function interpolateKeyFrame(param1:Keyframe, param2:Keyframe, param3:Keyframe, param4:Number) : void {
NumberKey(param1).interpolate(NumberKey(param2),NumberKey(param3),param4);
}
override public function slice(param1:Number, param2:Number = 1.7976931348623157e+308) : Track {
var local3:NumberTrack = new NumberTrack(object,this.property);
alternativa3d::sliceImplementation(local3,param1,param2);
return local3;
}
}
}
|
package alternativa.tanks.display.usertitle {
public class PowerBar extends ArtilleryBar {
public function PowerBar() {
super();
}
public function setPower(param1:Number, param2:Number) : void {
radialBar.setValue(param1);
label.text = Math.min(param2 * 100,100).toFixed() + "%";
this.resize();
}
override protected function resize() : void {
label.x = -(label.width >> 1) + X_OFFSET;
label.y = (label.height >> 1) - Y_OFFSET;
}
}
}
|
package {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol84")]
public dynamic class TextInput_upSkin extends MovieClip {
public function TextInput_upSkin() {
super();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.rank {
import projects.tanks.client.tanksservices.model.rankloader.RankInfo;
public interface RankService {
function getRankName(param1:int) : String;
function getNormalizedRankIndex(param1:int) : int;
function initRanks(param1:Vector.<RankInfo>) : void;
function get rankNames() : Vector.<String>;
}
}
|
package alternativa.tanks.model.item.skins {
import platform.client.fp10.core.type.IGameObject;
[ModelInterface]
public interface AvailableShotSkins {
function getSkins() : Vector.<IGameObject>;
}
}
|
package _codec {
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 alternativa.types.Byte;
public class VectorCodecbyteLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecbyteLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(Byte,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.<int> = new Vector.<int>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = int(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:int = 0;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<int> = Vector.<int>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class ArtilleryElevatingBarrelModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ArtilleryElevatingBarrelModelServer;
private var client:IArtilleryElevatingBarrelModelBase = IArtilleryElevatingBarrelModelBase(this);
private var modelId:Long = Long.getLong(2038268188,-682177215);
private var _updateId:Long = Long.getLong(101482701,848604323);
private var _update_barrelStateCodec:ICodec;
public function ArtilleryElevatingBarrelModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ArtilleryElevatingBarrelModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ArtilleryElevatingBarrelCC,false)));
this._update_barrelStateCodec = this._protocol.getCodec(new TypeCodecInfo(BarrelElevationCommand,false));
}
protected function getInitParam() : ArtilleryElevatingBarrelCC {
return ArtilleryElevatingBarrelCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._updateId:
this.client.update(BarrelElevationCommand(this._update_barrelStateCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol844")]
public dynamic class ScrollArrowUp_downSkin extends MovieClip {
public function ScrollArrowUp_downSkin() {
super();
}
}
}
|
package alternativa.tanks.model.item.skins {
import platform.client.fp10.core.type.IGameObject;
[ModelInterface]
public interface MountShotSkin {
function getMountedSkin() : IGameObject;
function mount(param1:IGameObject) : void;
}
}
|
package projects.tanks.client.clans.clan.incomingnotificator {
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 ClanIncomingNotificatorModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _removeId:Long = Long.getLong(1686269419,2119469073);
private var _remove_userIdCodec:ICodec;
private var model:IModel;
public function ClanIncomingNotificatorModelServer(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._remove_userIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function remove(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._remove_userIdCodec.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._removeId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_instIcon.png")]
public class MakeUp_instIcon extends BitmapAsset {
public function MakeUp_instIcon() {
super();
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.sms.types {
public class Country {
private var _id:String;
private var _name:String;
public function Country(param1:String = null, param2:String = null) {
super();
this._id = param1;
this._name = param2;
}
public function get id() : String {
return this._id;
}
public function set id(param1:String) : void {
this._id = 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 = "Country [";
local1 += "id = " + this.id + " ";
local1 += "name = " + this.name + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.garage.availableitems {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.AvailableItemsAlert;
import alternativa.tanks.loader.IModalLoaderService;
import alternativa.tanks.service.notificationcategories.INotificationGarageCategoriesService;
import flash.events.Event;
import forms.events.PartsListEvent;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.client.panel.model.garage.GarageItemInfo;
import projects.tanks.client.panel.model.garage.availableitems.AvailableItemsModelBase;
import projects.tanks.client.panel.model.garage.availableitems.IAvailableItemsModelBase;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
[ModelInfo]
public class AvailableItemsModel extends AvailableItemsModelBase implements IAvailableItemsModelBase {
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var notificationGarageCategoriesService:INotificationGarageCategoriesService;
[Inject]
public static var modalLoaderService:IModalLoaderService;
public static const CHANNEL:String = "available";
public function AvailableItemsModel() {
super();
}
public function showAvailableItems(param1:Vector.<GarageItemInfo>) : void {
if(lobbyLayoutService.getCurrentState() == LayoutState.GARAGE) {
this.showAlert(param1);
} else {
clearData(Vector);
putData(Vector,param1);
if(lobbyLayoutService.inBattle()) {
putData(Boolean,true);
}
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,getFunctionWrapper(this.onEndLayoutSwitch));
}
notificationGarageCategoriesService.notifyAboutAvailableItems(param1);
}
private function onEndLayoutSwitch(param1:LobbyLayoutServiceEvent) : void {
var local2:Boolean = false;
var local3:Vector.<GarageItemInfo> = null;
if(param1.state == LayoutState.BATTLE) {
putData(Boolean,true);
} else {
local2 = Boolean(getData(Boolean));
if(local2) {
clearData(Boolean);
if(getData(Vector) != null) {
local3 = Vector.<GarageItemInfo>(getData(Vector));
this.showAlert(local3);
}
}
}
}
private function showAlert(param1:Vector.<GarageItemInfo>) : void {
var local2:AvailableItemsAlert = AvailableItemsAlert(getData(AvailableItemsAlert));
if(local2 != null) {
this.destroyAlert();
}
var local3:AvailableItemsAlert = new AvailableItemsAlert(param1,TanksLocale.TEXT_HEADER_CONGRATULATION,TanksLocale.TEXT_GARAGE_NEW_ITEMS_ALERT);
local3.addEventListener(Event.CANCEL,getFunctionWrapper(this.onClickCloseButton));
local3.addEventListener(PartsListEvent.SELECT_PARTS_LIST_ITEM,getFunctionWrapper(this.onItemSelect));
putData(AvailableItemsAlert,local3);
}
private function onItemSelect(param1:PartsListEvent) : void {
var local2:AvailableItemsAlert = AvailableItemsAlert(getData(AvailableItemsAlert));
modalLoaderService.show();
server.select(local2.partsList.selectedItem);
this.destroyAlert();
}
private function onClickCloseButton(param1:Event) : void {
this.destroyAlert();
}
private function destroyAlert() : void {
if(lobbyLayoutService.hasEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH)) {
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,getFunctionWrapper(this.onEndLayoutSwitch));
}
var local1:AvailableItemsAlert = AvailableItemsAlert(getData(AvailableItemsAlert));
local1.removeEventListener(Event.CANCEL,getFunctionWrapper(this.onClickCloseButton));
local1.removeEventListener(PartsListEvent.SELECT_PARTS_LIST_ITEM,getFunctionWrapper(this.onItemSelect));
clearData(Vector);
clearData(AvailableItemsAlert);
}
}
}
|
package alternativa.tanks.models.weapon.shaft.states {
import alternativa.tanks.models.weapon.shaft.ShaftEventType;
import alternativa.tanks.models.weapon.shaft.ShaftWeapon;
public class ManualTargetingActivationState implements IShaftState {
private var weapon:ShaftWeapon;
private var stateDuration:int;
private var timeLeft:int;
public function ManualTargetingActivationState(param1:ShaftWeapon, param2:int) {
super();
this.weapon = param1;
this.stateDuration = param2;
}
public function enter(param1:int) : void {
this.weapon.startAimingActivation();
this.timeLeft = this.stateDuration;
}
public function exit() : void {
}
public function update(param1:int, param2:int) : void {
var local3:Number = NaN;
if(this.weapon.isAimedModeLocked()) {
this.weapon.processEvent(ShaftEventType.STOP);
} else if(this.timeLeft <= 0) {
this.weapon.setAimingActivationProgress(1);
this.weapon.processEvent(ShaftEventType.SWITCH);
} else {
this.timeLeft -= param2;
local3 = 1 - this.timeLeft / this.stateDuration;
if(local3 > 1) {
local3 = 1;
}
this.weapon.setAimingActivationProgress(local3);
}
}
public function processEvent(param1:ShaftEventType, param2:*) : void {
switch(param1) {
case ShaftEventType.TRIGGER_RELEASE:
this.weapon.processEvent(ShaftEventType.TRIGGER_RELEASE);
}
}
}
}
|
package projects.tanks.clients.fp10.TanksLauncherErrorScreen {
import assets.window.bitmaps.WindowBGTile;
import assets.window.bitmaps.WindowBottom;
import assets.window.bitmaps.WindowLeft;
import assets.window.bitmaps.WindowRight;
import assets.window.bitmaps.WindowTop;
import assets.window.elemets.WindowBottomLeftCorner;
import assets.window.elemets.WindowBottomRightCorner;
import assets.window.elemets.WindowTopLeftCorner;
import assets.window.elemets.WindowTopRightCorner;
import flash.display.Shape;
import flash.display.Sprite;
public class TankWindow extends Sprite {
private var _width:int;
private var _height:int;
private var tl:WindowTopLeftCorner = new WindowTopLeftCorner();
private var tr:WindowTopRightCorner = new WindowTopRightCorner();
private var bl:WindowBottomLeftCorner = new WindowBottomLeftCorner();
private var br:WindowBottomRightCorner = new WindowBottomRightCorner();
private var bgBMP:WindowBGTile = new WindowBGTile(0,0);
private var topBMP:WindowTop = new WindowTop(0,0);
private var bottomBMP:WindowBottom = new WindowBottom(0,0);
private var leftBMP:WindowLeft = new WindowLeft(0,0);
private var rightBMP:WindowRight = new WindowRight(0,0);
private var bg:Shape = new Shape();
private var top:Shape = new Shape();
private var bottom:Shape = new Shape();
private var left:Shape = new Shape();
private var right:Shape = new Shape();
public function TankWindow(width:int = -1, height:int = -1) {
super();
this._width = width;
this._height = height;
this.ConfigUI();
this.draw();
}
override public function set width(w:Number) : void {
this._width = int(w);
this.draw();
}
override public function get width() : Number {
return this._width;
}
override public function set height(h:Number) : void {
this._height = int(h);
this.draw();
}
override public function get height() : Number {
return this._height;
}
private function ConfigUI() : void {
this._width = this._width == -1 ? int(scaleX * 100) : this._width;
this._height = this._height == -1 ? int(scaleY * 100) : this._height;
scaleX = 1;
scaleY = 1;
addChild(this.bg);
addChild(this.top);
addChild(this.bottom);
addChild(this.left);
addChild(this.right);
addChild(this.tl);
addChild(this.tr);
addChild(this.bl);
addChild(this.br);
}
private function draw() : void {
this.bg.graphics.clear();
this.bg.graphics.beginBitmapFill(this.bgBMP);
this.bg.graphics.drawRect(7,7,this._width - 14,this._height - 14);
this.bg.graphics.endFill();
this.top.graphics.clear();
this.top.graphics.beginBitmapFill(this.topBMP);
this.top.graphics.drawRect(0,0,this._width - 22,11);
this.top.graphics.endFill();
this.top.x = 11;
this.bottom.graphics.clear();
this.bottom.graphics.beginBitmapFill(this.bottomBMP);
this.bottom.graphics.drawRect(0,0,this._width - 22,11);
this.bottom.graphics.endFill();
this.bottom.x = 11;
this.bottom.y = this._height - 11;
this.left.graphics.clear();
this.left.graphics.beginBitmapFill(this.leftBMP);
this.left.graphics.drawRect(0,0,11,this._height - 22);
this.left.graphics.endFill();
this.left.x = 0;
this.left.y = 11;
this.right.graphics.clear();
this.right.graphics.beginBitmapFill(this.rightBMP);
this.right.graphics.drawRect(0,0,11,this._height - 22);
this.right.graphics.endFill();
this.right.x = this._width - 11;
this.right.y = 11;
this.tl.x = 0;
this.tl.y = 0;
this.tr.x = this._width - this.tr.width;
this.tr.y = 0;
this.bl.x = 0;
this.bl.y = this._height - this.bl.height;
this.br.x = this._width - this.br.width;
this.br.y = this._height - this.br.height;
}
}
}
|
package controls.windowinner {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.windowinner.WindowInner_topClass.png")]
public class WindowInner_topClass extends BitmapAsset {
public function WindowInner_topClass() {
super();
}
}
}
|
package alternativa.tanks.battle.scene3d {
import alternativa.engine3d.core.Camera3D;
public class Fog {
public var color:int;
public var alpha:Number;
public var near:Number;
public var far:Number;
private var camera:Camera3D;
public function Fog(param1:Camera3D) {
super();
this.camera = param1;
}
public function enable() : void {
if(this.color != 0) {
this.camera.fogNear = this.near;
this.camera.fogFar = this.far;
this.camera.fogAlpha = this.alpha;
this.camera.fogColor = this.color;
}
}
public function disable() : void {
this.camera.fogNear = 0;
this.camera.fogFar = 1000000;
this.camera.fogAlpha = 0;
}
public function setup(param1:int, param2:Number, param3:Number, param4:Number) : void {
this.color = param1;
this.alpha = param2;
this.near = param3;
this.far = param4;
}
}
}
|
package alternativa.tanks.model.captcha
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class CaptchaRefreshButton__bitmapData extends BitmapAsset
{
public function CaptchaRefreshButton__bitmapData()
{
super();
}
}
}
|
package alternativa.osgi.service.command.impl {
import alternativa.osgi.service.command.CommandService;
import alternativa.osgi.service.command.FormattedOutput;
public class CommandServiceImpl implements CommandService {
private static const TOKENIZER:RegExp = /(?:[^"\s]+)|(?:"[^"]*")/g;
private const DEFAULT_SCOPE:String = "cmd";
public var commands:Vector.<Command> = new Vector.<Command>();
public function CommandServiceImpl() {
super();
}
public function registerCommand(param1:String, param2:String, param3:String, param4:Array, param5:Function) : void {
var local6:Command = new Command(param1,param2,param3,param4,param5);
this.commands.push(local6);
}
public function removeCommand(param1:String, param2:String, param3:Array) : void {
var local5:Command = null;
var local4:int = 0;
while(local4 < this.commands.length) {
local5 = this.commands[local4];
if(this.isEqualsFullCmd(local5,param1,param2)) {
if(local5.argsType.toString() == param3.toString()) {
this.commands.splice(local4,1);
return;
}
}
local4++;
}
}
public function execute(param1:String, param2:FormattedOutput) : void {
var local6:String = null;
var local7:Vector.<String> = null;
var local3:Vector.<String> = this.parseCommands(param1);
var local4:FormattedOutputToString = new FormattedOutputToString();
this.parseAndExecuteCommand(local3[0],[],local4);
var local5:int = 1;
while(local5 < local3.length) {
local6 = local3[local5];
local7 = local4.content;
local4 = new FormattedOutputToString();
this.parseAndExecuteCommand(local6,[local7],local4);
local5++;
}
param2.addLines(local4.content);
}
private function parseCommands(param1:String) : Vector.<String> {
var local7:String = null;
var local8:String = null;
var local2:Vector.<String> = new Vector.<String>();
var local3:Boolean = true;
var local4:int = 0;
var local5:int = 0;
local5 = 0;
while(local5 < param1.length) {
local7 = param1.charAt(local5);
if(local7 == "\"") {
local3 = !local3;
}
if(local7 == "|" && local3) {
local8 = param1.substr(local4,local5 - local4);
local2.push(local8);
local4 = local5 + 1;
}
local5++;
}
var local6:String = param1.substr(local4,param1.length - local4);
local2.push(local6);
return local2;
}
private function parseAndExecuteCommand(param1:String, param2:Array, param3:FormattedOutput) : void {
var local6:String = null;
var local7:String = null;
var local10:Command = null;
var local11:Array = null;
param1 = param1.replace(/^\s+|\s+$/g,"");
var local4:Array = param1.match(TOKENIZER);
if(local4.length == 0) {
throw new CommandNotFoundError(param1,"");
}
var local5:Array = (local4[0] as String).split(".");
if(local5.length == 1) {
local6 = "cmd";
local7 = local5[0];
} else {
if(local5.length != 2) {
throw new InvalidCommandFormatError(param1);
}
local6 = local5[0];
local7 = local5[1];
}
local4.shift();
var local8:int = 0;
while(local8 < this.commands.length) {
local10 = this.commands[local8];
if(this.isEqualsFullCmd(local10,local6,local7)) {
if(local10.argsType.length === local4.length + param2.length) {
local11 = this.convert(local10.argsType,local4);
local11 = local11.concat(param2);
local10.excute(local11,param3);
return;
}
}
local8++;
}
var local9:String = "";
local8 = 0;
while(local8 < this.commands.length) {
local10 = this.commands[local8];
if(local10.scope != this.DEFAULT_SCOPE) {
if(local10.cmd == local7 || local10.scope == local6 || local10.scope == local7) {
local9 += local10.scope + "." + local10.cmd + " " + local10.help() + "\n";
}
}
local8++;
}
throw new CommandNotFoundError(param1,local9);
}
private function isEqualsFullCmd(param1:Command, param2:String, param3:String) : Boolean {
return param1.scope == param2 && param1.cmd == param3;
}
private function convert(param1:Array, param2:Array) : Array {
var argsType:Array = param1;
var stringParams:Array = param2;
return stringParams.map(function(param1:*, param2:int, param3:Array):* {
var local5:* = undefined;
var local4:* = argsType[param2];
switch(local4) {
case String:
local5 = param1 as String;
if(local5.charAt(0) == "\"") {
local5 = local5.substr(1);
}
if(local5.charAt(local5.length - 1) == "\"") {
local5 = local5.substr(0,local5.length - 1);
}
return local5;
case int:
return int(param1);
case uint:
return uint(param1);
case Number:
return Number(param1);
default:
return;
}
});
}
}
}
|
package controls.chat
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChatPermissionsLevel_cm extends BitmapAsset
{
public function ChatPermissionsLevel_cm()
{
super();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p7 extends BitmapAsset
{
public function RangsIcon_p7()
{
super();
}
}
}
|
package alternativa.tanks.models.tank.device {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class TankDeviceAdapt implements TankDevice {
private var object:IGameObject;
private var impl:TankDevice;
public function TankDeviceAdapt(param1:IGameObject, param2:TankDevice) {
super();
this.object = param1;
this.impl = param2;
}
public function getDevice() : Long {
var result:Long = null;
try {
Model.object = this.object;
result = this.impl.getDevice();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.drones {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.materials.PaintMaterial;
import alternativa.utils.TextureMaterialRegistry;
import projects.tanks.clients.flash.commons.models.coloring.IColoring;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class DroneMaterialFactory {
[Inject]
public static var textureMaterialRegistry:TextureMaterialRegistry;
private static const DETAILS:String = "details.png";
private static const LIGHTMAP:String = "lightmap.jpg";
public function DroneMaterialFactory() {
super();
}
public function createMaterial(param1:Tanks3DSResource, param2:IColoring) : PaintMaterial {
if(param2.isAnimated()) {
return textureMaterialRegistry.getAnimatedPaint(param2.getAnimatedColoring(),param1.textures[LIGHTMAP],param1.textures[DETAILS],param1.id);
}
return textureMaterialRegistry.getPaint(param2.getColoring(),param1.textures[LIGHTMAP],param1.textures[DETAILS],param1.id);
}
public function releaseMaterial(param1:TextureMaterial) : void {
textureMaterialRegistry.releaseMaterial(param1);
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.common.shell {
import projects.tanks.client.battlefield.types.Vector3d;
public class ShellState {
private var _clientTime:int;
private var _direction:Vector3d;
private var _position:Vector3d;
public function ShellState(param1:int = 0, param2:Vector3d = null, param3:Vector3d = null) {
super();
this._clientTime = param1;
this._direction = param2;
this._position = param3;
}
public function get clientTime() : int {
return this._clientTime;
}
public function set clientTime(param1:int) : void {
this._clientTime = param1;
}
public function get direction() : Vector3d {
return this._direction;
}
public function set direction(param1:Vector3d) : void {
this._direction = param1;
}
public function get position() : Vector3d {
return this._position;
}
public function set position(param1:Vector3d) : void {
this._position = param1;
}
public function toString() : String {
var local1:String = "ShellState [";
local1 += "clientTime = " + this.clientTime + " ";
local1 += "direction = " + this.direction + " ";
local1 += "position = " + this.position + " ";
return local1 + "]";
}
}
}
|
package controls {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.TankWindowInner_bottomRightClass.png")]
public class TankWindowInner_bottomRightClass extends BitmapAsset {
public function TankWindowInner_bottomRightClass() {
super();
}
}
}
|
package controls.statassets {
import assets.resultwindow.bres_BG_ORANGECORNER;
import flash.display.BitmapData;
public class OrangeRoundRect extends BlackRoundRect {
public function OrangeRoundRect() {
super();
tl = new bres_BG_ORANGECORNER(1,1);
px = new BitmapData(1,1,false,12804096);
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.UpgradeIndicator_m0Class.png")]
public class UpgradeIndicator_m0Class extends BitmapAsset {
public function UpgradeIndicator_m0Class() {
super();
}
}
}
|
package alternativa.tanks.view.forms {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.controller.events.NavigationEvent;
import alternativa.tanks.controller.events.PasswordRestoreCaptchaEvent;
import alternativa.tanks.loader.ILoaderWindowService;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.base.TankInputBase;
import flash.display.Bitmap;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.FocusEvent;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.text.TextFormatAlign;
import flash.ui.Keyboard;
import forms.TankWindowWithHeader;
import forms.events.AlertEvent;
import org.robotlegs.core.IInjector;
import projects.tanks.clients.flash.commons.models.captcha.CaptchaSection;
import projects.tanks.clients.flash.commons.models.captcha.RefreshCaptchaClickedEvent;
import projects.tanks.clients.flash.commons.services.validate.IValidateService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import services.alertservice.Alert;
public class PasswordRestoreForm extends Sprite {
[Inject]
public static var validateService:IValidateService;
[Inject]
public static var loaderWindowService:ILoaderWindowService;
private static const MARGIN:int = 20;
private static const INFO_MARGIN:int = 10;
[Inject]
public var localeService:ILocaleService;
[Inject]
public var injector:IInjector;
public var captchaSection:CaptchaSection;
public var cancelButton:DefaultButtonBase;
public var recoverButton:DefaultButtonBase;
private var _windowWidth:int = 0;
private var _windowHeight:int = 0;
public var email:TankInputBase;
public function PasswordRestoreForm() {
super();
}
[PostConstruct]
public function postConstruct() : void {
var nextElementY:int;
var infoLinkContent:String;
var infoLink:LabelBase = null;
var window:TankWindowWithHeader = TankWindowWithHeader.createWindow(TanksLocale.TEXT_HEADER_ACCOUNT_RECOVERY,this._windowWidth,this._windowHeight);
var label:LabelBase = new LabelBase();
addChild(window);
addChild(label);
label.multiline = true;
label.align = TextFormatAlign.CENTER;
label.text = this.localeService.getText(TanksLocale.TEXT_ACCOUNT_RECOVERY_FORM_HELP_LABEL_TEXT);
label.x = MARGIN + 5;
label.y = MARGIN;
nextElementY = label.y + label.height - 6;
if(this._windowWidth < label.width) {
this._windowWidth = label.width + 2 * MARGIN + 5;
}
this.email = new TankInputBase();
this.email.width = this._windowWidth - 2 * MARGIN - 5;
this.email.x = MARGIN + 5;
this.email.y = nextElementY + MARGIN;
nextElementY += this.email.height + MARGIN;
infoLinkContent = this.localeService.getText(TanksLocale.TEXT_RESTORE_PASSWORD_INFO);
if(infoLinkContent != "") {
infoLink = new LabelBase();
infoLink.htmlText = infoLinkContent;
infoLink.x = int(this._windowWidth / 2 - infoLink.width / 2);
infoLink.y = nextElementY + INFO_MARGIN;
nextElementY = infoLink.y + infoLink.height + INFO_MARGIN;
addChild(infoLink);
} else {
nextElementY += MARGIN;
}
this.captchaSection = this.injector.instantiate(CaptchaSection);
this.captchaSection.refreshButton.addEventListener(MouseEvent.CLICK,function(param1:MouseEvent):void {
dispatchEvent(new RefreshCaptchaClickedEvent());
});
window.addChild(this.captchaSection);
this.captchaSection.y = nextElementY;
this.captchaSection.x = MARGIN + 5;
this.captchaSection.width = this._windowWidth - 2 * MARGIN - 5;
this.captchaSection.visible = true;
nextElementY += this.captchaSection.height + MARGIN;
this.cancelButton = new DefaultButtonBase();
this.recoverButton = new DefaultButtonBase();
addChild(this.cancelButton);
addChild(this.recoverButton);
addChild(this.email);
this.cancelButton.x = this._windowWidth - MARGIN - this.cancelButton.width;
this.cancelButton.y = nextElementY + MARGIN;
this.recoverButton.x = MARGIN + 5;
this.recoverButton.y = nextElementY + MARGIN;
nextElementY += MARGIN + this.cancelButton.height;
this._windowHeight = nextElementY + MARGIN;
window.height = this._windowHeight + 5;
window.width = this._windowWidth + 5;
this.cancelButton.label = this.localeService.getText(TanksLocale.TEXT_ACCOUNT_RECOVERY_FORM_BUTTON_CANCEL_TEXT);
this.recoverButton.label = this.localeService.getText(TanksLocale.TEXT_ACCOUNT_RECOVERY_FORM_BUTTON_RECOVER_TEXT);
this.cancelButton.addEventListener(MouseEvent.CLICK,this.onClickCancelButton);
this.recoverButton.addEventListener(MouseEvent.CLICK,this.onClickRecoverButton);
this.email.addEventListener(KeyboardEvent.KEY_DOWN,this.onPlayClickedKey);
this.recoverButton.enable = false;
this.email.addEventListener(FocusEvent.FOCUS_IN,this.restoreInput);
this.email.addEventListener(KeyboardEvent.KEY_UP,this.enableButton);
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
}
private function onAddedToStage(param1:Event) : void {
stage.focus = this.email;
stage.addEventListener(Event.RESIZE,this.alignYourself);
this.email.validValue = true;
this.alignYourself(null);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemovedFromStage);
dispatchEvent(new RefreshCaptchaClickedEvent());
loaderWindowService.hide();
}
private function onRemovedFromStage(param1:Event) : void {
stage.removeEventListener(Event.RESIZE,this.alignYourself);
}
private function onPlayClickedKey(param1:KeyboardEvent) : void {
if(param1.keyCode == Keyboard.ENTER && this.recoverButton.enable) {
this.onRecoverAttempt();
}
}
private function enableButton(param1:KeyboardEvent) : void {
this.recoverButton.enable = validateService.isEmailValid(this.email.value);
}
private function alignYourself(param1:Event) : void {
this.x = int((stage.stageWidth - this._windowWidth) / 2);
this.y = int((stage.stageHeight - this._windowHeight) / 2);
}
public function statusOkRestoreEmail() : void {
this.showAlertWindow(Alert.ALERT_RECOVERY_LINK_SENDED);
}
public function statusMailNotFoundRestoreEmail() : void {
this.showAlertWindow(Alert.ERROR_EMAIL_NOTFOUND);
}
private function onClickRecoverButton(param1:MouseEvent) : void {
this.onRecoverAttempt();
}
private function onRecoverAttempt() : void {
dispatchEvent(new PasswordRestoreCaptchaEvent(this.captchaAnswer,this.email.value));
}
private function onClickCancelButton(param1:MouseEvent) : void {
this.goToLoginForm();
}
private function restoreInput(param1:Event) : void {
this.email.validValue = true;
}
private function showAlertWindow(param1:int) : void {
var alertType:int = param1;
var errorWindow:Alert = new Alert(alertType);
this.injector.injectInto(errorWindow);
parent.addChild(errorWindow);
stage.focus = errorWindow.closeButton;
if(alertType == Alert.ALERT_RECOVERY_LINK_SENDED) {
errorWindow.addEventListener(AlertEvent.ALERT_BUTTON_PRESSED,function(param1:AlertEvent):void {
goToLoginForm();
});
}
}
private function goToLoginForm() : void {
dispatchEvent(new NavigationEvent(NavigationEvent.GO_TO_LOGIN_FORM));
}
public function get captchaAnswer() : String {
return this.captchaSection.captchaAnswer.value;
}
public function set captchaImage(param1:Bitmap) : void {
this.captchaSection.captcha = param1;
}
public function captchaFailed() : void {
dispatchEvent(new RefreshCaptchaClickedEvent());
}
}
}
|
package alternativa.tanks.camera {
import alternativa.math.Vector3;
public class CameraPositionData {
public var t:Number = 0;
public var extraPitch:Number = 0;
public var position:Vector3 = new Vector3();
public function CameraPositionData() {
super();
}
}
}
|
ο»Ώpackage com.lorentz.SVG.parser {
import com.lorentz.SVG.data.path.SVGArcToCommand;
import com.lorentz.SVG.data.path.SVGClosePathCommand;
import com.lorentz.SVG.data.path.SVGCurveToCubicCommand;
import com.lorentz.SVG.data.path.SVGCurveToCubicSmoothCommand;
import com.lorentz.SVG.data.path.SVGCurveToQuadraticCommand;
import com.lorentz.SVG.data.path.SVGCurveToQuadraticSmoothCommand;
import com.lorentz.SVG.data.path.SVGLineToCommand;
import com.lorentz.SVG.data.path.SVGLineToHorizontalCommand;
import com.lorentz.SVG.data.path.SVGLineToVerticalCommand;
import com.lorentz.SVG.data.path.SVGMoveToCommand;
import com.lorentz.SVG.data.path.SVGPathCommand;
import com.lorentz.SVG.utils.MathUtils;
import flash.geom.Matrix;
import flash.geom.Rectangle;
public class SVGParserCommon {
public static function parsePathData(input:String):Vector.<com.lorentz.SVG.data.path.SVGPathCommand> {
var commands:Vector.<com.lorentz.SVG.data.path.SVGPathCommand> = new Vector.<com.lorentz.SVG.data.path.SVGPathCommand>();
for each(var commandString:String in input.match(/[A-DF-Za-df-z][^A-Za-df-z]*/g)){
var type:String = commandString.charAt(0);
var args:Vector.<String> = SVGParserCommon.splitNumericArgs(commandString.substr(1));
if(type == "Z" || type == "z"){
commands.push(new SVGClosePathCommand());
continue;
}
var a:int = 0;
while (a<args.length){
if(type=="M" && a>0) //Subsequent pairs of coordinates are treated as implicit lineto commands
type = "L";
if(type=="m" && a>0) //Subsequent pairs of coordinates are treated as implicit lineto commands
type = "l";
switch (type) {
case "M" :
case "m" :
commands.push(new SVGMoveToCommand(type=="M", Number(args[a++]), Number(args[a++])));
break;
case "L" :
case "l" :
commands.push(new SVGLineToCommand(type=="L", Number(args[a++]), Number(args[a++])));
break;
case "H" :
case "h" :
commands.push(new SVGLineToHorizontalCommand(type=="H", Number(args[a++])));
break;
case "V" :
case "v" :
commands.push(new SVGLineToVerticalCommand(type=="V", Number(args[a++])));
break;
case "Q" :
case "q" :
commands.push(new SVGCurveToQuadraticCommand(type=="Q", Number(args[a++]), Number(args[a++]), Number(args[a++]), Number(args[a++])));
break;
case "T" :
case "t" :
commands.push(new SVGCurveToQuadraticSmoothCommand(type=="T", Number(args[a++]), Number(args[a++])));
break;
case "C" :
case "c" :
commands.push(new SVGCurveToCubicCommand(type=="C", Number(args[a++]), Number(args[a++]), Number(args[a++]), Number(args[a++]), Number(args[a++]), Number(args[a++])));
break;
case "S" :
case "s" :
commands.push(new SVGCurveToCubicSmoothCommand(type=="S", Number(args[a++]), Number(args[a++]), Number(args[a++]), Number(args[a++])));
break;
case "A" :
case "a" :
commands.push(new SVGArcToCommand(type=="A", Number(args[a++]), Number(args[a++]), Number(args[a++]), args[a++]!="0", args[a++]!="0", Number(args[a++]), Number(args[a++])));
break;
default : trace("Invalid PathCommand type: " + type);
a = args.length; //Break args loop
}
}
}
return commands;
}
public static function splitNumericArgs(input:String):Vector.<String> {
var returnData:Vector.<String> = new Vector.<String>();
var matchedNumbers:Array = input.match(/(?:\+|-)?(?:(?:\d*\.\d+)|(?:\d+))(?:e(?:\+|-)?\d+)?/g);
for each(var numberString:String in matchedNumbers){
returnData.push(numberString);
}
return returnData;
}
public static function parseTransformation(m:String):Matrix {
if(m.length == 0) {
return new Matrix();
}
var transformations:Array = m.match(/(\w+?\s*\([^)]*\))/g);
var mat:Matrix = new Matrix();
if(transformations is Array){
for(var i:int = transformations.length - 1; i >= 0; i--)
{
var parts:Array = /(\w+?)\s*\(([^)]*)\)/.exec(transformations[i]);
if(parts is Array){
var name:String = parts[1].toLowerCase();
var args:Vector.<String> = splitNumericArgs(parts[2]);
switch(name){
case "matrix" :
mat.concat(new Matrix(Number(args[0]), Number(args[1]), Number(args[2]), Number(args[3]), Number(args[4]), Number(args[5])));
break;
case "translate" :
mat.translate(Number(args[0]), args.length > 1 ? Number(args[1]) : 0);
break;
case "scale" :
mat.scale(Number(args[0]), args.length > 1 ? Number(args[1]) : Number(args[0]));
break;
case "rotate" :
if(args.length > 1){
var tx:Number = args.length > 1 ? Number(args[1]) : 0;
var ty:Number = args.length > 2 ? Number(args[2]) : 0;
mat.translate(-tx, -ty);
mat.rotate(MathUtils.degressToRadius(Number(args[0])));
mat.translate(tx, ty);
} else {
mat.rotate(MathUtils.degressToRadius(Number(args[0])));
}
break;
case "skewx" :
var skewXMatrix:Matrix = new Matrix();
skewXMatrix.c = Math.tan(MathUtils.degressToRadius(Number(args[0])));
mat.concat(skewXMatrix);
break;
case "skewy" :
var skewYMatrix:Matrix = new Matrix();
skewYMatrix.b = Math.tan(MathUtils.degressToRadius(Number(args[0])));
mat.concat(skewYMatrix);
break;
}
}
}
}
return mat;
}
public static function parseViewBox(viewBox:String):Rectangle {
if(viewBox == null || viewBox == "") {
return null;
}
var params:Object = viewBox.split(/\s/);
return new Rectangle(params[0], params[1], params[2], params[3]);
}
public static function parsePreserveAspectRatio(text:String):Object {
var parts:Array = /(?:(defer)\s+)?(\w*)(?:\s+(meet|slice))?/gi.exec(text.toLowerCase());
return {
defer: parts[1] != undefined,
align: parts[2] || "xmidymid",
meetOrSlice: parts[3] || "meet"
};
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.map {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import projects.tanks.client.battlefield.models.map.DynamicShadowParams;
public class CodecDynamicShadowParams implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_angleX:ICodec;
private var codec_angleZ:ICodec;
private var codec_lightColor:ICodec;
private var codec_shadowColor:ICodec;
public function CodecDynamicShadowParams() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_angleX = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_angleZ = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_lightColor = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_shadowColor = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:DynamicShadowParams = new DynamicShadowParams();
local2.angleX = this.codec_angleX.decode(param1) as Number;
local2.angleZ = this.codec_angleZ.decode(param1) as Number;
local2.lightColor = this.codec_lightColor.decode(param1) as int;
local2.shadowColor = this.codec_shadowColor.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:DynamicShadowParams = DynamicShadowParams(param2);
this.codec_angleX.encode(param1,local3.angleX);
this.codec_angleZ.encode(param1,local3.angleZ);
this.codec_lightColor.encode(param1,local3.lightColor);
this.codec_shadowColor.encode(param1,local3.shadowColor);
}
}
}
|
package alternativa.tanks.gui.clanmanagement.clanmemberlist.list {
import alternativa.tanks.gui.clanmanagement.clanmemberlist.IClanActionListener;
import alternativa.tanks.models.clan.membersdata.ClanMembersDataService;
import alternativa.tanks.models.foreignclan.ForeignClanService;
import alternativa.types.Long;
import base.DiscreteSprite;
import flash.display.Bitmap;
import flash.display.BitmapData;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
public class DeleteIndicator extends DiscreteSprite implements IClanActionListener {
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var clanMembersData:ClanMembersDataService;
[Inject]
public static var foreignClanService:ForeignClanService;
private static var deleteIconClass:Class = DeleteIndicator_deleteIconClass;
private static var deleteIconBitmapData:BitmapData = Bitmap(new deleteIconClass()).bitmapData;
private var invisible:Boolean;
private var userId:Long;
private var currentUserId:Long;
public function DeleteIndicator(param1:Boolean = false, param2:Long = null, param3:Long = null) {
super();
this.userId = param2;
this.currentUserId = param3;
this.tabChildren = false;
this.tabEnabled = false;
this.buttonMode = this.useHandCursor = true;
this.invisible = param1;
var local4:Bitmap = new Bitmap(deleteIconBitmapData);
addChild(local4);
}
public function updateActions() : void {
visible = !this.invisible && clanUserInfoService.hasAction(ClanAction.REMOVE_FROM_CLAN) && this.deleteAllowed() && !foreignClanService.isShowForeignClan();
}
private function deleteAllowed() : Boolean {
if(this.userId == null || this.currentUserId == null) {
return true;
}
return clanMembersData.getPermission(this.currentUserId).value < clanMembersData.getPermission(this.userId).value;
}
}
}
|
package forms.events
{
import flash.events.Event;
public class BattleListEvent extends Event
{
public static const CREATE_GAME:String = "CreateGame";
public static const START_CREATED_GAME:String = "StartCreatedGame";
public static const START_DM_GAME:String = "StartDeathMatch";
public static const START_TDM_RED:String = "StartTeamDeathMatchRED";
public static const START_TDM_BLUE:String = "StartTeamDeathMatchBLUE";
public static const SELECT_BATTLE:String = "SelectBattle";
public static const NEW_BATTLE_NAME_ADDED:String = "NewBattleNameAdded";
public function BattleListEvent(type:String)
{
super(type,true,false);
}
}
}
|
package assets.window.bitmaps {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.window.bitmaps.WindowBGTile.jpg")]
public class WindowBGTile extends BitmapData {
public function WindowBGTile(param1:int, param2:int, param3:Boolean = true, param4:uint = 0) {
super(param1,param2,param3,param4);
}
}
}
|
package projects.tanks.client.clans.user {
public interface IClanUserLoaderModelBase {
function showWindow() : void;
}
}
|
package {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol128")]
public dynamic class ScrollBar_thumbIcon extends MovieClip {
public function ScrollBar_thumbIcon() {
super();
}
}
}
|
package projects.tanks.client.battleselect.model.battleselect {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class BattleSelectModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BattleSelectModelServer;
private var client:IBattleSelectModelBase = IBattleSelectModelBase(this);
private var modelId:Long = Long.getLong(600945976,725191480);
private var _battleItemsPacketJoinSuccessId:Long = Long.getLong(1673040790,-1477360154);
private var _selectId:Long = Long.getLong(1230896613,-954387929);
private var _select_itemCodec:ICodec;
public function BattleSelectModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BattleSelectModelServer(IModel(this));
this._select_itemCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._battleItemsPacketJoinSuccessId:
this.client.battleItemsPacketJoinSuccess();
break;
case this._selectId:
this.client.select(IGameObject(this._select_itemCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.battlefield.gui.statistics.field
{
import controls.Label;
import controls.resultassets.WhiteFrame;
import flash.display.Bitmap;
import flash.display.GradientType;
import flash.display.Graphics;
import flash.display.SpreadMethod;
import flash.display.Sprite;
import flash.events.Event;
import flash.geom.Matrix;
import flash.text.TextFieldAutoSize;
import flash.utils.getTimer;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
public class CTFScoreIndicator extends Sprite
{
[Embed(source="1080.png")]
private static var flagBlueClass:Class;
[Embed(source="824.png")]
private static var flagRedClass:Class;
[Embed(source="1060.png")]
private static var flagBlueLostClass:Class;
[Embed(source="1158.png")]
private static var flagRedLostClass:Class;
[Embed(source="780.png")]
private static var flagFlashClass:Class;
private static const FONT_COLOR_RED:uint = 16742221;
private static const FONT_COLOR_BLUE:uint = 4760319;
private static const BG_COLOR_RED:uint = 9249024;
private static const BG_COLOR_BLUE:uint = 16256;
private static const ICON_WIDTH:int = 30;
private static const LABEL_Y:int = 6;
private var border:WhiteFrame;
private var blueIndicator:FlagIndicator;
private var redIndicator:FlagIndicator;
private var labelRed:Label;
private var labelBlue:Label;
private var time:int;
private var redInterpolator:ColorInterpolator;
private var blueInterpolator:ColorInterpolator;
private var blinker:CTFScoreIndicatorBlinker;
public function CTFScoreIndicator()
{
this.redInterpolator = new ColorInterpolator(FONT_COLOR_RED,16777215);
this.blueInterpolator = new ColorInterpolator(FONT_COLOR_BLUE,16777215);
this.blinker = new CTFScoreIndicatorBlinker(0,1,Vector.<int>([200,600]),Vector.<Number>([10,1.1]));
super();
this.border = new WhiteFrame();
addChild(this.border);
this.labelRed = this.createLabel(FONT_COLOR_RED);
this.labelBlue = this.createLabel(FONT_COLOR_BLUE);
this.blueIndicator = new FlagIndicator(new flagBlueClass(),new flagBlueLostClass(),new flagFlashClass(),this.blinker);
this.blueIndicator.y = 5;
addChild(this.blueIndicator);
this.redIndicator = new FlagIndicator(new flagRedClass(),new flagRedLostClass(),new flagFlashClass(),this.blinker);
this.redIndicator.y = 5;
addChild(this.redIndicator);
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemovedFromStage);
}
public function initScore(redScore:int, blueScore:int) : void
{
this.labelRed.text = redScore.toString();
this.labelBlue.text = blueScore.toString();
this.redIndicator.setState(FlagIndicator.STATE_AT_BASE);
this.blueIndicator.setState(FlagIndicator.STATE_AT_BASE);
this.update();
}
public function get redScore() : int
{
return int(this.labelRed.text);
}
public function set redScore(value:int) : void
{
if(int(this.labelRed.text) == value)
{
return;
}
this.labelRed.text = value.toString();
this.blueIndicator.setState(FlagIndicator.STATE_FLASHING);
this.update();
}
public function get blueScore() : int
{
return int(this.labelBlue.text);
}
public function set blueScore(value:int) : void
{
if(int(this.labelBlue.text) == value)
{
return;
}
this.labelBlue.text = value.toString();
this.redIndicator.setState(FlagIndicator.STATE_FLASHING);
this.update();
}
public function showFlagFlash(teamType:BattleTeamType) : void
{
var flagInficator:FlagIndicator = this.getFlagInficator(teamType);
flagInficator.setState(FlagIndicator.STATE_FLASHING);
}
public function showFlagAtBase(teamType:BattleTeamType) : void
{
var flagInficator:FlagIndicator = this.getFlagInficator(teamType);
flagInficator.setState(FlagIndicator.STATE_AT_BASE);
}
public function showFlagCarried(teamType:BattleTeamType) : void
{
var flagInficator:FlagIndicator = this.getFlagInficator(teamType);
flagInficator.setState(FlagIndicator.STATE_CARRIED);
}
public function showFlagDropped(teamType:BattleTeamType) : void
{
var flagInficator:FlagIndicator = this.getFlagInficator(teamType);
flagInficator.setState(FlagIndicator.STATE_DROPPED);
}
public function setTeamScore(teamType:BattleTeamType, score:int) : void
{
switch(teamType)
{
case BattleTeamType.BLUE:
this.blueScore = score;
break;
case BattleTeamType.RED:
this.redScore = score;
}
}
private function update() : void
{
var x:int = 0;
var maxLabelWidth:int = this.labelRed.width > this.labelBlue.width ? int(int(this.labelRed.width)) : int(int(this.labelBlue.width));
this.redIndicator.x = 5 + 5;
x = this.redIndicator.x + ICON_WIDTH + 5;
this.labelRed.x = x + (maxLabelWidth - this.labelRed.width >> 1);
x += maxLabelWidth + 5 + 5;
this.labelBlue.x = x + (maxLabelWidth - this.labelBlue.width >> 1);
x += maxLabelWidth + 5;
this.blueIndicator.x = x;
x += ICON_WIDTH + 5 + 5;
this.updateBgAndBorder(x);
}
private function updateBgAndBorder(width:int) : void
{
this.border.width = width;
var fillType:String = GradientType.LINEAR;
var colors:Array = [BG_COLOR_RED,BG_COLOR_BLUE];
var alphas:Array = [1,1];
var r:int = 8 / width * 255;
var ratios:Array = [127 - r,127 + r];
var matrix:Matrix = new Matrix();
matrix.createGradientBox(width - 2 * 2,this.border.height - 2 * 2,0,0,0);
var spreadMethod:String = SpreadMethod.PAD;
var g:Graphics = graphics;
g.clear();
g.beginGradientFill(fillType,colors,alphas,ratios,matrix,spreadMethod);
g.drawRect(2,2,width - 2 * 2,this.border.height - 2 * 2);
g.endFill();
}
private function createLabel(color:uint) : Label
{
var label:Label = new Label();
label.color = color;
label.size = 18;
label.bold = true;
label.autoSize = TextFieldAutoSize.CENTER;
label.y = LABEL_Y;
label.text = "0";
addChild(label);
return label;
}
private function onAddedToStage(event:Event) : void
{
this.update();
this.time = getTimer();
stage.addEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
private function onRemovedFromStage(event:Event) : void
{
stage.removeEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
private function onEnterFrame(event:Event) : void
{
var now:int = getTimer();
var delta:int = now - this.time;
this.time = now;
this.blinker.update(now,delta);
this.redIndicator.update(now,delta);
this.blueIndicator.update(now,delta);
this.updateScoreColor(this.labelRed,this.redInterpolator,this.blueIndicator.flashBitmap);
this.updateScoreColor(this.labelBlue,this.blueInterpolator,this.redIndicator.flashBitmap);
}
private function updateScoreColor(scoreField:Label, interpolator:ColorInterpolator, flashBitmap:Bitmap) : void
{
var newColor:uint = 0;
if(flashBitmap.visible)
{
newColor = interpolator.interpolate(flashBitmap.alpha);
}
else
{
newColor = interpolator.startColor;
}
if(newColor != scoreField.textColor)
{
scoreField.textColor = newColor;
}
}
private function getFlagInficator(teamType:BattleTeamType) : FlagIndicator
{
switch(teamType)
{
case BattleTeamType.BLUE:
return this.blueIndicator;
case BattleTeamType.RED:
return this.redIndicator;
default:
throw new ArgumentError("Unsupported team type");
}
}
}
}
class ColorInterpolator
{
public var startColor:uint;
private var endColor:uint;
private var deltaRed:Number;
private var deltaGreen:Number;
private var deltaBlue:Number;
function ColorInterpolator(startColor:uint, endColor:uint)
{
super();
this.startColor = startColor;
this.endColor = endColor;
this.deltaRed = (endColor >> 16 & 255) - (startColor >> 16 & 255);
this.deltaGreen = (endColor >> 8 & 255) - (startColor >> 8 & 255);
this.deltaBlue = (endColor & 255) - (startColor & 255);
}
public function interpolate(t:Number) : uint
{
var r:int = (this.startColor >> 16 & 255) + t * this.deltaRed;
var g:int = (this.startColor >> 8 & 255) + t * this.deltaGreen;
var b:int = (this.startColor & 255) + t * this.deltaBlue;
return r << 16 | g << 8 | b;
}
}
import flash.display.GradientType;
import flash.display.Graphics;
import flash.display.Shape;
import flash.geom.Matrix;
class FlashMask extends Shape
{
private static const STATE_GROW:int = 1;
private static const STATE_WAIT:int = 2;
private static const STATE_FADE:int = 3;
private static const GROW_SPEED:Number = 10 / 1000;
private static const FADE_SPEED:Number = 1 / 1000;
private static const MAX_WAIT_TIME:int = 200;
private var m:Matrix;
private var state:int;
private var waitTime:int;
function FlashMask()
{
this.m = new Matrix();
super();
blendMode = "add";
visible = false;
}
public function init(x:int, y:int, w:int, h:int, color:uint) : void
{
this.x = x;
this.y = y;
this.m.createGradientBox(w,h);
var g:Graphics = graphics;
g.clear();
g.beginGradientFill(GradientType.RADIAL,[color,0],[1,1],[127,255],this.m);
g.drawRect(0,0,w,h);
g.endFill();
visible = true;
alpha = 0;
this.state = STATE_GROW;
}
public function update(delta:int) : Boolean
{
switch(this.state)
{
case STATE_GROW:
alpha += GROW_SPEED * delta;
if(alpha >= 1)
{
alpha = 1;
this.state = STATE_WAIT;
this.waitTime = MAX_WAIT_TIME;
}
break;
case STATE_WAIT:
this.waitTime -= delta;
if(this.waitTime <= 0)
{
this.state = STATE_FADE;
}
break;
case STATE_FADE:
alpha -= FADE_SPEED * delta;
if(alpha <= 0)
{
visible = false;
return false;
}
break;
}
return true;
}
}
|
package _codec.projects.tanks.client.panel.model.shop.indemnity {
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.indemnity.IndemnityCC;
public class CodecIndemnityCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_indemnitySize:ICodec;
public function CodecIndemnityCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_indemnitySize = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:IndemnityCC = new IndemnityCC();
local2.indemnitySize = this.codec_indemnitySize.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:IndemnityCC = IndemnityCC(param2);
this.codec_indemnitySize.encode(param1,local3.indemnitySize);
}
}
}
|
package alternativa.register
{
import alternativa.init.Main;
import alternativa.service.IClassService;
import alternativa.types.Long;
import flash.utils.Dictionary;
public class ClassRegister implements IClassService
{
private var _classes:Dictionary;
private var _classList:Array;
public function ClassRegister()
{
super();
this._classList = new Array();
this._classes = new Dictionary();
}
public function createClass(id:String, parent:ClientClass, name:String, modelsToAdd:Array, modelsToRemove:Array) : ClientClass
{
var parentModels:Vector.<String> = null;
var i:int = 0;
var parentParams:Dictionary = null;
var modelId:* = undefined;
var models:Vector.<String> = new Vector.<String>();
if(parent != null)
{
parentModels = parent.models;
for(i = 0; i < parentModels.length; i++)
{
if(modelsToRemove != null)
{
if(modelsToRemove.indexOf(parentModels[i]) == -1)
{
models.push(parentModels[i]);
}
}
else
{
models.push(parentModels[i]);
}
}
}
if(modelsToAdd != null)
{
for(i = 0; i < modelsToAdd.length; i++)
{
models.push(modelsToAdd[i]);
}
}
models.sort(this.compareModelsId);
var newClass:ClientClass = new ClientClass(id,parent,name,models);
if(parent != null)
{
parent.addChild(newClass);
parentParams = parent.modelsParams;
for(modelId in parentParams)
{
newClass.setModelParams(modelId,parentParams[modelId]);
}
}
this._classes[id] = newClass;
this._classList.push(newClass);
Main.writeToConsole("ClassRegister ClientClass id:" + id + " name:" + name + " Π·Π°ΡΠ΅Π³ΠΈΡΡΡΠΈΡΠΎΠ²Π°Π½");
return newClass;
}
private function compareModelsId(id1:Long, id2:Long) : int
{
var result:int = id1.high - id2.high;
if(result == 0)
{
result = id1.low - id2.low;
}
return result;
}
public function destroyClass(id:String) : void
{
this._classList.splice(this._classList.indexOf(this._classes[id]),1);
this._classes[id] = null;
}
public function getClass(id:String) : ClientClass
{
return this._classes[id];
}
public function get classes() : Dictionary
{
return this._classes;
}
public function get classList() : Array
{
return this._classList;
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.facilities {
public interface IBattleFacilitiesModelBase {
}
}
|
package forms.registration.bubbles {
import alternativa.osgi.service.locale.ILocaleService;
import flash.geom.Point;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.BubbleHelper;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperAlign;
public class EmailInvalidBubble extends BubbleHelper {
[Inject]
public static var localeService:ILocaleService;
private var margin:int = 12;
public function EmailInvalidBubble() {
super();
text = localeService.getText(TanksLocale.TEXT_ERROR_EMAIL_INVALID);
arrowLehgth = 20;
arrowAlign = HelperAlign.TOP_LEFT;
_showLimit = 3;
}
public function setEmailInvalidText() : void {
text = localeService.getText(TanksLocale.TEXT_ERROR_EMAIL_INVALID);
}
public function setEmailForbiddenText() : void {
text = localeService.getText(TanksLocale.TEXT_ERROR_EMAIL_DOMAIN_IS_FORBIDDEN);
}
public function setEmailIsNotUniqueText() : void {
text = localeService.getText(TanksLocale.TEXT_ERROR_EMAIL_NOT_UNIQUE);
}
public function redraw() : void {
var local1:Point = new Point();
local1.x = Math.round(descriptionLabel.textWidth + this.margin * 2);
local1.y = Math.round(descriptionLabel.textHeight + this.margin * 2) - 3;
draw(local1);
}
}
}
|
package alternativa.tanks.models.tank {
import alternativa.osgi.service.command.FormattedOutput;
import alternativa.tanks.models.battle.battlefield.BattleUserInfoService;
import flash.utils.Dictionary;
public class TanksList {
private var tanksInBattle:Dictionary;
private var userInfoService:BattleUserInfoService;
public function TanksList(param1:Dictionary, param2:BattleUserInfoService) {
super();
this.tanksInBattle = param1;
this.userInfoService = param2;
}
public function printTanksList(param1:FormattedOutput) : void {
}
}
}
|
package alternativa.tanks.engine3d {
import alternativa.engine3d.core.MipMapping;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.materials.AnimatedPaintMaterial;
import alternativa.tanks.materials.PaintMaterial;
import alternativa.types.Long;
import alternativa.utils.TextureMaterialRegistry;
import alternativa.utils.clearDictionary;
import flash.display.BitmapData;
import flash.utils.Dictionary;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import platform.client.fp10.core.resource.types.TextureResource;
public class TextureMaterialRegistryBase implements TextureMaterialRegistry {
[Inject]
public static var battleService:BattleService;
private var materialStat:CachedEntityStat = new CachedEntityStat();
private var materialFactory:TextureMaterialFactory;
private var mipMappingEnabled:Boolean;
private const materials:Vector.<TextureMaterial> = new Vector.<TextureMaterial>();
private const entryForTexture:Dictionary = new Dictionary();
private const entryForMaterial:Dictionary = new Dictionary();
public function TextureMaterialRegistryBase(param1:TextureMaterialFactory) {
super();
this.materialFactory = param1;
}
public function getMaterialStat() : CachedEntityStat {
return this.materialStat;
}
public function getAnimatedPaint(param1:MultiframeTextureResource, param2:BitmapData, param3:BitmapData, param4:Long) : AnimatedPaintMaterial {
var local9:MaterialEntry = null;
++this.materialStat.requestCount;
var local5:String = param1.id + " " + param4;
if(local5 in this.entryForTexture) {
local9 = this.entryForTexture[local5];
++local9.referenceCount;
return local9.material as AnimatedPaintMaterial;
}
var local6:int = param1.data.width / param1.frameWidth;
var local7:int = param1.data.height / param1.frameHeight;
var local8:AnimatedPaintMaterial = new AnimatedPaintMaterial(param1.data,param2,param3,local6,local7,param1.fps,param1.numFrames,this.mipMappingEnabled ? int(MipMapping.PER_PIXEL) : 0);
local9 = this.createPaintMaterialEntry(local5,local8);
++local9.referenceCount;
this.materials.push(local8);
++this.materialStat.createCount;
return local8;
}
public function getPaint(param1:TextureResource, param2:BitmapData, param3:BitmapData, param4:Long) : PaintMaterial {
var local7:MaterialEntry = null;
++this.materialStat.requestCount;
var local5:String = param1.id + " " + param4;
if(local5 in this.entryForTexture) {
local7 = this.entryForTexture[local5];
++local7.referenceCount;
return local7.material as PaintMaterial;
}
var local6:PaintMaterial = new PaintMaterial(param1.data,param2,param3,this.mipMappingEnabled ? int(MipMapping.PER_PIXEL) : 0);
local7 = this.createPaintMaterialEntry(local5,local6);
++local7.referenceCount;
this.materials.push(local6);
++this.materialStat.createCount;
return local6;
}
public function getMaterial(param1:BitmapData, param2:Boolean = true) : TextureMaterial {
if(param1 == null) {
throw new ArgumentError("Texture is null");
}
++this.materialStat.requestCount;
var local3:MaterialEntry = this.getOrCreateEntry(param1,param2);
++local3.referenceCount;
return local3.material;
}
private function getOrCreateEntry(param1:BitmapData, param2:Boolean) : MaterialEntry {
var local4:TextureMaterial = null;
var local3:MaterialEntry = this.entryForTexture[param1];
if(local3 == null) {
local4 = this.createMaterial(param1,param2);
local3 = this.createMaterialEntry(param1,local4);
}
return local3;
}
private function createMaterial(param1:BitmapData, param2:Boolean) : TextureMaterial {
var local3:BitmapData = this.getTexture(param1,param2);
var local4:TextureMaterial = this.materialFactory.createTextureMaterial(local3,this.mipMappingEnabled);
this.materials.push(local4);
++this.materialStat.createCount;
return local4;
}
protected function getTexture(param1:BitmapData, param2:Boolean) : BitmapData {
throw new Error("Not implemented");
}
private function createPaintMaterialEntry(param1:String, param2:TextureMaterial) : MaterialEntry {
var local3:MaterialEntry = new MaterialEntry(param1,param2);
this.entryForTexture[param1] = local3;
this.entryForMaterial[param2] = local3;
return local3;
}
private function createMaterialEntry(param1:BitmapData, param2:TextureMaterial) : MaterialEntry {
var local3:MaterialEntry = new MaterialEntry(param1,param2);
this.entryForTexture[param1] = local3;
this.entryForMaterial[param2] = local3;
return local3;
}
public function addMaterial(param1:TextureMaterial) : void {
var local2:MaterialEntry = this.createMaterialEntry(null,param1);
++local2.referenceCount;
this.entryForMaterial[param1] = local2;
this.materials.push(param1);
}
public function releaseMaterial(param1:TextureMaterial) : void {
if(param1 == null) {
return;
}
var local2:MaterialEntry = this.entryForMaterial[param1];
if(local2 != null) {
++this.materialStat.releaseCount;
--local2.referenceCount;
if(local2.referenceCount == 0) {
this.removeMaterialEntry(local2);
}
}
}
private function removeMaterialEntry(param1:MaterialEntry) : void {
++this.materialStat.destroyCount;
var local2:TextureMaterial = param1.material;
if(param1.keyData in this.entryForTexture) {
delete this.entryForTexture[param1.keyData];
}
delete this.entryForMaterial[local2];
param1.material = null;
var local3:int = int(this.materials.indexOf(local2));
this.materials.splice(local3,1);
local2.dispose();
}
protected function forEachMaterial(param1:Function) : void {
var local2:TextureMaterial = null;
for each(local2 in this.materials) {
param1(local2);
}
}
public function setMipMapping(param1:Boolean) : void {
if(this.mipMappingEnabled != param1) {
if(param1) {
this.enableMipMapping();
} else {
this.disableMipMapping();
}
}
}
private function enableMipMapping() : void {
if(!this.mipMappingEnabled) {
this.mipMappingEnabled = true;
this.forEachMaterial(this.disposeResource);
this.forEachMaterial(this._enableMipMapping);
}
}
private function _enableMipMapping(param1:TextureMaterial) : void {
param1.mipMapping = MipMapping.PER_PIXEL;
}
private function disableMipMapping() : void {
if(this.mipMappingEnabled) {
this.mipMappingEnabled = false;
this.forEachMaterial(this.disposeResource);
this.forEachMaterial(this._disableMipMapping);
}
}
private function disposeResource(param1:TextureMaterial) : void {
param1.disposeResource();
}
private function _disableMipMapping(param1:TextureMaterial) : void {
param1.mipMapping = MipMapping.NONE;
}
public function clear() : void {
this.forEachMaterial(this._clearTexture);
this.materials.length = 0;
clearDictionary(this.entryForTexture);
clearDictionary(this.entryForMaterial);
this.materialStat.clear();
}
private function _clearTexture(param1:TextureMaterial) : void {
param1.texture = null;
}
protected function getEntry(param1:TextureMaterial) : MaterialEntry {
return this.entryForMaterial[param1];
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p15 extends BitmapAsset
{
public function RangIconNormal_p15()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.socialnetwork {
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 SocialNetworkPanelModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _removeLinkId:Long = Long.getLong(1574515206,794016557);
private var _removeLink_socialNetworkIdCodec:ICodec;
private var model:IModel;
public function SocialNetworkPanelModelServer(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._removeLink_socialNetworkIdCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function removeLink(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._removeLink_socialNetworkIdCodec.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._removeLinkId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.gui.payment.controls {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.payment.controls.ProceedButton_ButtonOverCenter.png")]
public class ProceedButton_ButtonOverCenter extends BitmapAsset {
public function ProceedButton_ButtonOverCenter() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased.assault {
public interface IAssaultModelBase {
}
}
|
package projects.tanks.client.panel.model.challenge.stars {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class StarsInfoModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:StarsInfoModelServer;
private var client:IStarsInfoModelBase = IStarsInfoModelBase(this);
private var modelId:Long = Long.getLong(2020503521,-1456828147);
private var _setStarsId:Long = Long.getLong(1144166575,-1384472857);
private var _setStars_starsCodec:ICodec;
public function StarsInfoModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new StarsInfoModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(StarsInfoCC,false)));
this._setStars_starsCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
protected function getInitParam() : StarsInfoCC {
return StarsInfoCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._setStarsId:
this.client.setStars(int(this._setStars_starsCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.grouped {
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.garage.models.item.grouped.GroupedCC;
public class CodecGroupedCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_group:ICodec;
private var codec_grouped:ICodec;
public function CodecGroupedCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_group = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_grouped = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:GroupedCC = new GroupedCC();
local2.group = this.codec_group.decode(param1) as int;
local2.grouped = this.codec_grouped.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:GroupedCC = GroupedCC(param2);
this.codec_group.encode(param1,local3.group);
this.codec_grouped.encode(param1,local3.grouped);
}
}
}
|
package forms.friends.list.renderer.background
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class FriendCellSelected_leftIconClass extends BitmapAsset
{
public function FriendCellSelected_leftIconClass()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.common {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class WeaponBuffListenerEvents implements WeaponBuffListener {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function WeaponBuffListenerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function weaponBuffStateChanged(param1:IGameObject, param2:Boolean, param3:Number) : void {
var i:int = 0;
var m:WeaponBuffListener = null;
var user:IGameObject = param1;
var buffed:Boolean = param2;
var recoilForce:Number = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = WeaponBuffListener(this.impl[i]);
m.weaponBuffStateChanged(user,buffed,recoilForce);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.gui.shop.payment {
import alternativa.tanks.gui.payment.events.SMSformEvent;
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.gui.payment.forms.commons.DescriptionBlock;
import alternativa.tanks.gui.shop.components.paymentview.PaymentView;
import alternativa.tanks.gui.shop.forms.SMSForm;
import alternativa.tanks.model.payment.category.PayModeView;
import platform.client.fp10.core.type.IGameObject;
public class PaymentFormWithoutChosenItemView extends PaymentView {
private static const MAX_INNER_WINDOW_HEIGHT:int = 160;
private static const MIN_INNER_WINDOW_HEIGHT:int = 70;
private var chosenPayMode:IGameObject;
private var descriptionBlock:DescriptionBlock;
private var view:PayModeForm;
private var previousHeight:int;
public function PaymentFormWithoutChosenItemView(param1:IGameObject) {
super();
this.chosenPayMode = param1;
this.descriptionBlock = new DescriptionBlock(param1,MAX_INNER_WINDOW_HEIGHT);
addChild(this.descriptionBlock);
this.view = PayModeView(param1.adapt(PayModeView)).getView();
this.view.y = this.descriptionBlock.getHeight();
this.view.addEventListener(SMSformEvent.SELECT_COUNTRY,this.onSMSformCountrySelected);
addChild(this.view);
this.previousHeight = this.view.getMinHeight();
}
override public function render(param1:int, param2:int) : void {
super.render(param1,param2);
var local3:int = this.previousHeight - param2;
var local4:int = this.descriptionBlock.getInnerWindowHeight();
if(param2 < this.view.getMinHeight() && local4 > MIN_INNER_WINDOW_HEIGHT && local3 > 0) {
this.updateView(Math.max(local4 - local3,MIN_INNER_WINDOW_HEIGHT));
} else if(local3 < 0 && local4 < MAX_INNER_WINDOW_HEIGHT) {
this.updateView(Math.min(local4 - local3,MAX_INNER_WINDOW_HEIGHT));
}
this.previousHeight = param2;
if(this.view is SMSForm) {
SMSForm(this.view).resize(param1,param2 - this.descriptionBlock.getHeight());
}
}
private function updateView(param1:int) : void {
this.descriptionBlock.updateHeight(param1);
this.view.y = this.descriptionBlock.getHeight();
}
private function onSMSformCountrySelected(param1:SMSformEvent) : void {
this.descriptionBlock.updateDescription();
}
}
}
|
package alternativa.proplib.objects {
import alternativa.engine3d.core.Object3D;
public class PropObject {
public var object:Object3D;
private var _type:int;
public function PropObject(type:int) {
super();
this._type = type;
}
public function get type() : int {
return this._type;
}
public function traceProp() : void {
trace(this.object);
}
}
}
|
package alternativa.protocol.codec.primitive {
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
public class FloatCodec implements IPrimitiveCodec {
public function FloatCodec() {
super();
}
public function nullValue() : Object {
return Number.NEGATIVE_INFINITY;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
param1.writer.writeFloat(Number(param2));
}
public function decode(param1:ProtocolBuffer) : Object {
return param1.reader.readFloat();
}
public function init(param1:IProtocol) : void {
}
}
}
|
package alternativa.tanks.gui.communication.tabs.clanchat {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.chat.ChatAddressModeUtil;
import alternativa.tanks.gui.clanchat.*;
import alternativa.tanks.gui.communication.tabs.AbstractCommunicationPanelTab;
import alternativa.tanks.gui.communication.tabs.chat.ChatTab;
import controls.TankWindowInner;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.base.TankInputBase;
import fl.controls.LabelButton;
import fl.controls.ScrollBar;
import fl.events.ScrollEvent;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.text.GridFitType;
import flash.text.TextField;
import flash.text.TextFormat;
import flash.ui.Keyboard;
import forms.ColorConstants;
import forms.events.LoginFormEvent;
import forms.userlabel.UserLabelClickWithCtrlEvent;
import projects.tanks.client.chat.models.chat.chat.ChatAddressMode;
import projects.tanks.client.chat.types.ChatMessage;
import projects.tanks.client.chat.types.MessageType;
import projects.tanks.client.chat.types.UserStatus;
import projects.tanks.client.users.services.chatmoderator.ChatModeratorLevel;
import projects.tanks.clients.flash.commons.services.datetime.DateFormatter;
import projects.tanks.clients.flash.commons.services.validate.ValidateService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.blockuser.IBlockUserService;
import services.contextmenu.ContextMenuServiceEvent;
import services.contextmenu.IContextMenuService;
import utils.ScrollStyleUtils;
public class ClanChatTab extends AbstractCommunicationPanelTab {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var contextMenuService:IContextMenuService;
[Inject]
public static var blockUserService:IBlockUserService;
private static const ADDITIONAL_SCROLL_AREA_HEIGHT:Number = 7;
private static const BLOCK_COMMAND_PATTERN:RegExp = /^\s*\/block\s+(\S+)/i;
private static const UNBLOCK_COMMAND_PATTERN:RegExp = /^\s*\/unblock\s+(\S+)/i;
private static const ADDRESS_PATTERN:RegExp = new RegExp("^" + ValidateService.PLAIN_UID_PATTERN + "(: |; )","i");
private static const REPLY_PATTERN:RegExp = /^re(: |; )(.*)/i;
private static const ADDRESS_MESSAGE_PATTERN:RegExp = /^([^:;]*)(: |; )(.*)/;
private static const UNBLOCKALL_COMMAND_PATTERN:RegExp = /^\s*\/unblockall/i;
private static const BLOCKLIST_COMMAND_PATTERN:RegExp = /^\s*\/blocklist/i;
private static const SHOWIP_COMMAND_PATTERN:RegExp = /^\s*\/showip/i;
private static const HIDEIP_COMMAND_PATTERN:RegExp = /^\s*\/hideip/i;
private var inner:TankWindowInner = new TankWindowInner(100,100,TankWindowInner.GREEN);
private var inputControl:TankInputBase = new TankInputBase();
private var input:TextField;
private var disabledChatLabel:LabelBase = new LabelBase();
private var addressMode:ChatAddressMode = ChatAddressMode.PUBLIC_TO_ALL;
private var selectedUid:String = "";
private var previousSelectedUid:String;
private var sendButton:DefaultButtonBase = new DefaultButtonBase();
private var _selfUid:String;
private var lastRespondent:String;
private var systemUserStatus:UserStatus = new UserStatus(ChatModeratorLevel.NONE,"",0,"System",null);
private var emptyUserStatus:UserStatus = new UserStatus(ChatModeratorLevel.NONE,"",0,"",null);
private var message:String = "";
private var currentDate:Date;
public var output:ChatOutput;
public function ClanChatTab() {
super();
this.output = new ChatOutput();
}
public function set selfUid(param1:String) : void {
this._selfUid = param1;
this.output.selfUid = this._selfUid;
}
override public function render() : void {
this.init();
this.output.scrollDown();
}
public function init() : void {
this.input = this.inputControl.textField;
this.input.maxChars = 299;
addChild(this.inner);
this.inner.x = this.inner.y = 11;
this.inner.showBlink = true;
this.input.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyPressed);
this.input.addEventListener(MouseEvent.CLICK,this.onInputClick);
this.sendButton.addEventListener(MouseEvent.CLICK,this.sendMessage);
addChild(this.inputControl);
this.disabledChatLabel.mouseEnabled = false;
this.disabledChatLabel.color = ColorConstants.LIST_LABEL_HINT;
this.disabledChatLabel.text = localeService.getText(TanksLocale.TEXT_DISABLED_CHAT_LABEL_TEXT);
addChild(this.output);
this.output.move(15,15);
ScrollStyleUtils.setGreenStyle(this.output);
this.output.addEventListener(UserLabelClickWithCtrlEvent.USER_LABEL_CLICK_WITH_CTRL_EVENT,this.onClickWithCtrlUserLabel);
this.output.addEventListener(ScrollEvent.SCROLL,this.onScroll);
this.output.verticalScrollBar.addEventListener(Event.ENTER_FRAME,this.updateScrollOnEnterFrame);
this.inputControl.addEventListener(LoginFormEvent.TEXT_CHANGED,this.processMessageTyping);
contextMenuService.addEventListener(ContextMenuServiceEvent.WRITE_IN_PUBLIC,this.onClickWriteInChatContextMenu);
this.sendButton.width = ChatTab.SEND_BUTTON_WIDTH;
this.sendButton.label = localeService.getText(TanksLocale.TEXT_CHAT_PANEL_BUTTON_SEND);
addChild(this.sendButton);
this.input.gridFitType = GridFitType.SUBPIXEL;
var local1:TextFormat = new TextFormat();
local1.color = 16728642;
var local2:TextFormat = new TextFormat();
local2.color = 16777215;
}
private function onClickWithCtrlUserLabel(param1:UserLabelClickWithCtrlEvent) : void {
this.pasteUidToInput(param1.uid,param1.shiftPressed ? ChatAddressMode.PRIVATE : ChatAddressMode.PUBLIC_ADDRESSED);
}
private function onClickWriteInChatContextMenu(param1:ContextMenuServiceEvent) : void {
this.pasteUidToInput(param1.uid,param1.type == ContextMenuServiceEvent.WRITE_IN_PUBLIC ? ChatAddressMode.PUBLIC_ADDRESSED : ChatAddressMode.PRIVATE);
}
private function pasteUidToInput(param1:String, param2:ChatAddressMode) : void {
this.addressMode = param2;
this.input.text = param1 + ChatAddressModeUtil.getAddressMarker(param2) + this.message;
stage.focus = this.input;
this.input.setSelection(this.input.length,this.input.length);
this.selectedUid = param1;
this.highlightUidInChat(this.selectedUid);
}
private function updateScrollOnEnterFrame(param1:Event) : void {
var local4:Sprite = null;
var local5:Sprite = null;
var local2:ScrollBar = this.output.verticalScrollBar;
var local3:int = 0;
while(local3 < local2.numChildren) {
local4 = Sprite(local2.getChildAt(local3));
if(local4.hitArea != null) {
local5 = local4.hitArea;
local5.graphics.clear();
} else {
local5 = new Sprite();
local5.mouseEnabled = false;
local4.hitArea = local5;
this.output.addChild(local5);
}
local5.graphics.beginFill(0,0);
if(local4 is LabelButton) {
local5.graphics.drawRect(local2.x - ADDITIONAL_SCROLL_AREA_HEIGHT,local4.y - 14,local4.width + ADDITIONAL_SCROLL_AREA_HEIGHT,local4.height + 28);
} else {
local5.graphics.drawRect(local2.x - ADDITIONAL_SCROLL_AREA_HEIGHT,local4.y,local4.width + ADDITIONAL_SCROLL_AREA_HEIGHT,local4.height);
}
local5.graphics.endFill();
local3++;
}
}
private function onInputClick(param1:MouseEvent) : void {
if(stage.focus == null) {
stage.focus = this.input;
}
}
private function onScroll(param1:ScrollEvent) : void {
this.output.deltaWidth = 18;
this.output.setSize(this.inner.width + 1,this.inner.height - 8);
this.output.removeEventListener(ScrollEvent.SCROLL,this.onScroll);
this.output.wasScrolled = true;
}
private function processMessageTyping(param1:Event) : void {
var local2:String = null;
var local3:Array = null;
if(this.input.text.search(REPLY_PATTERN) != -1) {
if(this.lastRespondent == null) {
this.input.text = "";
return;
}
local3 = this.input.text.match(REPLY_PATTERN);
this.addressMode = ChatAddressModeUtil.parseAddressMode(local3[1]);
this.message = local3[2];
this.input.text = this.lastRespondent + local3[1] + this.message;
this.selectedUid = this.lastRespondent;
this.input.setSelection(this.input.length,this.input.length);
} else if(this.input.text.search(ADDRESS_PATTERN) != -1) {
local3 = this.input.text.match(ADDRESS_MESSAGE_PATTERN);
this.selectedUid = local3[1];
local2 = local3[2];
this.message = local3[3];
this.addressMode = ChatAddressModeUtil.parseAddressMode(local2);
} else {
this.addressMode = ChatAddressMode.PUBLIC_TO_ALL;
this.selectedUid = "";
this.message = this.input.text;
}
this.highlightUidInChat(this.selectedUid);
}
private function highlightUidInChat(param1:String) : void {
if(this.previousSelectedUid != param1) {
this.previousSelectedUid = param1;
this.output.highlightUids(param1);
}
}
private function onKeyPressed(param1:KeyboardEvent) : void {
if(param1.keyCode == Keyboard.ENTER) {
this.send();
}
}
private function sendMessage(param1:MouseEvent) : void {
this.send();
}
private function processLocalChatCommand(param1:String) : Boolean {
var local3:String = null;
var local4:Array = null;
var local5:int = 0;
var local6:ChatMessage = null;
var local2:String = null;
if(param1.search(BLOCK_COMMAND_PATTERN) != -1) {
local3 = param1.replace(BLOCK_COMMAND_PATTERN,"$1");
blockUserService.blockUser(local3);
local2 = localeService.getText(TanksLocale.TEXT_CHAT_PANEL_COMMAND_BLOCK,local3);
this.input.text = "/block ";
} else if(param1.search(UNBLOCK_COMMAND_PATTERN) != -1) {
local3 = param1.replace(UNBLOCK_COMMAND_PATTERN,"$1");
blockUserService.unblockUser(local3);
local2 = localeService.getText(TanksLocale.TEXT_CHAT_PANEL_COMMAND_UNBLOCK,local3);
this.input.text = "/unblock ";
} else if(param1.search(UNBLOCKALL_COMMAND_PATTERN) != -1) {
blockUserService.unblockAll();
local2 = localeService.getText(TanksLocale.TEXT_CHAT_PANEL_COMMAND_UNBLOCK_ALL);
this.input.text = "";
} else if(param1.search(BLOCKLIST_COMMAND_PATTERN) != -1) {
local4 = blockUserService.getBlockList();
if(local4.length > 0) {
local2 = "\n" + localeService.getText(TanksLocale.TEXT_CHAT_PANEL_COMMAND_BLOCK_LIST) + "\nβββββββββββββ\n";
local5 = 0;
while(local5 < local4.length) {
local2 += String(local5 + 1) + ": " + local4[local5] + "\n";
local5++;
}
} else {
local2 = "...";
}
this.input.text = "";
} else if(param1.search(SHOWIP_COMMAND_PATTERN) != -1) {
this.output.showIPMode = true;
local2 = "show IP";
} else if(param1.search(HIDEIP_COMMAND_PATTERN) != -1) {
this.output.showIPMode = false;
local2 = "hide IP";
}
if(local2 != null) {
local6 = new ChatMessage();
local6.addressMode = ChatAddressMode.PRIVATE;
local6.sourceUser = this.systemUserStatus;
local6.targetUser = this.emptyUserStatus;
local6.messageType = MessageType.SYSTEM;
local6.text = local2;
this.addMessage(local6,local2);
return true;
}
return false;
}
private function send() : void {
if(this.input.text == "") {
return;
}
var local1:String = this.message;
this.message = "";
if(this.processLocalChatCommand(this.input.text)) {
return;
}
if(ChatAddressModeUtil.isPersonal(this.addressMode)) {
dispatchEvent(new SendChatMessageEvent(local1,this.selectedUid));
this.input.text = this.selectedUid + ChatAddressModeUtil.getAddressMarker(this.addressMode);
} else {
dispatchEvent(new SendChatMessageEvent(local1));
this.input.text = "";
}
this.input.setSelection(this.input.length,this.input.length);
this.output.scrollDown();
}
override public function resize(param1:int, param2:int) : void {
x = 1;
y = 37;
this.inner.width = param1;
this.inner.height = param2 - 35;
this.sendButton.y = param2 - 20;
this.sendButton.x = param1 - ChatTab.SEND_BUTTON_WIDTH + 11;
this.inputControl.x = 11;
this.inputControl.y = this.sendButton.y;
this.inputControl.width = this.sendButton.x - 16;
this.disabledChatLabel.x = this.inputControl.x + 3;
this.disabledChatLabel.y = this.inputControl.y + 7;
this.output.setSize(this.inner.width + 1,this.inner.height - 8);
}
public function addMessage(param1:ChatMessage, param2:String, param3:Boolean = false) : void {
var local8:Date = null;
var local4:MessageType = param1.messageType;
if(local4 == null) {
local4 = MessageType.USER;
}
if(local4 == MessageType.WARNING) {
param3 = true;
}
var local5:UserStatus = param1.sourceUser;
if(local5 == null) {
local5 = this.emptyUserStatus;
}
var local6:UserStatus = param1.targetUser;
if(local6 == null) {
local6 = this.emptyUserStatus;
}
if(blockUserService.isBlocked(local5.uid)) {
return;
}
var local7:Date = new Date(new Date().getTime() - param1.timePassedInSec * 1000);
if(this.currentDate == null) {
this.currentDate = new Date(local7.getFullYear(),local7.getMonth(),local7.getDate());
this.output.addLine(this.emptyUserStatus,this.emptyUserStatus,ChatAddressMode.PUBLIC_TO_ALL,this.getDateText(),this.currentDate,MessageType.SYSTEM,true,isActive);
} else {
local8 = new Date(this.currentDate.getFullYear(),this.currentDate.getMonth(),this.currentDate.getDate() + 1);
if(local7.getTime() >= local8.getTime()) {
this.currentDate.setFullYear(local7.getFullYear(),local7.getMonth(),local7.getDate());
this.output.addLine(this.emptyUserStatus,this.emptyUserStatus,ChatAddressMode.PUBLIC_TO_ALL,this.getDateText(),this.currentDate,MessageType.SYSTEM,true,isActive);
}
}
this.output.addLine(local5,local6,param1.addressMode,param2,local7,local4,param3,isActive);
this.output.highlightUidsInLastMessage(this.selectedUid);
if(local6.uid == this._selfUid) {
this.lastRespondent = local5.uid;
}
}
public function sendNotificationNewMessageAdded() : void {
dispatchEvent(new ClanChatTabNewMessageEvent());
}
private function getDateText() : String {
return "<p style=\'text-align: center;\'>" + DateFormatter.formatDateToLocalized(this.currentDate) + "</p>";
}
override public function hide() : void {
contextMenuService.removeEventListener(ContextMenuServiceEvent.WRITE_IN_PUBLIC,this.onClickWriteInChatContextMenu);
if(this.input != null) {
this.input.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKeyPressed);
this.input.removeEventListener(MouseEvent.CLICK,this.onInputClick);
}
if(this.sendButton != null) {
this.sendButton.removeEventListener(MouseEvent.CLICK,this.sendMessage);
}
if(this.output != null) {
this.output.verticalScrollBar.removeEventListener(Event.ENTER_FRAME,this.updateScrollOnEnterFrame);
this.output.removeEventListener(ScrollEvent.SCROLL,this.onScroll);
this.output.removeEventListener(UserLabelClickWithCtrlEvent.USER_LABEL_CLICK_WITH_CTRL_EVENT,this.onClickWithCtrlUserLabel);
}
if(this.inputControl != null) {
this.inputControl.removeEventListener(LoginFormEvent.TEXT_CHANGED,this.processMessageTyping);
}
}
}
}
|
package controls.buttons.h30px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h30px.GreenMediumButtonSkin_rightUpClass.png")]
public class GreenMediumButtonSkin_rightUpClass extends BitmapAsset {
public function GreenMediumButtonSkin_rightUpClass() {
super();
}
}
}
|
package alternativa.tanks.model.news
{
public class NewsItemServer
{
public var date:String;
public var text:String;
public var iconId:String;
public function NewsItemServer(date:String, text:String, iconId:String = "update")
{
super();
this.date = date;
this.text = text;
this.iconId = iconId;
}
}
}
|
package alternativa.tanks.model.item.properties {
[ModelInterface]
public interface ItemProperties {
function getProperties() : Vector.<ItemPropertyValue>;
function getPropertiesForInfoWindow() : Vector.<ItemPropertyValue>;
}
}
|
package alternativa.debug.dump
{
import alternativa.init.Main;
import alternativa.osgi.service.dump.dumper.IDumper;
import alternativa.resource.IResource;
import alternativa.resource.ImageResource;
import alternativa.resource.ResourceStatus;
import alternativa.service.IResourceService;
import alternativa.types.Long;
public class ResourceDumper implements IDumper
{
public function ResourceDumper()
{
super();
}
public function dump(params:Vector.<String>) : String
{
var resourceRegister:IResourceService = null;
var p:String = null;
var batchLoadingHistory:Array = null;
var i:int = 0;
var batchId:int = 0;
var resourcesList:Array = null;
var j:int = 0;
var resourceId:Long = null;
var resourceStatus:ResourceStatus = null;
var s:String = null;
var resources:Vector.<IResource> = null;
var result:String = "\n";
resourceRegister = Main.osgi.getService(IResourceService) as IResourceService;
if(params.length > 0)
{
p = params[0];
switch(p)
{
case "status":
batchLoadingHistory = resourceRegister.batchLoadingHistory;
for(i = 0; i < batchLoadingHistory.length; i++)
{
batchId = batchLoadingHistory[i] as int;
result += "\n\n BatchID: " + batchId + "\n";
resourcesList = resourceRegister.resourceLoadingHistory[batchId];
for(j = 0; j < resourcesList.length; j++)
{
resourceId = resourcesList[j];
resourceStatus = resourceRegister.resourceStatus[batchId][resourceId] as ResourceStatus;
s = "\nid: " + resourceId + " " + resourceStatus.typeName + " " + resourceStatus.name;
s += " status: " + resourceStatus.status;
result += s;
}
}
break;
case "images":
return this.getImageResourcesDump();
}
}
else
{
resources = resourceRegister.resourcesList;
for(i = 0; i < resources.length; i++)
{
result += " resource id: " + IResource(resources[i]).id + " " + IResource(resources[i]).name + "\n";
}
result += "\n";
}
return result;
}
private function getImageResourcesDump() : String
{
var s:String = null;
var count:int = 0;
var totalSize:int = 0;
var resource:ImageResource = null;
var size:int = 0;
var resourceRegister:IResourceService = IResourceService(Main.osgi.getService(IResourceService));
var resources:Vector.<IResource> = resourceRegister.resourcesList;
for(var i:int = 0; i < resources.length; i++)
{
resource = resources[i] as ImageResource;
if(resource != null && resource.data != null)
{
count++;
size = resource.data.width * resource.data.height * 4;
s += "Image " + count + ": size = " + size + "\n";
totalSize += size;
}
}
return s + ("Total size: " + totalSize + "\n");
}
public function get dumperName() : String
{
return "resource";
}
}
}
|
package projects.tanks.client.partners.impl.china.kuaiwan {
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 KuaiwanModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:KuaiwanModelServer;
private var client:IKuaiwanModelBase = IKuaiwanModelBase(this);
private var modelId:Long = Long.getLong(1470822165,2019480089);
public function KuaiwanModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new KuaiwanModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.gift.opened
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.PixelSnapping;
import flash.display.Sprite;
import flash.geom.ColorTransform;
public class Stars extends Sprite
{
private var stars:Array;
private var count:int;
private var radius:Number;
public function Stars(param1:BitmapData, param2:BitmapData, param3:int, param4:Number)
{
var _loc6_:Sprite = null;
var _loc7_:Number = NaN;
_loc6_ = null;
_loc7_ = NaN;
var _loc8_:Number = NaN;
var _loc9_:Number = NaN;
this.stars = new Array();
super();
this.count = param3;
this.radius = param4;
var _loc5_:int = 0;
while(_loc5_ < param3)
{
_loc6_ = new Sprite();
_loc6_.addChild(new Bitmap(param1,PixelSnapping.NEVER,true));
_loc6_.addChild(new Bitmap(param2,PixelSnapping.NEVER,true));
_loc7_ = 0.4 + Math.random();
_loc6_.getChildAt(0).scaleX = _loc7_;
_loc6_.getChildAt(0).scaleY = _loc7_;
_loc6_.getChildAt(0).x = -_loc6_.getChildAt(0).width / 2;
_loc6_.getChildAt(0).y = -_loc6_.getChildAt(0).height / 2;
_loc6_.getChildAt(0).blendMode = BlendMode.ADD;
_loc6_.getChildAt(1).scaleX = _loc7_;
_loc6_.getChildAt(1).scaleY = _loc7_;
_loc6_.getChildAt(1).x = -_loc6_.getChildAt(1).width / 2;
_loc6_.getChildAt(1).y = -_loc6_.getChildAt(1).height / 2;
addChild(_loc6_);
this.stars.push(_loc6_);
_loc8_ = Math.random() * Math.PI * 2;
_loc9_ = param4 / 3 + Math.random() * param4 * 2 / 3;
_loc6_.x = Math.cos(_loc8_) * _loc9_;
_loc6_.y = Math.sin(_loc8_) * _loc9_;
if(_loc5_ == 0)
{
_loc6_.x = 0;
_loc6_.y = 0;
}
_loc6_.rotation = Math.random() * 180;
_loc5_++;
}
}
public function update() : void
{
var _loc4_:Sprite = null;
var _loc1_:Number = NaN;
var _loc2_:Number = NaN;
_loc4_ = null;
var _loc3_:int = 0;
while(_loc3_ < this.count)
{
_loc4_ = this.stars[_loc3_];
_loc4_.rotation += 2;
if(_loc4_.rotation > 180)
{
_loc4_.rotation = 0;
}
if(_loc4_.rotation < 90)
{
_loc1_ = _loc4_.rotation / 90;
}
else
{
_loc1_ = 1 - (_loc4_.rotation - 90) / 90;
}
_loc2_ = 0.2 + 0.8 * _loc1_;
_loc4_.alpha = _loc1_;
_loc4_.scaleX = _loc2_;
_loc4_.scaleY = _loc2_;
_loc3_++;
}
}
public function colorize(param1:ColorTransform) : void
{
var _loc3_:Sprite = null;
var _loc2_:int = 0;
while(_loc2_ < this.count)
{
_loc3_ = this.stars[_loc2_];
_loc3_.getChildAt(0).transform.colorTransform = param1;
_loc2_++;
}
}
}
}
|
package alternativa.register
{
import alternativa.object.ClientObject;
import alternativa.service.ISpaceService;
import alternativa.types.Long;
import flash.utils.Dictionary;
public class SpaceRegister implements ISpaceService
{
private var _spaceList:Array;
private var _spaces:Dictionary;
public function SpaceRegister()
{
super();
this._spaceList = new Array();
this._spaces = new Dictionary();
}
public function addSpace(space:SpaceInfo) : void
{
this._spaceList.push(space);
}
public function removeSpace(space:SpaceInfo) : void
{
this._spaceList.splice(this._spaceList.indexOf(space),1);
this._spaces[space.id] = null;
}
public function get spaceList() : Array
{
return this._spaceList;
}
public function get spaces() : Dictionary
{
return this._spaces;
}
public function getSpaceByObjectId(id:String) : SpaceInfo
{
var info:SpaceInfo = null;
var space:SpaceInfo = null;
var objectRegister:ObjectRegister = null;
var stopSearch:Boolean = false;
var objects:Dictionary = null;
var object:ClientObject = null;
var i:int = 0;
while(info == null && i < this._spaceList.length)
{
space = this._spaceList[i] as SpaceInfo;
objectRegister = space.objectRegister;
stopSearch = false;
objects = objectRegister.getObjects();
for each(object in objects)
{
if(object.id == id)
{
stopSearch = true;
break;
}
}
if(stopSearch)
{
info = space;
}
else
{
i++;
}
}
return info;
}
public function setIdForSpace(space:SpaceInfo, id:Long) : void
{
space.id = id;
this._spaces[id] = space;
}
}
}
|
package projects.tanks.client.garage.models.user.present {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class PresentProfileModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:PresentProfileModelServer;
private var client:IPresentProfileModelBase = IPresentProfileModelBase(this);
private var modelId:Long = Long.getLong(566505089,2827348);
public function PresentProfileModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new PresentProfileModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(PresentsCC,false)));
}
protected function getInitParam() : PresentsCC {
return PresentsCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.panel.model.videoads.containers {
public class VideoAdsMobileLootBoxCC {
private var _adsAvailable:Boolean;
public function VideoAdsMobileLootBoxCC(param1:Boolean = false) {
super();
this._adsAvailable = param1;
}
public function get adsAvailable() : Boolean {
return this._adsAvailable;
}
public function set adsAvailable(param1:Boolean) : void {
this._adsAvailable = param1;
}
public function toString() : String {
var local1:String = "VideoAdsMobileLootBoxCC [";
local1 += "adsAvailable = " + this.adsAvailable + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.item.premium {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class PremiumItemAdapt implements PremiumItem {
private var object:IGameObject;
private var impl:PremiumItem;
public function PremiumItemAdapt(param1:IGameObject, param2:PremiumItem) {
super();
this.object = param1;
this.impl = param2;
}
public function isPremiumItem() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.isPremiumItem());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.service
{
import alternativa.osgi.service.log.ILogService;
public class Logger implements ILogService
{
public function Logger()
{
super();
}
public static function log(logLevel:int, message:String, exception:String = null) : void
{
}
public function log(logLevel:int, message:String, exception:String = null) : void
{
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_29 extends BitmapAsset
{
public function BigRangIcon_rang_29()
{
super();
}
}
}
|
package alternativa.tanks.services.battleinput {
public interface MouseMovementListener {
function onMouseRelativeMovement(param1:Number, param2:Number) : void;
}
}
|
package _codec.projects.tanks.client.battlefield.models.effects.duration.time {
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.battlefield.models.effects.duration.time.DurationCC;
public class CodecDurationCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_durationTimeInMs:ICodec;
private var codec_infinite:ICodec;
public function CodecDurationCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_durationTimeInMs = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_infinite = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:DurationCC = new DurationCC();
local2.durationTimeInMs = this.codec_durationTimeInMs.decode(param1) as int;
local2.infinite = this.codec_infinite.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:DurationCC = DurationCC(param2);
this.codec_durationTimeInMs.encode(param1,local3.durationTimeInMs);
this.codec_infinite.encode(param1,local3.infinite);
}
}
}
|
package _codec.projects.tanks.client.panel.model.bonus.showing.image {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.panel.model.bonus.showing.image.BonusImageCC;
public class CodecBonusImageCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_image:ICodec;
public function CodecBonusImageCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_image = param1.getCodec(new TypeCodecInfo(ImageResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BonusImageCC = new BonusImageCC();
local2.image = this.codec_image.decode(param1) as ImageResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BonusImageCC = BonusImageCC(param2);
this.codec_image.encode(param1,local3.image);
}
}
}
|
package alternativa.tanks.display.usertitle
{
import alternativa.engine3d.materials.TextureMaterial;
import flash.display.BitmapData;
import flash.display.Graphics;
import flash.display.Shape;
import flash.geom.Matrix;
import flash.geom.Rectangle;
public class ProgressBar
{
private static var matrix:Matrix = new Matrix();
private var maxValue:int;
private var barWidth:int;
private var shadowTipWidth:int;
private var shadowHeight:int;
private var barOffsetX:int;
private var barOffsetY:int;
private var skin:ProgressBarSkin;
private var barTipWidth:int;
private var barHeight:int;
private var _progress:int;
private var canvas:Shape;
private var x:int;
private var y:int;
private var rect:Rectangle;
public function ProgressBar(x:int, y:int, maxValue:int, barWidth:int, skin:ProgressBarSkin)
{
this.canvas = new Shape();
super();
this.x = x;
this.y = y;
this.maxValue = maxValue;
this.barWidth = barWidth;
this.setSkin(skin);
this.rect = new Rectangle(x,y,2 * this.shadowTipWidth + barWidth,this.shadowHeight);
}
public function setSkin(skin:ProgressBarSkin) : void
{
this.skin = skin;
this.barTipWidth = skin.leftTipBg.width;
this.barHeight = skin.leftTipBg.height;
this.shadowTipWidth = skin.shadowLeftTip.width;
this.shadowHeight = skin.shadow.height;
this.barOffsetX = this.shadowTipWidth - this.barTipWidth;
this.barOffsetY = this.shadowHeight - this.barHeight >> 1;
}
public function get progress() : int
{
return this._progress;
}
public function set progress(value:int) : void
{
if(value < 0)
{
value = 0;
}
else if(value > this.maxValue)
{
value = this.maxValue;
}
this._progress = value;
}
public function draw(texture:BitmapData, sp:TextureMaterial) : void
{
var bgStart:int = 0;
var g:Graphics = this.canvas.graphics;
g.clear();
g.beginBitmapFill(this.skin.shadowLeftTip);
g.drawRect(0,0,this.shadowTipWidth,this.shadowHeight);
g.beginBitmapFill(this.skin.shadow);
g.drawRect(this.shadowTipWidth,0,this.barWidth - 2 * this.barTipWidth,this.shadowHeight);
g.beginBitmapFill(this.skin.shadowRightTip);
g.drawRect(this.shadowTipWidth + this.barWidth - 2 * this.barTipWidth,0,this.shadowTipWidth,this.shadowHeight);
g.endFill();
var displayWidth:int = this.barWidth * this._progress / this.maxValue;
var w:int = this.barWidth - this.barTipWidth;
if(displayWidth >= this.barTipWidth)
{
if(displayWidth == this.barWidth)
{
this.drawFullBar(g,this.skin.color,this.skin.leftTipFg,this.skin.rightTipFg);
bgStart = displayWidth;
}
else
{
matrix.tx = this.barOffsetX;
matrix.ty = this.barOffsetY;
g.beginBitmapFill(this.skin.leftTipFg,matrix,false);
g.drawRect(this.barOffsetX,this.barOffsetY,this.barTipWidth,this.barHeight);
if(displayWidth > this.barTipWidth)
{
if(displayWidth > w)
{
displayWidth = w;
}
bgStart = displayWidth;
g.beginFill(this.skin.color);
g.drawRect(this.barOffsetX + this.barTipWidth,this.barOffsetY,displayWidth - this.barTipWidth,this.barHeight);
}
else
{
bgStart = this.barTipWidth;
}
}
}
if(bgStart == 0)
{
this.drawFullBar(g,this.skin.bgColor,this.skin.leftTipBg,this.skin.rightTipBg);
}
else if(bgStart < this.barWidth)
{
g.beginFill(this.skin.bgColor);
g.drawRect(this.barOffsetX + bgStart,this.barOffsetY,w - bgStart,this.barHeight);
matrix.tx = this.barOffsetX + w;
matrix.ty = this.barOffsetY;
g.beginBitmapFill(this.skin.rightTipBg,matrix,false);
g.drawRect(this.barOffsetX + w,this.barOffsetY,this.barTipWidth,this.barHeight);
}
g.endFill();
texture.fillRect(this.rect,0);
matrix.tx = this.x;
matrix.ty = this.y;
texture.draw(this.canvas,matrix);
sp.texture = texture;
}
private function drawFullBar(g:Graphics, color:uint, leftTip:BitmapData, rightTip:BitmapData) : void
{
var w:int = this.barWidth - this.barTipWidth;
matrix.tx = this.barOffsetX;
matrix.ty = this.barOffsetY;
g.beginBitmapFill(leftTip,matrix,false);
g.drawRect(this.barOffsetX,this.barOffsetY,this.barTipWidth,this.barHeight);
g.beginFill(color);
g.drawRect(this.barOffsetX + this.barTipWidth,this.barOffsetY,w - this.barTipWidth,this.barHeight);
matrix.tx = this.barOffsetX + w;
g.beginBitmapFill(rightTip,matrix,false);
g.drawRect(this.barOffsetX + w,this.barOffsetY,this.barTipWidth,this.barHeight);
}
}
}
|
package projects.tanks.client.commons.models.linkactivator {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class LinkActivatorModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:LinkActivatorModelServer;
private var client:ILinkActivatorModelBase = ILinkActivatorModelBase(this);
private var modelId:Long = Long.getLong(650947056,1487530419);
private var _aliveId:Long = Long.getLong(14163504,1184321813);
private var _alive_battleIdCodec:ICodec;
private var _battleNotFoundId:Long = Long.getLong(2016074577,529714967);
private var _deadId:Long = Long.getLong(969374437,-1423594874);
private var _dead_battleIdCodec:ICodec;
public function LinkActivatorModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new LinkActivatorModelServer(IModel(this));
this._alive_battleIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._dead_battleIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._aliveId:
this.client.alive(Long(this._alive_battleIdCodec.decode(param2)));
break;
case this._battleNotFoundId:
this.client.battleNotFound();
break;
case this._deadId:
this.client.dead(Long(this._dead_battleIdCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank31.png")]
public class PremiumRankBitmaps_bitmapSmallRank31 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank31() {
super();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.