code stringlengths 57 237k |
|---|
package projects.tanks.client.battlefield.gui.models.chat
{
public interface IChatModelBase
{
}
}
|
package _codec.projects.tanks.client.battlefield.models.ultimate.effects.mammoth {
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 platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.ultimate.effects.mammoth.MammothUltimateCC;
public class CodecMammothUltimateCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_active:ICodec;
private var codec_effectLoopSound:ICodec;
private var codec_effectRadius:ICodec;
private var codec_effectSparks1Sound:ICodec;
private var codec_effectSparks2Sound:ICodec;
private var codec_effectSparks3Sound:ICodec;
private var codec_effectSparks4Sound:ICodec;
private var codec_effectStartSound:ICodec;
private var codec_effectStopSound:ICodec;
private var codec_heart:ICodec;
private var codec_shine:ICodec;
private var codec_sparkles:ICodec;
public function CodecMammothUltimateCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_active = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_effectLoopSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_effectRadius = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_effectSparks1Sound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_effectSparks2Sound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_effectSparks3Sound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_effectSparks4Sound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_effectStartSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_effectStopSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_heart = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_shine = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_sparkles = param1.getCodec(new TypeCodecInfo(TextureResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:MammothUltimateCC = new MammothUltimateCC();
local2.active = this.codec_active.decode(param1) as Boolean;
local2.effectLoopSound = this.codec_effectLoopSound.decode(param1) as SoundResource;
local2.effectRadius = this.codec_effectRadius.decode(param1) as Number;
local2.effectSparks1Sound = this.codec_effectSparks1Sound.decode(param1) as SoundResource;
local2.effectSparks2Sound = this.codec_effectSparks2Sound.decode(param1) as SoundResource;
local2.effectSparks3Sound = this.codec_effectSparks3Sound.decode(param1) as SoundResource;
local2.effectSparks4Sound = this.codec_effectSparks4Sound.decode(param1) as SoundResource;
local2.effectStartSound = this.codec_effectStartSound.decode(param1) as SoundResource;
local2.effectStopSound = this.codec_effectStopSound.decode(param1) as SoundResource;
local2.heart = this.codec_heart.decode(param1) as TextureResource;
local2.shine = this.codec_shine.decode(param1) as TextureResource;
local2.sparkles = this.codec_sparkles.decode(param1) as TextureResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:MammothUltimateCC = MammothUltimateCC(param2);
this.codec_active.encode(param1,local3.active);
this.codec_effectLoopSound.encode(param1,local3.effectLoopSound);
this.codec_effectRadius.encode(param1,local3.effectRadius);
this.codec_effectSparks1Sound.encode(param1,local3.effectSparks1Sound);
this.codec_effectSparks2Sound.encode(param1,local3.effectSparks2Sound);
this.codec_effectSparks3Sound.encode(param1,local3.effectSparks3Sound);
this.codec_effectSparks4Sound.encode(param1,local3.effectSparks4Sound);
this.codec_effectStartSound.encode(param1,local3.effectStartSound);
this.codec_effectStopSound.encode(param1,local3.effectStopSound);
this.codec_heart.encode(param1,local3.heart);
this.codec_shine.encode(param1,local3.shine);
this.codec_sparkles.encode(param1,local3.sparkles);
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.kits.description.panel {
import alternativa.tanks.gui.shop.shopitems.item.kits.description.KitPackageDescriptionView;
import flash.display.Bitmap;
import flash.display.Shape;
import flash.display.Sprite;
public class KitPackageDescriptionPanel extends Sprite {
private var top:Bitmap;
private var topLeft:Bitmap;
private var topRight:Bitmap;
private var left:Bitmap;
private var right:Bitmap;
private var bottom:Bitmap;
private var bottomLeft:Bitmap;
private var bottomRight:Bitmap;
private var center:Bitmap;
private var backgroundFillTopPart:Shape;
private var backgroundFillBottomPart:Shape;
public function KitPackageDescriptionPanel() {
super();
this.topLeft = new Bitmap(KitPackageDescriptionPanelBitmaps.leftTopCorner);
addChild(this.topLeft);
this.top = new Bitmap(KitPackageDescriptionPanelBitmaps.topLine);
addChild(this.top);
this.topRight = new Bitmap(KitPackageDescriptionPanelBitmaps.rightTopCorner);
addChild(this.topRight);
this.left = new Bitmap(KitPackageDescriptionPanelBitmaps.leftLine);
addChild(this.left);
this.right = new Bitmap(KitPackageDescriptionPanelBitmaps.rightLine);
addChild(this.right);
this.bottom = new Bitmap(KitPackageDescriptionPanelBitmaps.bottomLine);
addChild(this.bottom);
this.bottomLeft = new Bitmap(KitPackageDescriptionPanelBitmaps.leftBottomCorner);
addChild(this.bottomLeft);
this.bottomRight = new Bitmap(KitPackageDescriptionPanelBitmaps.rightBottomCorner);
addChild(this.bottomRight);
this.center = new Bitmap(KitPackageDescriptionPanelBitmaps.centerLine);
addChild(this.center);
this.backgroundFillTopPart = new Shape();
addChild(this.backgroundFillTopPart);
this.backgroundFillBottomPart = new Shape();
addChild(this.backgroundFillBottomPart);
}
public function resize(param1:int) : void {
var local2:int = 0;
var local3:int = 0;
local2 = KitPackageDescriptionView.WIDTH;
local3 = (param1 + 2) * KitPackageDescriptionView.ITEM_HEIGHT + KitPackageDescriptionView.LEFT_TOP_MARGIN * 3 - this.topLeft.height;
this.top.x = this.topLeft.width;
this.top.width = local2 - this.topRight.width - this.topLeft.width;
this.topRight.x = local2 - this.topRight.width;
this.bottomLeft.y = local3 - this.bottomLeft.height;
this.bottomRight.x = this.topRight.x;
this.bottomRight.y = this.bottomLeft.y;
this.bottom.y = this.bottomLeft.y;
this.bottom.x = this.top.x;
this.bottom.width = this.top.width;
this.left.y = this.topLeft.height;
this.left.height = this.bottomLeft.y - this.left.y;
this.right.y = this.left.y;
this.right.x = this.topRight.x;
this.right.height = this.bottomRight.y - this.right.y;
this.center.x = 1;
this.center.y = local3 - KitPackageDescriptionView.LEFT_TOP_MARGIN * 2 - KitPackageDescriptionView.ITEM_HEIGHT + this.center.height;
this.center.width = local2 - 2;
this.fillBackgroundShape(this.backgroundFillTopPart,this.topLeft.width,this.topLeft.height,this.top.width,this.center.y - this.center.height);
this.fillBackgroundShape(this.backgroundFillBottomPart,this.topLeft.width,this.center.y + this.center.height,this.top.width,KitPackageDescriptionView.LEFT_TOP_MARGIN * 2 + KitPackageDescriptionView.ITEM_HEIGHT - this.center.height * 3);
}
private function fillBackgroundShape(param1:Shape, param2:Number, param3:Number, param4:Number, param5:Number) : void {
param1.graphics.clear();
param1.graphics.beginBitmapFill(KitPackageDescriptionPanelBitmaps.backgroundPixel);
param1.graphics.drawRect(param2,param3,param4,param5);
}
}
}
|
package alternativa.tanks.controller.events {
import flash.display.Bitmap;
import flash.events.Event;
public class CaptchaUpdatedEvent extends Event {
public static const STAND_ALONE_CAPTCHA_UPDATED:String = "CaptchaUpdatedEvent.STAND_ALONE_CAPTCHA_UPDATED";
public static const LOGIN_FORM_CAPTCHA_UPDATED:String = "CaptchaUpdatedEvent.LOGIN_FORM_CAPTCHA_UPDATED";
public static const REGISTRATION_FORM_CAPTCHA_UPDATED:String = "CaptchaUpdatedEvent.REGISTRATION_FORM_CAPTCHA_UPDATED";
public static const RESTORE_PASSWORD_FORM_CAPTCHA_UPDATED:String = "CaptchaUpdatedEvent.RESTORE_PASSWORD_FORM_CAPTCHA_UPDATED";
public static const EMAIL_CHANGE_HASH_CAPTCHA_UPDATED:String = "CaptchaUpdatedEvent.EMAIL_CHANGE_HASH_CAPTCHA_UPDATED";
private var _image:Bitmap;
public function CaptchaUpdatedEvent(param1:String, param2:Bitmap) {
super(param1);
this._image = param2;
}
public function get image() : Bitmap {
return this._image;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.map {
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.map.DynamicShadowParams;
public class VectorCodecDynamicShadowParamsLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecDynamicShadowParamsLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(DynamicShadowParams,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.<DynamicShadowParams> = new Vector.<DynamicShadowParams>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = DynamicShadowParams(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:DynamicShadowParams = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<DynamicShadowParams> = Vector.<DynamicShadowParams>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.challenges.toclient {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.shop.challenges.toclient.ChallengeShopItemsCC;
public class VectorCodecChallengeShopItemsCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecChallengeShopItemsCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ChallengeShopItemsCC,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.<ChallengeShopItemsCC> = new Vector.<ChallengeShopItemsCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ChallengeShopItemsCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ChallengeShopItemsCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ChallengeShopItemsCC> = Vector.<ChallengeShopItemsCC>(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.clients.fp10.TanksLauncherErrorScreen {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.TanksLauncherErrorScreen.TankBackground_bitmapBg.png")]
public class TankBackground_bitmapBg extends BitmapAsset {
public function TankBackground_bitmapBg() {
super();
}
}
}
|
package alternativa.tanks.sfx.christmas {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.sfx.christmas.ChristmasTreeToyEffect_OrangeTexture.png")]
public class ChristmasTreeToyEffect_OrangeTexture extends BitmapAsset {
public function ChristmasTreeToyEffect_OrangeTexture() {
super();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIcon_p1 extends BitmapAsset
{
public function RangIcon_p1()
{
super();
}
}
}
|
package alternativa.tanks.gui.icons {
import base.DiscreteSprite;
import flash.display.Bitmap;
import flash.display.BitmapData;
public class AcceptedIndicator extends DiscreteSprite {
private static var acceptedIconClass:Class = AcceptedIndicator_acceptedIconClass;
private static var acceptedIconBitmapData:BitmapData = Bitmap(new acceptedIconClass()).bitmapData;
public function AcceptedIndicator() {
super();
this.tabEnabled = this.tabChildren = false;
this.buttonMode = this.useHandCursor = true;
addChild(new Bitmap(acceptedIconBitmapData));
}
}
}
|
package alternativa.tanks.materials {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.TextureResourcesRegistry;
import alternativa.gfx.core.IndexBufferResource;
import alternativa.gfx.core.ProgramResource;
import alternativa.gfx.core.VertexBufferResource;
import flash.display.BitmapData;
import flash.utils.ByteArray;
import flash.utils.Dictionary;
import flash.utils.getTimer;
use namespace alternativa3d;
public class AnimatedPaintMaterial extends PaintMaterial {
private var programs:Dictionary = new Dictionary();
private var lastFrame:int = -1;
private var fps:int;
private var numFrames:int;
private var numFramesX:int;
private var numFramesY:int;
private var currentFrame:Number;
public var scaleX:Number;
public var scaleY:Number;
private var time:int;
private var frameWidth:Number;
private var frameHeight:Number;
public function AnimatedPaintMaterial(param1:BitmapData, param2:BitmapData, param3:BitmapData, param4:int, param5:int, param6:int, param7:int, param8:int = 0) {
super(param1,param2,param3,param8);
this.numFramesX = param4;
this.numFramesY = param5;
this.fps = param6;
this.numFrames = param7;
this.currentFrame = 0;
this.scaleX = param3.width / param1.width;
this.scaleY = param3.height / param1.height;
this.frameWidth = 1 / param4;
this.frameHeight = 1 / param5;
fragConst = Vector.<Number>([0,0.5,1,2,this.frameWidth,this.frameHeight,0,0]);
}
public function update() : void {
var local1:int = getTimer();
var local2:int = local1 - this.time;
this.time = local1;
this.currentFrame += local2 / 1000 * this.fps;
this.currentFrame %= this.numFrames;
if(this.lastFrame == this.currentFrame) {
return;
}
var local3:int = this.currentFrame % this.numFramesX;
var local4:int = this.currentFrame / this.numFramesY;
this.lastFrame = this.currentFrame;
uvTransformConst[0] = this.scaleX;
uvTransformConst[1] = 0;
uvTransformConst[2] = local3 * this.frameWidth;
uvTransformConst[3] = 0;
uvTransformConst[4] = 0;
uvTransformConst[5] = this.scaleY;
uvTransformConst[6] = local4 * this.frameHeight;
uvTransformConst[7] = 0;
fragConst[6] = uvTransformConst[2];
fragConst[7] = uvTransformConst[6];
}
override public function set mipMapping(param1:int) : void {
alternativa3d::_mipMapping = 0;
alternativa3d::textureResource = TextureResourcesRegistry.getTextureResource(bitmap,param1,repeat,alternativa3d::_hardwareMipMaps);
spriteSheetResource = TextureResourcesRegistry.getTextureResource(spriteSheetBitmap,false,true,false);
lightMapResource = TextureResourcesRegistry.getTextureResource(lightMapBitmap,param1,true,false);
}
override alternativa3d function drawOpaque(param1:Camera3D, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D) : void {
this.update();
super.alternativa3d::drawOpaque(param1,param2,param3,param4,param5,param6);
}
override alternativa3d function drawTransparent(param1:Camera3D, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D, param7:Boolean = false) : void {
super.alternativa3d::drawTransparent(param1,param2,param3,param4,param5,param6,param7);
}
override protected function getProgram(param1:Boolean, param2:Boolean, param3:Boolean, param4:Boolean, param5:Boolean, param6:Boolean, param7:Boolean, param8:Boolean, param9:Boolean, param10:Boolean, param11:Boolean, param12:Boolean, param13:Boolean, param14:Boolean, param15:Boolean, param16:Boolean, param17:Boolean, param18:Boolean, param19:Boolean, param20:Boolean, param21:Boolean, param22:Boolean) : ProgramResource {
var local25:ByteArray = null;
var local26:ByteArray = null;
var local23:int = int(param1) | int(param2) << 1 | int(param3) << 2 | int(param4) << 3 | int(param5) << 4 | int(param6) << 5 | int(param7) << 6 | int(param8) << 7 | int(param9) << 8 | int(param10) << 9 | int(param11) << 10 | int(param12) << 11 | int(param13) << 12 | int(param14) << 13 | int(param15) << 14 | int(param16) << 15 | int(param17) << 16 | int(param18) << 17 | int(param19) << 18 | int(param20) << 19 | int(param21) << 20 | int(param22) << 21;
var local24:ProgramResource = this.programs[local23];
if(local24 == null) {
local25 = new PaintVertexShader(!param22,param14 || param11 || param12 || param17,param13,param4,param14,param10,param2,param3,param3,param19).agalcode;
local26 = new AnimatedPaintFragmentShader(param6,param5,param7,param15,param21,!param1 && !param16 && !param15,param8,param9,param3,param13,param11,param12,param17,param18,param14,param10,param2,param20).agalcode;
local24 = new ProgramResource(local25,local26);
this.programs[local23] = local24;
}
return local24;
}
}
}
|
package _codec.projects.tanks.client.chat.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.chat.types.ChatMessage;
public class VectorCodecChatMessageLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecChatMessageLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ChatMessage,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.<ChatMessage> = new Vector.<ChatMessage>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ChatMessage(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ChatMessage = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ChatMessage> = Vector.<ChatMessage>(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.view.icons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.icons.BattleParamsCheckButtonIcons_droneClass.png")]
public class BattleParamsCheckButtonIcons_droneClass extends BitmapAsset {
public function BattleParamsCheckButtonIcons_droneClass() {
super();
}
}
}
|
package alternativa.utils {
import flash.utils.ByteArray;
public class LoaderUtils {
private static const SEPARATOR:String = "/";
public function LoaderUtils() {
super();
}
public static function getResourcePath(param1:ByteArray, param2:ByteArray) : String {
var local3:uint = 0;
var local4:uint = 0;
local3 = param2.readUnsignedInt();
local4 = param2.readUnsignedInt();
var local5:String = new Long(local3,local4).toOct();
return SEPARATOR + param1.readUnsignedInt().toString(8) + SEPARATOR + param1.readUnsignedShort().toString(8) + SEPARATOR + param1.readUnsignedByte().toString(8) + SEPARATOR + param1.readUnsignedByte().toString(8) + SEPARATOR + local5 + SEPARATOR;
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.kitview {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.shop.kitview.KitViewResourceCC;
public class VectorCodecKitViewResourceCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecKitViewResourceCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(KitViewResourceCC,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.<KitViewResourceCC> = new Vector.<KitViewResourceCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = KitViewResourceCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:KitViewResourceCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<KitViewResourceCC> = Vector.<KitViewResourceCC>(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.profile.rename {
public interface IAndroidRenameModelBase {
function renameFail() : void;
function renameSuccessful() : void;
}
}
|
package alternativa.tanks.model.payment.modes.sms {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.payment.modes.sms.types.Country;
public class SMSPayModeAdapt implements SMSPayMode {
private var object:IGameObject;
private var impl:SMSPayMode;
public function SMSPayModeAdapt(param1:IGameObject, param2:SMSPayMode) {
super();
this.object = param1;
this.impl = param2;
}
public function getCountries() : Vector.<Country> {
var result:Vector.<Country> = null;
try {
Model.object = this.object;
result = this.impl.getCountries();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.weapon.laser {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class LaserPointerAdapt implements LaserPointer {
private var object:IGameObject;
private var impl:LaserPointer;
public function LaserPointerAdapt(param1:IGameObject, param2:LaserPointer) {
super();
this.object = param1;
this.impl = param2;
}
public function updateDirection(param1:Vector3) : void {
var direction:Vector3 = param1;
try {
Model.object = this.object;
this.impl.updateDirection(direction);
}
finally {
Model.popObject();
}
}
public function aimAtTank(param1:Tank, param2:Vector3) : void {
var target:Tank = param1;
var localPoint:Vector3 = param2;
try {
Model.object = this.object;
this.impl.aimAtTank(target,localPoint);
}
finally {
Model.popObject();
}
}
public function hideLaser() : void {
try {
Model.object = this.object;
this.impl.hideLaser();
}
finally {
Model.popObject();
}
}
public function getLaserPointerBlueColor() : uint {
var result:uint = 0;
try {
Model.object = this.object;
result = uint(this.impl.getLaserPointerBlueColor());
}
finally {
Model.popObject();
}
return result;
}
public function getLaserPointerRedColor() : uint {
var result:uint = 0;
try {
Model.object = this.object;
result = uint(this.impl.getLaserPointerRedColor());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.service.itempropertyparams {
import alternativa.tanks.gui.ItemPropertyIcon;
import alternativa.tanks.service.itempropertyparams.aggregationmodes.UpgradeAggregationMode;
import flash.display.Bitmap;
import flash.display.BitmapData;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class ItemPropertyParams {
private var _sortIndex:int;
private var _bitmapData:BitmapData;
private var _name:String;
private var properties:Vector.<ItemProperty>;
private var aggregationMode:UpgradeAggregationMode;
private var _icon:ItemPropertyIcon;
private var multiplier:Number;
public function ItemPropertyParams(param1:int, param2:BitmapData, param3:String, param4:Vector.<ItemProperty>, param5:UpgradeAggregationMode, param6:Number, param7:BitmapData) {
super();
this._sortIndex = param1;
this._bitmapData = param2;
this._name = param3;
this.properties = param4;
this.aggregationMode = param5;
this.multiplier = param6;
this._icon = new ItemPropertyIcon(param2,param7);
}
public function get sortIndex() : int {
return this._sortIndex;
}
public function get bitmapData() : BitmapData {
return this._bitmapData;
}
public function get name() : String {
return this._name;
}
public function get icon() : ItemPropertyIcon {
return this._icon;
}
public function createBitmap() : Bitmap {
return new Bitmap(this.bitmapData);
}
public function getProperties() : Vector.<ItemProperty> {
return this.properties;
}
public function getAggregationMode() : UpgradeAggregationMode {
return this.aggregationMode;
}
public function getMultiplier() : Number {
return this.multiplier;
}
}
}
|
package alternativa.physics.collision {
import alternativa.physics.Body;
public interface BodyCollisionFilter {
function considerBodies(param1:Body, param2:Body) : Boolean;
}
}
|
package platform.client.fp10.core.resource.types {
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundLoaderContext;
import flash.media.SoundTransform;
import flash.net.URLRequest;
public class SoundEmptyWrapper extends Sound {
public function SoundEmptyWrapper() {
super();
}
override public function toString() : String {
return "[SoundEmptyWrapper]";
}
override public function play(param1:Number = 0, param2:int = 0, param3:SoundTransform = null) : SoundChannel {
return null;
}
override public function load(param1:URLRequest, param2:SoundLoaderContext = null) : void {
}
}
}
|
package alternativa.tanks.models.weapon.twins {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.sfx.LightAnimation;
import flash.media.Sound;
public class TwinsSFXData {
public var shotAnimation:TextureAnimation;
public var explosionAnimation:TextureAnimation;
public var muzzleFlashMaterial:TextureMaterial;
public var shotSound:Sound;
public var hitMarkMaterial:TextureMaterial;
public var shotLightingAnimation:LightAnimation;
public var shellLightingAnimation:LightAnimation;
public var hitLightingAnimation:LightAnimation;
public function TwinsSFXData() {
super();
}
}
}
|
package org.osflash.signals {
public interface ISignalOwner extends ISignal, IDispatcher {
function removeAll() : void;
}
}
|
package _codec.projects.tanks.client.battlefield.models.bonus.bonuslight {
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.bonus.bonuslight.BonusLightCC;
public class CodecBonusLightCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_attenuationBegin:ICodec;
private var codec_attenuationEnd:ICodec;
private var codec_intensity:ICodec;
private var codec_lightColor:ICodec;
public function CodecBonusLightCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_attenuationBegin = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_attenuationEnd = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_intensity = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_lightColor = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BonusLightCC = new BonusLightCC();
local2.attenuationBegin = this.codec_attenuationBegin.decode(param1) as Number;
local2.attenuationEnd = this.codec_attenuationEnd.decode(param1) as Number;
local2.intensity = this.codec_intensity.decode(param1) as Number;
local2.lightColor = this.codec_lightColor.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BonusLightCC = BonusLightCC(param2);
this.codec_attenuationBegin.encode(param1,local3.attenuationBegin);
this.codec_attenuationEnd.encode(param1,local3.attenuationEnd);
this.codec_intensity.encode(param1,local3.intensity);
this.codec_lightColor.encode(param1,local3.lightColor);
}
}
}
|
package projects.tanks.client.battlefield.models.user.suicide {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class SuicideModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _suicideCommandId:Long = Long.getLong(420120869,-795771890);
private var model:IModel;
public function SuicideModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
public function suicideCommand() : 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._suicideCommandId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.model.challenge
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class SpecialChallengePanel_noQuestBitmap extends BitmapAsset
{
public function SpecialChallengePanel_noQuestBitmap()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.healing {
public class IsisState {
public static const OFF:IsisState = new IsisState(0,"OFF");
public static const IDLE:IsisState = new IsisState(1,"IDLE");
public static const HEALING:IsisState = new IsisState(2,"HEALING");
public static const DAMAGING:IsisState = new IsisState(3,"DAMAGING");
private var _value:int;
private var _name:String;
public function IsisState(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<IsisState> {
var local1:Vector.<IsisState> = new Vector.<IsisState>();
local1.push(OFF);
local1.push(IDLE);
local1.push(HEALING);
local1.push(DAMAGING);
return local1;
}
public function toString() : String {
return "IsisState [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation {
public class ArtilleryElevatingBarrelCC {
private var _control:int;
private var _elevation:Number;
public function ArtilleryElevatingBarrelCC(param1:int = 0, param2:Number = 0) {
super();
this._control = param1;
this._elevation = param2;
}
public function get control() : int {
return this._control;
}
public function set control(param1:int) : void {
this._control = param1;
}
public function get elevation() : Number {
return this._elevation;
}
public function set elevation(param1:Number) : void {
this._elevation = param1;
}
public function toString() : String {
var local1:String = "ArtilleryElevatingBarrelCC [";
local1 += "control = " + this.control + " ";
local1 += "elevation = " + this.elevation + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.controls.buttons {
import flash.events.Event;
import flash.events.MouseEvent;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.text.TextLineMetrics;
import flash.ui.Mouse;
import flash.ui.MouseCursor;
import projects.tanks.clients.fp10.Prelauncher.Locale;
import projects.tanks.clients.fp10.Prelauncher.controls.LocalizedControl;
import projects.tanks.clients.fp10.Prelauncher.locales.Locales;
import projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp;
public class Button extends LocalizedControl {
private var onClick:Function;
protected var textField:TextField = new TextField();
public function Button(onClick:Function) {
super();
this.onClick = onClick;
this.scaleX = 0.71;
this.scaleY = this.scaleX;
addEventListener(Event.ADDED_TO_STAGE,this.addedToStage);
}
private function addedToStage(e:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.addedToStage);
var textFormat:TextFormat = new TextFormat();
textFormat.size = 32;
textFormat.bold = true;
textFormat.font = MakeUp.getFont(Locale.current);
this.textField.embedFonts = Locale.current.name != Locales.CN;
this.textField.defaultTextFormat = textFormat;
this.textField.autoSize = TextFieldAutoSize.CENTER;
this.textField.wordWrap = false;
this.textField.multiline = false;
this.textField.selectable = false;
addEventListener(MouseEvent.MOUSE_OVER,this.onMouseOver);
addEventListener(MouseEvent.MOUSE_OUT,this.onMouseOut);
addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
addEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
addEventListener(MouseEvent.CLICK,this.onMouseClick);
}
private function removedFromStage(e:Event) : void {
removeEventListener(Event.REMOVED_FROM_STAGE,this.removedFromStage);
addEventListener(Event.ADDED_TO_STAGE,this.addedToStage);
}
protected function textFieldToCenter() : void {
var metrics:TextLineMetrics = this.textField.getLineMetrics(0);
this.textField.x = -metrics.width >> 1;
this.textField.y = (-metrics.height >> 1) - 4;
}
private function onMouseOver(e:MouseEvent) : void {
Mouse.cursor = MouseCursor.BUTTON;
getChildAt(0).visible = false;
getChildAt(1).visible = true;
}
private function onMouseOut(e:MouseEvent) : void {
Mouse.cursor = MouseCursor.AUTO;
getChildAt(0).visible = true;
getChildAt(1).visible = false;
}
private function onMouseDown(e:MouseEvent) : void {
getChildAt(0).visible = true;
getChildAt(1).visible = false;
}
private function onMouseUp(e:MouseEvent) : void {
getChildAt(0).visible = false;
getChildAt(1).visible = true;
}
private function onMouseClick(e:MouseEvent) : void {
this.onClick.call(this,e);
}
}
}
|
package alternativa.tanks.models.tank.engine {
import projects.tanks.client.battlefield.models.tankparts.engine.EngineCC;
import projects.tanks.client.battlefield.models.tankparts.engine.EngineModelBase;
import projects.tanks.client.battlefield.models.tankparts.engine.IEngineModelBase;
[ModelInfo]
public class EngineModel extends EngineModelBase implements IEngineModelBase, Engine {
public function EngineModel() {
super();
}
public function getCC() : EngineCC {
return getInitParam();
}
}
}
|
package alternativa.tanks.gui.panel {
import alternativa.tanks.gui.panel.helpers.PlayerInfoHelper;
import controls.Label;
import flash.display.Sprite;
public class GearScoreInfo extends Sprite {
private static const OFFSET_IN_RATINGS:int = 3;
private static const TEXT_COLOR:uint = 1244928;
private static const TEXT_SIZE:uint = 11;
private static const Y_OFFSET:uint = 1;
private var ratingCode:Label = new Label();
private var ratingValue:Label = new Label();
private var previousLabel:Label;
private var score:int;
public function GearScoreInfo() {
super();
}
public function updateScore(param1:int) : void {
this.score = param1;
this.update();
}
public function update() : void {
this.clearAll();
this.addLabels(this.ratingCode,this.ratingValue,"GS: ",String(this.score));
}
protected function clearAll() : void {
this.previousLabel = null;
while(numChildren > 0) {
removeChildAt(0);
}
}
protected function addLabels(param1:Label, param2:Label, param3:String, param4:String) : void {
this.addRatingCodeLabel(param1,param3);
this.addRatingValueLabel(param2,param4);
}
private function addRatingCodeLabel(param1:Label, param2:String) : void {
param1.color = TEXT_COLOR;
param1.text = param2;
PlayerInfoHelper.setDefaultSharpnessAndThickness(param1);
if(this.previousLabel != null) {
this.updateLabelPosition(param1,this.previousLabel);
}
addChild(param1);
this.previousLabel = param1;
}
private function addRatingValueLabel(param1:Label, param2:String) : void {
param1.size = TEXT_SIZE;
param1.y = Y_OFFSET;
this.addRatingCodeLabel(param1,param2);
}
private function updateLabelPosition(param1:Label, param2:Label) : void {
param1.x = param2.x + param2.textWidth + OFFSET_IN_RATINGS;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.utils {
public class RelevantServerCalculator {
public static const MAX_RANK:int = 31;
private static const FRONT_GAP_PERCENT:Number = 0.09;
public function RelevantServerCalculator() {
super();
}
public static function getBestLocaleServer(param1:int, param2:int) : int {
return Math.round(getFloatBestServer(getCoefForCalculateServer(param1),param2));
}
public static function getFloatBestServer(param1:Number, param2:int) : Number {
var local3:Number = param1 * param2 + Math.ceil(FRONT_GAP_PERCENT * param2);
return Math.min(local3,param2);
}
public static function getCoefForCalculateServer(param1:int) : Number {
return 2 - Math.pow(param1,0.205);
}
}
}
|
package alternativa.tanks.models.weapon {
import alternativa.tanks.utils.ConstEncryptedNumber;
import alternativa.tanks.utils.EncryptedNumber;
public class WeaponConst {
private static const BASE_IMPACT_FORCE1:Number = 5000000;
public static const BASE_IMPACT_FORCE:EncryptedNumber = new ConstEncryptedNumber(BASE_IMPACT_FORCE1);
public static const DEFAULT_BARREL_INDEX:int = 0;
public function WeaponConst() {
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.effects.activationsfx {
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.effects.activationsfx.TankEffectSFXCC;
public class VectorCodecTankEffectSFXCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTankEffectSFXCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TankEffectSFXCC,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.<TankEffectSFXCC> = new Vector.<TankEffectSFXCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TankEffectSFXCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TankEffectSFXCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TankEffectSFXCC> = Vector.<TankEffectSFXCC>(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.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_bitmapPlasmaResistance_x2.png")]
public class ResistancesIcons_bitmapPlasmaResistance_x2 extends BitmapAsset {
public function ResistancesIcons_bitmapPlasmaResistance_x2() {
super();
}
}
}
|
package alternativa.tanks.models.battle.ctf {
import forms.ColorConstants;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class MessageColor {
public static const POSITIVE:uint = 65280;
public static const NEGATIVE:uint = 16776960;
public static const BLUE:uint = ColorConstants.USER_TITLE_BLUE;
public static const RED:uint = ColorConstants.USER_TITLE_RED;
public static const DEFAULT:uint = 65280;
public static const YELLOW:uint = 16776960;
public static const ORANGE:uint = 16750081;
public static const WHITE:uint = 14540253;
public function MessageColor() {
super();
}
public static function getUserNameColor(param1:BattleTeam, param2:Boolean) : uint {
if(param2) {
return MessageColor.YELLOW;
}
switch(param1) {
case BattleTeam.BLUE:
return MessageColor.BLUE;
case BattleTeam.RED:
return MessageColor.RED;
default:
return MessageColor.DEFAULT;
}
}
public static function getTextColor(param1:BattleTeam, param2:Boolean, param3:Boolean) : uint {
if(!param2) {
return MessageColor.WHITE;
}
if(param3) {
return 16777071;
}
switch(param1) {
case BattleTeam.BLUE:
return 10013694;
case BattleTeam.RED:
return 16685208;
default:
return MessageColor.DEFAULT;
}
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _e943d1cbcd51bc900c2711cd54301043797aa8b78b5b666704dcbdbf9e9bf746_flash_display_Sprite extends Sprite {
public function _e943d1cbcd51bc900c2711cd54301043797aa8b78b5b666704dcbdbf9e9bf746_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain(rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain(rest);
}
}
}
|
package alternativa.engine3d.objects {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
use namespace alternativa3d;
public class Bone extends Joint {
public var length:Number;
alternativa3d var lx:Number;
alternativa3d var ly:Number;
alternativa3d var lz:Number;
alternativa3d var ldot:Number;
public function Bone(param1:Number, param2:Number) {
super();
this.length = param1;
this.alternativa3d::distance = param2;
}
public function bindVerticesByDistance(param1:Skin) : void {
var local2:Vertex = param1.alternativa3d::vertexList;
while(local2 != null) {
this.bindVertexByDistance(local2);
local2 = local2.alternativa3d::next;
}
}
public function bindVertexByDistance(param1:Vertex) : void {
var local2:Number = param1.x - alternativa3d::md;
var local3:Number = param1.y - alternativa3d::mh;
var local4:Number = param1.z - alternativa3d::ml;
var local5:Number = local2 * this.alternativa3d::lx + local3 * this.alternativa3d::ly + local4 * this.alternativa3d::lz;
if(local5 > 0) {
if(this.alternativa3d::ldot > local5) {
local5 /= this.alternativa3d::ldot;
local2 = param1.x - alternativa3d::md - local5 * this.alternativa3d::lx;
local3 = param1.y - alternativa3d::mh - local5 * this.alternativa3d::ly;
local4 = param1.z - alternativa3d::ml - local5 * this.alternativa3d::lz;
} else {
local2 -= this.alternativa3d::lx;
local3 -= this.alternativa3d::ly;
local4 -= this.alternativa3d::lz;
}
}
bindVertex(param1,1 - Math.sqrt(local2 * local2 + local3 * local3 + local4 * local4) / alternativa3d::distance);
}
override alternativa3d function calculateBindingMatrix(param1:Object3D) : void {
super.alternativa3d::calculateBindingMatrix(param1);
this.alternativa3d::lx = alternativa3d::mc * this.length;
this.alternativa3d::ly = alternativa3d::mg * this.length;
this.alternativa3d::lz = alternativa3d::mk * this.length;
this.alternativa3d::ldot = this.alternativa3d::lx * this.alternativa3d::lx + this.alternativa3d::ly * this.alternativa3d::ly + this.alternativa3d::lz * this.alternativa3d::lz;
}
override alternativa3d function drawDebug(param1:Camera3D) : void {
var local2:Number = NaN;
var local3:Number = NaN;
var local4:Number = NaN;
var local5:Number = NaN;
var local6:Number = NaN;
if(numChildren == 0) {
local2 = alternativa3d::md * param1.alternativa3d::viewSizeX / alternativa3d::ml;
local3 = alternativa3d::mh * param1.alternativa3d::viewSizeY / alternativa3d::ml;
local4 = alternativa3d::mi * this.length + alternativa3d::ml;
local5 = (alternativa3d::ma * this.length + alternativa3d::md) * param1.alternativa3d::viewSizeX / local4;
local6 = (alternativa3d::me * this.length + alternativa3d::mh) * param1.alternativa3d::viewSizeY / local4;
if(alternativa3d::ml > 0 && local4 > 0) {
Debug.alternativa3d::drawBone(param1,local2,local3,local5,local6,10 * param1.alternativa3d::focalLength / alternativa3d::ml,39423);
}
} else {
super.alternativa3d::drawDebug(param1);
}
}
}
}
|
package alternativa.tanks.gui.newyear
{
import alternativa.engine3d.lights.OmniLight;
public class ToyLightAnimation
{
private var omni:OmniLight;
private var up:Boolean = false;
public function ToyLightAnimation(omni:OmniLight)
{
super();
this.omni = omni;
}
public function update() : void
{
if(!this.up)
{
this.omni.intensity -= 0.01;
if(this.omni.intensity <= 0)
{
this.up = true;
}
}
else
{
this.omni.intensity += 0.01;
if(this.omni.intensity >= 1)
{
this.up = false;
}
}
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_mineColorIconClass.png")]
public class HudInventoryIcon_mineColorIconClass extends BitmapAsset {
public function HudInventoryIcon_mineColorIconClass() {
super();
}
}
}
|
package com.lorentz.SVG.data.text
{
public class SVGTextToDraw
{
public var text:String;
public var parentFontSize:Number;
public var fontSize:Number;
public var fontFamily:String;
public var fontWeight:String;
public var fontStyle:String;
public var baselineShift:String;
public var color:uint = 0;
public var letterSpacing:Number = 0;
public var useEmbeddedFonts:Boolean;
public function clone():SVGTextToDraw {
var copy:SVGTextToDraw = new SVGTextToDraw();
copy.text = text;
copy.parentFontSize = parentFontSize;
copy.fontSize = fontSize;
copy.fontFamily = fontFamily;
copy.fontWeight = fontWeight;
copy.fontStyle = fontStyle;
copy.baselineShift = baselineShift;
copy.color = color;
copy.letterSpacing = letterSpacing;
copy.useEmbeddedFonts = useEmbeddedFonts;
return copy;
}
}
} |
package alternativa.tanks.gui.shop.shopitems.item.kits {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.shop.shopitems.item.kits.SpecialKitIcons_crystalClass.png")]
public class SpecialKitIcons_crystalClass extends BitmapAsset {
public function SpecialKitIcons_crystalClass() {
super();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p17 extends BitmapAsset
{
public function RangIconNormal_p17()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.gauss.state.targetselection {
public class GaussAimEventType {
public static const RESET:GaussAimEventType = new GaussAimEventType("RESET");
public static const DEACTIVATED:GaussAimEventType = new GaussAimEventType("DEACTIVATED");
public static const TARGET_LOCKED:GaussAimEventType = new GaussAimEventType("TARGET_LOCKED");
public static const TARGET_FOUND:GaussAimEventType = new GaussAimEventType("TARGET_FOUND");
public static const TARGET_LOCK_FAILED:GaussAimEventType = new GaussAimEventType("TARGET_LOCK_FAILED");
public static const TARGET_LOCK_LOST:GaussAimEventType = new GaussAimEventType("TARGET_LOCK_LOST");
private var value:String;
public function GaussAimEventType(param1:String) {
super();
this.value = param1;
}
[Obfuscation(rename="false")]
public function toString() : String {
return this.value;
}
}
}
|
package com.lorentz.SVG.display
{
import com.lorentz.SVG.display.base.SVGContainer;
public class SVGSwitch extends SVGContainer
{
public function SVGSwitch()
{
super("switch");
}
}
} |
package alternativa.tanks.model.garage.upgrade {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class FlushUpgradesAdapt implements FlushUpgrades {
private var object:IGameObject;
private var impl:FlushUpgrades;
public function FlushUpgradesAdapt(param1:IGameObject, param2:FlushUpgrades) {
super();
this.object = param1;
this.impl = param2;
}
public function flushToServer(param1:DelayUpgrades, param2:IGameObject) : void {
var delayUpgrades:DelayUpgrades = param1;
var item:IGameObject = param2;
try {
Model.object = this.object;
this.impl.flushToServer(delayUpgrades,item);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.user {
import flash.events.Event;
public class ClanUserServiceEvent extends Event {
public static const HIDE_CLAN_WINDOW:String = "ClanUserServiceEvent.HIDE_CLAN_WINDOW";
public function ClanUserServiceEvent(param1:String, param2:Boolean = false, param3:Boolean = false) {
super(param1,param2,param3);
}
}
}
|
package alternativa.resource.loaders
{
public class TextureInfo
{
public var diffuseMapFileName:String;
public var opacityMapFileName:String;
public function TextureInfo(diffuseMapFileName:String = null, opacityMapFileName:String = null)
{
super();
this.diffuseMapFileName = diffuseMapFileName;
this.opacityMapFileName = opacityMapFileName;
}
public function toString() : String
{
return "[TextureInfo diffuseMapFileName=" + this.diffuseMapFileName + ", opacityMapFileName=" + this.opacityMapFileName + "]";
}
}
}
|
package scpacker.networking
{
import flash.events.Event;
public interface INetworker
{
function connect(param1:String, param2:int) : void;
function addEventListener(param1:INetworkListener) : void;
function onConnected(param1:Event) : void;
function onDataSocket(param1:Event) : void;
function onCloseConnecting(param1:Event) : void;
function ioError(param1:Event) : void;
function securityError(param1:Event) : void;
}
}
|
package controls.base {
public class TestBase extends MainPanelBattlesButton {
public function TestBase() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.shared.shot {
[ModelInterface]
public interface WeaponReloadTimeChangedListener {
function weaponReloadTimeChanged(param1:int, param2:int) : void;
}
}
|
package scpacker.gui.en
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksIEN_coldload12 extends BitmapAsset
{
public function GTanksIEN_coldload12()
{
super();
}
}
}
|
package alternativa.tanks.help
{
import flash.utils.Timer;
public class HelperTimer extends Timer
{
private var _helper:Helper;
public function HelperTimer(delay:Number, repeatCount:int)
{
super(delay,repeatCount);
}
public function get helper() : Helper
{
return this._helper;
}
public function set helper(h:Helper) : void
{
this._helper = h;
}
}
}
|
package alternativa.tanks.models.sfx.colortransform {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ColorTransformConsumerEvents implements ColorTransformConsumer {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ColorTransformConsumerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function initColorTransform(param1:Vector.<ColorTransformEntry>) : void {
var i:int = 0;
var m:ColorTransformConsumer = null;
var entries:Vector.<ColorTransformEntry> = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ColorTransformConsumer(this.impl[i]);
m.initColorTransform(entries);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.battle.objects.tank {
public class ClientTankState {
public static const DEAD:ClientTankState = new ClientTankState("DEAD");
public static const SEMI_ACTIVE:ClientTankState = new ClientTankState("SEMI_ACTIVE");
public static const ACTIVE:ClientTankState = new ClientTankState("ACTIVE");
private var name:String;
public function ClientTankState(param1:String) {
super();
this.name = param1;
}
public function toString() : String {
return "ClientTankState." + this.name;
}
}
}
|
package projects.tanks.client.partners.impl.china.partner4399 {
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 Partner4399ModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function Partner4399ModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.angles.verticals {
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.angles.verticals.VerticalAnglesCC;
public class CodecVerticalAnglesCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_angleDown:ICodec;
private var codec_angleUp:ICodec;
public function CodecVerticalAnglesCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_angleDown = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_angleUp = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:VerticalAnglesCC = new VerticalAnglesCC();
local2.angleDown = this.codec_angleDown.decode(param1) as Number;
local2.angleUp = this.codec_angleUp.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:VerticalAnglesCC = VerticalAnglesCC(param2);
this.codec_angleDown.encode(param1,local3.angleDown);
this.codec_angleUp.encode(param1,local3.angleUp);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.friend {
import flash.events.IEventDispatcher;
import projects.tanks.clients.fp10.libraries.tanksservices.model.friends.FriendState;
public interface IFriendsInfoLabelUpdater extends IEventDispatcher {
function get state() : FriendState;
function incrementVisibleLabelsCounter() : void;
function decrementVisibleLabelsCounter() : void;
function updateLastAccessTime() : void;
}
}
|
package projects.tanks.client.panel.model.personaldiscount {
import projects.tanks.client.panel.model.garage.GarageItemInfo;
public interface IPersonalDiscountModelBase {
function showPersonalDiscount(param1:GarageItemInfo, param2:int, param3:int, param4:int) : void;
}
}
|
package projects.tanks.client.partners.impl.asiasoft {
public interface IAsiasoftLoginModelBase {
function gotoInitialUrl() : void;
function gotoUrl(param1:String) : void;
}
}
|
package alternativa.tanks.view.icons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.icons.BattleParamsCheckButtonIcons_goldBonusesClass.png")]
public class BattleParamsCheckButtonIcons_goldBonusesClass extends BitmapAsset {
public function BattleParamsCheckButtonIcons_goldBonusesClass() {
super();
}
}
}
|
package alternativa.tanks.battle.events {
public interface BattleEventListener {
function handleBattleEvent(param1:Object) : void;
}
}
|
package alternativa.tanks.models.battle.battlefield {
[ModelInterface]
public interface BattlefieldEvents {
function onBattleLoaded() : void;
}
}
|
package alternativa.tanks.models.weapons.charging {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class WeaponChargingCommunicationAdapt implements WeaponChargingCommunication {
private var object:IGameObject;
private var impl:WeaponChargingCommunication;
public function WeaponChargingCommunicationAdapt(param1:IGameObject, param2:WeaponChargingCommunication) {
super();
this.object = param1;
this.impl = param2;
}
public function startCharging(param1:int) : void {
var time:int = param1;
try {
Model.object = this.object;
this.impl.startCharging(time);
}
finally {
Model.popObject();
}
}
public function finishCharging(param1:int) : void {
var time:int = param1;
try {
Model.object = this.object;
this.impl.finishCharging(time);
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.panel.model.shop.kitpackage.view {
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 KitPackageViewModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function KitPackageViewModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.utils {
import alternativa.physics.collision.CollisionShape;
public class StaticCollisionPrimitiveValidator implements DataUnitValidator {
private var matrixValidator:Matrix4Validator;
public function StaticCollisionPrimitiveValidator(param1:CollisionShape) {
super();
this.matrixValidator = new Matrix4Validator(param1.transform);
}
public function hasIncorrectData() : Boolean {
return this.matrixValidator.isInvalid();
}
public function getType() : int {
return DataValidatorType.MAP_PHYSICS_GEOMETRY;
}
}
}
|
package alternativa.tanks.utils {
public class Task {
private var _taskSequence:TaskSequence;
public function Task() {
super();
}
public function run() : void {
}
internal function set taskSequence(param1:TaskSequence) : void {
this._taskSequence = param1;
}
final protected function completeTask() : void {
this._taskSequence.taskComplete(this);
}
}
}
|
package alternativa.tanks.gui
{
import assets.Diamond;
import controls.DefaultButton;
import flash.events.MouseEvent;
public class ReferalStatButton extends DefaultButton
{
private static var crystalIcon:Diamond = new Diamond();
private var _numCrystals:int;
private var _enable:Boolean = true;
public function ReferalStatButton()
{
super();
addChild(crystalIcon);
crystalIcon.y = 10;
}
public function set numCrystals(value:int) : void
{
this._numCrystals = value;
}
override public function set width(w:Number) : void
{
super.width = int(w);
stateDOWN.width = stateOFF.width = stateOVER.width = stateUP.width = this.width;
_label.width = this.width - 4 - crystalIcon.width;
}
override public function get width() : Number
{
return super.width;
}
override public function set label(text:String) : void
{
super.label = text;
crystalIcon.x = _label.textWidth + (_label.width - _label.textWidth) / 2 + 7;
}
override protected function onMouseEvent(event:MouseEvent) : void
{
if(this._enable)
{
switch(event.type)
{
case MouseEvent.MOUSE_OVER:
setState(2);
_label.y = 6;
crystalIcon.y = 10;
break;
case MouseEvent.MOUSE_OUT:
setState(1);
_label.y = 6;
crystalIcon.y = 10;
break;
case MouseEvent.MOUSE_DOWN:
setState(3);
_label.y = 7;
crystalIcon.y = 11;
break;
case MouseEvent.MOUSE_UP:
setState(1);
_label.y = 6;
crystalIcon.y = 10;
}
}
}
override public function set enable(flag:Boolean) : void
{
this._enable = flag;
if(this._enable)
{
addListeners();
}
else
{
removeListeners();
}
}
override public function get enable() : Boolean
{
return this._enable;
}
}
}
|
package alternativa.tanks.battle {
public interface PostPhysicsController {
function runAfterPhysicsUpdate(param1:Number) : void;
}
}
|
package alternativa.gfx.agal
{
public class SamplerFilter extends SamplerOption
{
private static const SAMPLER_FILTER_SHIFT:uint = 28;
public static const NEAREST:SamplerFilter = new SamplerFilter(0);
public static const LINEAR:SamplerFilter = new SamplerFilter(1);
public function SamplerFilter(param1:uint)
{
super(param1,SAMPLER_FILTER_SHIFT);
}
}
}
|
package fonts {
import flash.text.TextFormat;
public class TanksFontService {
private static var textFormat:TextFormat = new TextFormat("Tahoma");
private static var embedFonts:Boolean = false;
public function TanksFontService() {
super();
}
public static function getTextFormat(param1:int) : TextFormat {
return new TextFormat(textFormat.font,param1,textFormat.color,textFormat.bold,textFormat.italic,textFormat.underline,textFormat.url,textFormat.target,textFormat.align,textFormat.leftMargin,textFormat.rightMargin,textFormat.indent,textFormat.leading);
}
public static function isEmbedFonts() : Boolean {
return embedFonts;
}
public static function setTextFormat(param1:TextFormat, param2:Boolean) : void {
TanksFontService.textFormat = param1;
TanksFontService.embedFonts = param2;
}
}
}
|
package projects.tanks.client.garage.models.item.item {
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 ItemModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ItemModelServer(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.license.user {
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 LicenseClanUserModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function LicenseClanUserModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.gui {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.payment.controls.OrderingLine;
import controls.TankWindow;
import controls.TankWindowInner;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObject;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.text.TextFormat;
import flash.text.TextFormatAlign;
import forms.ColorConstants;
import projects.tanks.client.panel.model.donationalert.types.GoodInfoData;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
public class ThanksForPurchaseWindow extends DialogWindow {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var paymentDisplayService:PaymentDisplayService;
private static const WINDOW_SHADOW_OFFSET:int = 5;
private static const WIDTH:int = 270;
private static const WINDOW_MARGIN:int = 7 + WINDOW_SHADOW_OFFSET;
private static const IMAGE_MARGIN:int = 9;
private static const TEXT_INDENT:int = 33;
private var closeButton:DefaultButtonBase;
private var window:TankWindow;
private var crystalsInfoBox:TankWindowInner;
private var emailBlock:EmailBlock;
private var isEmailBlockVisible:Boolean;
public function ThanksForPurchaseWindow(param1:BitmapData, param2:Vector.<GoodInfoData>, param3:Boolean) {
var local6:TankWindowInner = null;
this.window = new TankWindow();
super();
this.isEmailBlockVisible = param3;
var local4:int = WINDOW_MARGIN * 2 + IMAGE_MARGIN * 2 + param1.width;
this.createCrystalsInfoBox(local4,param1,param2);
this.window.addChild(this.crystalsInfoBox);
this.crystalsInfoBox.x = WINDOW_MARGIN;
this.crystalsInfoBox.y = WINDOW_MARGIN;
var local5:int = this.crystalsInfoBox.y + this.crystalsInfoBox.height + 9;
if(param3) {
local6 = this.createInfoMessageBox(local4 - 2 * WINDOW_MARGIN);
this.window.addChild(local6);
local6.x = WINDOW_MARGIN;
local6.y = local5;
local5 = local6.y + local6.height + 10;
this.emailBlock = new EmailBlock(local4,WINDOW_MARGIN);
this.emailBlock.y = local5;
this.window.addChild(this.emailBlock);
local5 = this.emailBlock.y + this.emailBlock.height + 10;
}
this.closeButton = this.createCloseButton();
this.closeButton.y = local5;
this.closeButton.enable = !param3;
this.centerAlign(this.closeButton,local4);
this.window.addChild(this.closeButton);
this.window.height = this.closeButton.y + this.closeButton.height + 6 + WINDOW_SHADOW_OFFSET;
this.window.width = local4;
addChild(this.window);
}
private function createInfoMessageBox(param1:int) : TankWindowInner {
var local2:int = 0;
var local4:LabelBase = null;
local2 = 4;
var local3:int = 7;
local4 = new LabelBase();
local4.wordWrap = false;
local4.multiline = true;
local4.align = TextFormatAlign.LEFT;
local4.text = localeService.getText(TanksLocale.TEXT_THANKS_FOR_PURCHASE_INFO_ABOUT_EMAIL);
local4.size = 12;
local4.color = ColorConstants.GREEN_LABEL;
local4.selectable = false;
local4.x = TEXT_INDENT;
local4.y = local2;
var local5:TextFormat = local4.getTextFormat();
local5.leading = 3;
local4.setTextFormat(local5);
var local6:TankWindowInner = new TankWindowInner(param1,0,TankWindowInner.GREEN);
local6.addChild(local4);
local6.height = local2 + local3 + local4.height;
return local6;
}
private function createCrystalsInfoBox(param1:int, param2:BitmapData, param3:Vector.<GoodInfoData>) : void {
var local5:GoodInfoData = null;
this.crystalsInfoBox = new TankWindowInner(param1 - WINDOW_MARGIN * 2,0,TankWindowInner.GREEN);
var local4:Bitmap = new Bitmap(param2);
local4.x = (this.crystalsInfoBox.width - local4.width) / 2;
local4.y = this.crystalsInfoBox.height + WINDOW_MARGIN;
this.crystalsInfoBox.addChild(local4);
for each(local5 in param3) {
this.addNote(local5.name,local5.count);
}
this.crystalsInfoBox.height += WINDOW_MARGIN;
}
private function addNote(param1:String, param2:int) : void {
var local3:OrderingLine = null;
if(param2 > 0) {
local3 = new OrderingLine(WIDTH,param1,param2);
local3.x = TEXT_INDENT;
local3.y = this.crystalsInfoBox.height - 7;
this.crystalsInfoBox.addChild(local3);
}
}
private function createCloseButton() : DefaultButtonBase {
var local1:DefaultButtonBase = new DefaultButtonBase();
local1.label = localeService.getText(TanksLocale.TEXT_FREE_BONUSES_WINDOW_BUTTON_CLOSE_TEXT);
return local1;
}
public function addInDialogLayer() : void {
this.closeButton.addEventListener(MouseEvent.CLICK,this.onCloseButtonClick);
addEventListener(EmailBlockValidationEvent.EMAIL_VALIDATED_EVENT,this.onEmailValidationEvent);
if(paymentDisplayService.isPaymentDisplayed()) {
dialogService.addDialog(this);
} else {
dialogService.enqueueDialog(this);
}
}
private function onEmailValidationEvent(param1:EmailBlockValidationEvent) : void {
this.closeButton.enable = param1.isValid;
}
override protected function confirmationKeyPressed() : void {
if(this.closeButton.enable) {
this.onCloseButtonClick();
}
}
private function onCloseButtonClick(param1:MouseEvent = null) : void {
this.closeButton.removeEventListener(MouseEvent.CLICK,this.onCloseButtonClick);
removeEventListener(EmailBlockValidationEvent.EMAIL_VALIDATED_EVENT,this.onEmailValidationEvent);
dialogService.removeDialog(this);
dispatchEvent(new Event(Event.CANCEL));
}
public function get hasEmailBlock() : Boolean {
return this.isEmailBlockVisible;
}
public function get email() : String {
return this.emailBlock.email;
}
private function centerAlign(param1:DisplayObject, param2:Number) : void {
param1.x = (param2 - param1.width) / 2;
}
public function destroy() : void {
if(Boolean(this.emailBlock)) {
this.emailBlock.destroy();
this.emailBlock = null;
}
}
public function showEmailIsBusy(param1:String) : void {
this.emailBlock.showEmailIsBusy(param1);
}
public function showEmailIsForbidden(param1:String) : void {
this.emailBlock.showEmailIsForbidden(param1);
}
public function showEmailIsFree(param1:String) : void {
this.emailBlock.showEmailIsFree(param1);
}
}
}
|
package alternativa.tanks.service.logging {
import alternativa.osgi.OSGi;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.service.settings.SettingsServiceEvent;
import flash.events.EventDispatcher;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.settings.UserSettingsChangedEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.settings.UserSettingsChangedService;
public class UserSettingsChangedServiceImpl extends EventDispatcher implements UserSettingsChangedService {
private var settings:ISettingsService;
private const PARAM_SHOW_SKY_BOX:int = 1 << 0;
private const PARAM_SHOW_FPS:int = 1 << 1;
private const PARAM_SHOW_CHAT:int = 1 << 2;
private const PARAM_ADAPTIVE_FPS:int = 1 << 3;
private const PARAM_INVERSE_BACK_DRIVING:int = 1 << 4;
private const PARAM_BGSOUND:int = 1 << 5;
private const PARAM_MUTE_SOUND:int = 1 << 6;
private const PARAM_MIPMAPPING:int = 1 << 7;
private const PARAM_ALTERNATE_CAMERA:int = 1 << 8;
private const PARAM_SHADOWS:int = 1 << 9;
private const PARAM_SOFT_PARTICLES:int = 1 << 10;
private const PARAM_DUST:int = 1 << 11;
private const PARAM_FOG:int = 1 << 12;
private const PARAM_SSAO:int = 1 << 13;
private const PARAM_DYNAMIC_SHADOWS:int = 1 << 14;
private const PARAM_GRAPHICS_AUTO_QUALITY:int = 1 << 15;
private const PARAM_DYNAMIC_LIGHTING:int = 1 << 16;
private const PARAM_ANTIALIASING:int = 1 << 17;
private const PARAM_SHOW_DROP_ZONES:int = 1 << 18;
private const PARAM_MOUSE_CONTROL:int = 1 << 19;
public function UserSettingsChangedServiceImpl() {
super();
this.settings = ISettingsService(OSGi.getInstance().getService(ISettingsService));
this.settings.addEventListener(SettingsServiceEvent.SETTINGS_CHANGED,this.settingsAccepted);
}
private function settingsAccepted(param1:SettingsServiceEvent) : void {
var local2:int = 0;
if(this.settings.showSkyBox) {
local2 |= this.PARAM_SHOW_SKY_BOX;
}
if(this.settings.showFPS) {
local2 |= this.PARAM_SHOW_FPS;
}
if(this.settings.showChat) {
local2 |= this.PARAM_SHOW_CHAT;
}
if(this.settings.adaptiveFPS) {
local2 |= this.PARAM_ADAPTIVE_FPS;
}
if(this.settings.inverseBackDriving) {
local2 |= this.PARAM_INVERSE_BACK_DRIVING;
}
if(this.settings.bgSound) {
local2 |= this.PARAM_BGSOUND;
}
if(this.settings.muteSound) {
local2 |= this.PARAM_MUTE_SOUND;
}
if(this.settings.mipMapping) {
local2 |= this.PARAM_MIPMAPPING;
}
if(this.settings.alternateCamera) {
local2 |= this.PARAM_ALTERNATE_CAMERA;
}
if(this.settings.shadows) {
local2 |= this.PARAM_SHADOWS;
}
if(this.settings.softParticles) {
local2 |= this.PARAM_SOFT_PARTICLES;
}
if(this.settings.dust) {
local2 |= this.PARAM_DUST;
}
if(this.settings.fog) {
local2 |= this.PARAM_FOG;
}
if(this.settings.ssao) {
local2 |= this.PARAM_SSAO;
}
if(this.settings.dynamicShadows) {
local2 |= this.PARAM_DYNAMIC_SHADOWS;
}
if(this.settings.graphicsAutoQuality) {
local2 |= this.PARAM_GRAPHICS_AUTO_QUALITY;
}
if(this.settings.dynamicLighting) {
local2 |= this.PARAM_DYNAMIC_LIGHTING;
}
if(this.settings.antialiasing) {
local2 |= this.PARAM_ANTIALIASING;
}
if(this.settings.showDropZones) {
local2 |= this.PARAM_SHOW_DROP_ZONES;
}
if(this.settings.mouseControl) {
local2 |= this.PARAM_MOUSE_CONTROL;
}
dispatchEvent(new UserSettingsChangedEvent(local2));
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.pointbased {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.battle.pointbased.ClientTeamPoint;
import projects.tanks.client.battlefield.models.battle.pointbased.PointBasedBattleCC;
import projects.tanks.client.battlefield.models.battle.pointbased.flag.ClientFlag;
public class CodecPointBasedBattleCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_flags:ICodec;
private var codec_teamPoints:ICodec;
public function CodecPointBasedBattleCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_flags = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(ClientFlag,false),false,1));
this.codec_teamPoints = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(ClientTeamPoint,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:PointBasedBattleCC = new PointBasedBattleCC();
local2.flags = this.codec_flags.decode(param1) as Vector.<ClientFlag>;
local2.teamPoints = this.codec_teamPoints.decode(param1) as Vector.<ClientTeamPoint>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:PointBasedBattleCC = PointBasedBattleCC(param2);
this.codec_flags.encode(param1,local3.flags);
this.codec_teamPoints.encode(param1,local3.teamPoints);
}
}
}
|
package alternativa.tanks.models.battle.jgr.killstreak {
import alternativa.tanks.sfx.Sound3D;
public class KillStreakClientItem {
private var _messageToBoss:String;
private var _messageToVictims:String;
private var _sound:Sound3D;
public function KillStreakClientItem(param1:String, param2:String, param3:Sound3D) {
super();
this._messageToBoss = param1;
this._messageToVictims = param2;
this._sound = param3;
}
public function get messageToBoss() : String {
return this._messageToBoss;
}
public function set messageToBoss(param1:String) : void {
this._messageToBoss = param1;
}
public function get messageToVictims() : String {
return this._messageToVictims;
}
public function set messageToVictims(param1:String) : void {
this._messageToVictims = param1;
}
public function get sound() : Sound3D {
return this._sound;
}
public function set sound(param1:Sound3D) : void {
this._sound = param1;
}
}
}
|
package alternativa.tanks.models.weapons.charging {
public class DummyWeaponChargingCommunication implements WeaponChargingCommunication {
public static var INSTANCE:DummyWeaponChargingCommunication = new DummyWeaponChargingCommunication();
public function DummyWeaponChargingCommunication() {
super();
}
public function startCharging(param1:int) : void {
}
public function finishCharging(param1:int) : void {
}
}
}
|
package alternativa.tanks.gui.notinclan.clanslist {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.components.indicators.NewClanItemIndicator;
import alternativa.tanks.gui.notinclan.dialogs.ClanDialog;
import alternativa.tanks.models.user.IClanUserModel;
import alternativa.types.Long;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
import flash.utils.clearInterval;
import flash.utils.setInterval;
import forms.ColorConstants;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class UserIncomingRequestLabel extends ClanInfoLabel {
[Inject]
public static var localeService:ILocaleService;
private var acceptIndicator:AcceptIndicator = new AcceptIndicator();
public var newIndicator:NewClanItemIndicator;
private var restrictionTime:int;
private var restrictionInterval:uint = 0;
public function UserIncomingRequestLabel(param1:Long) {
this.newIndicator = this.createNewIndicator(param1);
super(param1);
}
override protected function onModelInfoLoaded(param1:Event = null) : void {
super.onModelInfoLoaded();
this.acceptIndicator.visible = false;
this.acceptIndicator.addEventListener(MouseEvent.CLICK,this.onAccept);
addChild(this.acceptIndicator);
this.newIndicator.updateNotifications();
if(param1 != null) {
this.newIndicator.visible = true;
}
addChild(this.newIndicator);
onRollOut();
this.initRestrictionTime();
}
public function initRestrictionTime() : void {
this.restrictionTime = clanUserInfoService.restrictionTime;
if(this.restrictionTime > 0 && this.restrictionInterval == 0) {
this.restrictionInterval = setInterval(this.restrictionCountDown,this.restrictionTime * 1000);
}
}
private function restrictionCountDown() : void {
clearInterval(this.restrictionInterval);
this.restrictionInterval = 0;
this.restrictionTime = 0;
}
override public function resize() : void {
super.resize();
this.newIndicator.x = width - 3 * ClanDialog.MARGIN - this.newIndicator.width + 2;
this.acceptIndicator.x = cancelIndicator.x - this.acceptIndicator.width - 3;
this.acceptIndicator.y = cancelIndicator.y;
}
private function createNewIndicator(param1:Long) : NewClanItemIndicator {
var local2:NewClanItemIndicator = new NewClanItemIndicator(param1);
local2.autoSize = TextFieldAutoSize.LEFT;
local2.align = TextFormatAlign.LEFT;
local2.color = ColorConstants.GREEN_LABEL;
local2.text = localeService.getText(TanksLocale.TEXT_FRIENDS_NEW);
local2.mouseEnabled = false;
return local2;
}
override public function showIndicators() : void {
super.showIndicators();
if(this.acceptIndicator != null && this.restrictionTime <= 0) {
this.acceptIndicator.visible = true;
}
}
override public function hideIndicators() : void {
super.hideIndicators();
if(this.acceptIndicator != null) {
this.acceptIndicator.visible = false;
}
}
private function onAccept(param1:MouseEvent) : void {
this.acceptIndicator.visible = false;
var local2:IGameObject = clanUserService.getObjectById(clanId);
(clanUserService.userObject.adapt(IClanUserModel) as IClanUserModel).acceptRequest(local2);
}
override protected function onCancelClick(param1:MouseEvent) : void {
cancelIndicator.visible = false;
var local2:IGameObject = clanUserService.getObjectById(clanId);
(clanUserService.userObject.adapt(IClanUserModel) as IClanUserModel).reject(local2);
}
}
}
|
package projects.tanks.client.tanksservices.model.notifier.online {
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 OnlineNotifierModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function OnlineNotifierModelServer(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 forms.registration.bubbles {
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.BubbleHelper;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperAlign;
public class NameIsNotUniqueBubble extends BubbleHelper {
[Inject]
public static var localeService:ILocaleService;
public function NameIsNotUniqueBubble() {
super();
text = localeService.getText(TanksLocale.TEXT_HELP_NAME_IS_NOT_UNIQUE);
arrowLehgth = 20;
arrowAlign = HelperAlign.TOP_LEFT;
_showLimit = 3;
}
}
}
|
package alternativa.tanks.models.battle.commonflag {
import alternativa.tanks.battle.objects.tank.Tank;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class FlagNotificationAdapt implements FlagNotification {
private var object:IGameObject;
private var impl:FlagNotification;
public function FlagNotificationAdapt(param1:IGameObject, param2:FlagNotification) {
super();
this.object = param1;
this.impl = param2;
}
public function guiShowFlagDropped(param1:CommonFlag) : void {
var flag:CommonFlag = param1;
try {
Model.object = this.object;
this.impl.guiShowFlagDropped(flag);
}
finally {
Model.popObject();
}
}
public function guiShowFlagCarried(param1:CommonFlag) : void {
var flag:CommonFlag = param1;
try {
Model.object = this.object;
this.impl.guiShowFlagCarried(flag);
}
finally {
Model.popObject();
}
}
public function guiShowFlagAtBase(param1:CommonFlag) : void {
var flag:CommonFlag = param1;
try {
Model.object = this.object;
this.impl.guiShowFlagAtBase(flag);
}
finally {
Model.popObject();
}
}
public function notifyFlagTaken(param1:CommonFlag, param2:Tank) : void {
var flag:CommonFlag = param1;
var carrier:Tank = param2;
try {
Model.object = this.object;
this.impl.notifyFlagTaken(flag,carrier);
}
finally {
Model.popObject();
}
}
public function notifyFlagReturned(param1:CommonFlag, param2:IGameObject) : void {
var flag:CommonFlag = param1;
var user:IGameObject = param2;
try {
Model.object = this.object;
this.impl.notifyFlagReturned(flag,user);
}
finally {
Model.popObject();
}
}
public function notifyFlagDropped(param1:CommonFlag) : void {
var flag:CommonFlag = param1;
try {
Model.object = this.object;
this.impl.notifyFlagDropped(flag);
}
finally {
Model.popObject();
}
}
public function notifyFlagThrown(param1:CommonFlag) : void {
var flag:CommonFlag = param1;
try {
Model.object = this.object;
this.impl.notifyFlagThrown(flag);
}
finally {
Model.popObject();
}
}
public function notifyFlagDelivered(param1:CommonFlag, param2:Tank) : void {
var flag:CommonFlag = param1;
var deliverer:Tank = param2;
try {
Model.object = this.object;
this.impl.notifyFlagDelivered(flag,deliverer);
}
finally {
Model.popObject();
}
}
public function notifyFlagFacedOff(param1:CommonFlag) : void {
var flag:CommonFlag = param1;
try {
Model.object = this.object;
this.impl.notifyFlagFacedOff(flag);
}
finally {
Model.popObject();
}
}
public function notifyReadyToFaceOff() : void {
try {
Model.object = this.object;
this.impl.notifyReadyToFaceOff();
}
finally {
Model.popObject();
}
}
}
}
|
package platform.client.fp10.core.resource.types {
import alternativa.osgi.service.locale.ILocaleService;
import platform.client.fp10.core.resource.ResourceInfo;
public class LocalizedImageResource extends ImageResource {
[Inject]
public static var localeService:ILocaleService;
public function LocalizedImageResource(param1:ResourceInfo) {
super(param1);
}
override protected function getImageFileName() : String {
return localeService.language.toLowerCase() + ".tnk";
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.armor.chassis.tracked {
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.armor.chassis.tracked.TrackedChassisCC;
public class CodecTrackedChassisCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_damping:ICodec;
public function CodecTrackedChassisCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_damping = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:TrackedChassisCC = new TrackedChassisCC();
local2.damping = this.codec_damping.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:TrackedChassisCC = TrackedChassisCC(param2);
this.codec_damping.encode(param1,local3.damping);
}
}
}
|
package alternativa.physics.collision {
import alternativa.physics.ShapeContact;
public interface Collider {
function getContacts(param1:CollisionShape, param2:CollisionShape, param3:Vector.<ShapeContact>) : void;
function haveCollision(param1:CollisionShape, param2:CollisionShape) : Boolean;
}
}
|
package alternativa.tanks.view.events {
import flash.events.Event;
public class SendChangeUidEvent extends Event {
public static const EVENT_TYPE:String = "SendChangeUidEvent.EVENT_TYPE";
private var _uid:String;
public function SendChangeUidEvent(param1:String) {
super(EVENT_TYPE);
this._uid = param1;
}
public function get uid() : String {
return this._uid;
}
override public function clone() : Event {
return new SendChangeUidEvent(this._uid);
}
}
}
|
package projects.tanks.client.panel.model.shop.androidspecialoffer.offers.purchaseofupgrades {
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 AndroidPurchaseOfUpgradesModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function AndroidPurchaseOfUpgradesModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.service.clan {
import alternativa.types.Long;
import flash.events.Event;
public class ClanMembersListEvent extends Event {
public static const REMOVE_USER:String = "ClanMembersListEvent.REMOVE_USER";
public static const ACCEPTED_USER:String = "ClanMembersListEvent.ACCEPTED_USER";
public static const REJECT_USER:String = "ClanMembersListEvent.REJECT_USER";
public static const REVOKE_USER:String = "ClanMembersListEvent.REVOKE_USER";
public var userId:Long;
public var userUid:String;
public function ClanMembersListEvent(param1:String, param2:Long, param3:String = "", param4:Boolean = false, param5:Boolean = false) {
super(param1,param4,param5);
this.userId = param2;
this.userUid = param3;
}
}
}
|
package alternativa.tanks.gui.friends {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
public class FriendActionIndicator extends Sprite {
private static var yesIconClass:Class = FriendActionIndicator_yesIconClass;
private static var yesIconBitmapData:BitmapData = Bitmap(new yesIconClass()).bitmapData;
private static var noIconClass:Class = FriendActionIndicator_noIconClass;
private static var noIconBitmapData:BitmapData = Bitmap(new noIconClass()).bitmapData;
public static const YES:int = 0;
public static const NO:int = 1;
public function FriendActionIndicator(param1:int) {
var local2:Bitmap = null;
super();
this.tabChildren = false;
this.tabEnabled = false;
this.buttonMode = this.useHandCursor = true;
switch(param1) {
case YES:
local2 = new Bitmap(yesIconBitmapData);
break;
case NO:
local2 = new Bitmap(noIconBitmapData);
}
addChild(local2);
}
}
}
|
package alternativa.tanks.models.weapon.splash {
import alternativa.tanks.utils.EncryptedNumber;
import alternativa.tanks.utils.EncryptedNumberImpl;
public class SplashParams {
private var maxSplashDamageRadius:EncryptedNumber;
private var minSplashDamageRadius:EncryptedNumber;
private var minSplashDamagePercent:EncryptedNumber;
private var maxSplashImpactForce:EncryptedNumber;
public function SplashParams(param1:Number, param2:Number, param3:Number, param4:Number) {
super();
this.maxSplashDamageRadius = new EncryptedNumberImpl(param1);
this.minSplashDamageRadius = new EncryptedNumberImpl(param2);
this.minSplashDamagePercent = new EncryptedNumberImpl(param3);
this.maxSplashImpactForce = new EncryptedNumberImpl(param4);
}
public function getSplashRadius() : Number {
return this.minSplashDamageRadius.getNumber();
}
public function getImpactForce(param1:Number) : Number {
return this.maxSplashImpactForce.getNumber() * this.getSplashImpactCoeff(param1);
}
private function getSplashImpactCoeff(param1:Number) : Number {
var local2:Number = Number(this.maxSplashDamageRadius.getNumber());
var local3:Number = Number(this.minSplashDamageRadius.getNumber());
var local4:Number = Number(this.minSplashDamagePercent.getNumber());
if(param1 < local2) {
return 1;
}
if(param1 > local3) {
return 0.1 * local4;
}
return 0.01 * (local4 + (local3 - param1) * (100 - local4) / (local3 - local2));
}
}
}
|
package alternativa.tanks.camera.controllers.spectator {
import alternativa.math.Vector3;
import alternativa.osgi.service.console.variables.ConsoleVarFloat;
import alternativa.tanks.camera.GameCamera;
internal class WalkMovement implements MovementMethod {
private static const direction:Vector3 = new Vector3();
private static const localDirection:Vector3 = new Vector3();
private var _accelerationInverted:Boolean = false;
private var conSpeed:ConsoleVarFloat;
private var conAcceleration:ConsoleVarFloat;
private var conDeceleration:ConsoleVarFloat;
public function WalkMovement(param1:ConsoleVarFloat, param2:ConsoleVarFloat, param3:ConsoleVarFloat) {
super();
this.conSpeed = param1;
this.conAcceleration = param2;
this.conDeceleration = param3;
}
public function getDisplacement(param1:UserInput, param2:GameCamera, param3:Number) : Vector3 {
localDirection.y = param1.getForwardDirection();
localDirection.x = param1.getSideDirection();
var local4:Number = Math.cos(param2.rotationZ);
var local5:Number = Math.sin(param2.rotationZ);
direction.x = localDirection.x * local4 - localDirection.y * local5;
direction.y = localDirection.x * local5 + localDirection.y * local4;
direction.z = param1.getVerticalDirection();
if(direction.lengthSqr() > 0) {
direction.normalize();
}
if(param1.isAccelerated()) {
if(this._accelerationInverted) {
direction.scale(this.conSpeed.value * this.conDeceleration.value * param3);
} else {
direction.scale(this.conSpeed.value * this.conAcceleration.value * param3);
}
} else {
direction.scale(this.conSpeed.value * param3);
}
return direction;
}
public function invertAcceleration() : void {
this._accelerationInverted = !this._accelerationInverted;
}
public function accelerationInverted() : Boolean {
return this._accelerationInverted;
}
public function setAccelerationInverted(param1:Boolean) : void {
this._accelerationInverted = param1;
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_cooldownGoldClass.png")]
public class ItemInfoPanelBitmaps_cooldownGoldClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_cooldownGoldClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.description {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.shop.description.ShopItemAdditionalDescriptionCC;
public class CodecShopItemAdditionalDescriptionCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_additionalDescription:ICodec;
public function CodecShopItemAdditionalDescriptionCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_additionalDescription = param1.getCodec(new TypeCodecInfo(String,true));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ShopItemAdditionalDescriptionCC = new ShopItemAdditionalDescriptionCC();
local2.additionalDescription = this.codec_additionalDescription.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ShopItemAdditionalDescriptionCC = ShopItemAdditionalDescriptionCC(param2);
this.codec_additionalDescription.encode(param1,local3.additionalDescription);
}
}
}
|
package alternativa.tanks.model.challenge
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChallengesIcons_winCryTypeBitmap extends BitmapAsset
{
public function ChallengesIcons_winCryTypeBitmap()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.presents {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class NewPresentsShowingModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _showPresentsId:Long = Long.getLong(914895541,882746119);
private var model:IModel;
public function NewPresentsShowingModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
public function showPresents() : 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._showPresentsId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.models.battlefield
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Graphics;
import flash.geom.Matrix;
public class ViewportBorder
{
[Embed(source="1010.png")]
private static var bmpClassCorner1:Class;
private static var bmdCorner1:BitmapData = Bitmap(new bmpClassCorner1()).bitmapData;
[Embed(source="1009.png")]
private static var bmpClassCorner2:Class;
private static var bmdCorner2:BitmapData = Bitmap(new bmpClassCorner2()).bitmapData;
[Embed(source="1012.png")]
private static var bmpClassCorner3:Class;
private static var bmdCorner3:BitmapData = Bitmap(new bmpClassCorner3()).bitmapData;
[Embed(source="1011.png")]
private static var bmpClassCorner4:Class;
private static var bmdCorner4:BitmapData = Bitmap(new bmpClassCorner4()).bitmapData;
[Embed(source="883.png")]
private static var bmpClassBorderLeft:Class;
private static var bmdBorderLeft:BitmapData = Bitmap(new bmpClassBorderLeft()).bitmapData;
[Embed(source="986.png")]
private static var bmpClassBorderRight:Class;
private static var bmdBorderRight:BitmapData = Bitmap(new bmpClassBorderRight()).bitmapData;
[Embed(source="796.png")]
private static var bmpClassBorderTop:Class;
private static var bmdBorderTop:BitmapData = Bitmap(new bmpClassBorderTop()).bitmapData;
[Embed(source="1201.png")]
private static var bmpClassBorderBottom:Class;
private static var bmdBorderBottom:BitmapData = Bitmap(new bmpClassBorderBottom()).bitmapData;
public function ViewportBorder()
{
super();
}
public function draw(g:Graphics, w:int, h:int) : void
{
this.fillBorderRect(g,bmdCorner1,4 - bmdCorner1.width,4 - bmdCorner1.height,bmdCorner1.width,bmdCorner1.height);
this.fillBorderRect(g,bmdCorner2,w - 4,4 - bmdCorner2.height,bmdCorner2.width,bmdCorner2.height);
this.fillBorderRect(g,bmdCorner3,4 - bmdCorner3.width,h - 4,bmdCorner3.width,bmdCorner3.height);
this.fillBorderRect(g,bmdCorner4,w - 4,h - 4,bmdCorner4.width,bmdCorner4.height);
this.fillBorderRect(g,bmdBorderTop,4,4 - bmdBorderTop.height,w - 2 * 4,bmdBorderTop.height);
this.fillBorderRect(g,bmdBorderBottom,4,h - 4,w - 2 * 4,bmdBorderBottom.height);
this.fillBorderRect(g,bmdBorderLeft,4 - bmdBorderLeft.width,4,bmdBorderLeft.width,h - 2 * 4);
this.fillBorderRect(g,bmdBorderRight,w - 4,4,bmdBorderRight.width,h - 2 * 4);
}
private function fillBorderRect(g:Graphics, bitmap:BitmapData, x:int, y:int, w:int, h:int) : void
{
var m:Matrix = new Matrix();
m.tx = x;
m.ty = y;
g.beginBitmapFill(bitmap,m);
g.drawRect(x,y,w,h);
g.endFill();
}
}
}
|
package forms.battlelist
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ViewBattleList_tdm extends BitmapAsset
{
public function ViewBattleList_tdm()
{
super();
}
}
}
|
package alternativa.tanks.model.info.param {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleselect.model.battle.param.BattleParamInfoCC;
public class BattleParamsEvents implements BattleParams {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function BattleParamsEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getConstructor() : BattleParamInfoCC {
var result:BattleParamInfoCC = null;
var i:int = 0;
var m:BattleParams = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattleParams(this.impl[i]);
result = m.getConstructor();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.weapon.railgun
{
import alternativa.math.Vector3;
public class RailgunShotResult
{
public var targets:Array;
public var hitPoints:Array;
public var dir:Vector3;
public function RailgunShotResult()
{
this.targets = [];
this.hitPoints = [];
this.dir = new Vector3();
super();
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.types.ItemGarageProperty;
public class ModuleResistancesEvents implements ModuleResistances {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ModuleResistancesEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getResistances() : Vector.<ItemGarageProperty> {
var result:Vector.<ItemGarageProperty> = null;
var i:int = 0;
var m:ModuleResistances = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ModuleResistances(this.impl[i]);
result = m.getResistances();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.