code
stringlengths 57
237k
|
|---|
package projects.tanks.client.partners.impl.miniplay {
public interface IMiniplayLoginModelBase {
}
}
|
package alternativa.tanks.sfx {
public class EffectsPair {
public var graphicEffect:GraphicEffect;
public var soundEffect:ISound3DEffect;
public function EffectsPair(param1:GraphicEffect, param2:ISound3DEffect) {
super();
this.graphicEffect = param1;
this.soundEffect = param2;
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.base {
import alternativa.tanks.gui.shop.components.item.GridItemBase;
import flash.display.Bitmap;
import flash.events.MouseEvent;
public class ShopButton extends GridItemBase {
private static const salesIconClass:Class = ShopButton_salesIconClass;
private static const DOWN_PIXELS:int = 1;
protected var salesIcon:Bitmap = new Bitmap(new salesIconClass().bitmapData);
protected var normalState:Bitmap;
protected var overState:Bitmap;
protected var previousY:int;
public function ShopButton(param1:ButtonItemSkin) {
super();
this.initAndAppendSkin(param1);
this.init();
}
private function initAndAppendSkin(param1:ButtonItemSkin) : void {
this.normalState = new Bitmap(param1.normalState);
this.overState = new Bitmap(param1.overState);
addChildAt(this.normalState,0);
addChildAt(this.overState,1);
this.overState.visible = false;
}
protected function init() : void {
buttonMode = true;
addEventListener(MouseEvent.MOUSE_OVER,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_OUT,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_UP,this.onMouseEvent);
}
public function setSkin(param1:ButtonItemSkin) : void {
removeChild(this.normalState);
removeChild(this.overState);
this.initAndAppendSkin(param1);
}
protected function onMouseEvent(param1:MouseEvent) : void {
this.overState.visible = param1.type == MouseEvent.MOUSE_OVER;
this.normalState.visible = !this.overState.visible;
switch(param1.type) {
case MouseEvent.MOUSE_OVER:
this.previousY = y;
break;
case MouseEvent.MOUSE_OUT:
y = this.previousY;
break;
case MouseEvent.MOUSE_UP:
y = this.previousY;
break;
case MouseEvent.MOUSE_DOWN:
y = this.previousY + DOWN_PIXELS;
}
}
override public function destroy() : void {
this.removeEvents();
}
protected function removeEvents() : void {
removeEventListener(MouseEvent.MOUSE_OVER,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_OUT,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_UP,this.onMouseEvent);
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.challenges.battlepass {
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.battlepass.BattlePassPackageCC;
public class VectorCodecBattlePassPackageCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattlePassPackageCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BattlePassPackageCC,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.<BattlePassPackageCC> = new Vector.<BattlePassPackageCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattlePassPackageCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattlePassPackageCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattlePassPackageCC> = Vector.<BattlePassPackageCC>(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.payment.modes.sms.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.panel.model.payment.modes.sms.types.Country;
public class VectorCodecCountryLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecCountryLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(Country,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.<Country> = new Vector.<Country>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = Country(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:Country = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<Country> = Vector.<Country>(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.entrance.model.entrance.google {
public interface IGoogleEntranceModelBase {
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.rocketlauncher.Rocket;
import alternativa.tanks.models.weapon.rocketlauncher.RocketLauncherObject;
import alternativa.tanks.models.weapon.rocketlauncher.radio.RocketExplodeEvent;
import alternativa.tanks.models.weapon.rocketlauncher.radio.RocketExplosion;
import alternativa.tanks.models.weapon.rocketlauncher.sfx.RocketLauncherEffects;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.RocketLauncherPriorityCalculator;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.RocketTargetPoint;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.SalvoShotState;
import alternativa.tanks.models.weapons.common.CommonLocalWeapon;
import alternativa.tanks.models.weapons.targeting.TargetingResult;
import alternativa.tanks.models.weapons.targeting.TargetingSystem;
import alternativa.tanks.models.weapons.targeting.direction.sector.SectorDirectionCalculator;
import alternativa.tanks.models.weapons.targeting.priority.TargetingPriorityCalculator;
import alternativa.tanks.models.weapons.targeting.processor.SingleTargetDirectionProcessor;
import flash.utils.getTimer;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher.RocketLauncherCC;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class RocketLauncherWeapon extends CommonLocalWeapon implements IRocketLauncherWeapon {
[Inject]
public static var battleService:BattleService;
private static var shotId:int;
private static const allGunParams:AllGlobalGunParams = new AllGlobalGunParams();
private static const shotDirection:Vector3 = new Vector3();
private var reloadingEndTime:int;
private var reloadingDuration:int;
private var currentBarrelIndex:int;
private var needReleaseTrigger:Boolean;
private var buffed:Boolean;
private var target:RocketTargetPoint;
private var targetingSystem:TargetingSystem;
private var weaponObject:RocketLauncherObject;
private var effects:RocketLauncherEffects;
private var rocketLauncherParams:RocketLauncherCC;
private var simpleShotState:SimpleShotState;
private var salvoShotState:SalvoShotState;
private var buffedShotState:BuffedShotState;
private var currentState:RocketLauncherWeaponState;
private var recoilForce:Number;
private var stunned:Boolean;
private var stunnedStatus:Number;
public function RocketLauncherWeapon(param1:IGameObject, param2:RocketLauncherObject, param3:RocketLauncherCC) {
super(true);
this.weaponObject = param2;
this.rocketLauncherParams = param3;
this.target = new RocketTargetPoint();
var local4:Number = param3.shotRange;
var local5:RocketLauncherPriorityCalculator = new RocketLauncherPriorityCalculator(param2,this.target,local4);
var local6:TargetingPriorityCalculator = new TargetingPriorityCalculator(local5);
this.targetingSystem = new TargetingSystem(new SectorDirectionCalculator(param1,param2,local4,local6),new SingleTargetDirectionProcessor(param1,local4),local6);
this.targetingSystem.getProcessor().setShotFromMuzzle();
this.reset();
}
override public function init(param1:WeaponPlatform) : void {
super.init(param1);
this.effects = new RocketLauncherEffects(this.weaponObject.getSfxData(),param1.getTurret3D());
this.simpleShotState = new SimpleShotState(this,this.weaponObject);
this.buffedShotState = new BuffedShotState(this,this.weaponObject);
this.salvoShotState = new SalvoShotState(this,getWeaponPlatform(),this.weaponObject,this.rocketLauncherParams);
this.currentState = this.simpleShotState;
this.recoilForce = this.weaponObject.commonData().getRecoilForce();
}
override public function getStatus() : Number {
return this.currentState.getStatus();
}
override protected function start(param1:int) : void {
super.start(param1);
this.currentState.start(param1);
}
override protected function stop(param1:int, param2:Boolean) : void {
this.currentState.stop(param1);
super.stop(param1,param2);
}
override public function releaseTrigger() : void {
this.needReleaseTrigger = true;
}
override public function runLogic(param1:int, param2:int) : void {
if(this.needReleaseTrigger) {
this.needReleaseTrigger = false;
super.releaseTrigger();
}
this.currentState.update(param1);
}
public function simpleShoot(param1:int) : void {
getWeaponPlatform().getAllGunParams(allGunParams,this.currentBarrelIndex);
shotDirection.copy(allGunParams.direction);
this.target.resetTarget();
this.shoot(param1);
}
public function salvoShoot(param1:int, param2:Number) : void {
getWeaponPlatform().getAllGunParams(allGunParams,this.currentBarrelIndex);
var local3:Vector3 = BattleUtils.tmpVector;
local3.cross2(allGunParams.elevationAxis,allGunParams.direction).normalize();
var local4:Number = Math.sqrt(1 - param2 * param2);
shotDirection.copy(local3).scale(param2).addScaled(local4,allGunParams.direction);
this.shoot(param1);
}
private function shoot(param1:int) : void {
this.reload(param1,this.currentState.getReloadTime());
var local2:WeaponPlatform = getWeaponPlatform();
var local3:Body = local2.getBody();
if(BattleUtils.isTurretAboveGround(local3,allGunParams)) {
this.doRealShot(param1);
} else {
this.weaponObject.shellCommunication().tryToDummyShoot(param1,this.currentBarrelIndex);
}
this.createShotEffects();
this.currentBarrelIndex = (this.currentBarrelIndex + 1) % local2.getNumberOfBarrels();
}
private function reload(param1:int, param2:int) : void {
this.reloadingDuration = param2;
this.reloadingEndTime = param1 + param2;
}
private function createShotEffects() : void {
var local1:WeaponPlatform = getWeaponPlatform();
local1.getBody().addWorldForceScaled(allGunParams.muzzlePosition,allGunParams.direction,-this.recoilForce);
local1.addDust();
this.effects.playShotEffect(allGunParams.muzzlePosition,this.currentBarrelIndex);
}
private function doRealShot(param1:int) : void {
if(this.target.hasTarget()) {
this.weaponObject.shellCommunication().tryToShootWithTarget(param1,this.currentBarrelIndex,shotId,shotDirection,this.target.getTank(),this.target.getLocalPoint());
} else {
this.calculateShotDirectionIfNeed();
this.weaponObject.shellCommunication().tryToShoot(param1,this.currentBarrelIndex,shotId,shotDirection);
}
var local2:Rocket = Rocket(battleService.getObjectPool().getObject(Rocket));
local2.init(this.rocketLauncherParams,this.weaponObject,this.target,this.currentBarrelIndex,this.effects,RocketExplodeEvent.ALL);
local2.addToGame(allGunParams,shotDirection,getWeaponPlatform().getBody(),false,shotId++);
}
private function calculateShotDirectionIfNeed() : void {
var local1:TargetingResult = null;
if(!BattleUtils.barrelCollidesWithStatic(allGunParams)) {
local1 = this.targetingSystem.target(allGunParams);
shotDirection.copy(local1.getDirection());
}
}
public function canExplodeRockets() : Boolean {
return this.weaponObject.getObject().hasModel(RocketExplosion);
}
public function explodeRockets() : void {
this.weaponObject.dispatchEvent(new RocketExplodeEvent(RocketExplodeEvent.ALL));
}
public function switchToSalvoState(param1:int) : void {
this.currentState = this.salvoShotState;
this.salvoShotState.start(param1);
}
public function switchToBuffedState(param1:int) : void {
this.currentState = this.buffedShotState;
this.buffedShotState.start(param1);
}
public function isBuffed() : Boolean {
return this.buffed;
}
public function onEndingOfSalvo(param1:int) : void {
this.currentState = this.simpleShotState;
}
public function getReloadingEndTime() : int {
return this.reloadingEndTime;
}
public function getReloadingDuration() : int {
return this.reloadingDuration;
}
public function canShoot(param1:int) : Boolean {
return isShooting() && param1 >= this.reloadingEndTime && !this.stunned;
}
override public function reset() : void {
super.reset();
this.target.resetTarget();
this.reloadingEndTime = getTimer();
this.currentBarrelIndex = 0;
this.currentState = this.simpleShotState;
}
public function setBuffState(param1:Boolean) : void {
this.buffed = param1;
}
override public function disable(param1:Boolean) : void {
super.disable(param1);
this.target.resetTarget();
if(!this.stunned) {
this.currentState = this.simpleShotState;
}
}
override public function enable() : void {
super.enable();
if(this.buffed) {
this.currentState = this.buffedShotState;
}
}
override public function destroy() : void {
super.destroy();
this.simpleShotState.close();
this.simpleShotState = null;
this.salvoShotState.close();
this.salvoShotState = null;
this.buffedShotState.close();
this.buffedShotState = null;
this.target = null;
this.targetingSystem = null;
this.weaponObject = null;
this.rocketLauncherParams = null;
this.currentState = null;
}
override public function getResistanceProperty() : ItemProperty {
return ItemProperty.ROCKET_LAUNCHER_RESISTANCE;
}
public function getTargetingSystem() : TargetingSystem {
return this.targetingSystem;
}
public function getTarget() : RocketTargetPoint {
return this.target;
}
public function getEffects() : RocketLauncherEffects {
return this.effects;
}
override public function updateRecoilForce(param1:Number) : void {
this.recoilForce = param1;
}
override public function weaponReloadTimeChanged(param1:int, param2:int) : void {
this.reloadingEndTime += param2 - param1;
}
override public function fullyRecharge() : void {
this.reloadingEndTime = 0;
this.stunnedStatus = 1;
}
override public function stun() : void {
var local1:int = int(battleService.getPhysicsTime());
var local2:* = this.currentState == this.salvoShotState && !this.salvoShotState.salvoStarted(local1);
this.stunnedStatus = local2 ? 1 : this.getStatus();
this.currentState.weaponStunned(local1);
this.currentState = this.simpleShotState;
this.stunned = true;
}
override public function calm(param1:int) : void {
this.reloadingDuration = this.rocketLauncherParams.salvoReloadTime;
this.reloadingEndTime += param1;
this.stunned = false;
}
public function isStunned() : Boolean {
return this.stunned;
}
public function getStunnedStatus() : Number {
return this.stunnedStatus;
}
}
}
|
package com.alternativaplatform.projects.tanks.client.garage.item
{
public interface IItemModelBase
{
}
}
|
package platform.client.fp10.core.registry.impl {
import alternativa.types.Long;
import flash.utils.Dictionary;
import platform.client.fp10.core.registry.GameTypeRegistry;
import platform.client.fp10.core.type.IGameClass;
import platform.client.fp10.core.type.impl.GameClass;
public class GameTypeRegistryImpl implements GameTypeRegistry {
private var _classes:Dictionary;
public function GameTypeRegistryImpl() {
super();
this._classes = new Dictionary();
}
public function createClass(param1:Long, param2:Vector.<Long>) : GameClass {
var local3:GameClass = new GameClass(param1,param2);
this._classes[param1] = local3;
return local3;
}
public function destroyClass(param1:Long) : void {
this._classes[param1] = null;
}
public function getClass(param1:Long) : IGameClass {
return this._classes[param1];
}
public function get classes() : Dictionary {
return this._classes;
}
}
}
|
package controls.cellrenderer
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class CellUnavailable_normalRight extends BitmapAsset
{
public function CellUnavailable_normalRight()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.user.pause {
public interface ITankPauseModelBase {
}
}
|
package _codec.projects.tanks.client.battlefield.models.ultimate.common {
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.ultimate.common.UltimateCC;
public class VectorCodecUltimateCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecUltimateCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(UltimateCC,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.<UltimateCC> = new Vector.<UltimateCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = UltimateCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:UltimateCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<UltimateCC> = Vector.<UltimateCC>(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.kitoffer {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.shop.shopitems.item.utils.FormatUtils;
import alternativa.tanks.loader.ILoaderWindowService;
import alternativa.tanks.model.quest.common.gui.window.buttons.skin.GreenBigButtonSkin;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.base.ThreeLineBigButton;
import controls.windowinner.WindowInner;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.text.TextFormatAlign;
import forms.ColorConstants;
import forms.TankWindowWithHeader;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.panel.model.kitoffer.KitOfferInfo;
import projects.tanks.client.panel.model.kitoffer.log.KitOfferAction;
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;
import utils.preview.IImageResource;
import utils.preview.ImageResourceLoadingWrapper;
public class KitOfferDialog extends DialogWindow implements IImageResource {
[Inject]
public static var paymentDisplayService:PaymentDisplayService;
[Inject]
public static var loaderWindowService:ILoaderWindowService;
[Inject]
public static var localeService:ILocaleService;
private static const IMAGE_WIDTH:int = 700;
private static const IMAGE_HEIGHT:int = 500;
private static const IMAGE_HOLDER_MARGIN:int = 2;
private static const IMAGE_HOLDER_WIDTH:int = IMAGE_WIDTH + IMAGE_HOLDER_MARGIN * 2;
private static const IMAGE_HOLDER_HEIGHT:int = IMAGE_HEIGHT + IMAGE_HOLDER_MARGIN * 2;
private static const MARGIN:int = 10;
private static const FOOTER_HEIGHT:int = 60;
private static const WIDTH:int = IMAGE_HOLDER_WIDTH + 2 * MARGIN;
private static const HEIGHT:int = IMAGE_HOLDER_HEIGHT + FOOTER_HEIGHT + 2 * MARGIN;
private var info:KitOfferInfo;
private var window:TankWindowWithHeader;
private var buyButton:ThreeLineBigButton;
private var closeButton:DefaultButtonBase;
private var imageHolder:WindowInner;
private var picture:Bitmap;
private var priceLabel:LabelBase;
public function KitOfferDialog(param1:KitOfferInfo) {
super();
this.info = param1;
this.addWindow();
this.addShopButton();
this.addWindowInner();
this.addImage();
this.addPrice();
this.addCloseButton();
}
private function addPrice() : void {
this.priceLabel = new LabelBase();
this.priceLabel.color = ColorConstants.WHITE;
this.priceLabel.align = TextFormatAlign.CENTER;
this.priceLabel.size = 26;
this.priceLabel.bold = true;
this.priceLabel.text = FormatUtils.valueToString(this.info.price,this.info.currencyRoundPrecision,false) + " " + this.info.currencyName;
this.priceLabel.x = 592 - this.priceLabel.width / 2;
this.priceLabel.y = 345 - this.priceLabel.height / 2;
this.imageHolder.addChild(this.priceLabel);
}
private function addImage() : void {
this.picture = new Bitmap();
this.imageHolder.addChild(this.picture);
if(this.info.image.isLazy && !this.info.image.isLoaded) {
this.info.image.loadLazyResource(new ImageResourceLoadingWrapper(this));
return;
}
this.drawImage(this.info.image.data);
}
private function drawImage(param1:BitmapData) : void {
this.picture.bitmapData = param1;
this.picture.x = (this.imageHolder.width - this.picture.width) / 2;
this.picture.y = (this.imageHolder.height - this.picture.height) / 2;
}
private function addWindowInner() : void {
this.imageHolder = new WindowInner(IMAGE_HOLDER_WIDTH,IMAGE_HOLDER_HEIGHT,WindowInner.TRANSPARENT);
this.window.addChild(this.imageHolder);
this.imageHolder.x = this.imageHolder.y = MARGIN;
this.imageHolder.buttonMode = true;
this.imageHolder.addEventListener(MouseEvent.CLICK,this.pictureClickHandler);
}
private function pictureClickHandler(param1:MouseEvent) : void {
dispatchEvent(new KitOfferResultEvent(KitOfferAction.PICTURE_CLICK));
this.navigateToShop();
this.close();
}
private function addWindow() : void {
this.window = TankWindowWithHeader.createWindow(TanksLocale.TEXT_HEADER_ATTENTION,WIDTH,HEIGHT);
addChild(this.window);
}
private function addShopButton() : void {
this.buyButton = new ThreeLineBigButton();
this.buyButton.setText(localeService.getText(TanksLocale.TEXT_GARAGE_BUY_TEXT));
this.buyButton.setSkin(GreenBigButtonSkin.GREEN_SKIN);
this.window.addChild(this.buyButton);
this.buyButton.x = (this.window.width - this.buyButton.width) / 2;
this.buyButton.y = this.window.height - this.buyButton.height - MARGIN;
this.buyButton.addEventListener(MouseEvent.CLICK,this.buyButtonClickHandler);
}
private function buyButtonClickHandler(param1:MouseEvent) : void {
dispatchEvent(new KitOfferResultEvent(KitOfferAction.BUY_BUTTON_CLICK));
this.navigateToShop();
this.close();
}
private function navigateToShop() : void {
paymentDisplayService.openPaymentForShopItem(this.info.shopItem);
}
private function addCloseButton() : void {
this.closeButton = new DefaultButtonBase();
this.closeButton.label = localeService.getText(TanksLocale.TEXT_CLOSE_LABEL);
this.window.addChild(this.closeButton);
this.closeButton.x = this.window.width - this.closeButton.width - MARGIN;
this.closeButton.y = this.window.height - this.closeButton.height - MARGIN;
this.closeButton.addEventListener(MouseEvent.CLICK,this.closeButtonClickHandler);
}
private function closeButtonClickHandler(param1:MouseEvent) : void {
dispatchEvent(new KitOfferResultEvent(KitOfferAction.EXIT_BUTTON_CLICK));
this.close();
}
private function close() : void {
this.picture.removeEventListener(MouseEvent.CLICK,this.pictureClickHandler);
this.buyButton.removeEventListener(MouseEvent.CLICK,this.buyButtonClickHandler);
this.closeButton.removeEventListener(MouseEvent.CLICK,this.closeButtonClickHandler);
dialogService.removeDialog(this);
dispatchEvent(new Event(Event.CANCEL));
}
public function setPreviewResource(param1:ImageResource) : void {
this.drawImage(param1.data);
}
override protected function cancelKeyPressed() : void {
dispatchEvent(new KitOfferResultEvent(KitOfferAction.EXIT_BUTTON_CLICK));
this.close();
}
}
}
|
package alternativa.tanks.model.item.modification {
import alternativa.types.Long;
[ModelInterface]
public interface IModification {
function getBaseItemId() : Long;
function getModificationIndex() : int;
}
}
|
package controls
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
public class Rank
{
public static var ranks:Array;
public function Rank()
{
super();
}
public static function name(value:int) : String
{
var localeService:ILocaleService = null;
var rankString:String = null;
if(ranks == null)
{
localeService = Main.osgi.getService(ILocaleService) as ILocaleService;
rankString = localeService.getText(TextConst.RANK_NAMES);
ranks = rankString.split(",");
}
return ranks[value - 1];
}
}
}
|
package controls.base {
import base.DiscreteSprite;
import controls.TextFieldUtf8;
import flash.display.BitmapData;
import flash.display.Graphics;
import flash.display.Shape;
import flash.events.MouseEvent;
import flash.system.Capabilities;
import flash.text.AntiAliasType;
import flash.text.GridFitType;
import flash.text.TextField;
import flash.text.TextFieldType;
import flash.text.TextFormat;
import flash.ui.Mouse;
import flash.ui.MouseCursor;
import fonts.TanksFontService;
import utils.FontParamsUtil;
public class TankInput extends DiscreteSprite {
private static const centerClass:Class = TankInput_centerClass;
private static const centerWrongClass:Class = TankInput_centerWrongClass;
private static const leftClass:Class = TankInput_leftClass;
private static const leftWrondClass:Class = TankInput_leftWrondClass;
private static const rightClass:Class = TankInput_rightClass;
private static const rightWrongClass:Class = TankInput_rightWrongClass;
public static const BORDER_THICKNESS:int = 5;
public static const DEFAULT_INPUT_HEIGHT:int = 30;
public static const DEFAULT_INPUT_WIDTH:int = 212;
private static const TEXT_FIELD_INTERNAL_X:int = 3;
private static const TEXT_FIELD_INTERNAL_Y:int = 7;
private static const VERSION_PATTERN:RegExp = /^(\w*) (\d*),(\d*),(\d*),(\d*)$/;
private const format:TextFormat = TanksFontService.getTextFormat(12);
private const bg:DiscreteSprite = new DiscreteSprite();
private const leftBorder:Shape = new Shape();
private const centerBorder:Shape = new Shape();
private const rightBorder:Shape = new Shape();
private const bmpLeft:BitmapData = new leftClass().bitmapData;
private const bmpCenter:BitmapData = new centerClass().bitmapData;
private const bmpRight:BitmapData = new rightClass().bitmapData;
private const bmpLeftWrong:BitmapData = new leftWrondClass().bitmapData;
private const bmpCenterWrong:BitmapData = new centerWrongClass().bitmapData;
private const bmpRightWrong:BitmapData = new rightWrongClass().bitmapData;
public var textField:TextField;
private var _hidden:Boolean;
private var _valid:Boolean = true;
private var _width:int;
private var _height:int;
public function TankInput() {
super();
addChild(this.bg);
this.bg.addChild(this.leftBorder);
this.bg.addChild(this.centerBorder);
this.bg.addChild(this.rightBorder);
this.addInternalTextField();
this.height = DEFAULT_INPUT_HEIGHT;
this.width = DEFAULT_INPUT_WIDTH;
}
private function addInternalTextField() : void {
var local1:String = Capabilities.version;
var local2:Object = VERSION_PATTERN.exec(local1);
if(local2 != null && Number(local2[2] + "." + local2[3]) < 10.1) {
this.textField = new TextFieldUtf8();
} else {
this.textField = new TextField();
}
this.textField.defaultTextFormat = this.format;
this.textField.antiAliasType = AntiAliasType.ADVANCED;
this.textField.gridFitType = GridFitType.PIXEL;
this.textField.embedFonts = TanksFontService.isEmbedFonts();
this.textField.type = TextFieldType.INPUT;
this.textField.x = TEXT_FIELD_INTERNAL_X;
this.textField.y = TEXT_FIELD_INTERNAL_Y;
this.setTextFieldHeight();
this.textField.sharpness = FontParamsUtil.SHARPNESS_TANK_INPUT_BASE;
this.textField.thickness = FontParamsUtil.THICKNESS_TANK_INPUT_BASE;
this.textField.addEventListener(MouseEvent.MOUSE_OVER,this.onMouseOver);
this.textField.addEventListener(MouseEvent.MOUSE_OUT,this.onMouseOut);
addChild(this.textField);
}
private function setTextFieldHeight() : void {
this.textField.height = this._height - 2 * BORDER_THICKNESS;
}
private function onMouseOver(param1:MouseEvent) : void {
Mouse.cursor = MouseCursor.IBEAM;
}
private function onMouseOut(param1:MouseEvent) : void {
Mouse.cursor = MouseCursor.AUTO;
}
public function set enable(param1:Boolean) : void {
this.textField.type = param1 ? TextFieldType.INPUT : TextFieldType.DYNAMIC;
this.textField.selectable = param1;
this.textField.mouseEnabled = param1;
this.textField.mouseWheelEnabled = param1;
this.textField.tabEnabled = param1;
}
override public function set x(param1:Number) : void {
super.x = int(param1);
}
override public function set y(param1:Number) : void {
super.y = int(param1);
}
override public function set width(param1:Number) : void {
this._width = Math.ceil(param1);
this.textField.width = this._width - 6;
this.draw();
}
override public function set height(param1:Number) : void {
this._height = Math.ceil(param1);
this.setTextFieldHeight();
this.draw();
}
public function set align(param1:String) : void {
this.format.align = param1;
this.updateTextFormat();
}
private function updateTextFormat() : void {
this.textField.defaultTextFormat = this.format;
this.textField.setTextFormat(this.format);
}
public function clear() : void {
this.textField.text = "";
this.validValue = true;
}
override public function set tabIndex(param1:int) : void {
this.textField.tabIndex = param1;
}
public function set restrict(param1:String) : void {
this.textField.restrict = param1;
}
public function set maxChars(param1:int) : void {
this.textField.maxChars = param1;
}
public function get value() : String {
return this.textField.text;
}
public function set value(param1:String) : void {
this.textField.text = param1;
}
public function set hidden(param1:Boolean) : void {
this._hidden = param1;
this.textField.displayAsPassword = this._hidden;
}
public function get hidden() : Boolean {
return this._hidden;
}
public function set validValue(param1:Boolean) : void {
this._valid = param1;
this.draw();
}
public function get validValue() : Boolean {
return this._valid;
}
private function draw() : void {
var local1:Graphics = this.leftBorder.graphics;
local1.clear();
local1.beginBitmapFill(this._valid ? this.bmpLeft : this.bmpLeftWrong);
local1.drawRect(0,0,BORDER_THICKNESS,this._height);
local1.endFill();
this.leftBorder.x = 0;
this.leftBorder.y = 0;
var local2:Graphics = this.centerBorder.graphics;
local2.clear();
local2.beginBitmapFill(this._valid ? this.bmpCenter : this.bmpCenterWrong);
local2.drawRect(0,0,this._width - 2 * BORDER_THICKNESS,this._height);
local2.endFill();
this.centerBorder.x = BORDER_THICKNESS;
this.centerBorder.y = 0;
var local3:Graphics = this.rightBorder.graphics;
local3.clear();
local3.beginBitmapFill(this._valid ? this.bmpRight : this.bmpRightWrong);
local3.drawRect(0,0,BORDER_THICKNESS,this._height);
local3.endFill();
this.rightBorder.x = this._width - BORDER_THICKNESS;
this.rightBorder.y = 0;
}
}
}
|
package alternativa.engine3d.primitives {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
use namespace alternativa3d;
public class Sphere extends Mesh {
public function Sphere(param1:Number = 100, param2:uint = 8, param3:uint = 8, param4:Boolean = false, param5:Material = null) {
var local9:uint = 0;
var local10:uint = 0;
var local12:Vertex = null;
var local13:Vertex = null;
var local14:Vertex = null;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
super();
if(param2 < 3) {
throw new ArgumentError(param2 + " radial segments not enough.");
}
if(param3 < 2) {
throw new ArgumentError(param3 + " height segments not enough.");
}
param1 = param1 < 0 ? 0 : param1;
var local6:Object = new Object();
var local7:Number = Math.PI * 2 / param2;
var local8:Number = Math.PI * 2 / (param3 << 1);
local10 = 0;
while(local10 <= param3) {
local15 = local8 * local10;
local16 = Math.sin(local15) * param1;
local17 = Math.cos(local15) * param1;
local9 = 0;
while(local9 <= param2) {
local18 = local7 * local9;
this.createVertex(-Math.sin(local18) * local16,Math.cos(local18) * local16,local17,local9 / param2,local10 / param3,local9 + "_" + local10,local6);
local9++;
}
local10++;
}
var local11:uint = 0;
local9 = 1;
while(local9 <= param2) {
local10 = 0;
while(local10 < param3) {
if(local10 < param3 - 1) {
local12 = local6[local11 + "_" + local10];
local13 = local6[local11 + "_" + (local10 + 1)];
local14 = local6[local9 + "_" + (local10 + 1)];
if(param4) {
this.createFace(local12,local14,local13,param5);
} else {
this.createFace(local12,local13,local14,param5);
}
}
if(local10 > 0) {
local12 = local6[local9 + "_" + (local10 + 1)];
local13 = local6[local9 + "_" + local10];
local14 = local6[local11 + "_" + local10];
if(param4) {
this.createFace(local12,local14,local13,param5);
} else {
this.createFace(local12,local13,local14,param5);
}
}
local10++;
}
local11 = local9;
local9++;
}
calculateFacesNormals(true);
boundMinX = -param1;
boundMinY = -param1;
boundMinZ = -param1;
boundMaxX = param1;
boundMaxY = param1;
boundMaxZ = param1;
}
private function createVertex(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:String, param7:Object) : Vertex {
var local8:Vertex = new Vertex();
local8.x = param1;
local8.y = param2;
local8.z = param3;
local8.u = param4;
local8.v = param5;
local8.alternativa3d::next = alternativa3d::vertexList;
alternativa3d::vertexList = local8;
param7[param6] = local8;
return local8;
}
private function createFace(param1:Vertex, param2:Vertex, param3:Vertex, param4:Material) : void {
var local5:Face = new Face();
local5.material = param4;
local5.alternativa3d::wrapper = new Wrapper();
local5.alternativa3d::wrapper.alternativa3d::vertex = param1;
local5.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local5.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = param2;
local5.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local5.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param3;
local5.alternativa3d::next = alternativa3d::faceList;
alternativa3d::faceList = local5;
}
override public function clone() : Object3D {
var local1:Sphere = new Sphere();
local1.clonePropertiesFrom(this);
return local1;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.notifier {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class NotifierAdapt implements Notifier {
private var object:IGameObject;
private var impl:Notifier;
public function NotifierAdapt(param1:IGameObject, param2:Notifier) {
super();
this.object = param1;
this.impl = param2;
}
public function subscribe(param1:Long, param2:UserInfoConsumer) : void {
var userId:Long = param1;
var consumer:UserInfoConsumer = param2;
try {
Model.object = this.object;
this.impl.subscribe(userId,consumer);
}
finally {
Model.popObject();
}
}
public function unSubscribe(param1:Long) : void {
var userId:Long = param1;
try {
Model.object = this.object;
this.impl.unSubscribe(userId);
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield {
import projects.tanks.client.battlefield.models.battle.battlefield.types.HitTraceData;
import projects.tanks.client.battleservice.BattleRoundParameters;
public interface IBattlefieldModelBase {
function battleFinish() : void;
function battleRestart() : void;
function battleStart(param1:BattleRoundParameters) : void;
function traceHit(param1:HitTraceData) : void;
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.cp {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.battlefield.models.battle.cp.ControlPointState;
public class CodecControlPointState implements ICodec {
public function CodecControlPointState() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ControlPointState = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = ControlPointState.RED;
break;
case 1:
local2 = ControlPointState.BLUE;
break;
case 2:
local2 = ControlPointState.NEUTRAL;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.colortransform
{
import scpacker.Base;
public class ColorTransformModelBase extends Base
{
public function ColorTransformModelBase()
{
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.pointbased.rugby {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.battle.pointbased.rugby.RugbyCC;
import projects.tanks.client.battlefield.models.battle.pointbased.rugby.RugbySoundFX;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class CodecRugbyCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_ballFallSpeeed:ICodec;
private var codec_ballModel:ICodec;
private var codec_ballRadius:ICodec;
private var codec_ballSpawnZone:ICodec;
private var codec_bigBlueBallMarker:ICodec;
private var codec_bigGreenBallMarker:ICodec;
private var codec_bigRedBallMarker:ICodec;
private var codec_blueBallMarker:ICodec;
private var codec_blueGoalModel:ICodec;
private var codec_cordResource:ICodec;
private var codec_greenBallMarker:ICodec;
private var codec_parachuteInnerResource:ICodec;
private var codec_parachuteResource:ICodec;
private var codec_redBallMarker:ICodec;
private var codec_redGoalModel:ICodec;
private var codec_sounds:ICodec;
public function CodecRugbyCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_ballFallSpeeed = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_ballModel = param1.getCodec(new TypeCodecInfo(Tanks3DSResource,false));
this.codec_ballRadius = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_ballSpawnZone = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_bigBlueBallMarker = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_bigGreenBallMarker = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_bigRedBallMarker = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_blueBallMarker = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_blueGoalModel = param1.getCodec(new TypeCodecInfo(Tanks3DSResource,false));
this.codec_cordResource = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_greenBallMarker = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_parachuteInnerResource = param1.getCodec(new TypeCodecInfo(Tanks3DSResource,false));
this.codec_parachuteResource = param1.getCodec(new TypeCodecInfo(Tanks3DSResource,false));
this.codec_redBallMarker = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_redGoalModel = param1.getCodec(new TypeCodecInfo(Tanks3DSResource,false));
this.codec_sounds = param1.getCodec(new TypeCodecInfo(RugbySoundFX,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:RugbyCC = new RugbyCC();
local2.ballFallSpeeed = this.codec_ballFallSpeeed.decode(param1) as Number;
local2.ballModel = this.codec_ballModel.decode(param1) as Tanks3DSResource;
local2.ballRadius = this.codec_ballRadius.decode(param1) as Number;
local2.ballSpawnZone = this.codec_ballSpawnZone.decode(param1) as TextureResource;
local2.bigBlueBallMarker = this.codec_bigBlueBallMarker.decode(param1) as TextureResource;
local2.bigGreenBallMarker = this.codec_bigGreenBallMarker.decode(param1) as TextureResource;
local2.bigRedBallMarker = this.codec_bigRedBallMarker.decode(param1) as TextureResource;
local2.blueBallMarker = this.codec_blueBallMarker.decode(param1) as TextureResource;
local2.blueGoalModel = this.codec_blueGoalModel.decode(param1) as Tanks3DSResource;
local2.cordResource = this.codec_cordResource.decode(param1) as TextureResource;
local2.greenBallMarker = this.codec_greenBallMarker.decode(param1) as TextureResource;
local2.parachuteInnerResource = this.codec_parachuteInnerResource.decode(param1) as Tanks3DSResource;
local2.parachuteResource = this.codec_parachuteResource.decode(param1) as Tanks3DSResource;
local2.redBallMarker = this.codec_redBallMarker.decode(param1) as TextureResource;
local2.redGoalModel = this.codec_redGoalModel.decode(param1) as Tanks3DSResource;
local2.sounds = this.codec_sounds.decode(param1) as RugbySoundFX;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:RugbyCC = RugbyCC(param2);
this.codec_ballFallSpeeed.encode(param1,local3.ballFallSpeeed);
this.codec_ballModel.encode(param1,local3.ballModel);
this.codec_ballRadius.encode(param1,local3.ballRadius);
this.codec_ballSpawnZone.encode(param1,local3.ballSpawnZone);
this.codec_bigBlueBallMarker.encode(param1,local3.bigBlueBallMarker);
this.codec_bigGreenBallMarker.encode(param1,local3.bigGreenBallMarker);
this.codec_bigRedBallMarker.encode(param1,local3.bigRedBallMarker);
this.codec_blueBallMarker.encode(param1,local3.blueBallMarker);
this.codec_blueGoalModel.encode(param1,local3.blueGoalModel);
this.codec_cordResource.encode(param1,local3.cordResource);
this.codec_greenBallMarker.encode(param1,local3.greenBallMarker);
this.codec_parachuteInnerResource.encode(param1,local3.parachuteInnerResource);
this.codec_parachuteResource.encode(param1,local3.parachuteResource);
this.codec_redBallMarker.encode(param1,local3.redBallMarker);
this.codec_redGoalModel.encode(param1,local3.redGoalModel);
this.codec_sounds.encode(param1,local3.sounds);
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.common.shell {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Byte;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import projects.tanks.client.battlefield.models.tankparts.weapons.common.TargetPosition;
import projects.tanks.client.battlefield.types.Vector3d;
public class ShellWeaponCommunicationModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ShellWeaponCommunicationModelServer;
private var client:IShellWeaponCommunicationModelBase = IShellWeaponCommunicationModelBase(this);
private var modelId:Long = Long.getLong(288784246,84754739);
private var _shootId:Long = Long.getLong(272048587,295381737);
private var _shoot_barrelIndexCodec:ICodec;
private var _shoot_shotIdCodec:ICodec;
private var _shoot_directionCodec:ICodec;
private var _shootDummyId:Long = Long.getLong(614158399,-327996881);
private var _shootDummy_barrelIndexCodec:ICodec;
private var _shootWithTargetId:Long = Long.getLong(1963572121,467312018);
private var _shootWithTarget_barrelIndexCodec:ICodec;
private var _shootWithTarget_shotIdCodec:ICodec;
private var _shootWithTarget_directionCodec:ICodec;
private var _shootWithTarget_targetCodec:ICodec;
private var _shootWithTarget_localTargetPointCodec:ICodec;
public function ShellWeaponCommunicationModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ShellWeaponCommunicationModelServer(IModel(this));
this._shoot_barrelIndexCodec = this._protocol.getCodec(new TypeCodecInfo(Byte,false));
this._shoot_shotIdCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._shoot_directionCodec = this._protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._shootDummy_barrelIndexCodec = this._protocol.getCodec(new TypeCodecInfo(Byte,false));
this._shootWithTarget_barrelIndexCodec = this._protocol.getCodec(new TypeCodecInfo(Byte,false));
this._shootWithTarget_shotIdCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._shootWithTarget_directionCodec = this._protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._shootWithTarget_targetCodec = this._protocol.getCodec(new TypeCodecInfo(TargetPosition,false));
this._shootWithTarget_localTargetPointCodec = this._protocol.getCodec(new TypeCodecInfo(Vector3d,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._shootId:
this.client.shoot(int(this._shoot_barrelIndexCodec.decode(param2)),int(this._shoot_shotIdCodec.decode(param2)),Vector3d(this._shoot_directionCodec.decode(param2)));
break;
case this._shootDummyId:
this.client.shootDummy(int(this._shootDummy_barrelIndexCodec.decode(param2)));
break;
case this._shootWithTargetId:
this.client.shootWithTarget(int(this._shootWithTarget_barrelIndexCodec.decode(param2)),int(this._shootWithTarget_shotIdCodec.decode(param2)),Vector3d(this._shootWithTarget_directionCodec.decode(param2)),TargetPosition(this._shootWithTarget_targetCodec.decode(param2)),Vector3d(this._shootWithTarget_localTargetPointCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.teamlight {
public final class TeamLightColor {
private var color:uint;
private var intensity:Number;
public function TeamLightColor(param1:uint, param2:Number) {
super();
this.color = param1;
this.intensity = param2;
}
public function getColor() : uint {
return this.color;
}
public function getIntensity() : Number {
return this.intensity;
}
}
}
|
package scpacker.gui.en
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksIEN_coldload3 extends BitmapAsset
{
public function GTanksIEN_coldload3()
{
super();
}
}
}
|
package alternativa.tanks.models.battlefield.gamemode
{
import alternativa.tanks.model.panel.IBattleSettings;
import alternativa.tanks.models.battlefield.BattleView3D;
import flash.display.BitmapData;
public interface IGameMode
{
function applyChanges(param1:BattleView3D) : void;
function applyChangesBeforeSettings(param1:IBattleSettings) : void;
function applyColorchangesToSkybox(param1:BitmapData) : BitmapData;
}
}
|
package alternativa.tanks.model.item.discount {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IDiscountEvents implements IDiscount {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IDiscountEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getDiscountInPercent() : int {
var result:int = 0;
var i:int = 0;
var m:IDiscount = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IDiscount(this.impl[i]);
result = int(m.getDiscountInPercent());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function applyDiscount(param1:int) : int {
var result:int = 0;
var i:int = 0;
var m:IDiscount = null;
var price:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IDiscount(this.impl[i]);
result = int(m.applyDiscount(price));
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.battlefield.models.bonus.bonus.battlebonuses.crystal {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import platform.client.fp10.core.type.IGameObject;
public class BattleGoldBonusesModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BattleGoldBonusesModelServer;
private var client:IBattleGoldBonusesModelBase = IBattleGoldBonusesModelBase(this);
private var modelId:Long = Long.getLong(118876660,-1267889929);
private var _goldTakenId:Long = Long.getLong(2126351838,-2114277847);
private var _goldTaken_userCodec:ICodec;
public function BattleGoldBonusesModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BattleGoldBonusesModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(BattleGoldBonusCC,false)));
this._goldTaken_userCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
}
protected function getInitParam() : BattleGoldBonusCC {
return BattleGoldBonusCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._goldTakenId:
this.client.goldTaken(IGameObject(this._goldTaken_userCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.abonements {
import projects.tanks.client.panel.model.abonements.IUserAbonementsModelBase;
import projects.tanks.client.panel.model.abonements.ShopAbonementData;
import projects.tanks.client.panel.model.abonements.UserAbonementsModelBase;
[ModelInfo]
public class UserAbonementsModel extends UserAbonementsModelBase implements IUserAbonementsModelBase {
public function UserAbonementsModel() {
super();
}
public function updateAbonement(param1:ShopAbonementData) : void {
}
}
}
|
package projects.tanks.client.tanksservices.model.notifier.referrals {
public interface IReferralNotifierModelBase {
function setIsReferral(param1:Vector.<ReferralNotifierData>) : void;
}
}
|
package alternativa.tanks.battle.objects.tank.tankskin {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.materials.TrackMaterial;
public class SkinMaterials {
public var hullMaterial:TextureMaterial;
public var turretMaterial:TextureMaterial;
public var leftTrackMaterial:TrackMaterial;
public var rightTrackMaterial:TrackMaterial;
public function SkinMaterials(param1:TextureMaterial, param2:TextureMaterial, param3:TrackMaterial = null, param4:TrackMaterial = null) {
super();
this.hullMaterial = param1;
this.turretMaterial = param2;
this.leftTrackMaterial = param3;
this.rightTrackMaterial = param4;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.splash {
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.splash.SplashCC;
public class CodecSplashCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_impactForce:ICodec;
private var codec_minSplashDamagePercent:ICodec;
private var codec_radiusOfMaxSplashDamage:ICodec;
private var codec_splashDamageRadius:ICodec;
public function CodecSplashCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_impactForce = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_minSplashDamagePercent = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_radiusOfMaxSplashDamage = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_splashDamageRadius = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:SplashCC = new SplashCC();
local2.impactForce = this.codec_impactForce.decode(param1) as Number;
local2.minSplashDamagePercent = this.codec_minSplashDamagePercent.decode(param1) as Number;
local2.radiusOfMaxSplashDamage = this.codec_radiusOfMaxSplashDamage.decode(param1) as Number;
local2.splashDamageRadius = this.codec_splashDamageRadius.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:SplashCC = SplashCC(param2);
this.codec_impactForce.encode(param1,local3.impactForce);
this.codec_minSplashDamagePercent.encode(param1,local3.minSplashDamagePercent);
this.codec_radiusOfMaxSplashDamage.encode(param1,local3.radiusOfMaxSplashDamage);
this.codec_splashDamageRadius.encode(param1,local3.splashDamageRadius);
}
}
}
|
package alternativa.tanks.controllers.battleinfo {
import alternativa.tanks.view.battleinfo.BattleInfoUserList;
import alternativa.tanks.view.battleinfo.team.BattleInfoTeamParams;
import alternativa.tanks.view.battleinfo.team.BattleInfoTeamView;
import alternativa.types.Long;
import fl.data.DataProvider;
import flash.utils.Dictionary;
import projects.tanks.client.battleselect.model.battle.entrance.user.BattleInfoUser;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoService;
public class BattleInfoTeamController extends AbstractBattleInfoController {
[Inject]
public static var userInfoService:IUserInfoService;
private var userId2userList:Dictionary = new Dictionary();
private var autoBalance:Boolean;
public function BattleInfoTeamController() {
super();
view = new BattleInfoTeamView();
}
override protected function updateUserLists() : void {
var local1:BattleInfoTeamParams = BattleInfoTeamParams(initParams);
this.updateUserList(maxPeopleCount,local1.usersRed,this.teamView.redUserList);
this.updateUserList(maxPeopleCount,local1.usersBlue,this.teamView.blueUserList);
this.autoBalance = initParams.createParams.autoBalance;
this.updateAvailableEnterInBattle();
}
private function updateUserList(param1:int, param2:Vector.<BattleInfoUser>, param3:BattleInfoUserList) : void {
param3.update(param1,param2);
this.updateUserId2userList(param3);
}
override protected function updateAvailableEnterInBattle() : void {
this.teamView.redFightButton.enabled = this.isFightButtonEnabledForTeam(this.teamView.redUserList,this.teamView.blueUserList) && this.isAvailableEnterInClanBattleForTeam(this.teamView.redUserList,this.teamView.blueUserList);
this.teamView.blueFightButton.enabled = this.isFightButtonEnabledForTeam(this.teamView.blueUserList,this.teamView.redUserList) && this.isAvailableEnterInClanBattleForTeam(this.teamView.blueUserList,this.teamView.redUserList);
}
private function isFightButtonEnabledForTeam(param1:BattleInfoUserList, param2:BattleInfoUserList) : Boolean {
return availableByRank && initParams.createParams.proBattle && param1.usersCount < maxPeopleCount && (!this.autoBalance || param1.usersCount <= param2.usersCount);
}
private function isAvailableEnterInClanBattleForTeam(param1:BattleInfoUserList, param2:BattleInfoUserList) : Boolean {
var local6:Long = null;
var local7:Long = null;
if(!initParams.createParams.clanBattle) {
return true;
}
if(!clanUserInfoService.clanMember) {
return false;
}
var local3:Boolean = true;
if(param1.usersCount == 0) {
local3 = true;
}
var local4:Long = userInfoService.getCurrentUserId();
var local5:Long = clanUserInfoService.userClanInfoByUserId(local4).clanId;
if(param2.usersCount > 0) {
local6 = param2.getTeamClanId();
if(local6 == local5) {
local3 = false;
}
}
if(param1.usersCount > 0) {
local7 = param1.getTeamClanId();
return local3 && local7 == local5;
}
return local3;
}
public function addUserToTeam(param1:BattleInfoUser, param2:BattleTeam) : void {
var local3:BattleInfoUserList = this.getTeamUserList(param2);
local3.addUser(param1);
this.userId2userList[param1.user] = local3;
this.updateAvailableEnterInBattle();
}
override public function removeUser(param1:Long) : void {
this.userId2userList[param1].removeUser(param1);
delete this.userId2userList[param1];
this.updateAvailableEnterInBattle();
}
public function updateTeamScore(param1:BattleTeam, param2:int) : void {
this.teamView.updateScore(param1,param2);
}
override public function updateUserScore(param1:Long, param2:int) : void {
this.userId2userList[param1].updateUserScore(param1,param2);
this.teamView.invalidateUserList();
}
override public function updateUserSuspiciousState(param1:Long, param2:Boolean) : void {
this.userId2userList[param1].updateUserSuspiciousState(param1,param2);
this.teamView.invalidateUserList();
}
override public function destroy() : void {
super.destroy();
this.userId2userList = null;
}
public function swapTeams() : void {
var local1:DataProvider = this.teamView.blueUserList.dataProvider;
this.teamView.blueUserList.dataProvider = this.teamView.redUserList.dataProvider;
this.teamView.redUserList.dataProvider = local1;
var local2:int = this.teamView.blueUserList.usersCount;
this.teamView.blueUserList.usersCount = this.teamView.redUserList.usersCount;
this.teamView.redUserList.usersCount = local2;
this.updateUserId2userList(this.teamView.redUserList);
this.updateUserId2userList(this.teamView.blueUserList);
this.updateAvailableEnterInBattle();
}
private function updateUserId2userList(param1:BattleInfoUserList) : void {
var local3:Object = null;
var local2:int = 0;
while(local2 < param1.dataProvider.length) {
local3 = param1.dataProvider.getItemAt(local2);
if(local3.id == null) {
break;
}
this.userId2userList[local3.id] = param1;
local2++;
}
}
private function get teamView() : BattleInfoTeamView {
return BattleInfoTeamView(view);
}
private function getTeamUserList(param1:BattleTeam) : BattleInfoUserList {
return param1 == BattleTeam.RED ? this.teamView.redUserList : this.teamView.blueUserList;
}
override protected function updateControlPanel() : void {
this.teamView.updateScore(BattleTeam.RED,BattleInfoTeamParams(initParams).scoreRed);
this.teamView.updateScore(BattleTeam.BLUE,BattleInfoTeamParams(initParams).scoreBlue);
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_forumIconMakeUp.png")]
public class MakeUp_forumIconMakeUp extends BitmapAsset {
public function MakeUp_forumIconMakeUp() {
super();
}
}
}
|
package projects.tanks.client.clans.user {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class ClanUserLoaderModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ClanUserLoaderModelServer;
private var client:IClanUserLoaderModelBase = IClanUserLoaderModelBase(this);
private var modelId:Long = Long.getLong(1420566941,-260091189);
private var _showWindowId:Long = Long.getLong(511635594,2072865495);
public function ClanUserLoaderModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ClanUserLoaderModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._showWindowId:
this.client.showWindow();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package controls.scroller.blue {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.scroller.blue.ScrollSkinBlue_thumbTop.png")]
public class ScrollSkinBlue_thumbTop extends BitmapAsset {
public function ScrollSkinBlue_thumbTop() {
super();
}
}
}
|
package alternativa.tanks.battle.objects.tank.tankskin.turret {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class CustomTurretSkinEvents implements CustomTurretSkin {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function CustomTurretSkinEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function createSkin(param1:Tanks3DSResource) : TurretSkin {
var result:TurretSkin = null;
var i:int = 0;
var m:CustomTurretSkin = null;
var resource:Tanks3DSResource = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = CustomTurretSkin(this.impl[i]);
result = m.createSkin(resource);
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package platform.client.fp10.core.service {
import platform.client.fp10.core.resource.Resource;
public interface IResourceTimer {
function addResource(param1:Resource) : void;
function removeResource(param1:Resource) : void;
function getMaxReloadAttemts() : int;
}
}
|
package _codec.projects.tanks.client.panel.model.payment {
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.payment.PaymentPackage;
public class CodecPaymentPackage implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_amountCrystals:ICodec;
private var codec_bonusCrystals:ICodec;
private var codec_currency:ICodec;
private var codec_premiumDurationInDays:ICodec;
private var codec_price:ICodec;
public function CodecPaymentPackage() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_amountCrystals = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_bonusCrystals = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_currency = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_premiumDurationInDays = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_price = param1.getCodec(new TypeCodecInfo(Number,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:PaymentPackage = new PaymentPackage();
local2.amountCrystals = this.codec_amountCrystals.decode(param1) as int;
local2.bonusCrystals = this.codec_bonusCrystals.decode(param1) as int;
local2.currency = this.codec_currency.decode(param1) as String;
local2.premiumDurationInDays = this.codec_premiumDurationInDays.decode(param1) as int;
local2.price = this.codec_price.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:PaymentPackage = PaymentPackage(param2);
this.codec_amountCrystals.encode(param1,local3.amountCrystals);
this.codec_bonusCrystals.encode(param1,local3.bonusCrystals);
this.codec_currency.encode(param1,local3.currency);
this.codec_premiumDurationInDays.encode(param1,local3.premiumDurationInDays);
this.codec_price.encode(param1,local3.price);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.groupinvite {
import alternativa.types.Long;
import flash.events.Event;
public class GroupInviteServiceEvent extends Event {
public static const ACCEPT:String = "GroupInviteServiceEvent.ACCEPT";
public static const REJECT:String = "GroupInviteServiceEvent.REJECT";
public var sender:Long;
public function GroupInviteServiceEvent(param1:String, param2:Long) {
this.sender = param2;
super(param1);
}
}
}
|
package alternativa.tanks.models.weapon.shaft.quickshot
{
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.collision.ICollisionDetector;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.tanks.models.ctf.ICTFModel;
import alternativa.tanks.models.tank.TankData;
import flash.utils.Dictionary;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
public class ShaftTargetSystem
{
private static const FLAG_CARRIER_BONUS:Number = 10;
private static const DISTANCE_WEIGHT:Number = 0.65;
private static const BASE_DISTANCE:Number = 20000;
private static const MAX_PRIORITY:Number = 1000;
private const COLLISION_GROUP:int = 16;
private const MAX_RAY_LENGTH:Number = 1.0E10;
private var collisionDetector:ICollisionDetector;
private var upAngleStep:Number;
private var upRaysNum:int;
private var downAngleStep:Number;
private var downRaysNum:int;
private var weakeningCoeff:Number;
private var multybodyPredicate:MultybodyCollisionPredicate;
private var intersection:RayIntersection;
private var dir:Vector3;
private var rotationMatrix:Matrix3;
private var origin:Vector3;
private var _v:Vector3;
private var bestDirectionIndex:int;
private var maxDirectionPriority:Number;
private var bestEffectivity:Number;
private var currTargets:Array;
private var currHitPoints:Array;
private var ctfModel:ICTFModel;
private var maxAngle:Number;
public function ShaftTargetSystem()
{
this.multybodyPredicate = new MultybodyCollisionPredicate();
this.intersection = new RayIntersection();
this.dir = new Vector3();
this.rotationMatrix = new Matrix3();
this.origin = new Vector3();
this._v = new Vector3();
this.currTargets = [];
this.currHitPoints = [];
super();
}
public function setParams(collisionDetector:ICollisionDetector, upAngle:Number, upRaysNum:int, downAngle:Number, downRaysNum:int, weakeningCoeff:Number, ctfModel:ICTFModel) : void
{
this.collisionDetector = collisionDetector;
this.upAngleStep = upAngle / upRaysNum;
this.upRaysNum = upRaysNum;
this.downAngleStep = downAngle / downRaysNum;
this.downRaysNum = downRaysNum;
this.weakeningCoeff = weakeningCoeff;
this.ctfModel = ctfModel;
this.maxAngle = upAngle > downAngle ? Number(Number(upAngle)) : Number(Number(downAngle));
}
public function getTargets(shooterData:TankData, barrelOrigin:Vector3, baseDir:Vector3, rotationAxis:Vector3, tanks:Dictionary, shotResult:ShaftShotResult) : void
{
shotResult.targets.length = 0;
shotResult.hitPoints.length = 0;
this.bestEffectivity = 0;
this.bestDirectionIndex = 10000;
this.maxDirectionPriority = 0;
this.checkAllDirections(shooterData,barrelOrigin,baseDir,rotationAxis,tanks,shotResult);
if(this.bestEffectivity == 0)
{
this.collectTargetsAlongRay(shooterData,barrelOrigin,baseDir,tanks,shotResult);
}
this.multybodyPredicate.bodies = null;
this.currHitPoints.length = 0;
this.currTargets.length = 0;
}
private function checkAllDirections(shooterData:TankData, barrelOrigin:Vector3, baseDir:Vector3, rotationAxis:Vector3, tanks:Dictionary, shotResult:ShaftShotResult) : void
{
var i:int = 0;
this.checkDirection(barrelOrigin,baseDir,0,0,shooterData,tanks,shotResult);
this.rotationMatrix.fromAxisAngle(rotationAxis,this.upAngleStep);
this.dir.vCopy(baseDir);
var angle:Number = 0;
for(i = 1; i <= this.upRaysNum; i++)
{
angle += this.upAngleStep;
this.dir.vTransformBy3(this.rotationMatrix);
this.checkDirection(barrelOrigin,this.dir,angle,i,shooterData,tanks,shotResult);
}
this.rotationMatrix.fromAxisAngle(rotationAxis,-this.downAngleStep);
this.dir.vCopy(baseDir);
angle = 0;
for(i = 1; i <= this.downRaysNum; i++)
{
angle += this.downAngleStep;
this.dir.vTransformBy3(this.rotationMatrix);
this.checkDirection(barrelOrigin,this.dir,angle,i,shooterData,tanks,shotResult);
}
}
private function checkDirection(barrelOrigin:Vector3, barrelDir:Vector3, angle:Number, dirIndex:int, shooterData:TankData, tanks:Dictionary, shotResult:ShaftShotResult) : void
{
var distance:Number = NaN;
var directionPriority:Number = NaN;
var len:int = 0;
var i:int = 0;
this.currTargets.length = 0;
this.currHitPoints.length = 0;
var effectivity:Number = this.evaluateDirection(barrelOrigin,barrelDir,shooterData,tanks,this.currTargets,this.currHitPoints);
if(effectivity > 0)
{
distance = this._v.vDiff(this.currHitPoints[0],barrelOrigin).vLength();
directionPriority = this.getDirectionPriority(angle,distance);
if(effectivity > this.bestEffectivity || effectivity == this.bestEffectivity && directionPriority > this.maxDirectionPriority)
{
this.bestEffectivity = effectivity;
this.bestDirectionIndex = dirIndex;
this.maxDirectionPriority = directionPriority;
shotResult.dir.vCopy(barrelDir);
len = this.currTargets.length;
for(i = 0; i < len; i++)
{
shotResult.targets[i] = this.currTargets[i];
shotResult.hitPoints[i] = this.currHitPoints[i];
}
shotResult.targets.length = len;
if(this.currHitPoints.length > len)
{
shotResult.hitPoints[len] = this.currHitPoints[len];
shotResult.hitPoints.length = len + 1;
}
else
{
shotResult.hitPoints.length = len;
}
}
}
}
private function evaluateDirection(barrelOrigin:Vector3, barrelDir:Vector3, shooterData:TankData, tanks:Dictionary, targets:Array, hitPoints:Array) : Number
{
var body:Body = null;
var targetData:TankData = null;
var targetIsEnemy:Boolean = false;
this.multybodyPredicate.bodies = new Dictionary();
this.multybodyPredicate.bodies[shooterData.tank] = true;
this.origin.vCopy(barrelOrigin);
var effectivity:Number = 0;
var effectivityCoeff:Number = 1;
var firstTarget:Boolean = true;
while(this.collisionDetector.intersectRay(this.origin,barrelDir,this.COLLISION_GROUP,this.MAX_RAY_LENGTH,this.multybodyPredicate,this.intersection))
{
body = this.intersection.primitive.body;
if(body == null)
{
hitPoints.push(this.intersection.pos.vClone());
break;
}
targetData = tanks[body];
if(targetData != null)
{
targetIsEnemy = shooterData.teamType == BattleTeamType.NONE || shooterData.teamType != targetData.teamType;
if(firstTarget)
{
if(targetData.health > 0 && !targetIsEnemy)
{
return 0;
}
firstTarget = false;
}
if(targetData.health > 0)
{
if(targetIsEnemy)
{
if(this.ctfModel != null && this.ctfModel.isFlagCarrier(targetData))
{
effectivity += FLAG_CARRIER_BONUS * effectivityCoeff;
}
else
{
effectivity += effectivityCoeff;
}
}
else
{
effectivity -= effectivityCoeff;
}
}
effectivityCoeff *= this.weakeningCoeff;
targets.push(targetData);
hitPoints.push(this.intersection.pos.vClone());
}
this.multybodyPredicate.bodies[body] = true;
this.origin.vCopy(this.intersection.pos);
}
return effectivity;
}
private function collectTargetsAlongRay(shooterData:TankData, barrelOrigin:Vector3, barrelDir:Vector3, tanks:Dictionary, shotResult:ShaftShotResult) : void
{
var body:Body = null;
var targetData:TankData = null;
shotResult.hitPoints.length = 0;
shotResult.targets.length = 0;
shotResult.dir.vCopy(barrelDir);
this.multybodyPredicate.bodies = new Dictionary();
this.multybodyPredicate.bodies[shooterData.tank] = true;
this.origin.vCopy(barrelOrigin);
while(this.collisionDetector.intersectRay(this.origin,barrelDir,this.COLLISION_GROUP,this.MAX_RAY_LENGTH,this.multybodyPredicate,this.intersection))
{
body = this.intersection.primitive.body;
if(body == null)
{
shotResult.hitPoints.push(this.intersection.pos.vClone());
break;
}
targetData = tanks[body];
if(targetData != null)
{
shotResult.targets.push(targetData);
shotResult.hitPoints.push(this.intersection.pos.vClone());
}
this.multybodyPredicate.bodies[body] = true;
this.origin.vCopy(this.intersection.pos);
}
}
private function getDirectionPriority(angle:Number, distance:Number) : Number
{
return MAX_PRIORITY - (DISTANCE_WEIGHT * distance / BASE_DISTANCE + (1 - DISTANCE_WEIGHT) * angle / this.maxAngle);
}
}
}
import alternativa.physics.Body;
import alternativa.physics.collision.IRayCollisionPredicate;
import flash.utils.Dictionary;
class MultybodyCollisionPredicate implements IRayCollisionPredicate
{
public var bodies:Dictionary;
function MultybodyCollisionPredicate()
{
this.bodies = new Dictionary();
super();
}
public function considerBody(body:Body) : Boolean
{
return this.bodies[body] == null;
}
}
|
package alternativa.physics.collision {
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.PhysicsMaterial;
import alternativa.physics.collision.types.AABB;
public class CollisionShape {
public static const BOX:int = 1;
public static const SPHERE:int = 2;
public static const RECT:int = 4;
public static const TRIANGLE:int = 8;
public var type:int;
public var collisionGroup:int;
public var body:Body;
public var localTransform:Matrix4;
public var transform:Matrix4 = new Matrix4();
public var aabb:AABB = new AABB();
public var material:PhysicsMaterial;
public function CollisionShape(param1:int, param2:int, param3:PhysicsMaterial) {
super();
this.type = param1;
this.collisionGroup = param2;
this.material = param3;
}
public function setBody(param1:Body, param2:Matrix4 = null) : void {
if(this.body == param1) {
return;
}
this.body = param1;
if(param1 != null) {
if(param2 != null) {
if(this.localTransform == null) {
this.localTransform = new Matrix4();
}
this.localTransform.copy(param2);
} else {
this.localTransform = null;
}
}
}
public function calculateAABB() : AABB {
return this.aabb;
}
public function raycast(param1:Vector3, param2:Vector3, param3:Number, param4:Vector3) : Number {
return -1;
}
public function clone() : CollisionShape {
var local1:CollisionShape = this.createPrimitive();
return local1.copyFrom(this);
}
public function copyFrom(param1:CollisionShape) : CollisionShape {
if(param1 == null) {
throw new ArgumentError("Parameter source cannot be null");
}
this.type = param1.type;
this.transform.copy(param1.transform);
this.collisionGroup = param1.collisionGroup;
this.setBody(param1.body,param1.localTransform);
this.aabb.copyFrom(param1.aabb);
return this;
}
protected function createPrimitive() : CollisionShape {
return new CollisionShape(this.type,this.collisionGroup,this.material);
}
}
}
|
package forms.userlabel {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.userlabel.ChatUserLabel_goldBattleStatusIconClass.png")]
public class ChatUserLabel_goldBattleStatusIconClass extends BitmapAsset {
public function ChatUserLabel_goldBattleStatusIconClass() {
super();
}
}
}
|
package alternativa.tanks.model.gift
{
import forms.garage.PartsListRenderer;
public class GiftRollerRenderer extends PartsListRenderer
{
public function GiftRollerRenderer()
{
super();
this.buttonMode = false;
this.useHandCursor = false;
}
}
}
|
package alternativa.resource
{
import alternativa.init.Main;
import alternativa.osgi.service.log.ILogService;
import alternativa.osgi.service.log.LogLevel;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BitmapDataChannel;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.events.SecurityErrorEvent;
import flash.geom.Point;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import flash.system.SecurityDomain;
public class ImageResource extends Resource
{
private static const LOADING_STATE_IMAGE_INFO:int = Resource.LOADING_STATE_INFO + 1;
private static const LOADING_STATE_IMAGE:int = Resource.LOADING_STATE_INFO + 2;
private static const IMAGE_INFO_XML:String = "image.xml";
private static const IMAGE_FILE:String = "image.jpg";
private static const ALPHA_FILE:String = "alpha.gif";
private static const LOADING_DIFFUSE:int = 0;
private static const LOADING_ALPHA:int = 1;
private var imageLoader:Loader;
private var imageInfoXml:XML;
private var state:int;
private var imageInfoLoader:URLLoader;
private var _data:BitmapData;
public function ImageResource()
{
super("Картинка");
}
public function get data() : BitmapData
{
return this._data;
}
override protected function doUnload() : void
{
if(this._data != null)
{
this._data.dispose();
this._data = null;
}
}
override protected function doClose() : void
{
switch(loadingState)
{
case LOADING_STATE_IMAGE_INFO:
this.imageInfoLoader.close();
this.destroyImageInfoLoader();
break;
case LOADING_STATE_IMAGE:
this.imageLoader.close();
this.destroyImageLoader();
}
if(this._data != null)
{
this._data.dispose();
this._data = null;
}
this.imageInfoXml = null;
}
override protected function loadResourceData() : void
{
this.imageInfoLoader = new URLLoader();
this.imageInfoLoader.addEventListener(Event.OPEN,this.onImageInfoLoadingOpen);
this.imageInfoLoader.addEventListener(ProgressEvent.PROGRESS,this.onImageInfoLoadingProgress);
this.imageInfoLoader.addEventListener(Event.COMPLETE,this.onImageInfoLoadingComplete);
this.imageInfoLoader.addEventListener(IOErrorEvent.IO_ERROR,this.onImageInfoLoadingError);
this.imageInfoLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onImageInfoLoadingError);
this.imageInfoLoader.load(new URLRequest(url + IMAGE_INFO_XML));
startTimeoutTimer();
}
override protected function createDummyData() : Boolean
{
this._data = new StubBitmapData(16711680);
return true;
}
private function onImageInfoLoadingOpen(event:Event) : void
{
loadingState = LOADING_STATE_IMAGE_INFO;
}
private function onImageInfoLoadingProgress(e:ProgressEvent) : void
{
updateLastActivityType();
}
private function onImageInfoLoadingComplete(e:Event) : void
{
setIdleLoadingState();
this.imageInfoXml = XML(this.imageInfoLoader.data);
this.destroyImageInfoLoader();
setStatus("Loading diffuse map");
this.state = LOADING_DIFFUSE;
this.createImageLoader();
this.imageLoader.load(new URLRequest(url + IMAGE_FILE),new LoaderContext(false,ApplicationDomain.currentDomain,SecurityDomain.currentDomain));
startTimeoutTimer();
}
private function destroyImageInfoLoader() : void
{
this.imageInfoLoader.removeEventListener(Event.OPEN,this.onImageInfoLoadingOpen);
this.imageInfoLoader.removeEventListener(ProgressEvent.PROGRESS,this.onImageInfoLoadingProgress);
this.imageInfoLoader.removeEventListener(Event.COMPLETE,this.onImageInfoLoadingComplete);
this.imageInfoLoader.removeEventListener(IOErrorEvent.IO_ERROR,this.onImageInfoLoadingError);
this.imageInfoLoader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onImageInfoLoadingError);
}
private function createImageLoader() : void
{
this.imageLoader = new Loader();
var loaderInfo:LoaderInfo = this.imageLoader.contentLoaderInfo;
loaderInfo.addEventListener(Event.OPEN,this.onImageLoadingOpen);
loaderInfo.addEventListener(ProgressEvent.PROGRESS,this.onImageLoadingProgress);
loaderInfo.addEventListener(Event.COMPLETE,this.onImageLoadingComplete);
loaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.onImageLoadingError);
}
private function onImageInfoLoadingError(e:ErrorEvent) : void
{
ILogService(Main.osgi.getService(ILogService)).log(LogLevel.LOG_ERROR,"Image resource loading error [id=" + id + "]. Using dummy image.");
setIdleLoadingState();
this.destroyImageInfoLoader();
this.createDummyData();
completeLoading();
}
private function onImageLoadingOpen(event:Event) : void
{
loadingState = LOADING_STATE_IMAGE;
}
private function onImageLoadingProgress(e:ProgressEvent) : void
{
loadingProgress(e.bytesLoaded,e.bytesTotal);
}
private function onImageLoadingComplete(e:Event) : void
{
setIdleLoadingState();
var bitmapData:BitmapData = Bitmap(this.imageLoader.content).bitmapData;
this.destroyImageLoader();
switch(this.state)
{
case LOADING_DIFFUSE:
setStatus("Diffuse map loaded");
this.processDiffuseData(bitmapData);
break;
case LOADING_ALPHA:
setStatus("Alpha map loaded");
this.processAlphaData(bitmapData);
}
}
private function onImageLoadingError(e:ErrorEvent) : void
{
setIdleLoadingState();
this.destroyImageLoader();
switch(this.state)
{
case LOADING_DIFFUSE:
this.processDiffuseData(new StubBitmapData(16711680));
break;
case LOADING_ALPHA:
this.processAlphaData(new StubBitmapData(16711680));
}
}
private function processDiffuseData(bitmapData:BitmapData) : void
{
this._data = bitmapData;
if(this.imageInfoXml.@alpha != "false")
{
this.state = LOADING_ALPHA;
setStatus("Alpha map loading started");
this.createImageLoader();
this.imageLoader.load(new URLRequest(url + ALPHA_FILE),new LoaderContext(false,ApplicationDomain.currentDomain,SecurityDomain.currentDomain));
startTimeoutTimer();
}
else
{
this.completeResourceLoading();
}
}
private function processAlphaData(alphaData:BitmapData) : void
{
this._data = this.mergeBitmapAlpha(this._data,alphaData,true);
this.completeResourceLoading();
}
private function mergeBitmapAlpha(bitmapData:BitmapData, alphaBitmapData:BitmapData, dispose:Boolean = false) : BitmapData
{
var res:BitmapData = new BitmapData(bitmapData.width,bitmapData.height);
var pt:Point = new Point();
res.copyPixels(bitmapData,bitmapData.rect,pt);
res.copyChannel(alphaBitmapData,alphaBitmapData.rect,pt,BitmapDataChannel.RED,BitmapDataChannel.ALPHA);
if(dispose)
{
bitmapData.dispose();
alphaBitmapData.dispose();
}
return res;
}
private function completeResourceLoading() : void
{
this.imageInfoXml = null;
completeLoading();
}
private function destroyImageLoader() : void
{
if(this.imageLoader == null)
{
return;
}
this.imageLoader.unload();
var loaderInfo:LoaderInfo = this.imageLoader.contentLoaderInfo;
loaderInfo.removeEventListener(Event.OPEN,this.onImageLoadingOpen);
loaderInfo.removeEventListener(ProgressEvent.PROGRESS,this.onImageLoadingProgress);
loaderInfo.removeEventListener(Event.COMPLETE,this.onImageLoadingComplete);
loaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,this.onImageLoadingError);
this.imageLoader = null;
}
public function destroy(b:Boolean) : *
{
this._data.dispose();
this._data = null;
this.destroyImageLoader();
}
}
}
|
package alternativa.tanks.model.news
{
import flash.display.BitmapData;
public class NewsIcons
{
[Embed(source="1134.png")]
private static const crystalls_box:Class;
[Embed(source="957.png")]
private static const crystalls_book:Class;
[Embed(source="1121.png")]
private static const fev_14:Class;
[Embed(source="1206.png")]
private static const crystall:Class;
[Embed(source="1095.png")]
private static const magazine:Class;
[Embed(source="1061.png")]
private static const hand_crystalls:Class;
[Embed(source="1179.png")]
private static const happy_birthday:Class;
[Embed(source="1171.png")]
private static const helm_space:Class;
[Embed(source="832.png")]
private static const news_lamp:Class;
[Embed(source="1059.png")]
private static const no_cheats:Class;
[Embed(source="1078.png")]
private static const shaft:Class;
[Embed(source="941.png")]
private static const shaft_secret:Class;
[Embed(source="937.png")]
private static const sale_20:Class;
[Embed(source="914.png")]
private static const shaft_targeting:Class;
[Embed(source="936.png")]
private static const technical:Class;
[Embed(source="1203.png")]
private static const fight:Class;
[Embed(source="949.png")]
private static const update:Class;
[Embed(source="975.png")]
private static const ml5:Class;
[Embed(source="983.png")]
private static const _8march:Class;
private static var instance:NewsIcons = new NewsIcons();
private static var Y:int = 100;
private var crystalls_box_bd:BitmapData;
private var crystalls_book_bd:BitmapData;
private var fev_14_bd:BitmapData;
private var crystall_bd:BitmapData;
private var magazine_bd:BitmapData;
private var hand_crystalls_bd:BitmapData;
private var happy_birthday_bd:BitmapData;
private var helm_space_bd:BitmapData;
private var news_lamp_bd:BitmapData;
private var no_cheats_bd:BitmapData;
private var shaft_bd:BitmapData;
private var shaft_secret_bd:BitmapData;
private var sale_20_bd:BitmapData;
private var shaft_targeting_bd:BitmapData;
private var technical_bd:BitmapData;
private var fight_bd:BitmapData;
private var update_bd:BitmapData;
private var ml5_bd:BitmapData;
private var _8_march_bd:BitmapData;
public function NewsIcons()
{
this.crystalls_box_bd = new crystalls_box().bitmapData;
this.crystalls_book_bd = new crystalls_book().bitmapData;
this.fev_14_bd = new fev_14().bitmapData;
this.crystall_bd = new crystall().bitmapData;
this.magazine_bd = new magazine().bitmapData;
this.hand_crystalls_bd = new hand_crystalls().bitmapData;
this.happy_birthday_bd = new happy_birthday().bitmapData;
this.helm_space_bd = new helm_space().bitmapData;
this.news_lamp_bd = new news_lamp().bitmapData;
this.no_cheats_bd = new no_cheats().bitmapData;
this.shaft_bd = new shaft().bitmapData;
this.shaft_secret_bd = new shaft_secret().bitmapData;
this.sale_20_bd = new sale_20().bitmapData;
this.shaft_targeting_bd = new shaft_targeting().bitmapData;
this.technical_bd = new technical().bitmapData;
this.fight_bd = new fight().bitmapData;
this.update_bd = new update().bitmapData;
this.ml5_bd = new ml5().bitmapData;
this._8_march_bd = new _8march().bitmapData;
super();
}
public static function getIcon(id:String) : BitmapData
{
var bitmapData:BitmapData = instance.update_bd;
try
{
bitmapData = instance[id + "_bd"];
}
catch(e:Error)
{
bitmapData = instance.update_bd;
}
return bitmapData;
}
}
}
|
package alternativa.tanks.model.item.discount.proabonement {
import alternativa.tanks.model.item.discount.DiscountInfo;
import alternativa.tanks.model.item.discount.ICollectDiscount;
import alternativa.tanks.model.item.discount.IDiscountCollector;
import projects.tanks.client.garage.models.item.discount.proabonement.IProAbonementRankDiscountModelBase;
import projects.tanks.client.garage.models.item.discount.proabonement.ProAbonementRankDiscountModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
[ModelInfo]
public class ProAbonementRankDiscountModel extends ProAbonementRankDiscountModelBase implements IProAbonementRankDiscountModelBase, ICollectDiscount, ProAbonementRankDiscount {
[Inject]
public static var userPropertiesService:IUserPropertiesService;
private static const MAX_RANK_INDEX:int = 31;
public function ProAbonementRankDiscountModel() {
super();
}
public function collectDiscountsInfo(param1:IDiscountCollector) : void {
param1.addDiscount(new DiscountInfo(this.getRankDiscount()));
}
public function getRankDiscount() : int {
return getInitParam().percentDiscountPerRank * (MAX_RANK_INDEX - userPropertiesService.rank);
}
}
}
|
package alternativa.tanks.gui.shopitems.item.kits.description.panel
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class KitPackageDescriptionPanelBitmaps_bitmapLeftBottomCorner extends BitmapAsset
{
public function KitPackageDescriptionPanelBitmaps_bitmapLeftBottomCorner()
{
super();
}
}
}
|
package alternativa.tanks.models.tank.event {
import alternativa.tanks.battle.objects.tank.Tank;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.user.tank.TankLogicState;
public class TankEntityCreationListenerAdapt implements TankEntityCreationListener {
private var object:IGameObject;
private var impl:TankEntityCreationListener;
public function TankEntityCreationListenerAdapt(param1:IGameObject, param2:TankEntityCreationListener) {
super();
this.object = param1;
this.impl = param2;
}
public function onTankEntityCreated(param1:Tank, param2:Boolean, param3:TankLogicState) : void {
var tank:Tank = param1;
var isLocal:Boolean = param2;
var logicState:TankLogicState = param3;
try {
Model.object = this.object;
this.impl.onTankEntityCreated(tank,isLocal,logicState);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.bg {
import alternativa.init.TanksServicesActivator;
import alternativa.osgi.OSGi;
import alternativa.osgi.service.display.IDisplay;
import flash.display.BitmapData;
import flash.display.DisplayObjectContainer;
import flash.display.Shape;
import flash.display.Stage;
import flash.events.Event;
import flash.geom.Rectangle;
public class BackgroundService implements IBackgroundService {
private static const bitmapBg:Class = BackgroundService_bitmapBg;
private static const bgBitmap:BitmapData = new bitmapBg().bitmapData;
private var osgi:OSGi;
private var stage:Stage;
private var bgLayer:DisplayObjectContainer;
private var bg:Shape;
private var bgCropRect:Rectangle;
public function BackgroundService() {
super();
this.osgi = TanksServicesActivator.osgi;
var local1:IDisplay = this.osgi.getService(IDisplay) as IDisplay;
this.stage = local1.stage;
this.bgLayer = local1.backgroundLayer;
this.bg = new Shape();
}
public function showBg() : void {
if(!this.bgLayer.contains(this.bg)) {
this.redrawBg();
this.bgLayer.addChild(this.bg);
this.stage.addEventListener(Event.RESIZE,this.redrawBg);
}
}
public function hideBg() : void {
if(this.bgLayer.contains(this.bg)) {
this.stage.removeEventListener(Event.RESIZE,this.redrawBg);
this.bgLayer.removeChild(this.bg);
}
}
public function drawBg(param1:Rectangle = null) : void {
this.bgCropRect = param1;
this.redrawBg();
}
private function redrawBg(param1:Event = null) : void {
this.bg.graphics.clear();
this.bg.graphics.beginBitmapFill(bgBitmap);
this.bg.graphics.drawRect(0,0,this.stage.stageWidth,this.stage.stageHeight);
if(this.bgCropRect != null) {
this.bg.graphics.drawRect(this.bgCropRect.x,this.bgCropRect.y,this.bgCropRect.width,this.bgCropRect.height);
}
}
}
}
|
package alternativa.tanks.view.mainview.groupinvite {
import alternativa.tanks.gui.icons.AcceptedIndicator;
import flash.display.Sprite;
import flash.events.MouseEvent;
import forms.ColorConstants;
import forms.userlabel.UserLabel;
public class InviteUserItem extends Sprite {
private var itemWidth:Number = 0;
private var inviteIndicator:AcceptedIndicator;
private var userLabel:UserLabel;
public function InviteUserItem(param1:Object) {
super();
this.userLabel = new UserLabel(param1.id,false);
this.userLabel.mouseEnabled = false;
this.userLabel.x = -4;
this.userLabel.y = 1;
this.userLabel.setUidColor(Boolean(param1.online) ? ColorConstants.GREEN_LABEL : ColorConstants.ACCESS_LABEL,true);
if(Boolean(param1.online)) {
this.inviteIndicator = new AcceptedIndicator();
this.inviteIndicator.y = 1;
this.inviteIndicator.visible = false;
this.inviteIndicator.addEventListener(MouseEvent.CLICK,this.onClick);
addChild(this.inviteIndicator);
}
addChild(this.userLabel);
}
private function onClick(param1:MouseEvent) : void {
this.inviteIndicator.visible = false;
dispatchEvent(new InviteUserEvent(this.userLabel.userId));
}
override public function get width() : Number {
return this.itemWidth;
}
override public function set width(param1:Number) : void {
this.itemWidth = param1;
this.resize();
}
private function resize() : void {
if(this.inviteIndicator != null) {
this.inviteIndicator.x = this.width - this.inviteIndicator.width - 7;
}
this.redraw();
}
private function redraw() : void {
graphics.clear();
graphics.beginFill(0,0);
graphics.drawRect(0,0,this.width,20);
graphics.endFill();
}
public function showAddIndicator() : void {
if(this.inviteIndicator != null) {
this.inviteIndicator.visible = true;
}
}
public function hideAddIndicator() : void {
if(this.inviteIndicator != null) {
this.inviteIndicator.visible = false;
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.donationalert.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.panel.model.donationalert.types.DonationData;
public class VectorCodecDonationDataLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecDonationDataLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(DonationData,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.<DonationData> = new Vector.<DonationData>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = DonationData(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:DonationData = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<DonationData> = Vector.<DonationData>(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.network
{
import alternativa.init.NetworkActivator;
import alternativa.osgi.service.console.IConsoleService;
import alternativa.protocol.Packet;
import alternativa.protocol.Protocol;
public class AlternativaNetworkClient
{
private static const CHANNEL:String = "NETCLIENT";
private var host:String;
private var protocol:Protocol;
private var packet:Packet;
public function AlternativaNetworkClient(host:String, protocol:Protocol)
{
super();
this.host = host;
this.protocol = protocol;
this.packet = new Packet();
}
public function newConnection(port:int, handler:ICommandHandler) : CommandSocket
{
var console:IConsoleService = NetworkActivator.osgi.getService(IConsoleService) as IConsoleService;
console.writeToConsoleChannel(CHANNEL,"New connection: host=%1, port=%2",this.host,port);
var s:CommandSocket = new CommandSocket(this.host,port,this.packet,this.protocol,handler);
s.connect(this.host,port);
return s;
}
}
}
|
package projects.tanks.client.battlefield.models.statistics.targetingmode {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class TargetingStatisticsModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _switchTargetingModeId:Long = Long.getLong(1681528153,1866528975);
private var _switchTargetingMode_targetingModeCodec:ICodec;
private var model:IModel;
public function TargetingStatisticsModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._switchTargetingMode_targetingModeCodec = this.protocol.getCodec(new EnumCodecInfo(TargetingMode,false));
}
public function switchTargetingMode(param1:TargetingMode) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._switchTargetingMode_targetingModeCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._switchTargetingModeId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.loader
{
import flash.display.Sprite;
import flash.text.TextField;
import flash.text.TextFormat;
public class ProcessBlock extends Sprite
{
public var processId:Object;
public var progressBar:ProgressBar;
public var statusLabel:TextField;
public function ProcessBlock(processId:Object)
{
super();
this.processId = processId;
var tf:TextFormat = new TextFormat("Tahoma",10,16777215);
this.statusLabel = new TextField();
this.statusLabel.text = "Status";
this.statusLabel.defaultTextFormat = tf;
this.statusLabel.wordWrap = true;
this.statusLabel.multiline = true;
this.statusLabel.selectable = false;
addChild(this.statusLabel);
this.statusLabel.x = 43;
this.statusLabel.width = 192;
this.progressBar = new ProgressBar();
addChild(this.progressBar);
this.progressBar.y = 15;
}
}
}
|
package alternativa.gfx.agal
{
import flash.utils.ByteArray;
public class SamplerRegister extends Register
{
protected var samplerbits:int = 5;
public function SamplerRegister(param1:int)
{
super();
this.index = param1;
}
public function dim(param1:SamplerDim) : SamplerRegister
{
this.addSamplerOption(param1);
return this;
}
public function type(param1:SamplerType) : SamplerRegister
{
this.addSamplerOption(param1);
return this;
}
public function special(param1:SamplerSpecial) : SamplerRegister
{
this.addSamplerOption(param1);
return this;
}
public function repeat(param1:SamplerRepeat) : SamplerRegister
{
this.addSamplerOption(param1);
return this;
}
public function mipmap(param1:SamplerMipMap) : SamplerRegister
{
this.addSamplerOption(param1);
return this;
}
public function filter(param1:SamplerFilter) : SamplerRegister
{
this.addSamplerOption(param1);
return this;
}
private function addSamplerOption(param1:SamplerOption) : void
{
this.samplerbits = param1.apply(this.samplerbits);
}
override public function writeSource(param1:ByteArray) : void
{
param1.writeShort(index);
param1.writeShort(0);
param1.writeUnsignedInt(this.samplerbits);
this.samplerbits = 5;
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.controls.bottompanel {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Shape;
import flash.events.Event;
import flash.geom.Rectangle;
import projects.tanks.clients.fp10.Prelauncher.Locale;
import projects.tanks.clients.fp10.Prelauncher.controls.LocalizedControl;
import projects.tanks.clients.fp10.Prelauncher.controls.bottompanel.LinkField.LinkField;
import projects.tanks.clients.fp10.Prelauncher.controls.bottompanel.PartnerLogo.PartnerLogo;
import projects.tanks.clients.fp10.Prelauncher.locales.CN.LocaleCN;
import projects.tanks.clients.fp10.Prelauncher.locales.Locales;
public class BottomPanel extends LocalizedControl {
private static var bottomLine:Class = BottomPanel_bottomLine;
public static var bottomLineData:BitmapData = (new bottomLine() as Bitmap).bitmapData;
public static var bottomPanelHeight:int = 100;
private static var panel:Shape = new Shape();
private const rectangle:Rectangle = new Rectangle(9,9,1,1);
public function BottomPanel() {
super();
}
public function createLines(locale:Locale) : void {
this.addPartners(locale);
if(locale.name == Locales.CN) {
this.createChineseLines(locale as LocaleCN);
return;
}
this.addLine(10,10,5,locale,LinkField.ABOUT);
this.addLine(10,58,15,locale,LinkField.LICENSE,LinkField.RULES,LinkField.CONFIDENT);
}
private function createChineseLines(locale:LocaleCN) : void {
this.addLine(10,4,5,locale,"chinese1","chinese2");
this.addLine(10,20,5,locale,"chinese3");
this.addLine(10,36,5,locale,"chinese4");
this.addLine(10,52,5,locale,"chinese5");
this.addLine(10,68,5,locale,"chinese6");
this.addLine(10,84,5,locale,"chinese7");
this.addLine(400,4,5,locale,"chinese21");
this.addLine(400,20,5,locale,"chinese22");
this.addLine(400,36,5,locale,"chinese23");
this.addLine(400,52,5,locale,"chinese24","chinese25");
this.addLine(400,68,5,locale,"chinese26","chinese27");
}
private function addPartners(locale:Locale) : void {
var type:String = null;
var link:String = null;
var partner:PartnerLogo = null;
var offsetX:Number = 40;
var offsetY:Number = 30;
var gap:Number = 10;
for(var i:int = locale.partners.length / 2; i >= 0; i--) {
type = locale.partners[i * 2];
link = locale.partners[i * 2 + 1];
partner = new PartnerLogo(type,link);
partner.x = stage.stageWidth - offsetX;
partner.y = offsetY;
addChild(partner);
offsetX += gap + partner.actualWidth;
}
}
override protected function onResize(e:Event) : void {
this.x = 5;
this.y = stage.stageHeight - bottomPanelHeight;
this.redrawPanel();
panel.scaleX = (stage.stageWidth - 10) / panel.width;
panel.scaleY = bottomPanelHeight / panel.height + 2;
if(panel.parent == null) {
addChild(panel);
}
}
private function redrawPanel() : void {
var top:Number = NaN;
var j:int = 0;
var gridX:Array = [this.rectangle.left,this.rectangle.right,bottomLineData.width];
var gridY:Array = [this.rectangle.top,this.rectangle.bottom,bottomLineData.height];
panel.graphics.clear();
var left:Number = 0;
for(var i:int = 0; i < 3; i++) {
top = 0;
for(j = 0; j < 3; j++) {
panel.graphics.beginBitmapFill(bottomLineData);
panel.graphics.drawRect(left,top,gridX[i] - left,gridY[j] - top);
panel.graphics.endFill();
top = Number(gridY[j]);
}
left = Number(gridX[i]);
}
panel.scale9Grid = this.rectangle;
}
override public function switchLocale(locale:Locale) : void {
removeChildren();
addChild(panel);
this.createLines(locale);
}
private function addText(type:String, locale:Locale, x:int, y:int) : LinkField {
var linkField:LinkField = new LinkField(type,locale);
linkField.x = x;
linkField.y = y;
addChild(linkField);
return linkField;
}
private function addLine(x:int, y:int, gap:int, locale:Locale, ... args) : void {
var type:String = null;
var lf:LinkField = null;
var offsetX:int = x;
for each(type in args) {
lf = this.addText(type,locale,offsetX,y);
offsetX += lf.getLineMetrics(0).width + gap;
}
}
}
}
|
package alternativa.tanks.service.referrals.buttonhelper {
import forms.stat.ReferralWindowBigButton;
public interface ReferralsButtonHelperService {
function getReferralInviteButton() : ReferralWindowBigButton;
}
}
|
package projects.tanks.client.panel.model.profile.usersettings {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import projects.tanks.client.chat.models.chat.users.personalmessagereceiver.PersonalMessageReceiveMode;
public class SettingsModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:SettingsModelServer;
private var client:ISettingsModelBase = ISettingsModelBase(this);
private var modelId:Long = Long.getLong(1428989873,1951780812);
private var _openAntiAddictionSettingsId:Long = Long.getLong(810018451,-1328707173);
private var _openAntiAddictionSettings_modeCodec:ICodec;
private var _openAntiAddictionSettings_realNameCodec:ICodec;
private var _openAntiAddictionSettings_idNumberCodec:ICodec;
private var _openSettingsId:Long = Long.getLong(826886748,-1809986386);
private var _openSettings_modeCodec:ICodec;
public function SettingsModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new SettingsModelServer(IModel(this));
this._openAntiAddictionSettings_modeCodec = this._protocol.getCodec(new EnumCodecInfo(PersonalMessageReceiveMode,false));
this._openAntiAddictionSettings_realNameCodec = this._protocol.getCodec(new TypeCodecInfo(String,true));
this._openAntiAddictionSettings_idNumberCodec = this._protocol.getCodec(new TypeCodecInfo(String,true));
this._openSettings_modeCodec = this._protocol.getCodec(new EnumCodecInfo(PersonalMessageReceiveMode,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._openAntiAddictionSettingsId:
this.client.openAntiAddictionSettings(PersonalMessageReceiveMode(this._openAntiAddictionSettings_modeCodec.decode(param2)),String(this._openAntiAddictionSettings_realNameCodec.decode(param2)),String(this._openAntiAddictionSettings_idNumberCodec.decode(param2)));
break;
case this._openSettingsId:
this.client.openSettings(PersonalMessageReceiveMode(this._openSettings_modeCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.engine3d {
import alternativa.engine3d.core.MipMapping;
import alternativa.engine3d.materials.TextureMaterial;
import flash.display.BitmapData;
public class DefaultTextureMaterialFactory implements TextureMaterialFactory {
public function DefaultTextureMaterialFactory() {
super();
}
public function createTextureMaterial(param1:BitmapData, param2:Boolean) : TextureMaterial {
return new TextureMaterial(param1,false,true,param2 ? int(MipMapping.PER_PIXEL) : 0);
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapSmallRank03.png")]
public class DefaultRanksBitmaps_bitmapSmallRank03 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapSmallRank03() {
super();
}
}
}
|
package alternativa.tanks.gui.payment.forms.platbox {
import flash.events.Event;
public class ProceedPaymentEvent extends Event {
public static const PROCEED:String = "ProceedPaymentEvent";
public function ProceedPaymentEvent() {
super(PROCEED);
}
}
}
|
package controls.buttons.h30px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h30px.OrangeMediumButtonSkin_leftOverClass.png")]
public class OrangeMediumButtonSkin_leftOverClass extends BitmapAsset {
public function OrangeMediumButtonSkin_leftOverClass() {
super();
}
}
}
|
package controls.buttons {
import assets.button.button_def_DOWN_CENTER;
import assets.button.button_def_DOWN_LEFT;
import assets.button.button_def_DOWN_RIGHT;
import assets.button.button_def_OVER_CENTER;
import assets.button.button_def_OVER_LEFT;
import assets.button.button_def_OVER_RIGHT;
import assets.button.button_def_UP_CENTER;
import assets.button.button_def_UP_LEFT;
import assets.button.button_def_UP_RIGHT;
import controls.buttons.h30px.GreenMediumButtonSkin;
import controls.buttons.h30px.H30ButtonSkin;
import flash.display.BitmapData;
public class CategoryButtonSkin extends FixedHeightButtonSkin {
public function CategoryButtonSkin() {
super(createStateSkinByBitmaps(new button_def_UP_LEFT(1,1),new button_def_UP_CENTER(1,1),new button_def_UP_RIGHT(1,1)),createStateSkinByBitmaps(new button_def_OVER_LEFT(1,1),new button_def_OVER_CENTER(1,1),new button_def_OVER_RIGHT(1,1)),createStateSkinByBitmaps(new button_def_DOWN_LEFT(1,1),new button_def_DOWN_CENTER(1,1),new button_def_DOWN_RIGHT(1,1)),createStateSkin(GreenMediumButtonSkin.leftDownClass,GreenMediumButtonSkin.middleDownClass,GreenMediumButtonSkin.rightDownClass));
}
private static function createStateSkinByBitmaps(param1:BitmapData, param2:BitmapData, param3:BitmapData) : FixedHeightRectangleSkin {
return FixedHeightRectangleSkin.createSkin(param1,param2,param3);
}
private static function createStateSkin(param1:Class, param2:Class, param3:Class) : FixedHeightRectangleSkin {
return new FixedHeightRectangleSkin(param1,param2,param3);
}
public static function createDisableButtonSkin() : H30ButtonSkin {
return new H30ButtonSkin(createStateSkinByBitmaps(new button_def_UP_LEFT(1,1),new button_def_UP_CENTER(1,1),new button_def_UP_RIGHT(1,1)),createStateSkinByBitmaps(new button_def_OVER_LEFT(1,1),new button_def_OVER_CENTER(1,1),new button_def_OVER_RIGHT(1,1)),createStateSkinByBitmaps(new button_def_DOWN_LEFT(1,1),new button_def_DOWN_CENTER(1,1),new button_def_DOWN_RIGHT(1,1)));
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher.sfx {
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 RocketLauncherSfxModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function RocketLauncherSfxModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.battlefield.models.drone.demoman {
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 DroneExplosionModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function DroneExplosionModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.engine3d.primitives {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
use namespace alternativa3d;
public class Sphere extends Mesh {
public function Sphere(param1:Number = 100, param2:uint = 8, param3:uint = 8, param4:Boolean = false, param5:Material = null) {
var local9:uint = 0;
var local10:uint = 0;
var local12:Vertex = null;
var local13:Vertex = null;
var local14:Vertex = null;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
super();
if(param2 < 3) {
throw new ArgumentError(param2 + " radial segments not enough.");
}
if(param3 < 2) {
throw new ArgumentError(param3 + " height segments not enough.");
}
param1 = param1 < 0 ? 0 : param1;
var local6:Object = new Object();
var local7:Number = Math.PI * 2 / param2;
var local8:Number = Math.PI * 2 / (param3 << 1);
local10 = 0;
while(local10 <= param3) {
local15 = local8 * local10;
local16 = Math.sin(local15) * param1;
local17 = Math.cos(local15) * param1;
local9 = 0;
while(local9 <= param2) {
local18 = local7 * local9;
this.createVertex(-Math.sin(local18) * local16,Math.cos(local18) * local16,local17,local9 / param2,local10 / param3,local9 + "_" + local10,local6);
local9++;
}
local10++;
}
var local11:uint = 0;
local9 = 1;
while(local9 <= param2) {
local10 = 0;
while(local10 < param3) {
if(local10 < param3 - 1) {
local12 = local6[local11 + "_" + local10];
local13 = local6[local11 + "_" + (local10 + 1)];
local14 = local6[local9 + "_" + (local10 + 1)];
if(param4) {
this.createFace(local12,local14,local13,param5);
} else {
this.createFace(local12,local13,local14,param5);
}
}
if(local10 > 0) {
local12 = local6[local9 + "_" + (local10 + 1)];
local13 = local6[local9 + "_" + local10];
local14 = local6[local11 + "_" + local10];
if(param4) {
this.createFace(local12,local14,local13,param5);
} else {
this.createFace(local12,local13,local14,param5);
}
}
local10++;
}
local11 = local9;
local9++;
}
calculateFacesNormals(true);
boundMinX = -param1;
boundMinY = -param1;
boundMinZ = -param1;
boundMaxX = param1;
boundMaxY = param1;
boundMaxZ = param1;
}
private function createVertex(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:String, param7:Object) : Vertex {
var local8:Vertex = new Vertex();
local8.x = param1;
local8.y = param2;
local8.z = param3;
local8.u = param4;
local8.v = param5;
local8.alternativa3d::next = alternativa3d::vertexList;
alternativa3d::vertexList = local8;
param7[param6] = local8;
return local8;
}
private function createFace(param1:Vertex, param2:Vertex, param3:Vertex, param4:Material) : void {
var local5:Face = new Face();
local5.material = param4;
local5.alternativa3d::wrapper = new Wrapper();
local5.alternativa3d::wrapper.alternativa3d::vertex = param1;
local5.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local5.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = param2;
local5.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local5.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param3;
local5.alternativa3d::next = alternativa3d::faceList;
alternativa3d::faceList = local5;
}
override public function clone() : Object3D {
var local1:Sphere = new Sphere();
local1.clonePropertiesFrom(this);
return local1;
}
}
}
|
package controls {
import fl.controls.List;
import fl.data.DataProvider;
import fl.events.ListEvent;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.text.AntiAliasType;
import flash.text.GridFitType;
import flash.text.TextFieldAutoSize;
[Embed(source="/_assets/assets.swf", symbol="symbol1318")]
public class TankCombo extends Sprite {
public var button:ComboButton = new ComboButton();
private var listBg:TankWindowInner = new TankWindowInner(100,150,100);
private var list:List = new List();
private var dp:DataProvider = new DataProvider();
private var state:Boolean = true;
public var _labelInfo:Label;
private var _selectedItem:Object;
private var _selectedIndex:int = 0;
private var _width:int;
private var _value:String;
public function TankCombo() {
super();
this._labelInfo = new Label();
this._labelInfo.x = -10;
this._labelInfo.y = 7;
this._labelInfo.antiAliasType = AntiAliasType.ADVANCED;
this._labelInfo.gridFitType = GridFitType.SUBPIXEL;
addChild(this.listBg);
addChild(this.list);
addChild(this.button);
addChild(this._labelInfo);
this.listBg.y = 3;
this.list.y = 33;
this.list.x = 3;
this.list.setSize(144,115);
this.list.rowHeight = 20;
this.list.dataProvider = this.dp;
this.list.setStyle("cellRenderer",ComboListRenderer);
this.button.addEventListener(MouseEvent.CLICK,this.switchState);
this.switchState();
this.list.addEventListener(ListEvent.ITEM_CLICK,this.onItemClick);
addEventListener(Event.ADDED_TO_STAGE,this.Conf);
}
public function get selectedItem() : Object {
return this._selectedItem;
}
public function set selectedItem(param1:Object) : void {
if(param1 == null) {
this._selectedItem = null;
this.button.label = "";
} else {
this._selectedIndex = this.dp.getItemIndex(param1);
this._selectedItem = this.dp.getItemAt(this._selectedIndex);
this.button.label = param1.gameName;
}
dispatchEvent(new Event(Event.CHANGE));
}
public function get selectedIndex() : int {
return this._selectedIndex;
}
public function set label(param1:String) : void {
this._labelInfo.text = param1;
this._labelInfo.autoSize = TextFieldAutoSize.RIGHT;
}
private function Conf(param1:Event) : void {
}
private function onItemClick(param1:ListEvent) : void {
var local2:Object = param1.item;
this._selectedIndex = param1.index;
if(local2.rang == 0) {
this.button.label = local2.gameName;
this._selectedItem = local2;
}
this.switchState();
dispatchEvent(new Event(Event.CHANGE));
}
private function switchStateClose(param1:MouseEvent = null) : void {
if(param1.currentTarget as DisplayObject != this.button) {
this.state = false;
this.listBg.visible = this.list.visible = this.state;
}
}
private function switchState(param1:MouseEvent = null) : void {
this.state = !this.state;
this.listBg.visible = this.list.visible = this.state;
}
public function addItem(param1:Object) : void {
var local2:Object = null;
this.dp.addItem(param1);
local2 = this.dp.getItemAt(0);
this._selectedItem = local2;
this.button.label = local2.gameName;
}
public function sortOn(param1:Object, param2:Object = null) : void {
var local3:Object = null;
this.dp.sortOn(param1,param2);
local3 = this.dp.getItemAt(0);
this._selectedItem = local3;
this._value = this._selectedItem.gameName;
this.button.label = local3.gameName;
}
public function clear() : void {
this.dp = new DataProvider();
this.list.dataProvider = this.dp;
this.button.label = "";
}
override public function set width(param1:Number) : void {
this._width = int(param1);
this.listBg.width = this._width;
this.button.width = this._width;
this.list.width = this._width - 6;
this.list.invalidate();
}
public function set value(param1:String) : void {
var local2:Object = null;
this._value = "";
this.button.label = this._value;
this._selectedItem = null;
var local3:int = 0;
while(local3 < this.dp.length) {
local2 = this.dp.getItemAt(local3);
if(local2.gameName == param1) {
this._selectedItem = local2;
this._value = this._selectedItem.gameName;
this.button.label = this._value;
this.list.selectedIndex = local3;
this.list.scrollToSelected();
}
local3++;
}
dispatchEvent(new Event(Event.CHANGE));
}
public function selectItemByField(param1:String, param2:Object) : void {
var local4:Object = null;
var local3:int = 0;
while(local3 < this.dp.length) {
local4 = this.dp.getItemAt(local3);
if(local4[param1] == param2) {
this._selectedItem = local4;
this._value = this._selectedItem.gameName;
this.button.label = this._value;
this.list.selectedIndex = local3;
this.list.scrollToSelected();
dispatchEvent(new Event(Event.CHANGE));
return;
}
local3++;
}
}
public function get value() : String {
return this._value;
}
}
}
|
package alternativa.tanks.model.item.upgradable {
import alternativa.tanks.service.item.ItemService;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParams;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParamsService;
import alternativa.tanks.service.upgradingitems.UpgradingItemsService;
import controls.timer.CountDownTimer;
import controls.timer.CountDownTimerOnCompleteAfter;
import flash.utils.getTimer;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.types.ItemGarageProperty;
import projects.tanks.client.garage.models.item.upgradeable.UpgradeParamsCC;
import projects.tanks.client.garage.models.item.upgradeable.types.GaragePropertyParams;
import projects.tanks.client.garage.models.item.upgradeable.types.UpgradeParamsData;
public class UpgradableItemParams implements CountDownTimerOnCompleteAfter {
[Inject]
public static var upgradingItemService:UpgradingItemsService;
[Inject]
public static var propertyService:ItemPropertyParamsService;
[Inject]
public static var itemService:ItemService;
private static const SECONDS_IN_MINUTE:int = 60;
public var properties:Vector.<UpgradableItemPropertyValue>;
public var visibleProperties:Vector.<UpgradableItemPropertyValue>;
public var timer:CountDownTimer = null;
private var currentLevel:int;
private var upgradeParams:UpgradeParamsData;
private var speedUpDiscount:int;
private var upgradeDiscount:int;
private var timeDiscount:int;
public function UpgradableItemParams(param1:UpgradeParamsCC, param2:IGameObject) {
var local3:GaragePropertyParams = null;
var local4:UpgradableItemPropertyValue = null;
var local5:UpgradableItemPropertyValue = null;
var local6:int = 0;
super();
this.currentLevel = param1.currentLevel;
this.upgradeParams = param1.itemData;
this.speedUpDiscount = param1.speedUpDiscount;
this.upgradeDiscount = param1.upgradeDiscount;
this.timeDiscount = param1.timeDiscount;
this.properties = new Vector.<UpgradableItemPropertyValue>();
for each(local3 in param1.itemData.properties) {
local5 = new UpgradableItemPropertyValue(this.upgradeParams.upgradeLevelsCount,local3);
this.properties.push(local5);
}
this.properties.sort(this.compare);
this.visibleProperties = new Vector.<UpgradableItemPropertyValue>();
for each(local4 in this.properties) {
if(local4.isVisibleInInfo()) {
this.visibleProperties.push(local4);
}
}
if(param1.remainingTimeInMS > 0) {
this.timer = upgradingItemService.getCountDownTimer(param2);
if(this.timer == null) {
this.timer = new CountDownTimer();
upgradingItemService.add(itemService.getGarageItemInfo(param2),this.timer);
}
local6 = Math.max(this.timer.getEndTime(),getTimer() + param1.remainingTimeInMS);
this.setTimer(this.timer);
this.timer.start(local6);
}
}
private function compare(param1:UpgradableItemPropertyValue, param2:UpgradableItemPropertyValue) : Number {
var local3:ItemPropertyParams = propertyService.getParams(param1.getProperty());
var local4:ItemPropertyParams = propertyService.getParams(param2.getProperty());
var local5:int = local3 != null ? local3.sortIndex : 0;
var local6:int = local4 != null ? local4.sortIndex : 0;
if(local5 < local6) {
return -1;
}
if(local5 > local6) {
return 1;
}
return 0;
}
private function setTimer(param1:CountDownTimer) : void {
this.timer = param1;
param1.addListener(CountDownTimerOnCompleteAfter,this);
}
public function getValue(param1:ItemGarageProperty) : UpgradableItemPropertyValue {
var local2:UpgradableItemPropertyValue = null;
for each(local2 in this.properties) {
if(local2.getProperty() == param1) {
return local2;
}
}
return null;
}
public function startUpgrade(param1:CountDownTimer) : void {
this.setTimer(param1);
}
public function speedUp() : void {
++this.currentLevel;
this.timer.removeListener(CountDownTimerOnCompleteAfter,this);
this.timer = null;
}
public function isUpgrading() : Boolean {
return this.timer != null;
}
public function onCompleteAfter(param1:CountDownTimer, param2:Boolean) : void {
this.speedUp();
}
public function getLevelsCount() : int {
return this.upgradeParams.upgradeLevelsCount;
}
public function isFullUpgraded() : Boolean {
return this.currentLevel == this.getLevelsCount();
}
public function getLevel() : int {
return this.currentLevel;
}
public function getStartUpgradePrice() : int {
var local1:int = this.getStartUpgradePriceForLevelWithoutDiscount(this.getLevel());
return this.applyDiscount(local1,this.upgradeDiscount);
}
private function getStartUpgradePriceForLevelWithoutDiscount(param1:int) : int {
if(this.getLevelsCount() == 1) {
return this.upgradeParams.initialUpgradePrice;
}
var local2:int = this.upgradeParams.initialUpgradePrice + (this.upgradeParams.finalUpgradePrice - this.upgradeParams.initialUpgradePrice) * param1 / (this.getLevelsCount() - 1) + 0.001;
return int((local2 + 5) / 10 + 0.01) * 10;
}
public function getSpeedUpPrice() : int {
var local1:Number = this.getSpeedUpPriceWithoutDiscount(this.timer.getRemainingSeconds() / SECONDS_IN_MINUTE);
return this.applyDiscount(local1,this.speedUpDiscount);
}
public function getInitialSpeedUpPrice() : int {
var local1:Number = this.getSpeedUpPriceWithoutDiscount(this.getTimeInMinutes());
return this.applyDiscount(local1,this.speedUpDiscount);
}
private function getSpeedUpPriceWithoutDiscount(param1:Number) : int {
return Math.round(param1 * this.upgradeParams.speedUpCoeff / this.upgradeParams.upgradeTimeCoeff) + 0.1;
}
public function getTimeInSeconds() : int {
return this.getTimeInMinutes() * SECONDS_IN_MINUTE + 0.1;
}
private function getTimeInMinutes() : Number {
var local1:int = this.getTimeInMinutesForLevelWithoutDiscount(this.getLevel()) * SECONDS_IN_MINUTE;
return this.applyDiscount(local1,this.timeDiscount) / SECONDS_IN_MINUTE;
}
private function getTimeInMinutesForLevelWithoutDiscount(param1:int) : Number {
return Math.round(this.getStartUpgradePriceForLevelWithoutDiscount(param1) * this.upgradeParams.upgradeTimeCoeff);
}
private function applyDiscount(param1:int, param2:int) : int {
if(param2 == 0) {
return param1;
}
return int(param1 * (100 - param2) / 100 + 0.001);
}
public function hasSpeedUpDiscount() : Boolean {
return this.speedUpDiscount > 0;
}
public function hasUpgradeDiscount() : Boolean {
return this.upgradeDiscount > 0 || this.timeDiscount > 0;
}
public function traceUpgrades() : void {
var local1:UpgradableItemPropertyValue = null;
var local2:int = 0;
var local3:Number = NaN;
for each(local1 in this.properties) {
}
local2 = 0;
while(local2 <= this.getLevelsCount()) {
for each(local1 in this.properties) {
}
if(local2 != this.getLevelsCount()) {
local3 = this.getTimeInMinutesForLevelWithoutDiscount(local2);
}
local2++;
}
}
}
}
|
package alternativa.tanks.models.battlefield.inventory
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import alternativa.tanks.model.panel.IPanelListener;
import alternativa.tanks.models.inventory.IInventory;
import alternativa.tanks.models.inventory.InventoryLock;
import alternativa.tanks.models.tank.ITankEventDispatcher;
import alternativa.tanks.models.tank.ITankEventListener;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.tank.TankEvent;
import controls.InventoryIcon;
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
import flash.utils.Dictionary;
import flash.utils.getTimer;
import projects.tanks.client.battlefield.gui.models.inventory.IInventoryModelBase;
import projects.tanks.client.battlefield.gui.models.inventory.InventoryModelBase;
public class InventoryModel extends InventoryModelBase implements IInventoryModelBase, IObjectLoadListener, IInventoryPanel, IInventory, IPanelListener, ITankEventListener
{
private static const PANEL_OFFSET_Y:int = 50;
private var container:DisplayObjectContainer;
private var inventorySlots:Vector.<InventoryPanelSlot>;
private var guiLayer:DisplayObjectContainer;
private var slotIndexByKeyCode:Dictionary;
private var inventoryItemModel:IInventoryItemModel;
private var uiLockCounter:int;
public function InventoryModel()
{
this.slotIndexByKeyCode = new Dictionary();
super();
_interfaces.push(IModel,IInventoryModelBase,IObjectLoadListener,IInventoryPanel,IInventory,IPanelListener);
this.guiLayer = Main.contentUILayer;
}
public function killCurrentUser(clientObject:ClientObject) : void
{
this.lockItems(InventoryLock.PLAYER_INACTIVE,true);
}
public function battleFinish(clientObject:ClientObject) : void
{
this.lockItems(InventoryLock.PLAYER_INACTIVE,true);
}
public function battleRestart(clientObject:ClientObject) : void
{
}
public function objectLoaded(object:ClientObject) : void
{
this.container = new Sprite();
this.container.visible = false;
this.guiLayer.addChild(this.container);
this.initSlots();
this.initKeyCodes();
var tankEventDispatcher:ITankEventDispatcher = ITankEventDispatcher(Main.osgi.getService(ITankEventDispatcher));
tankEventDispatcher.addTankEventListener(TankEvent.ACTIVATED,this);
Main.stage.addEventListener(Event.RESIZE,this.onResize);
this.onResize(null);
}
public function objectUnloaded(object:ClientObject) : void
{
if(this.inventorySlots == null)
{
return;
}
for(var i:int = 0; i < this.inventorySlots.length; i++)
{
this.clearSlot(i);
}
this.inventorySlots = null;
this.guiLayer.removeChild(this.container);
this.container = null;
var tankEventDispatcher:ITankEventDispatcher = ITankEventDispatcher(Main.osgi.getService(ITankEventDispatcher));
tankEventDispatcher.removeTankEventListener(TankEvent.ACTIVATED,this);
this.guiLayer.stage.removeEventListener(Event.RESIZE,this.onResize);
}
public function assignItemToSlot(item:InventoryItem, slotIndex:int) : void
{
var modelService:IModelService = null;
if(item == null)
{
return;
}
if(this.inventoryItemModel == null)
{
modelService = IModelService(Main.osgi.getService(IModelService));
this.inventoryItemModel = IInventoryItemModel(modelService.getModelsByInterface(IInventoryItemModel)[0]);
}
if(this.getActiveSlotsCount() == 0)
{
this.guiLayer.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.onKey);
this.guiLayer.stage.addEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
var slot:InventoryPanelSlot = this.inventorySlots[slotIndex];
slot.setItem(item);
this.container.visible = true;
}
public function itemActivated(item:InventoryItem) : void
{
var slot:InventoryPanelSlot = null;
for each(slot in this.inventorySlots)
{
if(slot.getItem() == item)
{
slot.updateCounter();
}
}
}
public function itemUpdated(item:InventoryItem) : void
{
var slot:InventoryPanelSlot = null;
for each(slot in this.inventorySlots)
{
if(slot.getItem() == item)
{
slot.updateCounter();
}
}
}
public function lockItem(itemType:int, lockMask:int, lock:Boolean) : void
{
var slot:InventoryPanelSlot = null;
var item:InventoryItem = null;
for each(slot in this.inventorySlots)
{
item = slot.getItem();
if(item != null && item.getId() == itemType)
{
slot.setLockMask(lockMask,lock);
}
}
}
public function lockItems(lockMask:int, lock:Boolean) : void
{
var slot:InventoryPanelSlot = null;
for each(slot in this.inventorySlots)
{
slot.setLockMask(lockMask,lock);
}
}
public function bugReportOpened() : void
{
this.updateUILock(1);
}
public function bugReportClosed() : void
{
this.updateUILock(-1);
}
public function friendsOpened() : void
{
this.updateUILock(1);
}
public function friendsClosed() : void
{
this.updateUILock(-1);
}
public function settingsOpened() : void
{
this.updateUILock(1);
}
public function onCloseGame() : void
{
this.updateUILock(1);
}
public function onCloseGameExit() : void
{
this.updateUILock(-1);
}
public function settingsAccepted() : void
{
this.updateUILock(-1);
}
public function settingsCanceled() : void
{
this.updateUILock(-1);
}
public function handleTankEvent(eventType:int, tankData:TankData) : void
{
var slot:InventoryPanelSlot = null;
var item:InventoryItem = null;
if(eventType == TankEvent.ACTIVATED && tankData.local)
{
for each(slot in this.inventorySlots)
{
slot.setLockMask(InventoryLock.PLAYER_INACTIVE,false);
item = slot.getItem();
if(item != null)
{
item.clearCooldown();
}
}
}
}
public function setMuteSound(mute:Boolean) : void
{
}
private function updateUILock(lockIncrement:int) : void
{
var slot:InventoryPanelSlot = null;
this.uiLockCounter += lockIncrement;
if(this.uiLockCounter < 0)
{
this.uiLockCounter = 0;
}
if(this.inventorySlots != null)
{
for each(slot in this.inventorySlots)
{
slot.setLockMask(InventoryLock.GUI,this.uiLockCounter > 0);
}
}
}
private function onResize(e:Event) : void
{
this.container.x = 0;
this.container.y = Main.stage.stageHeight - PANEL_OFFSET_Y;
}
private function initSlots() : void
{
var slot:InventoryPanelSlot = null;
var slotCanvas:DisplayObject = null;
this.inventorySlots = new Vector.<InventoryPanelSlot>(5);
var spacing:int = 10 + new InventoryIcon(InventoryIcon.EMPTY).width;
var x:int = 10;
for(var i:int = 0; i < 5; i++)
{
slot = new InventoryPanelSlot(i + 1);
this.inventorySlots[i] = slot;
slotCanvas = slot.getCanvas();
slotCanvas.x = x;
this.container.addChild(slotCanvas);
x += spacing;
}
}
private function onKey(e:KeyboardEvent) : void
{
var i:* = this.slotIndexByKeyCode[e.keyCode];
if(i == null)
{
return;
}
var slotIndex:int = i;
var slot:InventoryPanelSlot = this.inventorySlots[slotIndex];
if(slot.isLocked())
{
return;
}
var item:InventoryItem = slot.getItem();
if(item != null)
{
this.inventoryItemModel.requestActivation(item);
}
}
private function getActiveSlotsCount() : int
{
var count:int = 0;
var slot:InventoryPanelSlot = null;
for each(slot in this.inventorySlots)
{
if(slot.getItem() != null)
{
count++;
}
}
return count;
}
private function clearSlot(slotIndex:int) : void
{
var slot:InventoryPanelSlot = this.inventorySlots[slotIndex];
slot.setItem(null);
if(this.getActiveSlotsCount() == 0)
{
this.guiLayer.stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKey);
this.guiLayer.stage.removeEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
}
private function onEnterFrame(e:Event) : void
{
var slot:InventoryPanelSlot = null;
var now:int = getTimer();
for each(slot in this.inventorySlots)
{
slot.update(now);
}
}
private function initKeyCodes() : void
{
this.slotIndexByKeyCode[49] = 0;
this.slotIndexByKeyCode[Keyboard.NUMPAD_1] = 0;
this.slotIndexByKeyCode[50] = 1;
this.slotIndexByKeyCode[Keyboard.NUMPAD_2] = 1;
this.slotIndexByKeyCode[51] = 2;
this.slotIndexByKeyCode[Keyboard.NUMPAD_3] = 2;
this.slotIndexByKeyCode[52] = 3;
this.slotIndexByKeyCode[Keyboard.NUMPAD_4] = 3;
this.slotIndexByKeyCode[53] = 4;
this.slotIndexByKeyCode[Keyboard.NUMPAD_5] = 4;
}
}
}
|
package alternativa.tanks.models.weapon.common
{
import alternativa.math.Vector3;
import alternativa.tanks.models.weapon.IWeaponController;
public class WeaponCommonData
{
public var kickback:Number = 0;
public var impactCoeff:Number = 0;
public var impactForce:Number = 0;
public var turretRotationAccel:Number = 0;
public var turretRotationSpeed:Number = 0;
public var muzzles:Vector.<Vector3>;
public var currBarrel:int;
public var weaponController:IWeaponController;
public function WeaponCommonData()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.android {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class AndroidPayModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _checkForConsumeTokensId:Long = Long.getLong(815792077,-1486947250);
private var _checkForConsumeTokens_purchaseDataCodec:ICodec;
private var _consumeSuccessId:Long = Long.getLong(1194773696,-1519770162);
private var _consumeSuccess_tokenIdCodec:ICodec;
private var _makePaymentId:Long = Long.getLong(1511923011,-1242214449);
private var _makePayment_tokenIdCodec:ICodec;
private var _makePayment_itemIdCodec:ICodec;
private var _makePayment_currencyCodec:ICodec;
private var model:IModel;
public function AndroidPayModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._checkForConsumeTokens_purchaseDataCodec = this.protocol.getCodec(new TypeCodecInfo(PurchaseData,false));
this._consumeSuccess_tokenIdCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._makePayment_tokenIdCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._makePayment_itemIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._makePayment_currencyCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function checkForConsumeTokens(param1:PurchaseData) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._checkForConsumeTokens_purchaseDataCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._checkForConsumeTokensId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function consumeSuccess(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._consumeSuccess_tokenIdCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._consumeSuccessId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function makePayment(param1:String, param2:Long, param3:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._makePayment_tokenIdCodec.encode(this.protocolBuffer,param1);
this._makePayment_itemIdCodec.encode(this.protocolBuffer,param2);
this._makePayment_currencyCodec.encode(this.protocolBuffer,param3);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local4:SpaceCommand = new SpaceCommand(Model.object.id,this._makePaymentId,this.protocolBuffer);
var local5:IGameObject = Model.object;
var local6:ISpace = local5.space;
local6.commandSender.sendCommand(local4);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package forms.friends.list.renderer.background
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class FriendCellSelected_rightIconClass extends BitmapAsset
{
public function FriendCellSelected_rightIconClass()
{
super();
}
}
}
|
package alternativa.tanks.loader
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ProgressBar_bitmapLampOff extends BitmapAsset
{
public function ProgressBar_bitmapLampOff()
{
super();
}
}
}
|
package alternativa.tanks.display.usertitle {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.display.usertitle.ProgressBarSkin_hpRightBgRedCls.png")]
public class ProgressBarSkin_hpRightBgRedCls extends BitmapAsset {
public function ProgressBarSkin_hpRightBgRedCls() {
super();
}
}
}
|
package _codec.platform.client.fp10.core.resource.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 platform.client.fp10.core.resource.types.TextureResource;
public class VectorCodecTextureResourceLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTextureResourceLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TextureResource,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.<TextureResource> = new Vector.<TextureResource>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TextureResource(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TextureResource = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TextureResource> = Vector.<TextureResource>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.tank.ultimate.titan {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.math.Vector3;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.controlpoints.sfx.AnimatedBeam;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class ShieldBeamEffect extends PooledObject implements GraphicEffect {
private static const direction:Vector3 = new Vector3();
private static const unitLength:Number = 500;
private static const animationSpeed:Number = -0.2;
private static const beamWidth:Number = 80;
private static const uRange:Number = 0.3;
private static const alpha:Number = 1;
private static const activationDuration:int = 100;
private static const targetOffset:Number = 130;
private var beam:AnimatedBeam = new AnimatedBeam(1,1,1,0);
private var alive:Boolean = false;
private var endPosition:Vector3 = new Vector3();
private var startPosition:Vector3 = new Vector3();
private var endAnchor:Object3D;
private var container:Scene3DContainer;
private var lifeTime:int = 0;
public function ShieldBeamEffect(param1:Pool) {
super(param1);
}
public function init(param1:Object3D, param2:Vector3, param3:TextureMaterial, param4:TextureMaterial) : void {
this.endAnchor = param1;
this.startPosition.copy(param2);
this.beam.setMaterials(param4,param3);
this.beam.setUnitLength(unitLength);
this.beam.setWidth(beamWidth);
this.beam.setTipLength(50);
this.beam.setURange(uRange);
this.beam.animationSpeed = animationSpeed;
this.beam.alpha = alpha;
this.lifeTime = 0;
}
public function play(param1:int, param2:GameCamera) : Boolean {
this.lifeTime += param1;
this.endPosition.x = this.endAnchor.x;
this.endPosition.y = this.endAnchor.y;
this.endPosition.z = this.endAnchor.z;
direction.diff(this.endPosition,this.startPosition);
var local3:Number = Math.min(this.lifeTime / activationDuration,1);
var local4:Number = Math.max(0,direction.length() - targetOffset) * local3;
this.beam.setLength(local4);
direction.normalize();
SFXUtils.alignObjectPlaneToView(this.beam,this.startPosition,direction,param2.position);
this.beam.update(param1 * 0.001);
return this.alive;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.alive = true;
this.container = param1;
param1.addChild(this.beam);
}
public function destroy() : void {
if(this.container != null) {
this.container.removeChild(this.beam);
this.container = null;
}
}
public function kill() : void {
this.alive = false;
}
}
}
|
package alternativa.engine3d.loaders.events
{
import flash.events.Event;
public class LoaderEvent extends Event
{
public static const PART_OPEN:String = "partOpen";
public static const PART_COMPLETE:String = "partComplete";
private var _partsTotal:int;
private var _currentPart:int;
private var _target:Object;
public function LoaderEvent(param1:String, param2:int, param3:int, param4:Object = null)
{
super(param1);
this._partsTotal = param2;
this._currentPart = param3;
this._target = param4;
}
public function get partsTotal() : int
{
return this._partsTotal;
}
public function get currentPart() : int
{
return this._currentPart;
}
override public function get target() : Object
{
return this._target;
}
override public function clone() : Event
{
return new LoaderEvent(type,this._partsTotal,this._currentPart,this._target);
}
override public function toString() : String
{
return "[LoaderEvent type=" + type + ", partsTotal=" + this._partsTotal + ", currentPart=" + this._currentPart + ", target=" + this._target + "]";
}
}
}
|
package projects.tanks.client.battlefield.models.drone {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class DroneSFXModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:DroneSFXModelServer;
private var client:IDroneSFXModelBase = IDroneSFXModelBase(this);
private var modelId:Long = Long.getLong(2558086,-1197244864);
public function DroneSFXModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new DroneSFXModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(DroneSFXCC,false)));
}
protected function getInitParam() : DroneSFXCC {
return DroneSFXCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package {
import controls.panel.BaseButton;
[Embed(source="/_assets/assets.swf", symbol="symbol451")]
public dynamic class MainPanelBattlesButton extends BaseButton {
public function MainPanelBattlesButton() {
super();
}
}
}
|
package projects.tanks.client.clans.clan.accepted {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.client.clans.container.ContainerCC;
public class ClanAcceptedModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ClanAcceptedModelServer;
private var client:IClanAcceptedModelBase = IClanAcceptedModelBase(this);
private var modelId:Long = Long.getLong(202978443,152865914);
private var _onAddingId:Long = Long.getLong(1980347621,1611632721);
private var _onAdding_userIdCodec:ICodec;
private var _onRemovedId:Long = Long.getLong(1261234115,476186094);
private var _onRemoved_userIdCodec:ICodec;
public function ClanAcceptedModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ClanAcceptedModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ContainerCC,false)));
this._onAdding_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._onRemoved_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
}
protected function getInitParam() : ContainerCC {
return ContainerCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._onAddingId:
this.client.onAdding(Long(this._onAdding_userIdCodec.decode(param2)));
break;
case this._onRemovedId:
this.client.onRemoved(Long(this._onRemoved_userIdCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.panel.model.garage.rankupsupplybonus {
public interface IRankUpSupplyBonusModelBase {
function showRankUpSupplyBonusAlerts(param1:Vector.<RankUpSupplyBonusInfo>) : void;
}
}
|
package alternativa.protocol.codec.primitive
{
import alternativa.protocol.codec.AbstractCodec;
import alternativa.protocol.codec.NullMap;
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
public class DoubleCodec extends AbstractCodec
{
public function DoubleCodec()
{
super();
nullValue = Number.NEGATIVE_INFINITY;
}
override protected function doDecode(reader:IDataInput, nullmap:NullMap, notnull:Boolean) : Object
{
return reader.readDouble();
}
override protected function doEncode(dest:IDataOutput, object:Object, nullmap:NullMap, notnull:Boolean) : void
{
dest.writeDouble(Number(object));
}
}
}
|
package projects.tanks.client.panel.model.shop.specialkit.view.singleitem {
import platform.client.fp10.core.resource.types.ImageResource;
public class SingleItemKitViewCC {
private var _brandIcon:ImageResource;
private var _button:ImageResource;
private var _buttonOver:ImageResource;
private var _preview:ImageResource;
public function SingleItemKitViewCC(param1:ImageResource = null, param2:ImageResource = null, param3:ImageResource = null, param4:ImageResource = null) {
super();
this._brandIcon = param1;
this._button = param2;
this._buttonOver = param3;
this._preview = param4;
}
public function get brandIcon() : ImageResource {
return this._brandIcon;
}
public function set brandIcon(param1:ImageResource) : void {
this._brandIcon = param1;
}
public function get button() : ImageResource {
return this._button;
}
public function set button(param1:ImageResource) : void {
this._button = param1;
}
public function get buttonOver() : ImageResource {
return this._buttonOver;
}
public function set buttonOver(param1:ImageResource) : void {
this._buttonOver = param1;
}
public function get preview() : ImageResource {
return this._preview;
}
public function set preview(param1:ImageResource) : void {
this._preview = param1;
}
public function toString() : String {
var local1:String = "SingleItemKitViewCC [";
local1 += "brandIcon = " + this.brandIcon + " ";
local1 += "button = " + this.button + " ";
local1 += "buttonOver = " + this.buttonOver + " ";
local1 += "preview = " + this.preview + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.panel.model.referrals {
import alternativa.types.Long;
public class ReferralIncomeData {
private var _income:int;
private var _user:Long;
public function ReferralIncomeData(param1:int = 0, param2:Long = null) {
super();
this._income = param1;
this._user = param2;
}
public function get income() : int {
return this._income;
}
public function set income(param1:int) : void {
this._income = param1;
}
public function get user() : Long {
return this._user;
}
public function set user(param1:Long) : void {
this._user = param1;
}
public function toString() : String {
var local1:String = "ReferralIncomeData [";
local1 += "income = " + this.income + " ";
local1 += "user = " + this.user + " ";
return local1 + "]";
}
}
}
|
package platform.client.core.general.spaces.loading.modelconstructors {
import alternativa.types.Long;
public class ModelData {
private var _data:Object;
private var _id:Long;
public function ModelData(param1:Object = null, param2:Long = null) {
super();
this._data = param1;
this._id = param2;
}
public function get data() : Object {
return this._data;
}
public function set data(param1:Object) : void {
this._data = param1;
}
public function get id() : Long {
return this._id;
}
public function set id(param1:Long) : void {
this._id = param1;
}
public function toString() : String {
var local1:String = "ModelData [";
local1 += "data = " + this.data + " ";
local1 += "id = " + this.id + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_bitmapFreezeResistance_x2.png")]
public class ResistancesIcons_bitmapFreezeResistance_x2 extends BitmapAsset {
public function ResistancesIcons_bitmapFreezeResistance_x2() {
super();
}
}
}
|
package alternativa.tanks.model.payment.shop.discount {
import projects.tanks.client.panel.model.shop.discount.IShopDiscountModelBase;
import projects.tanks.client.panel.model.shop.discount.ShopDiscountModelBase;
[ModelInfo]
public class ShopDiscountModel extends ShopDiscountModelBase implements IShopDiscountModelBase, ShopDiscount {
public function ShopDiscountModel() {
super();
}
public function isEnabled() : Boolean {
return getInitParam().enabled;
}
public function applyDiscount(param1:Number) : Number {
if(this.isEnabled()) {
return param1 * (1 - getInitParam().discountInPercent * 0.01);
}
return param1;
}
}
}
|
package controls.resultassets
{
import assets.resultwindow.bres_BG_RED_PIXEL;
import assets.resultwindow.bres_BG_RED_TL;
public class ResultWindowRed extends ResultWindowBase
{
public function ResultWindowRed()
{
super();
tl = new bres_BG_RED_TL(1,1);
px = new bres_BG_RED_PIXEL(1,1);
}
}
}
|
package alternativa.engine3d.loaders.collada {
public class DaeLogger {
public function DaeLogger() {
super();
}
private function logMessage(param1:String, param2:XML) : void {
var local3:int = 0;
var local4:String = param2.nodeKind() == "attribute" ? "@" + param2.localName() : param2.localName() + (local3 > 0 ? "[" + local3 + "]" : "");
var local5:* = param2.parent();
while(local5 != null) {
local4 = local5.localName() + (local3 > 0 ? "[" + local3 + "]" : "") + "." + local4;
local5 = local5.parent();
}
}
private function logError(param1:String, param2:XML) : void {
this.logMessage("[ERROR] " + param1,param2);
}
public function logExternalError(param1:XML) : void {
this.logError("External urls don\'t supported",param1);
}
public function logSkewError(param1:XML) : void {
this.logError("<skew> don\'t supported",param1);
}
public function logJointInAnotherSceneError(param1:XML) : void {
this.logError("Joints in different scenes don\'t supported",param1);
}
public function logInstanceNodeError(param1:XML) : void {
this.logError("<instance_node> don\'t supported",param1);
}
public function logNotFoundError(param1:XML) : void {
this.logError("Element with url \"" + param1.toString() + "\" not found",param1);
}
public function logNotEnoughDataError(param1:XML) : void {
this.logError("Not enough data",param1);
}
}
}
|
package alternativa.types {
import flash.events.Event;
import flash.text.TextField;
import flash.text.TextFormat;
public class LogOutput extends TextField {
public function LogOutput() {
super();
defaultTextFormat = new TextFormat("Tahoma",11,16777215);
multiline = true;
wordWrap = true;
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemovedFromStage);
}
public function addLine(param1:String) : void {
appendText(param1 + "\n");
}
private function onAddedToStage(param1:Event) : void {
stage.addEventListener(Event.RESIZE,this.onStageResize);
this.onStageResize(null);
}
private function onRemovedFromStage(param1:Event) : void {
stage.removeEventListener(Event.RESIZE,this.onStageResize);
}
private function onStageResize(param1:Event) : void {
width = stage.stageWidth;
height = stage.stageHeight;
}
}
}
|
package alternativa.tanks.view.battlelist.modefilter {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battlelist.modefilter.BattleModeCheckBox_overStateClass.png")]
public class BattleModeCheckBox_overStateClass extends BitmapAsset {
public function BattleModeCheckBox_overStateClass() {
super();
}
}
}
|
package alternativa.tanks.gui.device {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.service.device.DeviceService;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParamsService;
import alternativa.tanks.service.money.IMoneyService;
import controls.base.DefaultButtonBase;
import fl.containers.ScrollPane;
import fl.controls.ScrollPolicy;
import flash.display.Sprite;
import flash.events.MouseEvent;
import forms.ColorConstants;
import forms.base.BaseFormWithInner;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.IDialogsService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import utils.ScrollStyleUtils;
public class DevicesWindow extends DialogWindow {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var moneyService:IMoneyService;
[Inject]
public static var propertyService:ItemPropertyParamsService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var dialogService:IDialogsService;
[Inject]
public static var deviceService:DeviceService;
private static const WINDOW_WIDTH:int = 509;
private static const WINDOW_HEIGHT:int = 450;
private static const VERTICAL_MARGIN:int = 8;
private static const HORIZONTAL_MARGIN:int = 12;
private static const MIN_DEVICE_PANEL_HEIGHT:int = 110;
private var baseForm:BaseFormWithInner = new BaseFormWithInner(WINDOW_WIDTH,WINDOW_HEIGHT,24);
private var scrollContainer:Sprite = new Sprite();
private var scrollPane:ScrollPane = new ScrollPane();
private var closeButton:DefaultButtonBase = new DefaultButtonBase();
private var devicePanels:Vector.<DevicePanel> = new Vector.<DevicePanel>();
private var scrollPaneBottomPadding:Sprite = new Sprite();
private var targetItem:IGameObject;
private var deviceController:DeviceController;
public function DevicesWindow(param1:IGameObject) {
super();
this.targetItem = param1;
this.addWindow();
this.addScrollPane();
this.addCloseButton();
this.addDevicePanels();
this.deviceController = new DeviceController(this.devicePanels,param1);
this.scrollPane.update();
dialogService.addDialog(this);
}
private function addWindow() : void {
this.baseForm.inner.showBlink = false;
this.baseForm.window.setHeaderId(TanksLocale.TEXT_HEADER_DEVICES);
this.baseForm.setHeight(WINDOW_HEIGHT);
addChild(this.baseForm);
}
private function addScrollPane() : void {
this.scrollPane.y = 10;
ScrollStyleUtils.setGreenStyle(this.scrollPane);
this.scrollPane.horizontalScrollPolicy = ScrollPolicy.OFF;
this.scrollPane.verticalScrollPolicy = ScrollPolicy.AUTO;
this.scrollPane.source = this.scrollContainer;
this.scrollPane.focusEnabled = false;
this.scrollPane.setSize(WINDOW_WIDTH,WINDOW_HEIGHT - 20);
this.baseForm.inner.addChild(this.scrollPane);
}
private function addCloseButton() : void {
this.closeButton.label = localeService.getText(TanksLocale.TEXT_GARAGE_CLOSE_TEXT);
this.closeButton.addEventListener(MouseEvent.CLICK,this.onMouseClick);
this.baseForm.window.addChild(this.closeButton);
}
private function addDevicePanels() : void {
var local4:Number = NaN;
var local1:Vector.<IGameObject> = this.getDevices(this.targetItem);
var local2:int = 6;
var local3:int = 0;
while(local3 < local1.length) {
local4 = Number(this.createDevicePanel(local1[local3],local2).height);
local2 += Math.max(local4,MIN_DEVICE_PANEL_HEIGHT);
local2 += 12;
local3++;
}
this.fitToContent(local2);
}
private function getDevices(param1:IGameObject) : Vector.<IGameObject> {
var local2:Vector.<IGameObject> = deviceService.getAvailableDevices(param1).concat();
this.addDefaultDevice(local2);
return local2;
}
private function addDefaultDevice(param1:Vector.<IGameObject>) : void {
param1.unshift(null);
}
private function fitToContent(param1:int) : void {
this.baseForm.setHeight(Math.min(param1 + 12,WINDOW_HEIGHT));
this.fixScrollPaneBottomPadding(param1);
this.alignCloseButton();
dialogService.centerDialog(this);
}
private function fixScrollPaneBottomPadding(param1:int) : void {
this.scrollPaneBottomPadding = new Sprite();
this.scrollContainer.addChild(this.scrollPaneBottomPadding);
this.scrollPaneBottomPadding.graphics.lineStyle(1,ColorConstants.WHITE,0);
this.scrollPaneBottomPadding.graphics.beginFill(ColorConstants.WHITE,0);
this.scrollPaneBottomPadding.graphics.drawRect(0,0,1,15);
this.scrollPaneBottomPadding.graphics.endFill();
this.scrollPaneBottomPadding.x = 0;
this.scrollPaneBottomPadding.y = param1;
}
private function createDevicePanel(param1:IGameObject, param2:int) : DevicePanel {
var local3:DevicePanel = new DevicePanel(this.targetItem,param1);
local3.y = param2;
this.scrollContainer.addChild(local3);
this.devicePanels.push(local3);
return local3;
}
private function alignCloseButton() : void {
this.closeButton.y = this.baseForm.window.height - 5 - this.closeButton.height - VERTICAL_MARGIN;
this.closeButton.x = this.baseForm.window.width - this.closeButton.width - HORIZONTAL_MARGIN;
}
private function onMouseClick(param1:MouseEvent) : void {
this.onClose();
}
override protected function cancelKeyPressed() : void {
this.onClose();
}
protected function onClose() : void {
var local1:DevicePanel = null;
this.deviceController.destroy();
this.deviceController = null;
this.removeEvents();
for each(local1 in this.devicePanels) {
local1.destroy();
}
dialogService.removeDialog(this);
}
protected function removeEvents() : void {
this.closeButton.removeEventListener(MouseEvent.CLICK,this.onClose);
}
override public function get width() : Number {
return this.baseForm.window.width;
}
override public function get height() : Number {
return this.baseForm.window.height;
}
}
}
|
package alternativa.tanks.view.battlelist.battleitem.renderer.normal {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battlelist.battleitem.renderer.normal.CellNormalSelected_normalRight.png")]
public class CellNormalSelected_normalRight extends BitmapAsset {
public function CellNormalSelected_normalRight() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.gauss.state {
import alternativa.tanks.models.weapon.gauss.GaussEventType;
public interface IGaussState {
function enter(param1:int, param2:GaussEventType, param3:*) : void;
function update(param1:int, param2:int) : void;
}
}
|
package utils.tweener.core {
public final class PropTween {
public var target:Object;
public var property:String;
public var start:Number;
public var change:Number;
public var name:String;
public var priority:int;
public var isPlugin:Boolean;
public var nextNode:PropTween;
public var prevNode:PropTween;
public function PropTween(param1:Object, param2:String, param3:Number, param4:Number, param5:String, param6:Boolean, param7:PropTween = null, param8:int = 0) {
super();
this.target = param1;
this.property = param2;
this.start = param3;
this.change = param4;
this.name = param5;
this.isPlugin = param6;
if(Boolean(param7)) {
param7.prevNode = this;
this.nextNode = param7;
}
this.priority = param8;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.listener {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.UserInfoConsumer;
public class UserNotifierAdapt implements UserNotifier {
private var object:IGameObject;
private var impl:UserNotifier;
public function UserNotifierAdapt(param1:IGameObject, param2:UserNotifier) {
super();
this.object = param1;
this.impl = param2;
}
public function getDataConsumer(param1:Long) : UserInfoConsumer {
var result:UserInfoConsumer = null;
var userId:Long = param1;
try {
Model.object = this.object;
result = this.impl.getDataConsumer(userId);
}
finally {
Model.popObject();
}
return result;
}
public function hasDataConsumer(param1:Long) : Boolean {
var result:Boolean = false;
var userId:Long = param1;
try {
Model.object = this.object;
result = Boolean(this.impl.hasDataConsumer(userId));
}
finally {
Model.popObject();
}
return result;
}
public function subcribe(param1:Long, param2:UserInfoConsumer) : void {
var userId:Long = param1;
var consumer:UserInfoConsumer = param2;
try {
Model.object = this.object;
this.impl.subcribe(userId,consumer);
}
finally {
Model.popObject();
}
}
public function refresh(param1:Long, param2:UserInfoConsumer) : void {
var userId:Long = param1;
var consumer:UserInfoConsumer = param2;
try {
Model.object = this.object;
this.impl.refresh(userId,consumer);
}
finally {
Model.popObject();
}
}
public function unsubcribe(param1:Vector.<Long>) : void {
var usersId:Vector.<Long> = param1;
try {
Model.object = this.object;
this.impl.unsubcribe(usersId);
}
finally {
Model.popObject();
}
}
public function getCurrentUserId() : Long {
var result:Long = null;
try {
Model.object = this.object;
result = this.impl.getCurrentUserId();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.colortransform.struct {
public class ColorTransformStruct {
private var _alphaMultiplier:Number;
private var _alphaOffset:int;
private var _blueMultiplier:Number;
private var _blueOffset:int;
private var _greenMultiplier:Number;
private var _greenOffset:int;
private var _redMultiplier:Number;
private var _redOffset:int;
private var _t:Number;
public function ColorTransformStruct(param1:Number = 0, param2:int = 0, param3:Number = 0, param4:int = 0, param5:Number = 0, param6:int = 0, param7:Number = 0, param8:int = 0, param9:Number = 0) {
super();
this._alphaMultiplier = param1;
this._alphaOffset = param2;
this._blueMultiplier = param3;
this._blueOffset = param4;
this._greenMultiplier = param5;
this._greenOffset = param6;
this._redMultiplier = param7;
this._redOffset = param8;
this._t = param9;
}
public function get alphaMultiplier() : Number {
return this._alphaMultiplier;
}
public function set alphaMultiplier(param1:Number) : void {
this._alphaMultiplier = param1;
}
public function get alphaOffset() : int {
return this._alphaOffset;
}
public function set alphaOffset(param1:int) : void {
this._alphaOffset = param1;
}
public function get blueMultiplier() : Number {
return this._blueMultiplier;
}
public function set blueMultiplier(param1:Number) : void {
this._blueMultiplier = param1;
}
public function get blueOffset() : int {
return this._blueOffset;
}
public function set blueOffset(param1:int) : void {
this._blueOffset = param1;
}
public function get greenMultiplier() : Number {
return this._greenMultiplier;
}
public function set greenMultiplier(param1:Number) : void {
this._greenMultiplier = param1;
}
public function get greenOffset() : int {
return this._greenOffset;
}
public function set greenOffset(param1:int) : void {
this._greenOffset = param1;
}
public function get redMultiplier() : Number {
return this._redMultiplier;
}
public function set redMultiplier(param1:Number) : void {
this._redMultiplier = param1;
}
public function get redOffset() : int {
return this._redOffset;
}
public function set redOffset(param1:int) : void {
this._redOffset = param1;
}
public function get t() : Number {
return this._t;
}
public function set t(param1:Number) : void {
this._t = param1;
}
public function toString() : String {
var local1:String = "ColorTransformStruct [";
local1 += "alphaMultiplier = " + this.alphaMultiplier + " ";
local1 += "alphaOffset = " + this.alphaOffset + " ";
local1 += "blueMultiplier = " + this.blueMultiplier + " ";
local1 += "blueOffset = " + this.blueOffset + " ";
local1 += "greenMultiplier = " + this.greenMultiplier + " ";
local1 += "greenOffset = " + this.greenOffset + " ";
local1 += "redMultiplier = " + this.redMultiplier + " ";
local1 += "redOffset = " + this.redOffset + " ";
local1 += "t = " + this.t + " ";
return local1 + "]";
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation.BarrelElevationCommand;
public class VectorCodecBarrelElevationCommandLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBarrelElevationCommandLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BarrelElevationCommand,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.<BarrelElevationCommand> = new Vector.<BarrelElevationCommand>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BarrelElevationCommand(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BarrelElevationCommand = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BarrelElevationCommand> = Vector.<BarrelElevationCommand>(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.battlelist.modefilter {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battlelist.modefilter.BattleModeIcons_dmIconClass.png")]
public class BattleModeIcons_dmIconClass extends BitmapAsset {
public function BattleModeIcons_dmIconClass() {
super();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.