code
stringlengths 57
237k
|
|---|
package alternativa.tanks.models.battle.dm {
import alternativa.physics.Body;
import alternativa.tanks.models.weapon.shared.RailgunTargetEvaluator;
public class DMRailgunTargetEvaluator implements RailgunTargetEvaluator {
public function DMRailgunTargetEvaluator() {
super();
}
public function getHitEfficiency(param1:Body) : Number {
return param1.tank.health > 0 ? 1 : 0;
}
public function isFriendly(param1:Body) : Boolean {
return false;
}
}
}
|
package projects.tanks.clients.flash.commons.models.challenge {
import flash.utils.getTimer;
import platform.client.fp10.core.type.IGameObject;
public class ChallengesServiceImpl implements ChallengeInfoService {
private var endTime:Number = 0;
private var item:IGameObject = null;
public function ChallengesServiceImpl() {
super();
}
public function isInTime() : Boolean {
return this.endTime > getTimer();
}
public function startEvent(param1:int) : void {
this.endTime = param1 == 0 ? 0 : param1 * 1000 + getTimer();
}
public function getEndTime() : Number {
return this.endTime;
}
}
}
|
package alternativa.tanks.models.weapon.shared {
import alternativa.physics.Body;
public interface CommonTargetEvaluator {
function getTargetPriority(param1:Body, param2:Number, param3:Number, param4:Number, param5:Number) : Number;
}
}
|
package _codec.projects.tanks.client.garage.models.item.upgradeable.types {
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.upgradeable.types.UpgradeParamsData;
public class VectorCodecUpgradeParamsDataLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecUpgradeParamsDataLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(UpgradeParamsData,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.<UpgradeParamsData> = new Vector.<UpgradeParamsData>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = UpgradeParamsData(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:UpgradeParamsData = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<UpgradeParamsData> = Vector.<UpgradeParamsData>(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.bg
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BackgroundService_bitmapBg extends BitmapAsset
{
public function BackgroundService_bitmapBg()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.quest.showing {
import alternativa.types.Long;
import platform.client.fp10.core.resource.types.ImageResource;
public class CommonQuestInfo {
private var _description:String;
private var _finishCriteria:int;
private var _image:ImageResource;
private var _prizes:Vector.<QuestPrizeInfo>;
private var _progress:int;
private var _questId:Long;
public function CommonQuestInfo(param1:String = null, param2:int = 0, param3:ImageResource = null, param4:Vector.<QuestPrizeInfo> = null, param5:int = 0, param6:Long = null) {
super();
this._description = param1;
this._finishCriteria = param2;
this._image = param3;
this._prizes = param4;
this._progress = param5;
this._questId = param6;
}
public function get description() : String {
return this._description;
}
public function set description(param1:String) : void {
this._description = param1;
}
public function get finishCriteria() : int {
return this._finishCriteria;
}
public function set finishCriteria(param1:int) : void {
this._finishCriteria = param1;
}
public function get image() : ImageResource {
return this._image;
}
public function set image(param1:ImageResource) : void {
this._image = param1;
}
public function get prizes() : Vector.<QuestPrizeInfo> {
return this._prizes;
}
public function set prizes(param1:Vector.<QuestPrizeInfo>) : void {
this._prizes = param1;
}
public function get progress() : int {
return this._progress;
}
public function set progress(param1:int) : void {
this._progress = param1;
}
public function get questId() : Long {
return this._questId;
}
public function set questId(param1:Long) : void {
this._questId = param1;
}
public function toString() : String {
var local1:String = "CommonQuestInfo [";
local1 += "description = " + this.description + " ";
local1 += "finishCriteria = " + this.finishCriteria + " ";
local1 += "image = " + this.image + " ";
local1 += "prizes = " + this.prizes + " ";
local1 += "progress = " + this.progress + " ";
local1 += "questId = " + this.questId + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.battle.gui.chat {
import flash.events.Event;
public class BattleChatEvent extends Event {
public static const SEND_MESSAGE:String = "sendMessage";
private var _message:String;
private var _teamOnly:Boolean;
public function BattleChatEvent(param1:String, param2:String, param3:Boolean) {
super(param1);
this._message = param2;
this._teamOnly = param3;
}
public function get message() : String {
return this._message;
}
public function get teamOnly() : Boolean {
return this._teamOnly;
}
[Obfuscation(rename="false")]
override public function clone() : Event {
return new BattleChatEvent(type,this._message,this._teamOnly);
}
[Obfuscation(rename="false")]
override public function toString() : String {
return "[BattleChatEvent type=" + type + ", message=" + this._message + ", teamOnly=" + this._teamOnly + "]";
}
}
}
|
package alternativa.engine3d.core
{
import flash.display.Sprite;
public class Canvas extends Sprite
{
public function Canvas()
{
super();
}
}
}
|
package alternativa.protocol {
import flash.utils.ByteArray;
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
public class ProtocolBuffer {
private var _writer:IDataOutput;
private var _reader:IDataInput;
private var _optionalMap:OptionalMap;
public function ProtocolBuffer(param1:IDataOutput, param2:IDataInput, param3:OptionalMap) {
super();
this._writer = param1;
this._reader = param2;
this._optionalMap = param3;
}
public function get writer() : IDataOutput {
return this._writer;
}
public function set writer(param1:IDataOutput) : void {
this._writer = param1;
}
public function get reader() : IDataInput {
return this._reader;
}
public function set reader(param1:IDataInput) : void {
this._reader = param1;
}
public function get optionalMap() : OptionalMap {
return this._optionalMap;
}
public function set optionalMap(param1:OptionalMap) : void {
this._optionalMap = param1;
}
public function toString() : String {
var local6:int = 0;
var local7:String = null;
var local1:String = "";
var local2:int = int(ByteArray(this.reader).position);
local1 += "\n=== Optional Map ===\n";
local1 += this.optionalMap.toString();
local1 += "\n=== Dump data (trunc 100 bytes) ===\n";
var local3:int = 0;
var local4:String = "";
var local5:int = 0;
while(Boolean(ByteArray(this.reader).bytesAvailable) && local5 < 100) {
local6 = int(this.reader.readByte());
local7 = String.fromCharCode(local6);
if(local6 >= 0 && local6 < 16) {
local1 += "0";
}
if(local6 < 0) {
local6 = 256 + local6;
}
local1 += local6.toString(16);
local1 += " ";
if(local6 < 12 && local6 > 128) {
local4 += ".";
} else {
local4 += local7;
}
local3++;
if(local3 > 16) {
local1 += "\t";
local1 += local4;
local1 += "\n";
local3 = 0;
local4 = "";
}
local5++;
}
if(local3 != 0) {
while(local3 < 18) {
local3++;
local1 += " ";
}
local1 += "\t";
local1 += local4;
local1 += "\n";
}
ByteArray(this.reader).position = local2;
return local1;
}
}
}
|
package projects.tanks.client.commons.models.detach {
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 DetachModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:DetachModelServer;
private var client:IDetachModelBase = IDetachModelBase(this);
private var modelId:Long = Long.getLong(1666840941,1681304473);
public function DetachModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new DetachModelServer(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.models.weapons.charging {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class WeaponChargingCommunicationEvents implements WeaponChargingCommunication {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function WeaponChargingCommunicationEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function startCharging(param1:int) : void {
var i:int = 0;
var m:WeaponChargingCommunication = null;
var time:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = WeaponChargingCommunication(this.impl[i]);
m.startCharging(time);
i++;
}
}
finally {
Model.popObject();
}
}
public function finishCharging(param1:int) : void {
var i:int = 0;
var m:WeaponChargingCommunication = null;
var time:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = WeaponChargingCommunication(this.impl[i]);
m.finishCharging(time);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.battleselect.model.matchmaking.view {
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.battleselect.model.matchmaking.modes.MatchmakingModeRank;
public class MatchmakingLayoutCC {
private var _holidayDescription:String;
private var _holidayEnabled:Boolean;
private var _holidayIcon:ImageResource;
private var _holidayTitle:String;
private var _matchmakingModeRanks:Vector.<MatchmakingModeRank>;
private var _minRankForProBattle:int;
public function MatchmakingLayoutCC(param1:String = null, param2:Boolean = false, param3:ImageResource = null, param4:String = null, param5:Vector.<MatchmakingModeRank> = null, param6:int = 0) {
super();
this._holidayDescription = param1;
this._holidayEnabled = param2;
this._holidayIcon = param3;
this._holidayTitle = param4;
this._matchmakingModeRanks = param5;
this._minRankForProBattle = param6;
}
public function get holidayDescription() : String {
return this._holidayDescription;
}
public function set holidayDescription(param1:String) : void {
this._holidayDescription = param1;
}
public function get holidayEnabled() : Boolean {
return this._holidayEnabled;
}
public function set holidayEnabled(param1:Boolean) : void {
this._holidayEnabled = param1;
}
public function get holidayIcon() : ImageResource {
return this._holidayIcon;
}
public function set holidayIcon(param1:ImageResource) : void {
this._holidayIcon = param1;
}
public function get holidayTitle() : String {
return this._holidayTitle;
}
public function set holidayTitle(param1:String) : void {
this._holidayTitle = param1;
}
public function get matchmakingModeRanks() : Vector.<MatchmakingModeRank> {
return this._matchmakingModeRanks;
}
public function set matchmakingModeRanks(param1:Vector.<MatchmakingModeRank>) : void {
this._matchmakingModeRanks = param1;
}
public function get minRankForProBattle() : int {
return this._minRankForProBattle;
}
public function set minRankForProBattle(param1:int) : void {
this._minRankForProBattle = param1;
}
public function toString() : String {
var local1:String = "MatchmakingLayoutCC [";
local1 += "holidayDescription = " + this.holidayDescription + " ";
local1 += "holidayEnabled = " + this.holidayEnabled + " ";
local1 += "holidayIcon = " + this.holidayIcon + " ";
local1 += "holidayTitle = " + this.holidayTitle + " ";
local1 += "matchmakingModeRanks = " + this.matchmakingModeRanks + " ";
local1 += "minRankForProBattle = " + this.minRankForProBattle + " ";
return local1 + "]";
}
}
}
|
package com.alternativaplatform.projects.tanks.client.models.ctf
{
import alternativa.types.Long;
public class CaptureTheFlagSoundFX
{
public var flagDropSoundId:Long;
public var flagReturnSoundId:Long;
public var flagTakeSoundId:Long;
public var winSoundId:Long;
public function CaptureTheFlagSoundFX()
{
super();
}
}
}
|
package _codec.projects.tanks.client.garage.models.garage {
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.garage.GarageModelCC;
public class VectorCodecGarageModelCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecGarageModelCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(GarageModelCC,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.<GarageModelCC> = new Vector.<GarageModelCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = GarageModelCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:GarageModelCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<GarageModelCC> = Vector.<GarageModelCC>(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 assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_NORMAL_BLUE_PIXEL.png")]
public dynamic class bres_NORMAL_BLUE_PIXEL extends BitmapData {
public function bres_NORMAL_BLUE_PIXEL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package projects.tanks.client.panel.model.rulesupdate.showing {
public class RulesUpdateShowingCC {
private var _bottomText:String;
private var _showAcceptRulesAlert:Boolean;
private var _topText:String;
public function RulesUpdateShowingCC(param1:String = null, param2:Boolean = false, param3:String = null) {
super();
this._bottomText = param1;
this._showAcceptRulesAlert = param2;
this._topText = param3;
}
public function get bottomText() : String {
return this._bottomText;
}
public function set bottomText(param1:String) : void {
this._bottomText = param1;
}
public function get showAcceptRulesAlert() : Boolean {
return this._showAcceptRulesAlert;
}
public function set showAcceptRulesAlert(param1:Boolean) : void {
this._showAcceptRulesAlert = param1;
}
public function get topText() : String {
return this._topText;
}
public function set topText(param1:String) : void {
this._topText = param1;
}
public function toString() : String {
var local1:String = "RulesUpdateShowingCC [";
local1 += "bottomText = " + this.bottomText + " ";
local1 += "showAcceptRulesAlert = " + this.showAcceptRulesAlert + " ";
local1 += "topText = " + this.topText + " ";
return local1 + "]";
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.category {
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.category.ItemCategoryCC;
public class VectorCodecItemCategoryCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecItemCategoryCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ItemCategoryCC,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.<ItemCategoryCC> = new Vector.<ItemCategoryCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ItemCategoryCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ItemCategoryCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ItemCategoryCC> = Vector.<ItemCategoryCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.client.panel.model.payment {
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 CrystalsPaymentModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function CrystalsPaymentModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.clans.user.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 ClanUserIncomingNotificatorModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _removeNotificationId:Long = Long.getLong(1499147069,1102150640);
private var _removeNotification_clanCodec:ICodec;
private var model:IModel;
public function ClanUserIncomingNotificatorModelServer(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._removeNotification_clanCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
}
public function removeNotification(param1:IGameObject) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._removeNotification_clanCodec.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._removeNotificationId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.sfx.drone {
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.engine3d.EffectsMaterialRegistry;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.sfx.AnimatedSpriteEffect;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.GraphicsUtils;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.battlefield.models.drone.demoman.DroneExplosionModelBase;
import projects.tanks.client.battlefield.models.drone.demoman.IDroneExplosionModelBase;
import projects.tanks.client.battlefield.types.Vector3d;
[ModelInfo]
public class DroneExplosionModel extends DroneExplosionModelBase implements IDroneExplosionModelBase, ObjectLoadListener {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var materialRegistry:EffectsMaterialRegistry;
private static const EXPLOSION_OFFSET_TO_CAMERA:Number = 110;
private var textureAnimation:TextureAnimation;
public function DroneExplosionModel() {
super();
}
public function objectLoaded() : void {
this.textureAnimation = GraphicsUtils.getTextureAnimationFromResource(materialRegistry,getInitParam().explosionTexture);
}
public function addExplosionEffect(param1:Vector3d, param2:Number) : void {
var local3:AnimatedSpriteEffect = AnimatedSpriteEffect(battleService.getObjectPool().getObject(AnimatedSpriteEffect));
local3.init(param2 * 2,param2 * 2,this.textureAnimation,0,this.createPositionProvider(new Vector3(param1.x,param1.y,param1.z)),0.5,0.75);
battleService.addGraphicEffect(local3);
}
private function createPositionProvider(param1:Vector3) : StaticObject3DPositionProvider {
var local2:StaticObject3DPositionProvider = StaticObject3DPositionProvider(battleService.getObjectPool().getObject(StaticObject3DPositionProvider));
local2.init(param1,EXPLOSION_OFFSET_TO_CAMERA);
return local2;
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank13.png")]
public class PremiumRankBitmaps_bitmapSmallRank13 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank13() {
super();
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ModTable_bitmapUpgradeSelectionCenter extends BitmapAsset
{
public function ModTable_bitmapUpgradeSelectionCenter()
{
super();
}
}
}
|
package alternativa.tanks.gui.notinclan.dialogs {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.clanmanagement.ClanActionsManager;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.IClanActionListener;
import alternativa.tanks.models.service.ClanService;
import controls.base.DefaultButtonBase;
import flash.events.Event;
import flash.events.MouseEvent;
import forms.TankWindowWithHeader;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
public class ClanDialog extends DialogWindow implements IClanActionListener {
[Inject]
public static var clanService:ClanService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var localeService:ILocaleService;
public static const MARGIN:Number = 11;
public static const SMALL_MARGIN:Number = 7;
protected var closeButton:DefaultButtonBase;
protected var window:TankWindowWithHeader;
private var _width:Number;
private var _height:Number;
public function ClanDialog() {
super();
ClanActionsManager.addActionsUpdateListener(this);
this.window = TankWindowWithHeader.createWindow(this.getImageHeaderId());
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
this.closeButton = new DefaultButtonBase();
this.closeButton.label = localeService.getText(TanksLocale.TEXT_CLOSE_LABEL);
this.closeButton.addEventListener(MouseEvent.CLICK,this.onCloseClick);
addChild(this.window);
addChild(this.closeButton);
this.window.width = this.width;
this.window.height = this.height;
this.closeButton.x = this.width - this.closeButton.width - MARGIN;
this.closeButton.y = this.height - this.closeButton.height - MARGIN;
dialogService.addDialog(this);
}
protected function getImageHeaderId() : String {
return "";
}
protected function onAddedToStage(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
}
protected function onCloseClick(param1:MouseEvent) : void {
display.stage.focus = null;
this.destroy();
}
public function destroy() : void {
ClanActionsManager.removeActionsListener(this);
dialogService.removeDialog(this);
this.removeEvents();
}
protected function removeEvents() : void {
}
override public function get width() : Number {
return 0;
}
override public function set width(param1:Number) : void {
this._width = param1;
}
override public function get height() : Number {
return 0;
}
override public function set height(param1:Number) : void {
this._height = param1;
}
public function updateActions() : void {
}
override public function forciblyClose() : void {
display.stage.focus = null;
this.destroy();
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_bfgtwinsIconClass.png")]
public class DeviceIcons_bfgtwinsIconClass extends BitmapAsset {
public function DeviceIcons_bfgtwinsIconClass() {
super();
}
}
}
|
package alternativa.tanks.gui.personaldiscount {
import flash.events.Event;
public class PersonalDiscountTimerLabelEvent extends Event {
public static const TIME_ON_COMPLETE_PERSONAL_DISCOUNT_TIMER:String = "PersonalDiscountTimerLabelOnCompleteTimer";
public function PersonalDiscountTimerLabelEvent(param1:String, param2:Boolean = false, param3:Boolean = false) {
super(param1,param2,param3);
}
}
}
|
package alternativa.tanks.models.inventory {
public class InventoryItemType {
public static const PIERCING:int = -1;
public static const ULTIMATE:int = 0;
public static const FIRST_AID:int = 1;
public static const ARMOR:int = 2;
public static const DAMAGE:int = 3;
public static const NITRO:int = 4;
public static const MINE:int = 5;
public static const GOLD:int = 6;
public static const BATTERY:int = 7;
public function InventoryItemType() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.androidspecialoffer.offers {
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.shop.androidspecialoffer.offers.MediumTimeOfferCC;
public class CodecMediumTimeOfferCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_paintPreview:ICodec;
public function CodecMediumTimeOfferCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_paintPreview = param1.getCodec(new TypeCodecInfo(ImageResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:MediumTimeOfferCC = new MediumTimeOfferCC();
local2.paintPreview = this.codec_paintPreview.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:MediumTimeOfferCC = MediumTimeOfferCC(param2);
this.codec_paintPreview.encode(param1,local3.paintPreview);
}
}
}
|
package projects.tanks.client.battleservice.model.battle.tdm {
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 BattleTDMModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BattleTDMModelServer;
private var client:IBattleTDMModelBase = IBattleTDMModelBase(this);
private var modelId:Long = Long.getLong(815932807,-684891581);
public function BattleTDMModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BattleTDMModelServer(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.utils {
import flash.net.SharedObject;
public class SharedObjectWrapper {
private var object:SharedObject;
private var data:Object;
public function SharedObjectWrapper(param1:SharedObject) {
super();
if(param1 == null) {
throw new Error("Parameter object is null");
}
this.object = param1;
this.data = param1.data;
}
public function flush(param1:int = 0) : String {
return this.object.flush(param1);
}
public function setData(param1:String, param2:*) : void {
this.data[param1] = param2;
}
public function deleteData(param1:String) : void {
delete this.data[param1];
}
public function getString(param1:String, param2:String) : String {
return this.data[param1] == null ? param2 : this.data[param1];
}
public function getInt(param1:String, param2:int) : int {
return this.data[param1] == null ? param2 : int(this.data[param1]);
}
public function getNumber(param1:String, param2:Number) : Number {
return this.data[param1] == null ? param2 : Number(this.data[param1]);
}
public function getBoolean(param1:String, param2:Boolean) : Boolean {
if(this.data[param1] === undefined) {
return param2;
}
return this.data[param1];
}
public function getObject(param1:String, param2:Object) : Object {
return this.data[param1] == null ? param2 : this.data[param1];
}
}
}
|
package projects.tanks.client.garage.models.garage {
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 GarageModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _itemBoughtId:Long = Long.getLong(1116487489,1026874107);
private var _itemBought_lightItemCodec:ICodec;
private var _itemBought_countCodec:ICodec;
private var _itemBought_expectedPriceCodec:ICodec;
private var _itemMountedId:Long = Long.getLong(251373796,595500642);
private var _itemMounted_itemCodec:ICodec;
private var _itemUnmountedId:Long = Long.getLong(1052047932,-1451701093);
private var _itemUnmounted_itemCodec:ICodec;
private var _kitBoughtId:Long = Long.getLong(2042194585,-27577510);
private var _kitBought_itemCodec:ICodec;
private var _kitBought_expectedPriceCodec:ICodec;
private var _readyToReloadId:Long = Long.getLong(508930523,-541032912);
private var model:IModel;
public function GarageModelServer(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._itemBought_lightItemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._itemBought_countCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._itemBought_expectedPriceCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._itemMounted_itemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._itemUnmounted_itemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._kitBought_itemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._kitBought_expectedPriceCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
}
public function itemBought(param1:IGameObject, param2:int, param3:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._itemBought_lightItemCodec.encode(this.protocolBuffer,param1);
this._itemBought_countCodec.encode(this.protocolBuffer,param2);
this._itemBought_expectedPriceCodec.encode(this.protocolBuffer,param3);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local4:SpaceCommand = new SpaceCommand(Model.object.id,this._itemBoughtId,this.protocolBuffer);
var local5:IGameObject = Model.object;
var local6:ISpace = local5.space;
local6.commandSender.sendCommand(local4);
this.protocolBuffer.optionalMap.clear();
}
public function itemMounted(param1:IGameObject) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._itemMounted_itemCodec.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._itemMountedId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function itemUnmounted(param1:IGameObject) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._itemUnmounted_itemCodec.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._itemUnmountedId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function kitBought(param1:IGameObject, param2:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._kitBought_itemCodec.encode(this.protocolBuffer,param1);
this._kitBought_expectedPriceCodec.encode(this.protocolBuffer,param2);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local3:SpaceCommand = new SpaceCommand(Model.object.id,this._kitBoughtId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function readyToReload() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._readyToReloadId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.gui.friends.list {
import alternativa.tanks.gui.friends.IFriendsListState;
import alternativa.tanks.gui.friends.IRejectAllIncomingButtonEnabled;
import alternativa.tanks.gui.friends.list.renderer.FriendsIncomingListRenderer;
import projects.tanks.clients.fp10.libraries.tanksservices.model.friends.FriendState;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.FriendActionServiceUidEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.FriendStateChangeEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendActionService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.NewFriendEvent;
import services.contextmenu.ContextMenuServiceEvent;
import services.contextmenu.IContextMenuService;
public class IncomingList extends FriendsList implements IFriendsListState {
[Inject]
public static var friendInfoService:IFriendInfoService;
[Inject]
public static var contextMenuService:IContextMenuService;
[Inject]
public static var friendActionService:IFriendActionService;
private var _rejectAllIncomingButton:IRejectAllIncomingButtonEnabled;
public function IncomingList(param1:IRejectAllIncomingButtonEnabled) {
super();
this._rejectAllIncomingButton = param1;
init(FriendsIncomingListRenderer);
_dataProvider.getItemAtHandler = this.markAsViewed;
}
public function initList() : void {
friendActionService.addEventListener(FriendActionServiceUidEvent.REQUEST_ACCEPTED,this.onRequestAccepted);
friendInfoService.addEventListener(FriendStateChangeEvent.CHANGE,this.onChangeFriendState);
friendInfoService.addEventListener(NewFriendEvent.INCOMING_CHANGE,this.onNewFriendChange);
contextMenuService.addEventListener(ContextMenuServiceEvent.REJECT_REQUEST,this.onRejectRequest);
_dataProvider.sortOn(["isNew","uid"],[Array.NUMERIC | Array.DESCENDING,Array.CASEINSENSITIVE]);
fillFriendsList(FriendState.INCOMING);
this.updateEnableRejectButton();
_list.scrollToIndex(0);
resize(_width,_height);
}
private function updateEnableRejectButton() : void {
this._rejectAllIncomingButton.setEnable(_dataProvider.length != 0);
}
private function onNewFriendChange(param1:NewFriendEvent) : void {
_dataProvider.setUserAsNew(param1.userId);
}
private function markAsViewed(param1:Object) : void {
if(!isViewed(param1) && Boolean(param1.isNew)) {
friendInfoService.removeNewIncomingFriend(param1.id);
setAsViewed(param1);
}
}
private function onChangeFriendState(param1:FriendStateChangeEvent) : void {
if(param1.state != FriendState.INCOMING) {
_dataProvider.removeUser(param1.userId);
this.updateEnableRejectButton();
resize(_width,_height);
return;
}
if(_dataProvider.getItemIndexByProperty("id",param1.userId,true) == -1) {
_dataProvider.addUser(param1.userId);
this.updateEnableRejectButton();
resize(_width,_height);
}
}
private function onRequestAccepted(param1:FriendActionServiceUidEvent) : * {
_dataProvider.removeUser(param1.userId);
this.updateEnableRejectButton();
resize(_width,_height);
}
private function onRejectRequest(param1:ContextMenuServiceEvent) : void {
_dataProvider.removeUser(param1.userId);
this.updateEnableRejectButton();
resize(_width,_height);
}
public function hide() : void {
friendActionService.removeEventListener(FriendActionServiceUidEvent.REQUEST_ACCEPTED,this.onRequestAccepted);
contextMenuService.removeEventListener(ContextMenuServiceEvent.REJECT_REQUEST,this.onRejectRequest);
friendInfoService.removeEventListener(FriendStateChangeEvent.CHANGE,this.onChangeFriendState);
friendInfoService.removeEventListener(NewFriendEvent.INCOMING_CHANGE,this.onNewFriendChange);
if(parent.contains(this)) {
parent.removeChild(this);
_dataProvider.removeAll();
}
}
public function filter(param1:String, param2:String) : void {
filterByProperty(param1,param2);
resize(_width,_height);
}
public function resetFilter() : void {
_dataProvider.resetFilter();
resize(_width,_height);
}
}
}
|
package alternativa.tanks.models.battlefield.gui
{
import assets.IconAlarm;
import controls.Label;
import controls.statassets.BlackRoundRect;
import flash.text.TextFieldAutoSize;
public class PauseIndicator extends BlackRoundRect
{
private var label1:Label;
private var label2:Label;
private var timelLabel:Label;
private var battleLeaveText:String;
private var _seconds:int;
public function PauseIndicator(pauseEnabledText:String, pressAnyKeyText:String, battleLeaveText:String)
{
var spacing:int = 0;
var yy:int = 0;
var fontSize:int = 0;
super();
this.battleLeaveText = battleLeaveText;
spacing = 5;
fontSize = 16;
var icon:IconAlarm = new IconAlarm();
addChild(icon);
icon.y = 33;
yy = icon.y + icon.height + 2 * spacing;
this.label1 = new Label();
this.label1.size = fontSize;
this.label1.text = pauseEnabledText;
this.label1.y = yy;
addChild(this.label1);
width = this.label1.textWidth;
yy += this.label1.height + spacing;
this.label2 = new Label();
this.label2.size = fontSize;
this.label2.text = pressAnyKeyText;
this.label2.y = yy;
addChild(this.label2);
if(width < this.label2.textWidth)
{
width = this.label2.textWidth;
}
yy += this.label2.height + spacing;
this.timelLabel = new Label();
this.timelLabel.size = fontSize;
this.timelLabel.autoSize = TextFieldAutoSize.LEFT;
this.timelLabel.text = battleLeaveText + " 99:99";
this.timelLabel.y = yy;
addChild(this.timelLabel);
if(width < this.timelLabel.textWidth)
{
width = this.timelLabel.textWidth;
}
width += 2 * 33;
icon.x = width - icon.width >> 1;
this.label1.x = width - this.label1.width >> 1;
this.label2.x = width - this.label2.width >> 1;
height = yy + this.timelLabel.height + 33 - 5;
}
public function set seconds(value:int) : void
{
if(this._seconds == value)
{
return;
}
this._seconds = value;
var minutes:int = this._seconds / 60;
this._seconds -= minutes * 60;
var s:String = this._seconds < 10 ? "0" + this._seconds : this._seconds.toString();
this.timelLabel.text = this.battleLeaveText + " " + minutes + ":" + s;
this.timelLabel.x = width - this.timelLabel.width >> 1;
}
}
}
|
package alternativa.tanks.camera
{
public interface ICameraController
{
function update(param1:int, param2:int) : void;
}
}
|
package alternativa.tanks.services.mipmapping.impl {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.command.FormattedOutput;
import alternativa.tanks.services.mipmapping.MipMappingService;
public class MipMappingServiceConsoleCommands {
private var osgi:OSGi;
public function MipMappingServiceConsoleCommands(param1:OSGi) {
super();
this.osgi = param1;
}
private function registerConsoleCommands(param1:OSGi) : void {
}
private function _showMipMapping(param1:FormattedOutput) : void {
}
private function _setMipMapping(param1:FormattedOutput, param2:int) : void {
}
private function getService() : MipMappingService {
return MipMappingService(this.osgi.getService(MipMappingService));
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.streamweapon {
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.streamweapon.StreamWeaponCC;
public class CodecStreamWeaponCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_energyCapacity:ICodec;
private var codec_energyDischargeSpeed:ICodec;
private var codec_energyRechargeSpeed:ICodec;
private var codec_weaponTickIntervalMsec:ICodec;
public function CodecStreamWeaponCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_energyCapacity = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_energyDischargeSpeed = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_energyRechargeSpeed = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_weaponTickIntervalMsec = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:StreamWeaponCC = new StreamWeaponCC();
local2.energyCapacity = this.codec_energyCapacity.decode(param1) as Number;
local2.energyDischargeSpeed = this.codec_energyDischargeSpeed.decode(param1) as Number;
local2.energyRechargeSpeed = this.codec_energyRechargeSpeed.decode(param1) as Number;
local2.weaponTickIntervalMsec = this.codec_weaponTickIntervalMsec.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:StreamWeaponCC = StreamWeaponCC(param2);
this.codec_energyCapacity.encode(param1,local3.energyCapacity);
this.codec_energyDischargeSpeed.encode(param1,local3.energyDischargeSpeed);
this.codec_energyRechargeSpeed.encode(param1,local3.energyRechargeSpeed);
this.codec_weaponTickIntervalMsec.encode(param1,local3.weaponTickIntervalMsec);
}
}
}
|
package projects.tanks.client.battlefield.models.bonus.battle {
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.types.Vector3d;
public class BonusSpawnData {
private var _battleBonusObject:IGameObject;
private var _bonusId:Long;
private var _lifeTime:int;
private var _spawnPosition:Vector3d;
public function BonusSpawnData(param1:IGameObject = null, param2:Long = null, param3:int = 0, param4:Vector3d = null) {
super();
this._battleBonusObject = param1;
this._bonusId = param2;
this._lifeTime = param3;
this._spawnPosition = param4;
}
public function get battleBonusObject() : IGameObject {
return this._battleBonusObject;
}
public function set battleBonusObject(param1:IGameObject) : void {
this._battleBonusObject = param1;
}
public function get bonusId() : Long {
return this._bonusId;
}
public function set bonusId(param1:Long) : void {
this._bonusId = param1;
}
public function get lifeTime() : int {
return this._lifeTime;
}
public function set lifeTime(param1:int) : void {
this._lifeTime = param1;
}
public function get spawnPosition() : Vector3d {
return this._spawnPosition;
}
public function set spawnPosition(param1:Vector3d) : void {
this._spawnPosition = param1;
}
public function toString() : String {
var local1:String = "BonusSpawnData [";
local1 += "battleBonusObject = " + this.battleBonusObject + " ";
local1 += "bonusId = " + this.bonusId + " ";
local1 += "lifeTime = " + this.lifeTime + " ";
local1 += "spawnPosition = " + this.spawnPosition + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.battle.gui.indicators {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.indicators.SuicideIndicator_reArmorIconClass.png")]
public class SuicideIndicator_reArmorIconClass extends BitmapAsset {
public function SuicideIndicator_reArmorIconClass() {
super();
}
}
}
|
package controls.statassets
{
import assets.stat.hall_SELECTED;
import flash.display.BitmapData;
public class StatLineSelected extends StatLineHeader
{
public function StatLineSelected()
{
super();
tl = new hall_SELECTED(1,1);
px = new BitmapData(1,1,false,543488);
frameColor = 5898034;
}
}
}
|
package assets.window.bitmaps {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.window.bitmaps.WindowBottom.png")]
public class WindowBottom extends BitmapData {
public function WindowBottom(param1:int, param2:int, param3:Boolean = true, param4:uint = 0) {
super(param1,param2,param3,param4);
}
}
}
|
package alternativa.tanks.battle.objects.tank.tankchassis {
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.objects.tank.TankConst;
import alternativa.tanks.battle.objects.tank.ValueSmoother;
import alternativa.tanks.utils.EncryptedNumber;
import alternativa.tanks.utils.EncryptedNumberImpl;
import alternativa.tanks.utils.MathUtils;
public class TrackedChassis {
public static const TURN_SPEED_COUNT:int = 7;
private static const MIN_ACCELERATION:Number = 400;
private static const _xAxis:Vector3 = new Vector3();
private static const _yAxis:Vector3 = new Vector3();
private static const _zAxis:Vector3 = new Vector3();
private static const _surfaceVelocity:Vector3 = new Vector3();
private static const _surfaceAngularVelocity:Vector3 = new Vector3();
private static const _relativeVelocity:Vector3 = new Vector3();
private static const _relativeAngularVelocity:Vector3 = new Vector3();
private static const _forceVector:Vector3 = new Vector3();
private static const _midPoint:Vector3 = new Vector3();
private var body:Body;
private var suspensionParams:SuspensionParams;
private var maxSpeedSmoother:ValueSmoother;
public var leftTrack:Track;
public var rightTrack:Track;
public var movementDirection:int;
public var turnDirection:int;
public var turnSpeedNumber:int;
public var inverseBackTurnMovement:Boolean;
private const _acceleration:EncryptedNumber = new EncryptedNumberImpl();
private const _reverseAcceleration:EncryptedNumber = new EncryptedNumberImpl();
private const _sideAcceleration:EncryptedNumber = new EncryptedNumberImpl();
private const _turnAcceleration:EncryptedNumber = new EncryptedNumberImpl();
private const _reverseTurnAcceleration:EncryptedNumber = new EncryptedNumberImpl();
private const _stabilizationAcceleration:EncryptedNumber = new EncryptedNumberImpl();
public function TrackedChassis(param1:Body, param2:SuspensionParams, param3:ValueSmoother, param4:Vector3) {
super();
this.body = param1;
this.suspensionParams = param2;
this.maxSpeedSmoother = param3;
this.createTracks(TankConst.NUM_RAYS_PER_TRACK,param4);
}
private function createTracks(param1:int, param2:Vector3) : void {
var local3:Number = param2.y * 0.8;
var local4:Number = param2.x - 40;
this.leftTrack = new Track(this.body,param1,new Vector3(-0.5 * local4,0,-0.5 * param2.z + TankConst.RAY_OFFSET),local3,this.suspensionParams,-1);
this.rightTrack = new Track(this.body,param1,new Vector3(0.5 * local4,0,-0.5 * param2.z + TankConst.RAY_OFFSET),local3,this.suspensionParams,1);
}
public function setAcceleration(param1:Number) : void {
this._acceleration.setNumber(param1);
}
public function setReverseAcceleration(param1:Number) : void {
this._reverseAcceleration.setNumber(param1);
}
public function setSideAcceleration(param1:Number) : void {
this._sideAcceleration.setNumber(param1);
}
public function setTurnAcceleration(param1:Number) : void {
this._turnAcceleration.setNumber(param1);
}
public function setReverseTurnAcceleration(param1:Number) : void {
this._reverseTurnAcceleration.setNumber(param1);
}
public function setStabilizationAcceleration(param1:Number) : void {
this._stabilizationAcceleration.setNumber(param1);
}
public function getAcceleration() : Number {
return this._acceleration.getNumber();
}
public function getActualMovementDirection() : int {
return this.movementDirection;
}
public function getActualTurnDirection() : int {
return this.turnDirection;
}
public function setTracksCollisionGroup(param1:int) : void {
this.leftTrack.setCollisionGroup(param1);
this.rightTrack.setCollisionGroup(param1);
}
public function applyForces(param1:Number, param2:Number, param3:Number) : void {
this.adjustSuspensionSpringCoeff();
this.calculateSuspensionContacts(param3);
this.applyMovementForces(param1,param2,param3);
this.applySlopeHack();
}
private function adjustSuspensionSpringCoeff() : void {
var local1:Number = this.body.scene.gravity.length() * this.body.mass;
this.suspensionParams.springCoeff = local1 / (2 * TankConst.NUM_RAYS_PER_TRACK * (this.suspensionParams.maxRayLength - this.suspensionParams.nominalRayLength));
}
private function calculateSuspensionContacts(param1:Number) : void {
this.leftTrack.calculateSuspensionContacts(param1);
this.rightTrack.calculateSuspensionContacts(param1);
}
private function applyMovementForces(param1:Number, param2:Number, param3:Number) : void {
if(this.leftTrack.numContacts + this.rightTrack.numContacts > 0) {
this.doApplyMovementForces(param1,param2,param3);
}
}
private function doApplyMovementForces(param1:Number, param2:Number, param3:Number) : void {
var local4:Vector3 = null;
var local5:Vector3 = null;
var local6:Matrix3 = null;
var local7:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local20:Number = NaN;
var local21:Number = NaN;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:Number = NaN;
var local25:int = 0;
var local26:Number = NaN;
var local27:Number = NaN;
var local28:Number = NaN;
var local29:Number = NaN;
var local30:int = 0;
var local31:Number = NaN;
var local32:Number = NaN;
var local33:Number = NaN;
var local34:Number = NaN;
var local35:Number = NaN;
local4 = this.body.state.velocity;
local5 = this.body.state.angularVelocity;
local6 = this.body.baseMatrix;
_xAxis.x = local6.m00;
_xAxis.y = local6.m10;
_xAxis.z = local6.m20;
_yAxis.x = local6.m01;
_yAxis.y = local6.m11;
_yAxis.z = local6.m21;
_zAxis.x = local6.m02;
_zAxis.y = local6.m12;
_zAxis.z = local6.m22;
local7 = 1;
var local8:Number = Math.PI / 4;
var local9:Number = TankConst.MAX_SLOPE_ANGLE;
if(_zAxis.z < Math.cos(local8)) {
if(_zAxis.z < Math.cos(local9)) {
local7 = 0;
} else {
local7 = (local9 - Math.acos(_zAxis.z)) / (local9 - local8);
}
}
this.calculateSurfaceVelocities(_surfaceVelocity,_surfaceAngularVelocity);
_relativeVelocity.x = local4.x - _surfaceVelocity.x;
_relativeVelocity.y = local4.y - _surfaceVelocity.y;
_relativeVelocity.z = local4.z - _surfaceVelocity.z;
_relativeAngularVelocity.x = local5.x - _surfaceAngularVelocity.x;
_relativeAngularVelocity.y = local5.y - _surfaceAngularVelocity.y;
_relativeAngularVelocity.z = local5.z - _surfaceAngularVelocity.z;
var local10:Number = _relativeVelocity.x * _yAxis.x + _relativeVelocity.y * _yAxis.y + _relativeVelocity.z * _yAxis.z;
var local11:Number = _relativeAngularVelocity.x * _zAxis.x + _relativeAngularVelocity.y * _zAxis.y + _relativeAngularVelocity.z * _zAxis.z;
var local12:Number = _relativeVelocity.x * _xAxis.x + _relativeVelocity.y * _xAxis.y + _relativeVelocity.z * _xAxis.z;
var local13:Number = this._sideAcceleration.getNumber() * local7 * param3;
if(local12 < 0) {
if(local13 > -local12) {
local12 = 0;
} else {
local12 += local13;
}
} else if(local12 > 0) {
if(local13 > local12) {
local12 = 0;
} else {
local12 -= local13;
}
}
_relativeVelocity.setLengthAlongDirection(_xAxis,local12);
local4.x = _surfaceVelocity.x + _relativeVelocity.x;
local4.y = _surfaceVelocity.y + _relativeVelocity.y;
local4.z = _surfaceVelocity.z + _relativeVelocity.z;
var local14:int = this.leftTrack.numContacts;
var local15:int = this.rightTrack.numContacts;
var local16:Number = Number(this._acceleration.getNumber());
var local17:Number = Number(this._turnAcceleration.getNumber());
if(local14 > 0 || local15 > 0) {
local18 = 0;
if(this.movementDirection == 0) {
local18 = -MathUtils.sign(local10) * local16 * param3;
if(MathUtils.sign(local10) != MathUtils.sign(local10 + local18)) {
local18 = -local10;
}
} else {
if(MathUtils.sign(local10) * MathUtils.sign(this.movementDirection) < 0) {
local16 = Number(this._reverseAcceleration.getNumber());
}
local18 = this.movementDirection * local16 * param3;
}
local19 = MathUtils.clamp(local10 + local18,-param1,param1);
local20 = local19 - local10;
local21 = 1;
local22 = MathUtils.clamp(1 - Math.abs(local10 / param1),0,1);
if(local22 < local21 && this.movementDirection * MathUtils.sign(local10) > 0) {
local20 *= local22 / local21;
}
local23 = local20 / param3;
if(Math.abs(local23) < MIN_ACCELERATION && Math.abs(local19) > 0.5 * this.maxSpeedSmoother.getTargetValue()) {
local23 = MathUtils.numberSign(local23,0.1) * MIN_ACCELERATION;
}
local24 = local23 * this.body.mass;
local25 = local14 + local15;
local26 = local24 * (local25 + 0.21 * (20 - local25)) / 10;
local27 = local26 / local25;
local28 = Math.PI / 4;
local29 = Math.PI / 3;
local30 = 0;
while(local30 < TankConst.NUM_RAYS_PER_TRACK) {
this.applyForceFromRay(this.leftTrack.rays[local30],_yAxis,local27,local29,local28);
this.applyForceFromRay(this.rightTrack.rays[local30],_yAxis,local27,local29,local28);
local30++;
}
local31 = 1;
if(local14 == 0 || local15 == 0) {
local31 = 0.5;
}
local32 = 0;
if(this.turnDirection == 0) {
local32 = -MathUtils.sign(local11) * this._stabilizationAcceleration.getNumber() * local7 * param3;
if(MathUtils.sign(local11) != MathUtils.sign(local11 + local32)) {
local32 = -local11;
}
} else {
if(this.isReversedTurn(this.turnDirection,local11,this.movementDirection,this.inverseBackTurnMovement)) {
local17 = Number(this._reverseTurnAcceleration.getNumber());
}
local32 = this.turnDirection * local17 * local7 * param3;
if(this.movementDirection == -1 && this.inverseBackTurnMovement) {
local32 = -local32;
}
}
local33 = param2;
if(this.turnDirection != 0) {
local33 = param2 * this.turnSpeedNumber / TURN_SPEED_COUNT;
}
local34 = local33 * local31;
local35 = MathUtils.clamp(local11 + local32,-local34,local34);
_relativeAngularVelocity.setLengthAlongDirection(_zAxis,local35);
local5.x = _surfaceAngularVelocity.x + _relativeAngularVelocity.x;
local5.y = _surfaceAngularVelocity.y + _relativeAngularVelocity.y;
local5.z = _surfaceAngularVelocity.z + _relativeAngularVelocity.z;
}
}
private function isReversedTurn(param1:int, param2:Number, param3:int, param4:Boolean) : Boolean {
var local5:int = param4 && param3 < 0 ? -1 : 1;
return param1 * param2 * local5 < 0;
}
private function calculateSurfaceVelocities(param1:Vector3, param2:Vector3) : void {
var local4:SuspensionRay = null;
var local5:int = 0;
var local6:Vector3 = null;
var local3:Number = 1 / (this.leftTrack.numContacts + this.rightTrack.numContacts);
var local7:Number = 0;
var local8:Number = 0;
var local9:Number = 0;
local5 = 0;
while(local5 < TankConst.NUM_RAYS_PER_TRACK) {
local4 = this.leftTrack.rays[local5];
if(local4.hasCollision) {
local6 = local4.rayHit.position;
local7 += local6.x;
local8 += local6.y;
local9 += local6.z;
}
local4 = this.rightTrack.rays[local5];
if(local4.hasCollision) {
local6 = local4.rayHit.position;
local7 += local6.x;
local8 += local6.y;
local9 += local6.z;
}
local5++;
}
local7 *= local3;
local8 *= local3;
local9 *= local3;
_midPoint.x = local7;
_midPoint.y = local8;
_midPoint.z = local9;
param1.x = 0;
param1.y = 0;
param1.z = 0;
param2.x = 0;
param2.y = 0;
param2.z = 0;
local5 = 0;
while(local5 < TankConst.NUM_RAYS_PER_TRACK) {
this.addVelocitiesFromRay(this.leftTrack.rays[local5],_midPoint,param1,param2);
this.addVelocitiesFromRay(this.rightTrack.rays[local5],_midPoint,param1,param2);
local5++;
}
param1.x *= local3;
param1.y *= local3;
param1.z *= local3;
param2.x *= local3;
param2.y *= local3;
param2.z *= local3;
}
private function addVelocitiesFromRay(param1:SuspensionRay, param2:Vector3, param3:Vector3, param4:Vector3) : void {
var local5:Vector3 = null;
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Vector3 = null;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
if(param1.hasCollision) {
param3.x += param1.contactVelocity.x;
param3.y += param1.contactVelocity.y;
param3.z += param1.contactVelocity.z;
local5 = param1.rayHit.position;
local6 = local5.x - param2.x;
local7 = local5.y - param2.y;
local8 = local5.z - param2.z;
local9 = local6 * local6 + local7 * local7 + local8 * local8;
if(local9 > 1) {
local10 = 1 / local9;
local11 = param1.contactVelocity;
local12 = (local7 * local11.z - local8 * local11.y) * local10;
local13 = (local8 * local11.x - local6 * local11.z) * local10;
local14 = (local6 * local11.y - local7 * local11.x) * local10;
param4.x += local12;
param4.y += local13;
param4.z += local14;
}
}
}
private function applyForceFromRay(param1:SuspensionRay, param2:Vector3, param3:Number, param4:Number, param5:Number) : void {
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
if(param1.hasCollision) {
local6 = param2.x;
local7 = param2.y;
local8 = param2.z;
local9 = local6 * local6 + local7 * local7 + local8 * local8;
if(local9 > 0.00001) {
local10 = Math.acos(param1.rayHit.normal.z);
if(local10 < 0) {
local10 = -local10;
}
if(local10 < param4) {
local11 = param3 / Math.sqrt(local9);
if(local10 > param5) {
local11 *= (param4 - local10) / (param4 - param5);
}
_forceVector.x = local6 * local11;
_forceVector.y = local7 * local11;
_forceVector.z = local8 * local11;
this.body.addWorldForceAtLocalPoint(param1.getOrigin(),_forceVector);
}
}
}
}
private function applySlopeHack() : void {
var local1:Matrix3 = null;
var local2:Vector3 = null;
var local3:Number = NaN;
var local4:Number = NaN;
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Number = NaN;
if(this.rightTrack.numContacts >= this.rightTrack.numRays >> 1 || this.leftTrack.numContacts >= this.leftTrack.numRays >> 1) {
local1 = this.body.baseMatrix;
local2 = this.body.scene.gravity;
local3 = local2.x * local1.m02 + local2.y * local1.m12 + local2.z * local1.m22;
local4 = local2.length();
local5 = Math.SQRT1_2 * local4;
if(local3 < -local5 || local3 > local5) {
local6 = (local1.m02 * local3 - local2.x) * this.body.mass;
local7 = (local1.m12 * local3 - local2.y) * this.body.mass;
local8 = (local1.m22 * local3 - local2.z) * this.body.mass;
this.body.addForceXYZ(local6,local7,local8);
}
}
}
}
}
|
package projects.tanks.client.panel.model.battlepass.purchasenotifier {
public class BattlePassPurchaseNotifierCC {
private var _purchased:Boolean;
public function BattlePassPurchaseNotifierCC(param1:Boolean = false) {
super();
this._purchased = param1;
}
public function get purchased() : Boolean {
return this._purchased;
}
public function set purchased(param1:Boolean) : void {
this._purchased = param1;
}
public function toString() : String {
var local1:String = "BattlePassPurchaseNotifierCC [";
local1 += "purchased = " + this.purchased + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.panel.model.shop.indemnity {
public interface IIndemnityModelBase {
}
}
|
package projects.tanks.client.entrance.model.entrance.partners {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import platform.client.fp10.core.type.IGameObject;
public class CompositePartnerModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:CompositePartnerModelServer;
private var client:ICompositePartnerModelBase = ICompositePartnerModelBase(this);
private var modelId:Long = Long.getLong(119483168,-902850894);
private var _linkAlreadyExistsId:Long = Long.getLong(1311759417,-1469962579);
private var _loginFailedId:Long = Long.getLong(1900698747,429778913);
private var _setPartnerObjectId:Long = Long.getLong(1922813084,1169013396);
private var _setPartnerObject_partnerObjectCodec:ICodec;
private var _showTutorialId:Long = Long.getLong(1248008117,296674690);
private var _startPartnerRegistrationId:Long = Long.getLong(547591075,572045158);
private var _wrongPasswordId:Long = Long.getLong(826220945,-1410348991);
public function CompositePartnerModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new CompositePartnerModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(CompositePartnerCC,false)));
this._setPartnerObject_partnerObjectCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
}
protected function getInitParam() : CompositePartnerCC {
return CompositePartnerCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._linkAlreadyExistsId:
this.client.linkAlreadyExists();
break;
case this._loginFailedId:
this.client.loginFailed();
break;
case this._setPartnerObjectId:
this.client.setPartnerObject(IGameObject(this._setPartnerObject_partnerObjectCodec.decode(param2)));
break;
case this._showTutorialId:
this.client.showTutorial();
break;
case this._startPartnerRegistrationId:
this.client.startPartnerRegistration();
break;
case this._wrongPasswordId:
this.client.wrongPassword();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.clans.panel.notification {
public interface IClanPanelNotificationModelBase {
function added() : void;
function removed() : void;
function updateRestrictionTimeJoinClan(param1:int) : void;
}
}
|
package platform.client.fp10.core.service.transport.impl {
import flash.utils.ByteArray;
import platform.client.fp10.core.network.connection.ConnectionInitializers;
import platform.client.fp10.core.network.connection.IConnection;
import platform.client.fp10.core.network.connection.SocketConnection;
import platform.client.fp10.core.network.handler.ControlCommandHandler;
import platform.client.fp10.core.service.transport.ITransportService;
public class TransportService implements ITransportService {
private var _controlCommandHandler:ControlCommandHandler;
private var _hash:ByteArray;
public function TransportService() {
super();
}
public function get controlCommandHandler() : ControlCommandHandler {
if(this._controlCommandHandler == null) {
this._controlCommandHandler = new ControlCommandHandler();
}
return this._controlCommandHandler;
}
public function get controlConnection() : IConnection {
return IConnection(this.controlCommandHandler.getCommandSender());
}
public function get hash() : ByteArray {
if(this._hash == null) {
this._hash = this.controlCommandHandler.getChannelContext().hash;
}
return this._hash;
}
public function createConnection(param1:ConnectionInitializers) : IConnection {
this._hash = null;
return new SocketConnection(param1);
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_nitroColorIconClass.png")]
public class HudInventoryIcon_nitroColorIconClass extends BitmapAsset {
public function HudInventoryIcon_nitroColorIconClass() {
super();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIcon_p23 extends BitmapAsset
{
public function RangIcon_p23()
{
super();
}
}
}
|
package alternativa.tanks.model.payment.modes.leogaming {
[ModelInterface]
public interface LeogamingPaymentMode {
function sendPhone(param1:String) : void;
function sendCode(param1:String) : void;
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes.braintree {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.payment.modes.braintree.BraintreePaymentCC;
public class VectorCodecBraintreePaymentCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBraintreePaymentCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BraintreePaymentCC,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.<BraintreePaymentCC> = new Vector.<BraintreePaymentCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BraintreePaymentCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BraintreePaymentCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BraintreePaymentCC> = Vector.<BraintreePaymentCC>(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 scpacker.test.spectator
{
import flash.events.KeyboardEvent;
public interface KeyboardHandler
{
function handleKeyDown(param1:KeyboardEvent) : void;
function handleKeyUp(param1:KeyboardEvent) : void;
}
}
|
package projects.tanks.client.garage.models.item.relativeproperties {
public class RelativeProperties {
public static const ARMOR:RelativeProperties = new RelativeProperties(0,"ARMOR");
public static const SPEED:RelativeProperties = new RelativeProperties(1,"SPEED");
public static const HANDLING:RelativeProperties = new RelativeProperties(2,"HANDLING");
public static const MASS:RelativeProperties = new RelativeProperties(3,"MASS");
public static const SIZE:RelativeProperties = new RelativeProperties(4,"SIZE");
public static const BURST_DAMAGE:RelativeProperties = new RelativeProperties(5,"BURST_DAMAGE");
public static const DPS:RelativeProperties = new RelativeProperties(6,"DPS");
public static const FIRE_RATE:RelativeProperties = new RelativeProperties(7,"FIRE_RATE");
public static const RANGE:RelativeProperties = new RelativeProperties(8,"RANGE");
public static const COMPLEXITY:RelativeProperties = new RelativeProperties(9,"COMPLEXITY");
private var _value:int;
private var _name:String;
public function RelativeProperties(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<RelativeProperties> {
var local1:Vector.<RelativeProperties> = new Vector.<RelativeProperties>();
local1.push(ARMOR);
local1.push(SPEED);
local1.push(HANDLING);
local1.push(MASS);
local1.push(SIZE);
local1.push(BURST_DAMAGE);
local1.push(DPS);
local1.push(FIRE_RATE);
local1.push(RANGE);
local1.push(COMPLEXITY);
return local1;
}
public function toString() : String {
return "RelativeProperties [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.score {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.field.score.ASScoreIndicator_blueScoreClass.png")]
public class ASScoreIndicator_blueScoreClass extends BitmapAsset {
public function ASScoreIndicator_blueScoreClass() {
super();
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.controls.bottompanel.LinkField {
import flash.events.MouseEvent;
import flash.net.URLRequest;
import flash.net.navigateToURL;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.ui.Mouse;
import flash.ui.MouseCursor;
import projects.tanks.clients.fp10.Prelauncher.Locale;
import projects.tanks.clients.fp10.Prelauncher.locales.Locales;
import projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp;
public class LinkField extends TextField {
public static const ABOUT:String = "aboutCompany";
public static const TECHSUPPORT:String = "techSupport";
public static const EMAIL:String = "email";
public static const RULES:String = "rules";
public static const CONFIDENT:String = "confidentialityPolicy";
public static const LICENSE:String = "license";
private const TEXT_COLOR:uint = 16777215;
private var textFormat:TextFormat = new TextFormat();
private var link:String;
private var fieldType:String;
public function LinkField(type:String, _locale:Locale = null) {
super();
var locale:Locale = _locale == null ? Locale.current : _locale;
if(locale[type] == null) {
return;
}
this.textFormat.font = MakeUp.getFont(locale);
this.textFormat.size = 12;
this.fieldType = type;
this.autoSize = TextFieldAutoSize.LEFT;
this.selectable = false;
this.textColor = this.TEXT_COLOR;
this.embedFonts = locale.name != Locales.CN;
if(locale[type].link != "") {
this.textFormat.underline = true;
this.link = locale[type].link;
addEventListener(MouseEvent.CLICK,this.onMouseClick);
addEventListener(MouseEvent.MOUSE_OVER,this.onMouseOver);
addEventListener(MouseEvent.MOUSE_OUT,this.onMouseOut);
}
this.defaultTextFormat = this.textFormat;
this.text = locale[type].text;
}
private function onMouseOver(e:MouseEvent) : void {
Mouse.cursor = MouseCursor.BUTTON;
}
private function onMouseOut(e:MouseEvent) : void {
Mouse.cursor = MouseCursor.AUTO;
}
private function onMouseClick(e:MouseEvent) : void {
navigateToURL(new URLRequest(this.link));
}
}
}
|
package alternativa.tanks.bonuses {
import alternativa.tanks.animations.AnimationTrack;
import alternativa.tanks.animations.KeyFrameAnimation;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class SpawnFlashRenderer extends PooledObject implements Renderer {
[Inject]
public static var battleService:BattleService;
private static const times:Vector.<Number> = Vector.<Number>([0,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5]);
private static const values:Vector.<Number> = Vector.<Number>([0,130.05,255,201.45,140.25,104.55,66.3,40.8,25.5,10.2,0]);
private static const animationTrack:AnimationTrack = new AnimationTrack(times,values);
private var colorTransform:AnimatedColorTransform = new AnimatedColorTransform();
private var animation:KeyFrameAnimation = new KeyFrameAnimation(animationTrack,this.colorTransform);
private var bonus:BattleBonus;
public function SpawnFlashRenderer(param1:Pool) {
super(param1);
}
public function start(param1:BattleBonus) : void {
this.bonus = param1;
param1.onRemove.add(this.destroy);
param1.onPickup.add(this.destroy);
param1.onDestroy.add(this.destroy);
param1.getBonusMesh().setColorTransform(this.colorTransform.colorTransform);
battleService.getBattleScene3D().addRenderer(this,0);
this.animation.start();
}
public function render(param1:int, param2:int) : void {
if(this.animation.isComplete()) {
this.bonus.enableTrigger();
this.destroy();
} else {
this.animation.update(param2 / 1000);
}
}
private function destroy() : void {
battleService.getBattleScene3D().removeRenderer(this,0);
this.bonus.onRemove.remove(this.destroy);
this.bonus.onPickup.remove(this.destroy);
this.bonus.onDestroy.remove(this.destroy);
this.bonus.getBonusMesh().setColorTransform(null);
this.bonus = null;
recycle();
}
}
}
|
package projects.tanks.client.battleselect.model.matchmaking.view {
public interface IMatchmakingLayoutModelBase {
function hideMatchmakingView() : void;
function showMatchmakingView() : void;
}
}
|
package alternativa.tanks.gui.clanmanagement {
import alternativa.osgi.service.command.CommandService;
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.ClanWindow;
import alternativa.tanks.gui.TabPanel;
import alternativa.tanks.gui.components.button.ClanUsersButton;
import alternativa.tanks.models.service.ClanInfoUpdateEvent;
import alternativa.tanks.models.service.ClanNotificationsManager;
import alternativa.tanks.models.service.ClanService;
import alternativa.tanks.models.service.ClanUserNotificationsManager;
import alternativa.tanks.service.clan.ClanFriendsService;
import alternativa.types.Long;
import flash.events.Event;
import forms.TankWindowWithHeader;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
public class ClanManagementPanel extends ClanWindow {
[Inject]
public static var display:IDisplay;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var clanService:ClanService;
[Inject]
public static var clanFriendsService:ClanFriendsService;
[Inject]
public static var commandService:CommandService;
private static const BUTTON_HEIGHT:int = 30;
private static const MARGIN:int = 11;
private static const FRAME:int = 7;
private var clanObject:IGameObject;
private var tabWindows:TabPanel = new TabPanel();
private var clanUsersWindows:ClanUsersWindow;
public var usersButton:ClanUsersButton;
public var topPanel:ClanTopManagementPanel;
private var clanProfileWindow:ClanProfileWindow;
public function ClanManagementPanel(param1:IGameObject) {
super();
_window = TankWindowWithHeader.createWindow(TanksLocale.TEXT_HEADER_CLAN);
this.clanObject = param1;
addChild(_window);
this.init();
}
private function init() : void {
_window.addChild(this.tabWindows);
this.topPanel = new ClanTopManagementPanel(this.clanObject);
_window.addChild(this.topPanel);
this.clanUsersWindows = new ClanUsersWindow(this.clanObject);
this.clanProfileWindow = new ClanProfileWindow(this.clanObject);
this.tabWindows.addTab(localeService.getText(TanksLocale.TEXT_CLAN_BUTTON_PROFILE),this.clanProfileWindow,ClanStateButton);
this.usersButton = ClanUsersButton(this.tabWindows.addTab(localeService.getText(TanksLocale.TEXT_CLAN_MEMBERS),this.clanUsersWindows,ClanUsersButton));
ClanNotificationsManager.addAcceptedIndicatorListener(this.usersButton);
ClanNotificationsManager.addIncomingIndicatorListener(this.usersButton);
addEventListener(ClanInfoUpdateEvent.UPDATE,this.onClanInfoUpdate);
this.usersButton.updateNotifications();
this.tabWindows.select(0);
this.onResize();
}
private function onClanInfoUpdate(param1:ClanInfoUpdateEvent) : void {
this.clanProfileWindow.setInfo(param1);
this.topPanel.setFlag(param1.clanFlag);
}
override public function onResize(param1:Event = null) : void {
super.onResize(param1);
_window.height = BUTTON_HEIGHT + 2 * MARGIN + FRAME + this.topPanel.height;
this.topPanel.x = MARGIN;
this.topPanel.y = FRAME + MARGIN + BUTTON_HEIGHT;
this.topPanel.width = width - 2 * MARGIN;
this.tabWindows.width = width;
this.tabWindows.height = height;
this.tabWindows.onResize();
}
public function addingAcceptedUser(param1:Long) : void {
clanService.clanMembers.push(param1);
this.clanUsersWindows.addUser(param1);
this.topPanel.userAdded();
this.clanProfileWindow.userAdded();
}
public function removeAcceptedUser(param1:Long) : void {
var local2:int = int(clanService.clanMembers.indexOf(param1));
if(local2 >= 0) {
clanService.clanMembers.splice(local2,1);
this.clanUsersWindows.removeUser(param1);
this.topPanel.userRemoved();
this.clanProfileWindow.userRemoved();
}
}
override public function destroy() : void {
ClanNotificationsManager.clearListeners();
ClanUserNotificationsManager.resetManager();
ClanPermissionsManager.removeListeners();
ClanActionsManager.removeListeners();
if(_window != null) {
_window.removeChild(this.tabWindows);
this.tabWindows.destroy();
this.tabWindows = null;
}
super.destroy();
}
public function maxMembers() : void {
this.clanUsersWindows.maxMembers();
}
}
}
|
package alternativa.tanks.model.payment.modes.pricerange {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class PriceRangeEvents implements PriceRange {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function PriceRangeEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function priceIsValid(param1:Number) : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:PriceRange = null;
var price:Number = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PriceRange(this.impl[i]);
result = Boolean(m.priceIsValid(price));
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.panel.model.donationalert.types {
public class GoodInfoData {
private var _count:int;
private var _name:String;
public function GoodInfoData(param1:int = 0, param2:String = null) {
super();
this._count = param1;
this._name = param2;
}
public function get count() : int {
return this._count;
}
public function set count(param1:int) : void {
this._count = 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 = "GoodInfoData [";
local1 += "count = " + this.count + " ";
local1 += "name = " + this.name + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.garage.models.item.drone {
public class HasBatteriesNotifyCC {
private var _hasBatteries:Boolean;
public function HasBatteriesNotifyCC(param1:Boolean = false) {
super();
this._hasBatteries = param1;
}
public function get hasBatteries() : Boolean {
return this._hasBatteries;
}
public function set hasBatteries(param1:Boolean) : void {
this._hasBatteries = param1;
}
public function toString() : String {
var local1:String = "HasBatteriesNotifyCC [";
local1 += "hasBatteries = " + this.hasBatteries + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.user {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IClanUserModelAdapt implements IClanUserModel {
private var object:IGameObject;
private var impl:IClanUserModel;
public function IClanUserModelAdapt(param1:IGameObject, param2:IClanUserModel) {
super();
this.object = param1;
this.impl = param2;
}
public function loadingInServiceSpace() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.loadingInServiceSpace());
}
finally {
Model.popObject();
}
return result;
}
public function addInClan(param1:IGameObject) : void {
var clan:IGameObject = param1;
try {
Model.object = this.object;
this.impl.addInClan(clan);
}
finally {
Model.popObject();
}
}
public function rejectAll() : void {
try {
Model.object = this.object;
this.impl.rejectAll();
}
finally {
Model.popObject();
}
}
public function revoke(param1:IGameObject) : void {
var clan:IGameObject = param1;
try {
Model.object = this.object;
this.impl.revoke(clan);
}
finally {
Model.popObject();
}
}
public function reject(param1:IGameObject) : void {
var clan:IGameObject = param1;
try {
Model.object = this.object;
this.impl.reject(clan);
}
finally {
Model.popObject();
}
}
public function acceptRequest(param1:IGameObject) : void {
var clan:IGameObject = param1;
try {
Model.object = this.object;
this.impl.acceptRequest(clan);
}
finally {
Model.popObject();
}
}
}
}
|
package _codec.platform.client.core.general.spaces.loading.dispatcher.types {
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.core.general.spaces.loading.dispatcher.types.ObjectsDependencies;
import platform.client.fp10.core.resource.Resource;
public class CodecObjectsDependencies implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_callbackId:ICodec;
private var codec_resources:ICodec;
public function CodecObjectsDependencies() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_callbackId = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_resources = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Resource,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ObjectsDependencies = new ObjectsDependencies();
local2.callbackId = this.codec_callbackId.decode(param1) as int;
local2.resources = this.codec_resources.decode(param1) as Vector.<Resource>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ObjectsDependencies = ObjectsDependencies(param2);
this.codec_callbackId.encode(param1,local3.callbackId);
this.codec_resources.encode(param1,local3.resources);
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.fund {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.models.battle.gui.gui.statistics.field.IconField;
import assets.Diamond;
import controls.Money;
import flash.display.DisplayObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class FundField extends IconField {
[Inject]
public static var localeService:ILocaleService;
private var diamond:Diamond = new Diamond();
public function FundField(param1:DisplayObject) {
super(param1);
}
override protected function init() : void {
super.init();
addChild(this.diamond);
this.diamond.y = 4;
this.update();
}
public function initFund(param1:int) : void {
var local2:String = localeService.getText(TanksLocale.TEXT_BATTLE_FUND);
label.text = local2 + ": " + Money.numToString(param1,false);
this.update();
}
private function update() : void {
this.diamond.x = label.x + label.width + 2;
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.partners.steam {
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.gui.shop.forms.GoToUrlForm;
import alternativa.tanks.model.payment.category.PayModeView;
import alternativa.tanks.model.payment.modes.asyncurl.AsyncUrlPayMode;
import alternativa.tanks.model.payment.paymentstate.PaymentWindowService;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.partners.impl.steam.ISteamPaymentModelBase;
import projects.tanks.client.partners.impl.steam.SteamPaymentModelBase;
import projects.tanks.clients.fp10.models.tankspartnersmodel.services.SteamDataService;
[ModelInfo]
public class SteamPaymentModel extends SteamPaymentModelBase implements ISteamPaymentModelBase, PayModeView, AsyncUrlPayMode, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var paymentWindowService:PaymentWindowService;
[Inject]
public static var steamDataService:SteamDataService;
private static const TRANSACTION_REQUEST_CODE:int = 28;
private static const STEAM_RESPONSE:String = "steamResponse";
public function SteamPaymentModel() {
super();
}
public function requestAsyncUrl() : void {
server.makePaymentRequest(paymentWindowService.getChosenItem().id);
}
private function onResponse(param1:Object) : void {
if(param1.req_type != TRANSACTION_REQUEST_CODE) {
return;
}
var local2:Object = steamDataService.getSteamWorks().microTxnResult();
if(local2 == null) {
return;
}
var local3:String = local2.orderID;
var local4:String = local2.appID.toString();
if(local4 != steamDataService.getAppId()) {
return;
}
if(Boolean(local2.authorized)) {
server.finalizePayment(local3);
}
}
public function getView() : PayModeForm {
return PayModeForm(getData(PayModeForm));
}
public function objectLoaded() : void {
steamDataService.getSteamWorks().addEventListener(STEAM_RESPONSE,getFunctionWrapper(this.onResponse));
putData(PayModeForm,new GoToUrlForm(object));
}
public function objectUnloaded() : void {
steamDataService.getSteamWorks().removeEventListener(STEAM_RESPONSE,getFunctionWrapper(this.onResponse));
this.getView().destroy();
clearData(PayModeForm);
}
}
}
|
package alternativa.tanks.model.garage.upgrade {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class UpgradeGarageItemEvents implements UpgradeGarageItem {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function UpgradeGarageItemEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function isUpgradesEnabled() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:UpgradeGarageItem = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = UpgradeGarageItem(this.impl[i]);
result = Boolean(m.isUpgradesEnabled());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.gui.shopitems.item.kits.description.panel
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class KitPackageDescriptionPanelBitmaps_bitmapLeftTopCorner extends BitmapAsset
{
public function KitPackageDescriptionPanelBitmaps_bitmapLeftTopCorner()
{
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.ActionOutputLine_ctfRedPlayerPickBlueflagIcon.png")]
public class ActionOutputLine_ctfRedPlayerPickBlueflagIcon extends BitmapAsset {
public function ActionOutputLine_ctfRedPlayerPickBlueflagIcon() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.shaft
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class Indicator_aim_m0 extends BitmapAsset
{
public function Indicator_aim_m0()
{
super();
}
}
}
|
package com.lorentz.SVG.utils
{
public interface ICloneable
{
function clone():Object;
}
}
|
package controls.resultassets {
import assets.resultwindow.bres_BG_GREEN_PIXEL;
import assets.resultwindow.bres_BG_GREEN_TL;
public class ResultWindowGreen extends ResultWindowBase {
public function ResultWindowGreen() {
super();
tl = new bres_BG_GREEN_TL(1,1);
px = new bres_BG_GREEN_PIXEL(1,1);
}
}
}
|
package alternativa.tanks.models.weapon.artillery {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IArtilleryModelEvents implements IArtilleryModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IArtilleryModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getDefaultElevation() : Number {
var result:Number = NaN;
var i:int = 0;
var m:IArtilleryModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IArtilleryModel(this.impl[i]);
result = Number(m.getDefaultElevation());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getWeapon() : ArtilleryWeapon {
var result:ArtilleryWeapon = null;
var i:int = 0;
var m:IArtilleryModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IArtilleryModel(this.impl[i]);
result = m.getWeapon();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.battle.ctf {
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.models.battle.commonflag.CommonFlag;
import alternativa.tanks.models.battle.commonflag.ICommonFlagModeModel;
public class FlagPickupTimeoutTask implements LogicUnit {
[Inject]
public static var battleService:BattleService;
private var callback:ICommonFlagModeModel;
private var flag:CommonFlag;
private var triggerTime:int;
public function FlagPickupTimeoutTask(param1:ICommonFlagModeModel, param2:CommonFlag, param3:int) {
super();
this.callback = param1;
this.flag = param2;
this.triggerTime = param3;
}
public function runLogic(param1:int, param2:int) : void {
if(param1 >= this.triggerTime) {
battleService.getBattleRunner().removeLogicUnit(this);
this.callback.onPickupTimeoutPassed(this.flag);
}
}
}
}
|
package alternativa.tanks.help
{
import flash.text.TextFormat;
public interface IHelpService
{
function registerHelper(param1:String, param2:int, param3:Helper, param4:Boolean) : void;
function unregisterHelper(param1:String, param2:int) : void;
function showHelper(param1:String, param2:int, param3:Boolean = false) : void;
function hideHelper(param1:String, param2:int) : void;
function showHelp() : void;
function hideHelp() : void;
function setHelperTextFormat(param1:TextFormat) : void;
}
}
|
package alternativa.tanks.sfx
{
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class AnimatedPlaneEffect extends PooledObject implements IGraphicEffect
{
private static const BASE_SIZE:Number = 100;
private var scaleSpeed:Number;
protected var scale:Number;
protected var baseScale:Number;
protected var plane:AnimatedPlane;
private var currentTime:int;
private var maxTime:int;
private var container:Scene3DContainer;
public function AnimatedPlaneEffect(param1:ObjectPool)
{
super(param1);
this.plane = new AnimatedPlane(BASE_SIZE,BASE_SIZE);
this.plane.useShadowMap = false;
this.plane.useLight = false;
this.plane.shadowMapAlphaThreshold = 2;
this.plane.depthMapAlphaThreshold = 2;
this.plane.softAttenuation = 0;
}
public function init(param1:Number, param2:Vector3, param3:Vector3, param4:TextureAnimation, param5:Number) : void
{
this.plane.init(param4,0.001 * param4.fps);
this.maxTime = this.plane.getOneLoopTime();
this.currentTime = 0;
this.scaleSpeed = 0.001 * param5;
this.baseScale = param1 / BASE_SIZE;
this.scale = this.baseScale;
this.plane.x = param2.x;
this.plane.y = param2.y;
this.plane.z = param2.z;
this.plane.rotationX = param3.x;
this.plane.rotationY = param3.y;
this.plane.rotationZ = param3.z;
}
public function addToContainer(param1:Scene3DContainer) : void
{
this.container = param1;
param1.addChild(this.plane);
}
public function play(param1:int, param2:GameCamera) : Boolean
{
if(this.currentTime >= this.maxTime)
{
return false;
}
this.plane.setTime(this.currentTime);
this.currentTime += param1;
this.plane.scaleX = this.scale;
this.plane.scaleY = this.scale;
this.scale = this.baseScale + this.baseScale * this.scaleSpeed * this.currentTime;
return true;
}
public function destroy() : void
{
this.container.removeChild(this.plane);
this.container = null;
this.plane.clear();
this.plane.destroy();
}
public function kill() : void
{
this.currentTime = this.maxTime;
}
public function get owner() : ClientObject
{
return null;
}
}
}
|
package alternativa.tanks.models.effects.firstaid
{
import alternativa.model.IModel;
import alternativa.object.ClientObject;
import alternativa.types.Long;
import com.alternativaplatform.projects.tanks.client.warfare.models.effects.firstaid.FirstAidModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.effects.firstaid.IFirstAidModelBase;
public class FirstAidModel extends FirstAidModelBase implements IFirstAidModelBase
{
public function FirstAidModel()
{
super();
_interfaces.push(IModel,IFirstAidModelBase);
}
public function activated(clientObject:ClientObject, tankId:Long) : void
{
}
}
}
|
package projects.tanks.client.panel.model.shop.paintpackage {
public interface IPaintPackageModelBase {
}
}
|
package alternativa.tanks.models.controlpoints.message {
import alternativa.osgi.service.locale.ILocaleService;
public class ControlPointMessage {
[Inject]
public static var localeService:ILocaleService;
public var color:uint;
private var localizedStringKey:String;
public function ControlPointMessage(param1:uint, param2:String) {
super();
this.color = param1;
this.localizedStringKey = param2;
}
public function getMessage(param1:String) : String {
return localeService.getText(this.localizedStringKey).replace("{point}",param1);
}
}
}
|
package alternativa.tanks.models.weapon.shotgun.sfx {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Sprite3D;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.battle.scene3d.RotationState;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.engine3d.AnimatedSprite3D;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.RayCollisionFilter;
import alternativa.tanks.models.weapon.shotgun.PelletDirectionCalculator;
import alternativa.tanks.models.weapon.shotgun.ShotgunObject;
import alternativa.tanks.models.weapon.weakening.DistanceWeakening;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import alternativa.tanks.sfx.AnimatedPlane;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.display.BlendMode;
public class ShotgunShotEffect extends PooledObject implements GraphicEffect {
[Inject]
public static var battleService:BattleService;
private static const DECAL_RADIUS:Number = 16;
private static const FIRE_SIZE:Number = 270;
private static const SMOKE_RESP_DISTANCE:Number = 100;
private static const SMOKE_LIFE_TIME:Number = 1.3;
private static const SMOKE_MOVE_DISTANCE:Number = 400;
private static const SMOKE_LIFT_DISTANCE:Number = 150;
private static const SMOKE_SCALE:Number = 2.5;
private static const SMOKE_SIZE:Number = 200;
private static const SMOKE_DELAY_TIME:Number = 0.08;
private static const PELLET_LIFE_TIME:Number = 0.3;
private static const SHIFT_RICOCHET_TIME:Number = 0.05;
private static const MAX_DISTANCE:Number = 5000;
private static const SPARKLE_MIN_SIZE:Number = 6;
private static const SPARKLE_LIFE_TIME:Number = 0.2;
private static const SPARKLE_SCALE:Number = 30;
private static const rayHit:RayHit = new RayHit();
private static const collisionFilter:RayCollisionFilter = new RayCollisionFilter();
private static const originAlong:Vector3 = new Vector3();
private static const pelletOrigin:Vector3 = new Vector3();
private static const pelletRicochetOrigin:Vector3 = new Vector3();
private static const pelletDirection:Vector3 = new Vector3();
private var fireAlong:AnimatedPlane = new AnimatedPlane(FIRE_SIZE,FIRE_SIZE,0,FIRE_SIZE / 2,0);
private var fireAcross:AnimatedPlane = new AnimatedPlane(FIRE_SIZE,FIRE_SIZE,0,0,0);
private var smoke:AnimatedSprite3D = new AnimatedSprite3D(SMOKE_SIZE,SMOKE_SIZE);
private var pellets:Vector.<PelletTrail> = new Vector.<PelletTrail>();
private var ricochetPellets:Vector.<PelletTrail> = new Vector.<PelletTrail>();
private var sparkles:Vector.<Sprite3D> = new Vector.<Sprite3D>();
private var muzzlePosition:Vector3 = new Vector3();
private var muzzleDirection:Vector3 = new Vector3();
private var time:Number = 0;
private var container:Scene3DContainer;
private var shotgunSFX:ShotgunSFXData;
private var maxSmokeDistance:Number;
private var buffed:Boolean = false;
public function ShotgunShotEffect(param1:Pool) {
super(param1);
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.fireAlong);
param1.addChild(this.fireAcross);
param1.addChild(this.smoke);
var local2:int = 0;
while(local2 < this.pellets.length) {
param1.addChild(this.pellets[local2]);
local2++;
}
var local3:int = 0;
while(local3 < this.sparkles.length) {
param1.addChild(this.sparkles[local3]);
local3++;
}
var local4:int = 0;
while(local4 < this.ricochetPellets.length) {
param1.addChild(this.ricochetPellets[local4]);
local4++;
}
}
public function play(param1:int, param2:GameCamera) : Boolean {
if(this.allNotHaveParent()) {
return false;
}
var local3:Number = param1 / 1000;
this.playFire(param2);
this.playPelletTrail(param2,this.pellets);
this.playSmoke(local3);
this.playSparkle();
if(this.time >= SHIFT_RICOCHET_TIME) {
this.playRicochetPelletTrail(param2,this.ricochetPellets);
}
this.time += local3;
this.checkForRemoveChildren();
return true;
}
private function allNotHaveParent() : Boolean {
return this.fireAlong.parent == null && this.fireAcross.parent == null && this.smoke.parent == null && this.pellets[0].parent == null && this.sparkles[0].parent == null && this.ricochetPellets[0].parent == null;
}
private function playFire(param1:GameCamera) : void {
var local3:Number = NaN;
SFXUtils.calculateAlphaForObject(this.fireAlong,param1.position,this.muzzleDirection,false,8,0.9);
SFXUtils.calculateAlphaForObject(this.fireAcross,param1.position,this.muzzleDirection,true,4,0.3);
this.fireAlong.setTime(this.time);
var local2:int = this.time * this.shotgunSFX.shotAlongAnimation.fps;
if(local2 == 5) {
local3 = FIRE_SIZE * 0.35;
originAlong.copy(this.muzzlePosition).addScaled(local3,this.muzzleDirection);
} else if(local2 >= 6) {
local3 = FIRE_SIZE * 0.5;
originAlong.copy(this.muzzlePosition).addScaled(local3,this.muzzleDirection);
} else {
originAlong.copy(this.muzzlePosition);
}
SFXUtils.alignObjectPlaneToView(this.fireAlong,originAlong,this.muzzleDirection,param1.position);
this.fireAcross.setTime(this.time);
local2 = this.time * this.shotgunSFX.shotAcrossAnimation.fps;
local3 = 0.1 * FIRE_SIZE + local2 * 0.1 * FIRE_SIZE;
this.fireAcross.x = this.muzzlePosition.x + this.muzzleDirection.x * local3;
this.fireAcross.y = this.muzzlePosition.y + this.muzzleDirection.y * local3;
this.fireAcross.z = this.muzzlePosition.z + this.muzzleDirection.z * local3;
}
private function playPelletTrail(param1:GameCamera, param2:Vector.<PelletTrail>) : void {
var local4:PelletTrail = null;
var local3:Number = this.time / PELLET_LIFE_TIME;
for each(local4 in param2) {
this.playPellet(local4,local3,param1);
}
}
private function playPellet(param1:PelletTrail, param2:Number, param3:GameCamera) : Number {
var local4:Number = param1.distance * param2;
pelletOrigin.copy(param1.position).addScaled(local4,param1.direction);
param1.alpha = 1 - 2 * Math.abs(0.5 - param2);
SFXUtils.alignObjectPlaneToView(param1,pelletOrigin,param1.direction,param3.position);
param1.visible = true;
return local4;
}
private function playRicochetPelletTrail(param1:GameCamera, param2:Vector.<PelletTrail>) : void {
var local4:PelletTrail = null;
var local3:Number = (this.time - SHIFT_RICOCHET_TIME) / PELLET_LIFE_TIME;
for each(local4 in param2) {
if(!local4.isRicochet) {
return;
}
this.playPellet(local4,local3,param1);
}
}
private function playSmoke(param1:Number) : void {
var local2:int = 0;
var local3:Number = NaN;
var local4:Number = NaN;
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
if(this.time > SMOKE_DELAY_TIME) {
this.smoke.visible = true;
local2 = this.time * this.smoke.getFps();
this.smoke.setFrameIndex(local2);
local3 = this.time - SMOKE_DELAY_TIME;
local4 = Math.sqrt(local3 / SMOKE_LIFE_TIME);
if(this.maxSmokeDistance > SMOKE_RESP_DISTANCE) {
local7 = Math.min(this.maxSmokeDistance - SMOKE_RESP_DISTANCE,SMOKE_MOVE_DISTANCE);
local5 = SMOKE_RESP_DISTANCE + local7 * local4;
} else {
local5 = 0;
this.smoke.visible = false;
}
this.smoke.x = this.muzzlePosition.x + this.muzzleDirection.x * local5;
this.smoke.y = this.muzzlePosition.y + this.muzzleDirection.y * local5;
this.smoke.z = this.muzzlePosition.z + this.muzzleDirection.z * local5 + SMOKE_LIFT_DISTANCE * local4;
local6 = 1 + (SMOKE_SCALE - 1) * local4;
this.smoke.scaleX = local6;
this.smoke.scaleY = local6;
this.smoke.scaleZ = local6;
this.smoke.alpha = Math.sin(local3 * Math.PI / SMOKE_LIFE_TIME) * (this.buffed ? 0.5 : 1);
this.smoke.rotation -= 0.3 * param1;
} else {
this.smoke.visible = false;
}
}
private function playSparkle() : void {
var local3:Sprite3D = null;
var local1:Number = (this.time - SHIFT_RICOCHET_TIME) / SPARKLE_LIFE_TIME;
local1 *= local1;
var local2:Number = 1 + (SPARKLE_SCALE - 1) * local1;
for each(local3 in this.sparkles) {
local3.scaleX = local2;
local3.scaleY = local2;
local3.scaleZ = local2;
local3.alpha = 1 - local1;
}
}
private function checkForRemoveChildren() : void {
var local1:PelletTrail = null;
var local2:PelletTrail = null;
var local3:Sprite3D = null;
if(this.time > PELLET_LIFE_TIME) {
for each(local1 in this.pellets) {
this.container.removeChild(local1);
}
}
if(this.time > PELLET_LIFE_TIME + SHIFT_RICOCHET_TIME) {
for each(local2 in this.ricochetPellets) {
if(local2.parent != null) {
this.container.removeChild(local2);
}
}
}
if(this.time > this.fireAlong.getOneLoopTime()) {
this.container.removeChild(this.fireAlong);
}
if(this.time > this.fireAcross.getOneLoopTime()) {
this.container.removeChild(this.fireAcross);
}
if(this.time > SMOKE_DELAY_TIME + SMOKE_LIFE_TIME) {
this.container.removeChild(this.smoke);
}
if(this.time > SPARKLE_LIFE_TIME) {
for each(local3 in this.sparkles) {
this.container.removeChild(local3);
}
}
}
public function destroy() : void {
var local1:int = 0;
while(local1 < this.pellets.length) {
this.pellets[local1].clear();
local1++;
}
var local2:int = 0;
while(local2 < this.ricochetPellets.length) {
this.ricochetPellets[local2].clear();
this.ricochetPellets[local2].visible = false;
local2++;
}
var local3:int = 0;
while(local3 < this.sparkles.length) {
this.sparkles[local3].material = null;
local3++;
}
this.fireAcross.clear();
this.fireAlong.clear();
this.smoke.clear();
recycle();
}
public function kill() : void {
var local1:int = 0;
while(local1 < this.pellets.length) {
this.container.removeChild(this.pellets[local1]);
this.container.removeChild(this.ricochetPellets[local1]);
this.container.removeChild(this.sparkles[local1]);
local1++;
}
this.container.removeChild(this.fireAlong);
this.container.removeChild(this.fireAcross);
this.container.removeChild(this.smoke);
}
public function init(param1:ShotgunObject, param2:AllGlobalGunParams, param3:WeaponPlatform, param4:Vector3, param5:ShotgunSFXData, param6:Boolean) : void {
this.shotgunSFX = param5;
this.buffed = param6;
this.muzzlePosition.copy(param2.muzzlePosition);
this.muzzleDirection.copy(param2.direction);
this.initShotFire();
this.initSmoke();
this.initPelletEffectsAndCorrectMaxSmokeDistance(param1,param2,param4,param3.getBody());
this.time = 0;
}
private function initShotFire() : void {
this.fireAlong.blendMode = BlendMode.ADD;
var local1:TextureAnimation = this.shotgunSFX.shotAlongAnimation;
this.fireAlong.init(local1,local1.fps);
this.fireAlong.shadowMapAlphaThreshold = 2;
this.fireAlong.useShadowMap = false;
this.fireAlong.depthMapAlphaThreshold = 2;
this.fireAlong.useLight = false;
var local2:TextureAnimation = this.shotgunSFX.shotAcrossAnimation;
this.fireAcross.init(local2,local2.fps);
this.fireAcross.blendMode = BlendMode.ADD;
this.fireAcross.rotationX = Math.atan2(this.muzzleDirection.z,Math.sqrt(this.muzzleDirection.x * this.muzzleDirection.x + this.muzzleDirection.y * this.muzzleDirection.y)) - Math.PI / 2;
this.fireAcross.rotationY = 0;
this.fireAcross.rotationZ = -Math.atan2(this.muzzleDirection.x,this.muzzleDirection.y);
this.fireAcross.shadowMapAlphaThreshold = 2;
this.fireAcross.useShadowMap = false;
this.fireAcross.depthMapAlphaThreshold = 2;
this.fireAcross.useLight = false;
}
private function initSmoke() : void {
this.smoke.setAnimationData(this.shotgunSFX.smokeAnimation);
this.smoke.setFrameIndex(0);
this.smoke.rotation = Math.random() * Math.PI * 2;
this.smoke.shadowMapAlphaThreshold = 2;
this.smoke.useShadowMap = false;
this.smoke.depthMapAlphaThreshold = 2;
this.smoke.useLight = false;
this.smoke.softAttenuation = 130;
this.maxSmokeDistance = MAX_DISTANCE;
}
private function initPelletEffectsAndCorrectMaxSmokeDistance(param1:ShotgunObject, param2:AllGlobalGunParams, param3:Vector3, param4:Body) : void {
var local10:Vector3 = null;
var local5:Vector.<Vector3> = this.getPelletDirections(param1,param2,param3);
var local6:TanksCollisionDetector = battleService.getBattleRunner().getCollisionDetector();
collisionFilter.exclusion = param4;
var local7:DistanceWeakening = param1.distanceWeakening();
var local8:Number = local7.getDistance();
while(this.pellets.length < local5.length) {
this.addNewPelletAndSparkle();
}
var local9:int = 0;
while(local9 < local5.length) {
local10 = local5[local9];
this.initPelletTrailAndSparkleEffectsAndCorrectMaxSmokeDistance(local9,local6,local10,param2.barrelOrigin,local8);
local9++;
}
}
private function getPelletDirections(param1:ShotgunObject, param2:AllGlobalGunParams, param3:Vector3) : Vector.<Vector3> {
var local4:PelletDirectionCalculator = param1.pelletDirectionCalculator();
local4.next();
return local4.getDirectionsFor(param2.elevationAxis,param3);
}
private function addNewPelletAndSparkle() : void {
this.pellets.push(this.createPelletTrail());
this.ricochetPellets.push(this.createPelletTrail());
var local1:Sprite3D = new Sprite3D(0,0);
local1.blendMode = BlendMode.ADD;
local1.shadowMapAlphaThreshold = 2;
local1.useShadowMap = false;
local1.depthMapAlphaThreshold = 2;
local1.useLight = false;
this.sparkles.push(local1);
}
private function createPelletTrail() : PelletTrail {
var local1:PelletTrail = new PelletTrail();
local1.blendMode = BlendMode.ADD;
local1.shadowMapAlphaThreshold = 2;
local1.useShadowMap = false;
local1.depthMapAlphaThreshold = 2;
local1.useLight = false;
return local1;
}
private function initPelletTrailAndSparkleEffectsAndCorrectMaxSmokeDistance(param1:int, param2:TanksCollisionDetector, param3:Vector3, param4:Vector3, param5:Number) : void {
var local9:Boolean = false;
var local10:Sprite3D = null;
var local6:Boolean = param2.raycast(param4,param3,CollisionGroup.WEAPON,param5,collisionFilter,rayHit);
var local7:Number = MAX_DISTANCE;
var local8:PelletTrail = this.pellets[param1];
local8.position.copy(this.muzzlePosition);
if(local6) {
local9 = BattleUtils.isTankBody(rayHit.shape.body);
local8.direction.diff(rayHit.position,this.muzzlePosition);
local7 = this.getMaxPelletDistancesAndCorrectMaxSmokeDistance(param4,local7,local8,local9);
local8.direction.normalize();
local10 = this.sparkles[param1];
this.initSparkle(local10,rayHit.position,param3);
if(!local9) {
this.initPelletTrailAndSparkleEffectsRicochet(param1,param3,local10,param2);
}
} else {
local8.direction.copy(param3);
}
this.initPelletTrail(local8,local7);
}
private function initPelletTrailAndSparkleEffectsRicochet(param1:int, param2:Vector3, param3:Sprite3D, param4:TanksCollisionDetector) : void {
var local8:Boolean = false;
pelletRicochetOrigin.copy(rayHit.position);
pelletDirection.copy(rayHit.normal);
pelletDirection.scale(-2 * rayHit.normal.dot(param2)).add(param2);
pelletRicochetOrigin.addScaled(0.1,pelletDirection);
var local5:Number = MAX_DISTANCE;
var local6:Boolean = param4.raycast(pelletRicochetOrigin,pelletDirection,CollisionGroup.WEAPON,local5,null,rayHit);
var local7:PelletTrail = this.ricochetPellets[param1];
local7.isRicochet = true;
local7.position.copy(pelletRicochetOrigin);
if(local6) {
local7.direction.diff(rayHit.position,pelletRicochetOrigin);
local8 = BattleUtils.isTankBody(rayHit.shape.body);
local5 = this.getMaxPelletRicochetDistances(pelletRicochetOrigin,local7,local8);
local7.direction.normalize();
if(!local8) {
this.showMark(pelletRicochetOrigin,rayHit.position);
} else {
this.initSparkle(param3,rayHit.position,pelletDirection);
}
} else {
local7.direction.copy(pelletDirection);
}
this.initPelletTrail(local7,local5);
}
private function getMaxPelletDistancesAndCorrectMaxSmokeDistance(param1:Vector3, param2:Number, param3:PelletTrail, param4:Boolean) : Number {
var local5:Number = param1.distanceTo(rayHit.position);
var local6:Number = param1.distanceTo(this.muzzlePosition);
if(local5 > local6) {
param2 = param3.direction.length();
} else {
param2 = 0;
}
if(!param4) {
this.maxSmokeDistance = Math.min(param2,this.maxSmokeDistance);
}
return param2;
}
private function getMaxPelletRicochetDistances(param1:Vector3, param2:PelletTrail, param3:Boolean) : Number {
if(!param3) {
return param2.direction.length();
}
return param1.distanceTo(rayHit.position);
}
private function initPelletTrail(param1:PelletTrail, param2:Number) : void {
var local3:Number = 3 + Math.random() * 8;
var local4:Number = 0.3 + Math.random() * 0.3;
var local5:Number = Math.min(Math.random() * 200,param2);
var local6:Number = Math.min(400 + Math.random() * 2100,param2);
var local7:Number = 300 + Math.random() * 500;
if(local7 + local6 > param2) {
local7 = Math.max(0,param2 - local6);
}
param1.init(local3,local4,local5,local6,local7,this.shotgunSFX.pelletTrailMaterial);
}
private function initSparkle(param1:Sprite3D, param2:Vector3, param3:Vector3) : void {
var local4:Number = SPARKLE_MIN_SIZE + Math.random() * SPARKLE_MIN_SIZE;
var local5:Number = local4 / 2;
param1.width = local4;
param1.height = local4;
param1.material = this.shotgunSFX.sparkleMaterial;
param1.x = param2.x - local5 * param3.x;
param1.y = param2.y - local5 * param3.y;
param1.z = param2.z - local5 * param3.z;
param1.rotation = Math.random() * Math.PI * 2;
param1.visible = true;
}
private function showMark(param1:Vector3, param2:Vector3) : void {
var local3:Vector.<TextureMaterial> = this.shotgunSFX.explosionMarkMaterials;
var local4:int = Math.floor(Math.random() * local3.length);
battleService.getBattleScene3D().addDecal(param2,param1,DECAL_RADIUS,local3[local4],RotationState.WITHOUT_ROTATION);
}
}
}
|
package resources.windowheaders.background
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BackgroundHeader_verticalBackgroundHeaderClass extends BitmapAsset
{
public function BackgroundHeader_verticalBackgroundHeaderClass()
{
super();
}
}
}
|
package com.lorentz.SVG.data.path
{
public class SVGCurveToQuadraticCommand extends SVGPathCommand
{
public var x1:Number = 0;
public var y1:Number = 0;
public var x:Number = 0;
public var y:Number = 0;
public var absolute:Boolean = false;
public function SVGCurveToQuadraticCommand(absolute:Boolean, x1:Number = 0, y1:Number = 0, x:Number = 0, y:Number = 0)
{
super();
this.absolute = absolute;
this.x1 = x1;
this.y1 = y1;
this.x = x;
this.y = y;
}
override public function get type():String {
return absolute ? "Q" : "q";
}
override public function clone():Object {
var copy:SVGCurveToQuadraticCommand = new SVGCurveToQuadraticCommand(absolute);
copy.x1 = x1;
copy.y1 = y1;
copy.x = x;
copy.y = y;
return copy;
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.components.button.ClanButtonActionListener;
import alternativa.tanks.models.clan.accepted.IClanAcceptedModel;
import alternativa.tanks.models.clan.info.IClanInfoModel;
import alternativa.tanks.models.clan.membersdata.ClanMembersDataService;
import alternativa.tanks.models.service.ClanInfoUpdateEvent;
import alternativa.tanks.models.service.ClanService;
import alternativa.tanks.models.service.ClanServiceEvent;
import alternativa.types.Long;
import base.DiscreteSprite;
import controls.TankWindow;
import controls.TankWindowInner;
import controls.windowinner.WindowInner;
import flash.display.Bitmap;
import flash.events.Event;
import flash.events.MouseEvent;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
public class ClanProfileWindow extends DiscreteSprite {
[Inject]
public static var clanService:ClanService;
[Inject]
public static var clanMembersData:ClanMembersDataService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var localeService:ILocaleService;
private static const FRAME:int = 7;
private static const MARGIN:int = 11;
private static const BUTTON_HEIGHT:int = 30;
public static const INFO_INNER_HEIGHT:int = 120;
private var bitmapDeachIcon:Class;
private var bitmapKillsIcon:Class;
private var bitmapKillsDeathsIcon:Class;
private var bitmapPlayersIcon:Class;
private var bonusesWindow:TankWindow;
private var bonusesInner:WindowInner;
private var descriptionWindow:TankWindow;
private var editButton:ClanButtonActionListener;
private var countMembersItem:ClanBonusItem;
private var killsCountItem:ClanBonusItem;
private var deathsCountItem:ClanBonusItem;
private var killsDeathsItem:ClanBonusItem;
private var _width:int;
private var _height:int;
private var clanInfo:IClanInfoModel;
private var editedClanInfo:ClanInfoUpdateEvent;
private var description:ClanDescriptionPanel;
public function ClanProfileWindow(param1:IGameObject) {
var local5:Long = null;
this.bitmapDeachIcon = ClanProfileWindow_bitmapDeachIcon;
this.bitmapKillsIcon = ClanProfileWindow_bitmapKillsIcon;
this.bitmapKillsDeathsIcon = ClanProfileWindow_bitmapKillsDeathsIcon;
this.bitmapPlayersIcon = ClanProfileWindow_bitmapPlayersIcon;
this.editButton = new ClanButtonActionListener(ClanAction.EDIT_PROFILE);
super();
this.clanInfo = IClanInfoModel(param1.adapt(IClanInfoModel));
this.bonusesWindow = new TankWindow();
this.descriptionWindow = new TankWindow();
addChild(this.bonusesWindow);
addChild(this.descriptionWindow);
this.bonusesInner = new WindowInner(this._width,INFO_INNER_HEIGHT,TankWindowInner.GREEN);
this.bonusesWindow.addChild(this.bonusesInner);
var local2:IClanAcceptedModel = IClanAcceptedModel(param1.adapt(IClanAcceptedModel));
var local3:int = 0;
var local4:int = 0;
for each(local5 in local2.getAcceptedUsers()) {
local3 += clanMembersData.getKills(local5);
local4 += clanMembersData.getDeaths(local5);
}
this.countMembersItem = new ClanBonusItem(new this.bitmapPlayersIcon() as Bitmap,localeService.getText(TanksLocale.TEXT_CLAN_PLAYERS_IN_CLAN),"");
this.setMembersCount();
this.killsCountItem = new ClanBonusItem(new this.bitmapKillsIcon() as Bitmap,localeService.getText(TanksLocale.TEXT_CLAN_TANKS_DESTROYED),local3.toString());
this.deathsCountItem = new ClanBonusItem(new this.bitmapDeachIcon() as Bitmap,localeService.getText(TanksLocale.TEXT_CLAN_TANKS_LOST),local4.toString());
this.killsDeathsItem = new ClanBonusItem(new this.bitmapKillsDeathsIcon() as Bitmap,localeService.getText(TanksLocale.TEXT_CLAN_KILL_DEATH_RATION),"");
if(local4 == 0) {
this.killsDeathsItem.setValue("0.00");
} else {
this.killsDeathsItem.setValue((Number(local3) / local4).toFixed(2));
}
this.bonusesInner.addChild(this.countMembersItem);
this.bonusesInner.addChild(this.killsCountItem);
this.bonusesInner.addChild(this.deathsCountItem);
this.bonusesInner.addChild(this.killsDeathsItem);
this.description = new ClanDescriptionPanel(this.clanInfo.getDescription());
this.descriptionWindow.addChild(this.description);
this.editButton.label = localeService.getText(TanksLocale.TEXT_CLAN_EDIT_PROFILE);
ClanActionsManager.addActionsUpdateListener(this.editButton);
this.editButton.updateActions();
this.editButton.addEventListener(MouseEvent.CLICK,this.onEditClick);
addChild(this.editButton);
clanService.addEventListener(ClanServiceEvent.CLAN_BLOCK,this.onClanBlock);
}
private function onClanBlock(param1:ClanServiceEvent) : void {
this.description.setDescriptionText(this.clanInfo.getDescription());
}
private function onEditClick(param1:MouseEvent) : void {
new ClanEditProfileDialog(this.clanInfo,this.editedClanInfo,this);
}
public function dispatchUpdate(param1:ClanInfoUpdateEvent) : void {
dispatchEvent(param1);
this.description.setDescriptionText(param1.clanDescription);
}
private function onResize(param1:Event = null) : void {
this.bonusesWindow.y = MARGIN + ClanTopManagementPanel.HEIGHT - 3;
this.bonusesWindow.width = this.width;
this.bonusesWindow.height = INFO_INNER_HEIGHT + 2 * MARGIN;
this.descriptionWindow.y = this.bonusesWindow.y + this.bonusesWindow.height;
this.descriptionWindow.width = this.width;
this.descriptionWindow.height = this.height - this.descriptionWindow.y;
this.bonusesInner.x = MARGIN;
this.bonusesInner.y = MARGIN;
this.bonusesInner.width = this.bonusesWindow.width - 2 * MARGIN;
this.bonusesInner.height = INFO_INNER_HEIGHT;
this.description.x = MARGIN;
this.description.y = MARGIN;
this.description.width = this.descriptionWindow.width - 2 * MARGIN;
this.description.height = this.descriptionWindow.height - BUTTON_HEIGHT - FRAME - 2 * MARGIN;
this.description.onResize();
this.bonusesInner.addChild(this.countMembersItem);
this.bonusesInner.addChild(this.killsCountItem);
this.bonusesInner.addChild(this.deathsCountItem);
this.bonusesInner.addChild(this.killsDeathsItem);
this.countMembersItem.x = MARGIN;
this.killsCountItem.x = this.countMembersItem.x + this.countMembersItem.width + MARGIN;
this.deathsCountItem.x = this.killsCountItem.x + this.killsCountItem.width + MARGIN;
this.killsDeathsItem.x = this.deathsCountItem.x + this.deathsCountItem.width + MARGIN;
this.countMembersItem.y = MARGIN;
this.killsCountItem.y = this.countMembersItem.y;
this.deathsCountItem.y = this.countMembersItem.y;
this.killsDeathsItem.y = this.countMembersItem.y;
this.editButton.x = MARGIN;
this.editButton.y = this._height - this.editButton.height - MARGIN - 1;
}
private function setMembersCount() : void {
this.countMembersItem.setValue(clanService.membersCount.toString());
}
public function userAdded() : void {
this.setMembersCount();
}
public function userRemoved() : void {
this.setMembersCount();
}
public function setInfo(param1:ClanInfoUpdateEvent) : void {
this.editedClanInfo = param1;
this.onResize();
}
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 projects.tanks.client.battlefield.models.tankparts.weapon.angles.verticals.autoaiming {
public interface IWeaponVerticalAnglesModelBase {
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.pointbased.rugby {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.battle.pointbased.rugby.RugbySoundFX;
public class VectorCodecRugbySoundFXLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRugbySoundFXLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(RugbySoundFX,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.<RugbySoundFX> = new Vector.<RugbySoundFX>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = RugbySoundFX(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:RugbySoundFX = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<RugbySoundFX> = Vector.<RugbySoundFX>(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.utils.objectpool
{
public class PooledObject
{
protected var objectPool:ObjectPool;
public function PooledObject(objectPool:ObjectPool)
{
super();
this.objectPool = objectPool;
}
public final function storeInPool() : void
{
this.objectPool.putObject(this.getClass(),this);
}
protected function getClass() : Class
{
throw new Error("Not implemented");
}
}
}
|
package alternativa.gfx.core {
import alternativa.gfx.alternativagfx;
import flash.display3D.Context3D;
use namespace alternativagfx;
public class Resource {
public var context:Context3D = null;
public function Resource() {
super();
}
public function dispose() : void {
this.context = null;
}
public function reset() : void {
this.context = null;
}
public function get available() : Boolean {
return false;
}
alternativagfx function create(param1:Context3D) : void {
this.context = param1;
}
alternativagfx function upload() : void {
}
public function isCreated(param1:Context3D) : Boolean {
return this.context != null && this.context == param1;
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.ActionOutputLine_rgbPlayerLooseBallIcon.png")]
public class ActionOutputLine_rgbPlayerLooseBallIcon extends BitmapAsset {
public function ActionOutputLine_rgbPlayerLooseBallIcon() {
super();
}
}
}
|
package alternativa.tanks.camera {
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.osgi.service.console.variables.ConsoleVarFloat;
public class ProjectileHitCameraModifier implements ICameraStateModifier {
private static var amplitude:ConsoleVarFloat;
private static var swayAmplitude:ConsoleVarFloat;
private static var time1:ConsoleVarFloat;
private static var time2:ConsoleVarFloat;
private static var m:Matrix3 = new Matrix3();
private static var m1:Matrix3 = new Matrix3();
private var hitDirection:Vector3 = new Vector3();
private var swayAxis:Vector3 = new Vector3();
private var power:Number;
private var t:Number;
private var state:int;
public function ProjectileHitCameraModifier() {
super();
}
public static function initVars() : void {
amplitude = new ConsoleVarFloat("hitcam_ampl",50,-1000,1000);
swayAmplitude = new ConsoleVarFloat("hitcam_sway",-0.05,-10,10);
time1 = new ConsoleVarFloat("hitcam_time1",0.1,0,10);
time2 = new ConsoleVarFloat("hitcam_time2",0.5,0,10);
}
public function init(param1:Vector3, param2:Number) : void {
this.hitDirection.copy(param1);
this.power = param2;
this.swayAxis.reset(this.hitDirection.y,-this.hitDirection.x,0).normalize();
this.t = 0;
this.state = 0;
}
public function update(param1:int, param2:int, param3:Vector3, param4:Vector3) : Boolean {
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
this.t += param2 * 0.001;
switch(this.state) {
case 0:
if(this.t > time1.value) {
this.t = time1.value;
this.state = 1;
}
local5 = Math.sin(Math.PI / 2 / time1.value * this.t);
break;
case 1:
if(this.t > time2.value) {
this.t = time2.value;
this.state = 2;
}
local6 = Math.PI / (time2.value - time1.value);
local7 = Math.PI * time1.value / (time1.value - time2.value);
local5 = 0.5 * (1 + Math.cos(local6 * this.t + local7));
break;
case 2:
return false;
}
param3.addScaled(local5 * amplitude.value * this.power,this.hitDirection);
m.setRotationMatrix(param4.x,param4.y,param4.z);
m1.fromAxisAngle(this.swayAxis,local5 * swayAmplitude.value * this.power);
m.append(m1);
m.getEulerAngles(param4);
return true;
}
public function onAddedToController(param1:IFollowCameraController) : void {
}
public function destroy() : void {
}
}
}
|
package _codec.projects.tanks.client.battleselect.model.battle.entrance.user {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battleselect.model.battle.entrance.user.BattleInfoUser;
public class VectorCodecBattleInfoUserLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattleInfoUserLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BattleInfoUser,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.<BattleInfoUser> = new Vector.<BattleInfoUser>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattleInfoUser(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattleInfoUser = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattleInfoUser> = Vector.<BattleInfoUser>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.drone {
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.drone.DroneIndicatorCC;
public class CodecDroneIndicatorCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_batteryAmount:ICodec;
private var codec_canOverheal:ICodec;
private var codec_droneReady:ICodec;
private var codec_timeToReloadMs:ICodec;
public function CodecDroneIndicatorCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_batteryAmount = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_canOverheal = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_droneReady = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_timeToReloadMs = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:DroneIndicatorCC = new DroneIndicatorCC();
local2.batteryAmount = this.codec_batteryAmount.decode(param1) as int;
local2.canOverheal = this.codec_canOverheal.decode(param1) as Boolean;
local2.droneReady = this.codec_droneReady.decode(param1) as Boolean;
local2.timeToReloadMs = this.codec_timeToReloadMs.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:DroneIndicatorCC = DroneIndicatorCC(param2);
this.codec_batteryAmount.encode(param1,local3.batteryAmount);
this.codec_canOverheal.encode(param1,local3.canOverheal);
this.codec_droneReady.encode(param1,local3.droneReady);
this.codec_timeToReloadMs.encode(param1,local3.timeToReloadMs);
}
}
}
|
package alternativa.tanks.models.tank.spawn {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ITankSpawnerAdapt implements ITankSpawner {
private var object:IGameObject;
private var impl:ITankSpawner;
public function ITankSpawnerAdapt(param1:IGameObject, param2:ITankSpawner) {
super();
this.object = param1;
this.impl = param2;
}
public function getIncarnationId() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getIncarnationId());
}
finally {
Model.popObject();
}
return result;
}
public function readyToSpawn() : void {
try {
Model.object = this.object;
this.impl.readyToSpawn();
}
finally {
Model.popObject();
}
}
public function setLocal() : void {
try {
Model.object = this.object;
this.impl.setLocal();
}
finally {
Model.popObject();
}
}
public function setRemote() : void {
try {
Model.object = this.object;
this.impl.setRemote();
}
finally {
Model.popObject();
}
}
public function setReadyToPlace() : void {
try {
Model.object = this.object;
this.impl.setReadyToPlace();
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.model.shop.items.crystallitem
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.model.shop.ShopWindow;
import alternativa.tanks.model.shop.items.base.ShopItemBase;
import alternativa.tanks.model.shop.items.base.ShopItemSkins;
import alternativa.tanks.model.shop.items.utils.FormatUtils;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.text.TextFieldAutoSize;
public class CrystalPackageItem extends ShopItemBase
{
public static var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
private static const LEFT_PADDING:int = 18;
private static const RIGHT_PADDING:int = 18;
private static const TOP_PADDING:int = 17;
private static const BOTTOM_PADDING:int = 17;
private static const CRYSTAL_ICON_X:int = 153;
private static const CRYSTAL_ICON_Y:int = -2;
private static const CRYSTALS_TEXT_LABEL_COLOR:uint = 23704;
private static const MONEY_TEXT_LABEL_COLOR:uint = 4144959;
private var crystalsIcon:Bitmap;
private var crystalLabel:LabelBase;
private var crystalBlueIcon:Bitmap;
private var priceLabel:LabelBase;
private var presentLabel:LabelBase;
private var presentSecondLabel:LabelBase;
private var presentIcon:Bitmap;
private var additionalData:Object;
public function CrystalPackageItem(itemId:String, additionalData:Object)
{
this.additionalData = additionalData;
super(itemId,ShopItemSkins.GREEN);
}
override protected function init() : void
{
super.init();
if(this.hasPresent)
{
this.initPackageWithPresent();
}
else
{
this.initPackageWithoutPresent();
}
this.initCrystalsAndPriceInnerLabels();
this.render();
}
private function initCrystalsAndPriceInnerLabels() : void
{
this.crystalLabel = new LabelBase();
this.crystalLabel.text = FormatUtils.valueToString(this.additionalData.crystalls_count,0,false);
this.crystalLabel.color = CRYSTALS_TEXT_LABEL_COLOR;
this.crystalLabel.autoSize = TextFieldAutoSize.LEFT;
this.crystalLabel.size = 30;
this.crystalLabel.bold = true;
this.crystalLabel.mouseEnabled = false;
addChild(this.crystalLabel);
this.crystalBlueIcon = new Bitmap(CrystalPackageItemIcons.crystalBlue);
addChild(this.crystalBlueIcon);
this.priceLabel = new LabelBase();
fixChineseCurrencyLabelRendering(this.priceLabel);
this.priceLabel.text = FormatUtils.valueToString(this.additionalData.price,0,false) + " " + this.additionalData.currency;
this.priceLabel.color = MONEY_TEXT_LABEL_COLOR;
this.priceLabel.autoSize = TextFieldAutoSize.LEFT;
this.priceLabel.size = 22;
this.priceLabel.bold = true;
this.priceLabel.mouseEnabled = false;
addChild(this.priceLabel);
}
private function initPackageWithPresent() : void
{
if(ShopWindow.haveDoubleCrystalls)
{
setSkin(ShopItemSkins.RED);
}
this.presentLabel = new LabelBase();
this.presentLabel.text = "+" + FormatUtils.valueToString(this.additionalData.bonus_crystalls,0,false);
this.presentLabel.color = 16777215;
this.presentLabel.autoSize = TextFieldAutoSize.LEFT;
this.presentLabel.size = 22;
this.presentLabel.bold = true;
this.presentLabel.mouseEnabled = false;
addChild(this.presentLabel);
this.presentSecondLabel = new LabelBase();
this.presentSecondLabel.text = "в подарок!";
this.presentSecondLabel.color = 16777215;
this.presentSecondLabel.autoSize = TextFieldAutoSize.LEFT;
this.presentSecondLabel.size = 18;
this.presentSecondLabel.mouseEnabled = false;
addChild(this.presentSecondLabel);
this.presentIcon = new Bitmap(CrystalPackageItemIcons.crystalWhite);
addChild(this.presentIcon);
}
private function initPackageWithoutPresent() : void
{
setSkin(ShopItemSkins.GREY);
}
private function get hasPresent() : Boolean
{
return this.additionalData.bonus_crystalls > 0;
}
private function render() : void
{
this.crystalLabel.x = LEFT_PADDING;
this.crystalLabel.y = TOP_PADDING;
this.crystalBlueIcon.x = this.crystalLabel.x + this.crystalLabel.width + 3;
this.crystalBlueIcon.y = TOP_PADDING + 8;
this.priceLabel.x = LEFT_PADDING;
this.priceLabel.y = this.crystalLabel.y + this.crystalLabel.height - 5;
if(this.crystalsIcon)
{
this.crystalsIcon.x = CRYSTAL_ICON_X;
this.crystalsIcon.y = CRYSTAL_ICON_Y;
}
if(this.hasPresent)
{
this.presentIcon.x = WIDTH - RIGHT_PADDING - this.presentIcon.width;
this.presentLabel.x = this.presentIcon.x - this.presentLabel.width;
this.presentSecondLabel.x = this.presentLabel.x;
this.presentSecondLabel.y = HEIGHT - BOTTOM_PADDING - this.presentSecondLabel.height;
this.presentLabel.y = this.presentSecondLabel.y - this.presentSecondLabel.height + 4;
this.presentIcon.y = this.presentLabel.y + 5;
}
}
override public function set gridPosition(param1:int) : void
{
super.gridPosition = param1;
var _loc2_:BitmapData = CrystalPackageItemIcons.crystalsPackages[gridPosition];
if(!_loc2_ && param1 != 0)
{
_loc2_ = CrystalPackageItemIcons.crystalsPackages[CrystalPackageItemIcons.crystalsPackages.length - 1];
}
if(_loc2_)
{
this.crystalsIcon = new Bitmap(_loc2_);
addChildAt(this.crystalsIcon,2);
}
this.render();
}
}
}
|
package platform.client.fp10.core.network.command.control.client {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
public class LogCommandCodec implements ICodec {
private var intCodec:ICodec;
private var stringCodec:ICodec;
public function LogCommandCodec(param1:IProtocol) {
super();
this.init(param1);
}
public function init(param1:IProtocol) : void {
this.intCodec = param1.getCodec(new TypeCodecInfo(int,false));
this.stringCodec = param1.getCodec(new TypeCodecInfo(String,false));
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local3:LogCommand = LogCommand(param2);
this.intCodec.encode(param1,local3.level);
this.stringCodec.encode(param1,local3.channel);
this.stringCodec.encode(param1,local3.message);
}
public function decode(param1:ProtocolBuffer) : Object {
return null;
}
}
}
|
package alternativa.tanks.service.impl {
import alternativa.tanks.servermodels.IGoogleEntranceModel;
import alternativa.tanks.servermodels.changeuid.IChangeUid;
import alternativa.tanks.servermodels.emailandpasswordchanger.IPasswordRecovery;
import alternativa.tanks.servermodels.emailconfirm.IEmailConfirm;
import alternativa.tanks.servermodels.invite.IInvite;
import alternativa.tanks.servermodels.login.ILogin;
import alternativa.tanks.servermodels.loginbyhash.ILoginByHash;
import alternativa.tanks.servermodels.loginwithoutregistration.ILoginWithoutRegistration;
import alternativa.tanks.servermodels.partners.ICompositePartnerModel;
import alternativa.tanks.servermodels.registartion.email.IEmailRegistration;
import alternativa.tanks.servermodels.registartion.password.IPasswordRegistration;
import alternativa.tanks.servermodels.socialnetwork.IExternalEntranceModel;
import alternativa.tanks.service.IEntranceServerFacade;
import org.robotlegs.mvcs.Actor;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.models.captcha.CaptchaLocation;
import projects.tanks.clients.flash.commons.models.captcha.IServerCaptcha;
public class EntranceServerFacade extends Actor implements IEntranceServerFacade {
private var _gameObject:IGameObject;
public function EntranceServerFacade() {
super();
}
public function checkCallsign(param1:String) : void {
this.checkIfGameObjectIsLoaded();
IPasswordRegistration(this._gameObject.adapt(IPasswordRegistration)).checkCallsign(param1);
}
public function checkEmail(param1:String) : void {
this.checkIfGameObjectIsLoaded();
IEmailRegistration(this._gameObject.adapt(IEmailRegistration)).checkEmail(param1);
}
public function checkInviteCode(param1:String) : void {
this.checkIfGameObjectIsLoaded();
IInvite(this._gameObject.adapt(IInvite)).checkInvite(param1);
}
public function sendEmailRestoreMessage(param1:String) : void {
this.checkIfGameObjectIsLoaded();
IPasswordRecovery(this._gameObject.adapt(IPasswordRecovery)).sendUsersRestorePasswordLink(param1);
}
public function login(param1:String, param2:String, param3:Boolean) : void {
this.checkIfGameObjectIsLoaded();
ILogin(this._gameObject.adapt(ILogin)).login(param1,param2,param3);
}
public function loginExternal(param1:String, param2:String) : void {
this.checkIfGameObjectIsLoaded();
IExternalEntranceModel(this._gameObject.adapt(IExternalEntranceModel)).login(param1,param2);
}
public function fightWithoutRegistration() : void {
this.checkIfGameObjectIsLoaded();
ILoginWithoutRegistration(this._gameObject.adapt(ILoginWithoutRegistration)).passToFirstBattle();
}
public function checkEmailChangeHash(param1:String) : void {
this.checkIfGameObjectIsLoaded();
IPasswordRecovery(this._gameObject.adapt(IPasswordRecovery)).startEmailAndPasswordChangeProcess(param1);
}
public function loginByHash(param1:String) : void {
this.checkIfGameObjectIsLoaded();
ILoginByHash(this._gameObject.adapt(ILoginByHash)).loginByHash(param1);
}
public function loginBySingleUseHash(param1:String) : void {
this.checkIfGameObjectIsLoaded();
ILoginByHash(this._gameObject.adapt(ILoginByHash)).loginBySingleUseHash(param1);
}
public function confirmEmail(param1:String, param2:String) : void {
this.checkIfGameObjectIsLoaded();
IEmailConfirm(this._gameObject.adapt(IEmailConfirm)).startEmailConfirm(param1,param2);
}
public function checkChangeUidHash(param1:String, param2:String) : void {
this.checkIfGameObjectIsLoaded();
IChangeUid(this._gameObject.adapt(IChangeUid)).checkChangeUidHash(param1,param2);
}
public function changeUidAndPassword(param1:String, param2:String) : void {
this.checkIfGameObjectIsLoaded();
IChangeUid(this._gameObject.adapt(IChangeUid)).changeUidAndPassword(param1,param2);
}
public function changeUid(param1:String) : void {
this.checkIfGameObjectIsLoaded();
IChangeUid(this._gameObject.adapt(IChangeUid)).changeUid(param1);
}
public function set entranceObject(param1:IGameObject) : void {
this._gameObject = param1;
}
public function registerUserThroughPassword(param1:String, param2:String, param3:String, param4:Boolean, param5:String, param6:String, param7:String) : void {
this.checkIfGameObjectIsLoaded();
(this._gameObject.adapt(IPasswordRegistration) as IPasswordRegistration).register(param1,param2,param3,param4,param5,param6,param7);
}
public function registerThroughEmail(param1:String, param2:String, param3:String, param4:String, param5:String, param6:String) : void {
this.checkIfGameObjectIsLoaded();
(this._gameObject.adapt(IEmailRegistration) as IEmailRegistration).register(param1,param2,param3,param4,param5,param6);
}
public function getNewCaptcha(param1:CaptchaLocation) : void {
this.checkIfGameObjectIsLoaded();
(this._gameObject.adapt(IServerCaptcha) as IServerCaptcha).getNewCaptcha(param1);
}
public function checkCaptcha(param1:String, param2:CaptchaLocation) : void {
this.checkIfGameObjectIsLoaded();
(this._gameObject.adapt(IServerCaptcha) as IServerCaptcha).checkCaptcha(param1,param2);
}
public function changePasswordAndEmail(param1:String, param2:String) : void {
this.checkIfGameObjectIsLoaded();
IPasswordRecovery(this._gameObject.adapt(IPasswordRecovery)).changePasswordAndEmail(param1,param2);
}
public function startExternalRegisterUser(param1:String, param2:Boolean, param3:String) : void {
this.checkIfGameObjectIsLoaded();
IExternalEntranceModel(this._gameObject.adapt(IExternalEntranceModel)).startExternalRegisterUser(param1,param2,param3);
}
public function startExternalLoginUser(param1:String, param2:Boolean, param3:String) : void {
this.checkIfGameObjectIsLoaded();
IExternalEntranceModel(this._gameObject.adapt(IExternalEntranceModel)).startExternalLoginUser(param1,param2,param3);
}
public function finishExternalRegisterUser(param1:String, param2:String) : void {
this.checkIfGameObjectIsLoaded();
IExternalEntranceModel(this._gameObject.adapt(IExternalEntranceModel)).finishExternalRegisterUser(param1,param2);
}
public function loadPartnerObject(param1:String) : void {
this.checkIfGameObjectIsLoaded();
ICompositePartnerModel(this._gameObject.adapt(ICompositePartnerModel)).loadPartnerObject(param1);
}
public function finishPartnerRegistration(param1:String, param2:String) : void {
this.checkIfGameObjectIsLoaded();
ICompositePartnerModel(this._gameObject.adapt(ICompositePartnerModel)).finishRegistration(param1,param2);
}
public function bindAccountToPartner(param1:String, param2:String) : void {
this.checkIfGameObjectIsLoaded();
ICompositePartnerModel(this._gameObject.adapt(ICompositePartnerModel)).bindAccount(param1,param2);
}
private function checkIfGameObjectIsLoaded() : void {
if(this._gameObject == null) {
throw new Error("Entrance gameObject is not loaded");
}
}
public function googleLogin(param1:String) : void {
this.checkIfGameObjectIsLoaded();
(this._gameObject.adapt(IGoogleEntranceModel) as IGoogleEntranceModel).login(param1);
}
}
}
|
package alternativa.tanks.models.weapon.shaft.sfx {
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
internal class Trail1 extends Mesh {
private var a:Vertex;
private var b:Vertex;
private var c:Vertex;
private var d:Vertex;
private var face:Face;
public function Trail1() {
super();
this.a = this.createVertex(-1,-1,0,0,1);
this.b = this.createVertex(1,-1,0,1,1);
this.c = this.createVertex(1,0,0,1,0);
this.d = this.createVertex(-1,0,0,0,0);
this.face = this.createQuad(this.a,this.b,this.c,this.d);
calculateFacesNormals();
sorting = Sorting.DYNAMIC_BSP;
shadowMapAlphaThreshold = 2;
depthMapAlphaThreshold = 2;
useShadowMap = false;
useLight = false;
}
public function init(param1:Number, param2:Number, param3:Number, param4:Material) : void {
alpha = 1;
var local5:Number = param1 / 2;
boundMinX = this.a.x = this.d.x = -local5;
boundMaxX = this.b.x = this.c.x = local5;
boundMinY = this.a.y = this.b.y = -param2;
boundMaxY = 0;
boundMinZ = boundMaxZ = 0;
this.a.v = this.b.v = param3;
this.face.material = param4;
}
public function set width(param1:Number) : void {
var local2:Number = param1 / 2;
boundMinX = this.a.x = this.d.x = -local2;
boundMaxX = this.b.x = this.c.x = local2;
}
public function get length() : Number {
return -this.a.y;
}
public function set length(param1:Number) : void {
if(param1 < 10) {
param1 = 10;
}
boundMinY = this.a.y = this.b.y = -param1;
}
private function createVertex(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number) : Vertex {
var local6:Vertex = new Vertex();
local6.next = vertexList;
vertexList = local6;
local6.x = param1;
local6.y = param2;
local6.z = param3;
local6.u = param4;
local6.v = param5;
return local6;
}
private function createQuad(param1:Vertex, param2:Vertex, param3:Vertex, param4:Vertex) : Face {
var local5:Face = new Face();
local5.next = faceList;
faceList = local5;
local5.wrapper = new Wrapper();
local5.wrapper.vertex = param1;
local5.wrapper.next = new Wrapper();
local5.wrapper.next.vertex = param2;
local5.wrapper.next.next = new Wrapper();
local5.wrapper.next.next.vertex = param3;
local5.wrapper.next.next.next = new Wrapper();
local5.wrapper.next.next.next.vertex = param4;
return local5;
}
}
}
|
package alternativa.protocol.codec.primitive {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
public class UShortCodec implements ICodec {
public function UShortCodec() {
super();
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
param1.writer.writeShort(int(param2));
}
public function decode(param1:ProtocolBuffer) : Object {
return param1.reader.readUnsignedShort();
}
public function init(param1:IProtocol) : void {
}
}
}
|
package utils
{
import flash.display.BitmapData;
public class FlipBitmapDataUtils
{
public function FlipBitmapDataUtils()
{
super();
}
public static function flipH(param1:BitmapData) : BitmapData
{
var _loc4_:int = 0;
var _loc2_:BitmapData = new BitmapData(param1.width,param1.height,true);
var _loc3_:int = 0;
while(_loc3_ < param1.width)
{
_loc4_ = 0;
while(_loc4_ < param1.height)
{
_loc2_.setPixel32(_loc3_,_loc4_,param1.getPixel32(param1.width - 1 - _loc3_,_loc4_));
_loc4_++;
}
_loc3_++;
}
return _loc2_;
}
public static function flipW(param1:BitmapData) : BitmapData
{
var _loc4_:int = 0;
var _loc2_:BitmapData = new BitmapData(param1.width,param1.height,true);
var _loc3_:int = 0;
while(_loc3_ < param1.width)
{
_loc4_ = 0;
while(_loc4_ < param1.height)
{
_loc2_.setPixel32(_loc3_,_loc4_,param1.getPixel32(_loc3_,param1.height - 1 - _loc4_));
_loc4_++;
}
_loc3_++;
}
return _loc2_;
}
}
}
|
package alternativa.tanks.models.battle.facilities {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import platform.client.fp10.core.type.IGameObject;
[ModelInterface]
public interface BattleFacilities {
function register(param1:IGameObject) : void;
function unregister(param1:IGameObject) : void;
function addCheckZone(param1:IGameObject, param2:Vector3, param3:Number, param4:Boolean) : void;
function addDynamicCheckZone(param1:IGameObject, param2:Tank, param3:Number, param4:Boolean) : void;
function removeCheckZone(param1:IGameObject) : void;
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_continuousHealClass.png")]
public class ItemInfoPanelBitmaps_continuousHealClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_continuousHealClass() {
super();
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ModTable_bitmapUpgradeSelectionRight extends BitmapAsset
{
public function ModTable_bitmapUpgradeSelectionRight()
{
super();
}
}
}
|
package alternativa.tanks.loader.dishonestprogressbar {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.loader.dishonestprogressbar.DishonestProgressBar_bgdRightClass.png")]
public class DishonestProgressBar_bgdRightClass extends BitmapAsset {
public function DishonestProgressBar_bgdRightClass() {
super();
}
}
}
|
package controls.saleicons {
import flash.display.Bitmap;
import flash.display.BitmapData;
public class SaleIcons {
private static const saleRedLabelClass:Class = SaleIcons_saleRedLabelClass;
private static const saleRedLabel:BitmapData = new saleRedLabelClass().bitmapData;
public function SaleIcons() {
super();
}
public static function createSaleRedLabelInstance() : Bitmap {
return new Bitmap(saleRedLabel);
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.