code
stringlengths 57
237k
|
|---|
package projects.tanks.client.battlefield.models.effects.activationsfx {
public interface ITankEffectSFXModelBase {
function effectActivated(param1:int) : void;
}
}
|
package _codec.projects.tanks.client.partners.impl.odnoklassniki {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.partners.impl.odnoklassniki.OdnoklassnikiUrlParams;
public class CodecOdnoklassnikiUrlParams implements ICodec {
public function CodecOdnoklassnikiUrlParams() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:OdnoklassnikiUrlParams = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = OdnoklassnikiUrlParams.API_SERVER;
break;
case 1:
local2 = OdnoklassnikiUrlParams.APICONNECTION;
break;
case 2:
local2 = OdnoklassnikiUrlParams.APPLICATION_KEY;
break;
case 3:
local2 = OdnoklassnikiUrlParams.AUTH_SIG;
break;
case 4:
local2 = OdnoklassnikiUrlParams.AUTHORIZED;
break;
case 5:
local2 = OdnoklassnikiUrlParams.CONTAINER;
break;
case 6:
local2 = OdnoklassnikiUrlParams.CUSTOM_ARGS;
break;
case 7:
local2 = OdnoklassnikiUrlParams.FIRST_START;
break;
case 8:
local2 = OdnoklassnikiUrlParams.HEADER_WIDGET;
break;
case 9:
local2 = OdnoklassnikiUrlParams.LOGGED_USER_ID;
break;
case 10:
local2 = OdnoklassnikiUrlParams.REFERER;
break;
case 11:
local2 = OdnoklassnikiUrlParams.REFPLACE;
break;
case 12:
local2 = OdnoklassnikiUrlParams.SESSION_KEY;
break;
case 13:
local2 = OdnoklassnikiUrlParams.SESSION_SECRET_KEY;
break;
case 14:
local2 = OdnoklassnikiUrlParams.SIG;
}
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 alternativa.tanks.gui.panel.buttons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.panel.buttons.ClanButton_attentionIconClass.png")]
public class ClanButton_attentionIconClass extends BitmapAsset {
public function ClanButton_attentionIconClass() {
super();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.battle {
import alternativa.types.Long;
import flash.events.Event;
public class LeaveBattleNotifierServiceEvent extends Event {
public static const LEAVE:String = "LeaveBattleNotifierServiceEvent.LEAVE_BATTLE";
public var userId:Long;
public function LeaveBattleNotifierServiceEvent(param1:String, param2:Long, param3:Boolean = false, param4:Boolean = false) {
this.userId = param2;
super(param1,param3,param4);
}
}
}
|
package projects.tanks.client.entrance.model.entrance.logging {
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 RegistrationUXLoggerModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:RegistrationUXLoggerModelServer;
private var client:IRegistrationUXLoggerModelBase = IRegistrationUXLoggerModelBase(this);
private var modelId:Long = Long.getLong(1494230661,807116609);
public function RegistrationUXLoggerModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new RegistrationUXLoggerModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.quest.daily {
import flash.events.Event;
import projects.tanks.client.panel.model.quest.daily.DailyQuestInfo;
public class DailyQuestChangeEvent extends Event {
public static const DAILY_QUEST_CHANGE:String = "DailyQuestChange";
public var dailyQuestInfo:DailyQuestInfo;
public function DailyQuestChangeEvent(param1:String, param2:DailyQuestInfo) {
super(param1,true);
this.dailyQuestInfo = param2;
}
}
}
|
package controls.cellrenderer {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.cellrenderer.CellUnavailable_normalCenter.png")]
public class CellUnavailable_normalCenter extends BitmapAsset {
public function CellUnavailable_normalCenter() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.common
{
import alternativa.engine3d.core.Camera3D;
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.osgi.service.dump.IDumpService;
import alternativa.osgi.service.dump.dumper.IDumper;
import alternativa.physics.altphysics;
import alternativa.service.IModelService;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.sfx.shoot.ICommonShootSFX;
import alternativa.tanks.models.tank.ITank;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.weapon.IWeapon;
import alternativa.tanks.models.weapon.IWeaponController;
import alternativa.tanks.models.weapon.WeaponConst;
import alternativa.tanks.sfx.EffectsPair;
import alternativa.tanks.vehicles.tanks.Tank;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.common.IWeaponCommonModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.common.WeaponCommonModelBase;
import flash.events.KeyboardEvent;
import flash.geom.Vector3D;
import flash.ui.Keyboard;
import flash.utils.getTimer;
import scpacker.resource.ResourceType;
import scpacker.resource.ResourceUtil;
import scpacker.tanks.WeaponsManager;
use namespace altphysics;
public class WeaponCommonModel extends WeaponCommonModelBase implements IWeaponCommonModelBase, IObjectLoadListener, IWeaponCommonModel, IWeapon, IDumper
{
private var triggerKeyCode:uint;
private var modelService:IModelService;
private var battlefield:IBattleField;
private var tankModel:ITank;
private var localUserData:TankData;
private var localCommonData:WeaponCommonData;
public var localWeaponController:IWeaponController;
private var triggerPressed:Boolean;
private var enabled:Boolean;
private var indicatorValue:Number = 0;
private var triggerKeyDown:Boolean;
private var triggerKeyUp:Boolean;
private var _hitPosition:Vector3;
private var numObjects:int;
public function WeaponCommonModel()
{
this._hitPosition = new Vector3();
super();
_interfaces.push(IModel,IWeaponCommonModelBase,IObjectLoadListener,IWeaponCommonModel,IWeapon);
this.triggerKeyCode = Keyboard.SPACE;
}
public function getWeaponController() : IWeaponController
{
return this.localWeaponController;
}
public function initObject(clientObject:ClientObject, impactForce:Number, kickback:Number, turretRotationAcceleration:Number, turretRotationSpeed:Number) : void
{
if(this.modelService == null)
{
this.modelService = Main.osgi.getService(IModelService) as IModelService;
this.battlefield = Main.osgi.getService(IBattleField) as IBattleField;
this.tankModel = Main.osgi.getService(ITank) as ITank;
}
var weaponData:WeaponCommonData = new WeaponCommonData();
var correctionCoeff:Number = WeaponConst.BASE_IMPACT_FORCE;
weaponData.kickback = kickback * correctionCoeff;
weaponData.impactCoeff = impactForce;
weaponData.impactForce = impactForce * correctionCoeff;
weaponData.turretRotationAccel = turretRotationAcceleration;
weaponData.turretRotationSpeed = turretRotationSpeed;
weaponData.muzzles = this.parseMuzzles(clientObject);
clientObject.putParams(WeaponCommonModel,weaponData);
++this.numObjects;
}
public function objectLoaded(clientObject:ClientObject) : void
{
var weaponData:WeaponCommonData = this.getCommonData(clientObject);
weaponData.weaponController = BattleController.getWeaponController(clientObject);
}
public function objectUnloaded(clientObject:ClientObject) : void
{
var dumpService:IDumpService = null;
if(this.localUserData != null && this.localUserData.turret == clientObject)
{
this.removeKeyboardListeners();
}
--this.numObjects;
if(this.numObjects == 0)
{
dumpService = IDumpService(Main.osgi.getService(IDumpService));
if(dumpService != null)
{
dumpService.unregisterDumper(this.dumperName);
}
}
}
public function getCommonData(clientObject:ClientObject) : WeaponCommonData
{
return WeaponCommonData(clientObject.getParams(WeaponCommonModel));
}
public function createShotEffects(turretObject:ClientObject, firingTank:Tank, barrelIndex:int, globalMuzzlePosition:Vector3, globalGunDirection:Vector3) : void
{
var commonData:WeaponCommonData = this.getCommonData(turretObject);
firingTank.addWorldForceScaled(globalMuzzlePosition,globalGunDirection,-commonData.kickback);
var sfxModel:ICommonShootSFX = WeaponsManager.getCommonShotSFX(WeaponsManager.getObjectFor(turretObject.id));
if(sfxModel == null)
{
return;
}
if(this.battlefield == null)
{
this.battlefield = Main.osgi.getService(IBattleField) as IBattleField;
}
var effectsPair:EffectsPair = sfxModel.createShotEffects(turretObject,commonData.muzzles[barrelIndex],firingTank.skin.turretMesh,this.battlefield.getBattlefieldData().viewport.camera);
this.battlefield.addGraphicEffect(effectsPair.graphicEffect);
this.battlefield.addSound3DEffect(effectsPair.soundEffect);
}
public function createExplosionEffects(turretObject:ClientObject, camera:Camera3D, isLocalHitPosition:Boolean, hitPosition:Vector3, globalHitDirection:Vector3, victimData:TankData, impactCoeff:Number) : void
{
var sfxModel:ICommonShootSFX = WeaponsManager.getCommonShotSFX(turretObject);
if(sfxModel == null)
{
return;
}
if(victimData != null)
{
if(isLocalHitPosition)
{
victimData.tank.baseMatrix.transformVector(hitPosition,this._hitPosition);
this._hitPosition.vAdd(victimData.tank.state.pos);
}
else
{
this._hitPosition.vCopy(hitPosition);
}
victimData.tank.addWorldForceScaled(this._hitPosition,globalHitDirection,this.getCommonData(turretObject).impactForce * impactCoeff);
}
else
{
this._hitPosition.vCopy(hitPosition);
}
var effectsPair:EffectsPair = sfxModel.createExplosionEffects(turretObject,this._hitPosition,camera,impactCoeff);
if(this.battlefield == null)
{
this.battlefield = Main.osgi.getService(IBattleField) as IBattleField;
}
this.battlefield.addGraphicEffect(effectsPair.graphicEffect);
this.battlefield.addSound3DEffect(effectsPair.soundEffect);
}
public function ownerLoaded(ownerObject:ClientObject) : void
{
var ownerTankData:TankData = this.tankModel.getTankData(ownerObject);
if(ownerTankData.local)
{
this.indicatorValue = 0;
this.localUserData = ownerTankData;
this.localCommonData = this.getCommonData(this.localUserData.turret);
this.localWeaponController = this.localCommonData.weaponController;
if(this.localWeaponController == null)
{
this.localWeaponController = BattleController.getWeaponController(ownerObject);
}
if(this.localWeaponController != null)
{
this.localWeaponController.setLocalUser(ownerTankData);
}
this.addKeyboardListeners();
this.triggerKeyUp = false;
this.triggerKeyDown = false;
this.enabled = false;
}
}
public function ownerUnloaded(ownerObject:ClientObject) : void
{
var ownerTankData:TankData = this.tankModel.getTankData(ownerObject);
var commonData:WeaponCommonData = this.getCommonData(ownerTankData.turret);
if(commonData.weaponController != null)
{
commonData.weaponController.stopEffects(ownerTankData);
}
if(ownerTankData.local)
{
if(this.localWeaponController != null)
{
this.localWeaponController.deactivateWeapon(getTimer(),false);
this.localWeaponController.clearLocalUser();
}
this.enabled = false;
this.localUserData = null;
this.localCommonData = null;
this.localWeaponController = null;
this.removeKeyboardListeners();
}
}
public function ownerDisabled(ownerObject:ClientObject) : void
{
var ownerTankData:TankData = this.tankModel.getTankData(ownerObject);
var commonData:WeaponCommonData = this.getCommonData(ownerTankData.turret);
if(commonData.weaponController != null)
{
commonData.weaponController.stopEffects(ownerTankData);
}
if(ownerTankData.local)
{
if(this.localWeaponController != null)
{
this.localWeaponController.deactivateWeapon(getTimer(),false);
this.localWeaponController.reset();
}
if(this.triggerKeyDown && this.triggerKeyUp)
{
this.triggerKeyUp = false;
this.triggerKeyDown = false;
}
this.enabled = false;
this.triggerPressed = false;
this.indicatorValue = 0;
}
}
public function reset() : void
{
if(this.localWeaponController != null)
{
this.localWeaponController.reset();
}
}
public function enable() : void
{
if(!this.enabled && this.localWeaponController != null)
{
this.enabled = true;
}
}
public function disable() : void
{
if(!this.enabled || this.localWeaponController == null)
{
return;
}
this.enabled = false;
this.triggerKeyDown = false;
this.triggerKeyUp = false;
this.triggerPressed = false;
this.localWeaponController.deactivateWeapon(getTimer(),true);
}
public function stop() : void
{
if(!this.enabled || this.localWeaponController == null)
{
return;
}
this.triggerKeyUp = true;
}
public function update(time:int, deltaTime:int) : Number
{
if(this.localWeaponController == null)
{
return 0;
}
var activatedThisUpdate:Boolean = false;
var doUpdate:Boolean = true;
if(this.enabled)
{
if(this.triggerKeyDown)
{
if(!this.triggerPressed)
{
this.triggerPressed = true;
activatedThisUpdate = true;
this.localWeaponController.activateWeapon(time);
}
}
if(this.triggerKeyUp)
{
if(this.triggerPressed)
{
if(activatedThisUpdate)
{
this.indicatorValue = this.localWeaponController.update(time,deltaTime);
doUpdate = false;
}
this.localWeaponController.deactivateWeapon(time,true);
this.triggerPressed = false;
}
this.triggerKeyUp = false;
this.triggerKeyDown = false;
}
}
if(doUpdate)
{
this.indicatorValue = this.localWeaponController.update(time,deltaTime);
}
return this.indicatorValue;
}
public function getTurretRotationAccel(clientObject:ClientObject) : Number
{
return this.getCommonData(clientObject).turretRotationAccel;
}
public function getTurretRotationSpeed(clientObject:ClientObject) : Number
{
return this.getCommonData(clientObject).turretRotationSpeed;
}
public function get dumperName() : String
{
return "weaponcommon";
}
public function dump(params:Vector.<String>) : String
{
return "=== WeaponCommonModel dump ===\n" + "enabled=" + this.enabled + "\n" + "triggerPressed=" + this.triggerPressed + "\n" + "triggerKeyDown=" + this.triggerKeyDown + "\n" + "triggerKeyUp=" + this.triggerKeyUp + "\n" + "indicatorValue=" + this.indicatorValue + "\n" + "=== end of WeaponCommonModel dump ===";
}
private function v3dto3(src:Vector.<Vector3D>) : Vector.<Vector3>
{
var v:Vector3D = null;
var f:Vector.<Vector3> = new Vector.<Vector3>();
for each(v in src)
{
f.push(new Vector3(v.x,v.y,v.z));
}
return f;
}
private function parseMuzzles(clientObject:ClientObject) : Vector.<Vector3>
{
return this.v3dto3(ResourceUtil.getResource(ResourceType.MODEL,clientObject.id).muzzles);
}
private function onKey(e:KeyboardEvent) : void
{
if(e.keyCode != this.triggerKeyCode || this.localWeaponController == null)
{
return;
}
if(e.type == KeyboardEvent.KEY_DOWN)
{
this.triggerKeyDown = true;
this.triggerKeyUp = false;
}
else if(!this.enabled)
{
this.triggerKeyUp = false;
this.triggerKeyDown = false;
}
else
{
this.triggerKeyUp = true;
}
}
private function addKeyboardListeners() : void
{
Main.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.onKey);
Main.stage.addEventListener(KeyboardEvent.KEY_UP,this.onKey);
}
private function removeKeyboardListeners() : void
{
Main.stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKey);
Main.stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKey);
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.locales.EN {
import projects.tanks.clients.fp10.Prelauncher.Locale;
import projects.tanks.clients.fp10.Prelauncher.controls.bottompanel.PartnerLogo.PartnerLogo;
import projects.tanks.clients.fp10.Prelauncher.locales.Locales;
import projects.tanks.clients.fp10.Prelauncher.locales.TextLinkPair;
public class LocaleEn extends Locale {
public function LocaleEn() {
super();
this.name = Locales.EN;
this.playText = "PLAY";
this.exitText = "EXIT";
partners.push(PartnerLogo.FB,"https://www.facebook.com/TankiOnline.en");
partners.push(PartnerLogo.TWITTER,"https://twitter.com/tankionlineen");
partners.push(PartnerLogo.YOUTUBE,"http://www.youtube.com/user/tankionlineint");
partners.push(PartnerLogo.INSTAGRAM,"http://instagram.com/tankionlineen");
partners.push(PartnerLogo.GP,"https://plus.google.com/+tankionlineint/");
partners.push(PartnerLogo.TWITCH,"http://www.twitch.tv/tankistarladder_en");
this.game = new TextLinkPair("Game","http://tankionline.com/en/");
this.materials = new TextLinkPair("Materials","http://tankionline.com/en/media/");
this.tournaments = new TextLinkPair("Tournament","http://tournament.tankionline.com/en/");
this.forum = new TextLinkPair("Forum","http://en.tankiforum.com/");
this.wiki = new TextLinkPair("Wiki","http://en.tankiwiki.com/");
this.ratings = new TextLinkPair("Ratings","http://ratings.tankionline.com/en/");
this.help = new TextLinkPair("Help","http://help.tankionline.com/en/");
this.license = new TextLinkPair("EULA","http://tankionline.com/en/eula/");
this.aboutCompany = new TextLinkPair("©2017 Tanki Online Europe Ltd. All rights reserved.","");
this.techSupport = new TextLinkPair("Contact us regarding any issues:","");
this.email = new TextLinkPair("help@tankionline.com","mailto:help@tankionline.com");
this.rules = new TextLinkPair("Rules","http://tankionline.com/en/rules/");
this.confidentialityPolicy = new TextLinkPair("Privacy policy","http://tankionline.com/en/privacy/");
}
}
}
|
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 BooleanCodec extends AbstractCodec
{
public function BooleanCodec()
{
super();
}
override protected function doDecode(reader:IDataInput, nullmap:NullMap, notnull:Boolean) : Object
{
return reader.readByte() != 0;
}
override protected function doEncode(dest:IDataOutput, object:Object, nullmap:NullMap, notnull:Boolean) : void
{
dest.writeByte(!!Boolean(object) ? int(int(int(1))) : int(int(int(0))));
}
}
}
|
package alternativa.types {
public class UShort {
public function UShort() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.garage.availableupgrades {
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.garage.availableupgrades.AvailableUpgradeItem;
public class VectorCodecAvailableUpgradeItemLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecAvailableUpgradeItemLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(AvailableUpgradeItem,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.<AvailableUpgradeItem> = new Vector.<AvailableUpgradeItem>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = AvailableUpgradeItem(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:AvailableUpgradeItem = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<AvailableUpgradeItem> = Vector.<AvailableUpgradeItem>(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 forms.friends
{
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.types.Long;
import controls.ValidationIcon;
import controls.base.LabelBase;
import controls.base.TankInputBase;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.FocusEvent;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.text.TextField;
import flash.ui.Keyboard;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import forms.ColorConstants;
import scpacker.networking.Network;
public class AddRequestView extends Sprite
{
public static var localeService:ILocaleService;
private static const SEARCH_TIMEOUT:int = 600;
public static var _validateCheckUidIcon:ValidationIcon;
private var _searchFriendTextInput:TankInputBase;
private var _searchFriendLabel:LabelBase;
private var _addRequestButton:FriendWindowButton;
private var _searchFriendTimeOut:uint;
private var _searchFriendUid:String;
private var _searchFriendExist:Boolean;
private var _searchUserId:Long;
private var network:Network;
public function AddRequestView(param1:Network)
{
super();
this.network = param1;
this.init();
}
private function init() : void
{
this._searchFriendTextInput = new TankInputBase();
this._searchFriendTextInput.maxChars = 20;
this._searchFriendTextInput.restrict = "0-9.a-zA-z_\\-*";
addChild(this._searchFriendTextInput);
this._searchFriendLabel = new LabelBase();
addChild(this._searchFriendLabel);
this._searchFriendLabel.mouseEnabled = false;
this._searchFriendLabel.color = ColorConstants.LIST_LABEL_HINT;
this._searchFriendLabel.text = "Отправить заявку другу...";
_validateCheckUidIcon = new ValidationIcon();
addChild(_validateCheckUidIcon);
this._addRequestButton = new FriendWindowButton();
addChild(this._addRequestButton);
this._addRequestButton.label = "Отправить";
this._addRequestButton.enable = false;
this.resize();
}
public function resize() : void
{
this._searchFriendTextInput.width = 235;
this._searchFriendTextInput.x = FriendsWindow.WINDOW_MARGIN;
this._searchFriendLabel.x = this._searchFriendTextInput.x + 3;
this._searchFriendLabel.y = this._searchFriendTextInput.y + 7;
_validateCheckUidIcon.x = this._searchFriendTextInput.x + this._searchFriendTextInput.width - _validateCheckUidIcon.width - 15;
_validateCheckUidIcon.y = this._searchFriendTextInput.y + 7;
this._addRequestButton.width = FriendsWindow.DEFAULT_BUTTON_WIDTH;
this._addRequestButton.x = this._searchFriendTextInput.width + 8;
}
public function hide() : void
{
clearTimeout(this._searchFriendTimeOut);
this.removeEvents();
this.clearSearchFriendTextInput();
this.visible = false;
}
private function removeEvents() : void
{
this._addRequestButton.removeEventListener(MouseEvent.CLICK,this.onClickAddRequestButton);
this._searchFriendTextInput.removeEventListener(FocusEvent.FOCUS_IN,this.onFocusInSearchFriend);
this._searchFriendTextInput.removeEventListener(FocusEvent.FOCUS_OUT,this.onFocusOutSearchFriend);
this._searchFriendTextInput.textField.removeEventListener(Event.CHANGE,this.onSearchFriendTextChange);
_validateCheckUidIcon.removeEventListener("valide",this.valide);
_validateCheckUidIcon.removeEventListener("inValide",this.inValide);
this._searchFriendTextInput.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
}
private function valide(param1:Event) : void
{
this._addRequestButton.enable = true;
}
private function inValide(param1:Event) : void
{
this._addRequestButton.enable = false;
}
public function show() : void
{
this.visible = true;
this.setEvents();
this._searchFriendTextInput.value = "";
this.updateVisibleSearchFriendLabel();
}
private function setEvents() : void
{
this._addRequestButton.addEventListener(MouseEvent.CLICK,this.onClickAddRequestButton);
this._searchFriendTextInput.addEventListener(FocusEvent.FOCUS_IN,this.onFocusInSearchFriend);
this._searchFriendTextInput.addEventListener(FocusEvent.FOCUS_OUT,this.onFocusOutSearchFriend);
this._searchFriendTextInput.textField.addEventListener(Event.CHANGE,this.onSearchFriendTextChange);
_validateCheckUidIcon.addEventListener("valide",this.valide);
_validateCheckUidIcon.addEventListener("inValide",this.inValide);
this._searchFriendTextInput.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
}
private function onClickAddRequestButton(param1:MouseEvent) : void
{
this.addRequest();
}
private function addRequest() : void
{
this.network.send("lobby;got_friend;" + this._searchFriendTextInput.value + ";");
this.clearSearchFriendTextInput();
}
private function clearSearchFriendTextInput() : void
{
this._searchFriendTextInput.value = "";
this._addRequestButton.enable = false;
_validateCheckUidIcon.turnOff();
this._searchFriendExist = false;
this._searchFriendUid = null;
}
private function onFocusInSearchFriend(param1:FocusEvent) : void
{
this._searchFriendLabel.visible = false;
}
private function onFocusOutSearchFriend(param1:FocusEvent) : void
{
this.updateVisibleSearchFriendLabel();
}
private function updateVisibleSearchFriendLabel() : void
{
if(this._searchFriendTextInput.value.length == 0)
{
this._searchFriendLabel.visible = true;
_validateCheckUidIcon.turnOff();
this._searchFriendTextInput.validValue = true;
}
}
private function onSearchFriendTextChange(param1:Event) : void
{
this._searchFriendExist = false;
this._addRequestButton.enable = false;
if((param1.currentTarget as TextField).text != "")
{
this.network.send("lobby;check_user;" + (param1.currentTarget as TextField).text + ";");
}
_validateCheckUidIcon.startProgress();
_validateCheckUidIcon.y = this._searchFriendTextInput.y + 5;
if(this._searchFriendTextInput.value.length > 0)
{
this._searchFriendLabel.visible = false;
}
clearTimeout(this._searchFriendTimeOut);
this._searchFriendTimeOut = setTimeout(this.searchFriendTextChange,SEARCH_TIMEOUT);
}
private function searchFriendTextChange() : void
{
if(this._searchFriendTextInput.value.length == 0)
{
_validateCheckUidIcon.turnOff();
this._searchFriendTextInput.validValue = true;
}
else
{
this._searchFriendUid = this._searchFriendTextInput.value;
}
}
private function onKeyUp(param1:KeyboardEvent) : void
{
if(param1.keyCode == Keyboard.ENTER)
{
this.addRequest();
}
}
private function checkUid(param1:Boolean) : *
{
this._searchFriendTextInput.validValue = param1;
if(param1)
{
_validateCheckUidIcon.markAsValid();
}
else
{
this._searchFriendUid = null;
_validateCheckUidIcon.markAsInvalid();
this._addRequestButton.enable = false;
}
_validateCheckUidIcon.y = this._searchFriendTextInput.y + 7;
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.gotourl {
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 projects.tanks.client.panel.model.payment.types.PaymentRequestUrl;
public class GoToUrlPaymentModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:GoToUrlPaymentModelServer;
private var client:IGoToUrlPaymentModelBase = IGoToUrlPaymentModelBase(this);
private var modelId:Long = Long.getLong(662905925,-149486694);
private var _receiveUrlId:Long = Long.getLong(1472761253,1269708281);
private var _receiveUrl_urlCodec:ICodec;
public function GoToUrlPaymentModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new GoToUrlPaymentModelServer(IModel(this));
this._receiveUrl_urlCodec = this._protocol.getCodec(new TypeCodecInfo(PaymentRequestUrl,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._receiveUrlId:
this.client.receiveUrl(PaymentRequestUrl(this._receiveUrl_urlCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.clients.flash.commons.models.challenge {
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.commons.models.challenge.time.ChallengesTimeModelBase;
import projects.tanks.client.commons.models.challenge.time.IChallengesTimeModelBase;
[ModelInfo]
public class ChallengeTimeModel extends ChallengesTimeModelBase implements IChallengesTimeModelBase, ObjectLoadListener {
[Inject]
public static var challengesService:ChallengeInfoService;
public function ChallengeTimeModel() {
super();
}
public function objectLoaded() : void {
challengesService.startEvent(getInitParam().timeLeftSec);
}
}
}
|
package alternativa.tanks.battle.events.death {
import platform.client.fp10.core.type.IGameObject;
public class TankDeadEvent {
public var victim:IGameObject;
public function TankDeadEvent(param1:IGameObject) {
super();
this.victim = param1;
}
}
}
|
package alternativa.tanks.models.weapon.ricochet {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IRicochetSFXModelAdapt implements IRicochetSFXModel {
private var object:IGameObject;
private var impl:IRicochetSFXModel;
public function IRicochetSFXModelAdapt(param1:IGameObject, param2:IRicochetSFXModel) {
super();
this.object = param1;
this.impl = param2;
}
public function getSfxData() : RicochetSFXData {
var result:RicochetSFXData = null;
try {
Model.object = this.object;
result = this.impl.getSfxData();
}
finally {
Model.popObject();
}
return result;
}
public function getRicochetEffects() : RicochetEffects {
var result:RicochetEffects = null;
try {
Model.object = this.object;
result = this.impl.getRicochetEffects();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package assets.icons {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.icons.play_icons_BLUE.png")]
public dynamic class play_icons_BLUE extends BitmapData {
public function play_icons_BLUE(param1:int = 46, param2:int = 26) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.model.garage.premium {
import alternativa.tanks.gui.item.actionpanel.SingleActionPanel;
import alternativa.tanks.model.garage.passtoshop.PassToShopService;
import alternativa.tanks.model.item.info.ItemActionPanel;
import flash.display.DisplayObjectContainer;
import flash.events.IEventDispatcher;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.commons.types.ShopCategoryEnum;
import projects.tanks.client.garage.models.premium.IPremiumInDepotModelBase;
import projects.tanks.client.garage.models.premium.PremiumInDepotModelBase;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
[ModelInfo]
public class PremiumInDepotModel extends PremiumInDepotModelBase implements IPremiumInDepotModelBase, ObjectLoadListener, ItemActionPanel {
[Inject]
public static var paymentDisplayService:PaymentDisplayService;
[Inject]
public static var passToShop:PassToShopService;
public function PremiumInDepotModel() {
super();
}
public function objectLoaded() : void {
var local1:SingleActionPanel = null;
if(passToShop.isPassToShopEnabled()) {
local1 = new SingleActionPanel(TanksLocale.TEXT_PREMIUM_BUTTON_EXTEND,this.handleDoubleClickOnItemPreview);
putData(SingleActionPanel,local1);
}
}
public function updateActionElements(param1:DisplayObjectContainer, param2:IEventDispatcher) : void {
if(passToShop.isPassToShopEnabled()) {
this.getActionPanel().updateActionElements(param1);
}
}
public function handleDoubleClickOnItemPreview() : void {
if(passToShop.isPassToShopEnabled()) {
paymentDisplayService.openPaymentAt(ShopCategoryEnum.PREMIUM);
}
}
private function getActionPanel() : SingleActionPanel {
return SingleActionPanel(getData(SingleActionPanel));
}
}
}
|
package alternativa.tanks.view.icons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.icons.BattleParamsCheckButtonIcons_dependentCooldownsClass.png")]
public class BattleParamsCheckButtonIcons_dependentCooldownsClass extends BitmapAsset {
public function BattleParamsCheckButtonIcons_dependentCooldownsClass() {
super();
}
}
}
|
package alternativa.tanks.display.usertitle {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.display.usertitle.ProgressBarSkin_hpLeftBgDmCls.png")]
public class ProgressBarSkin_hpLeftBgDmCls extends BitmapAsset {
public function ProgressBarSkin_hpLeftBgDmCls() {
super();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.rank {
import alternativa.types.Long;
import flash.utils.Dictionary;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.tanksservices.model.notifier.rank.IRankNotifierModelBase;
import projects.tanks.client.tanksservices.model.notifier.rank.RankNotifierData;
import projects.tanks.client.tanksservices.model.notifier.rank.RankNotifierModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.model.UserRefresh;
import projects.tanks.clients.fp10.libraries.tanksservices.model.listener.UserNotifier;
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.UserInfoConsumer;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
[ModelInfo]
public class RankNotifierModel extends RankNotifierModelBase implements IRankNotifierModelBase, UserRefresh, ObjectLoadListener {
[Inject]
public static var userPropertiesService:IUserPropertiesService;
private var data:Dictionary = new Dictionary();
public function RankNotifierModel() {
super();
}
public function objectLoaded() : void {
userPropertiesService.initRank(getInitParam().rank);
}
public function setRank(param1:Vector.<RankNotifierData>) : void {
var local2:RankNotifierData = null;
for each(local2 in param1) {
this.setAndUpdateConsumer(local2);
}
}
public function setAndUpdateConsumer(param1:RankNotifierData) : void {
var local4:UserInfoConsumer = null;
var local2:Long = param1.userId;
this.data[local2] = param1.rank;
var local3:UserNotifier = UserNotifier(object.adapt(UserNotifier));
if(local3.hasDataConsumer(local2)) {
local4 = local3.getDataConsumer(local2);
local4.setRank(param1.rank);
}
}
public function refresh(param1:Long, param2:UserInfoConsumer) : void {
if(param1 in this.data) {
param2.setRank(this.data[param1]);
}
}
public function remove(param1:Long) : void {
delete this.data[param1];
}
}
}
|
package alternativa.engine3d.objects {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.Material;
use namespace alternativa3d;
public class AnimSprite extends Sprite3D {
private var _materials:Vector.<Material>;
private var _frame:int = 0;
private var _loop:Boolean = false;
public function AnimSprite(param1:Number, param2:Number, param3:Vector.<Material> = null, param4:Boolean = false, param5:int = 0) {
super(param1,param2);
this._materials = param3;
this._loop = param4;
this.frame = param5;
}
public function get materials() : Vector.<Material> {
return this._materials;
}
public function set materials(param1:Vector.<Material>) : void {
this._materials = param1;
if(param1 != null) {
this.frame = this._frame;
} else {
material = null;
}
}
public function get loop() : Boolean {
return this._loop;
}
public function set loop(param1:Boolean) : void {
this._loop = param1;
this.frame = this._frame;
}
public function get frame() : int {
return this._frame;
}
public function set frame(param1:int) : void {
var local2:int = 0;
var local3:int = 0;
var local4:int = 0;
this._frame = param1;
if(this._materials != null) {
local2 = int(this._materials.length);
local3 = this._frame;
if(this._frame < 0) {
local4 = this._frame % local2;
local3 = this._loop && local4 != 0 ? local4 + local2 : 0;
} else if(this._frame > local2 - 1) {
local3 = this._loop ? int(this._frame % local2) : local2 - 1;
}
material = this._materials[local3];
}
}
override public function clone() : Object3D {
var local1:AnimSprite = new AnimSprite(width,height);
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
super.clonePropertiesFrom(param1);
var local2:AnimSprite = param1 as AnimSprite;
this._materials = local2._materials;
this._loop = local2._loop;
this._frame = local2._frame;
}
}
}
|
package alternativa.tanks.display.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.display.resistance.ResistanceShieldIcon_redShield.png")]
public class ResistanceShieldIcon_redShield extends BitmapAsset {
public function ResistanceShieldIcon_redShield() {
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.score {
import assets.icons.BattleInfoIcons;
public class DominationScoreField extends TeamScoreFieldBase implements TeamScoreIndicator {
private static const ICON_WIDTH:int = 21;
private static const ICON_Y:int = 9;
private var icon:BattleInfoIcons;
public function DominationScoreField() {
super();
this.icon = new BattleInfoIcons();
this.icon.type = BattleInfoIcons.TEAM_SCORE_BIG;
addChild(this.icon);
this.icon.y = ICON_Y;
}
override protected function calculateWidth() : int {
var local1:int = 5;
var local2:int = labelRed.width > labelBlue.width ? int(labelRed.width) : int(labelBlue.width);
labelRed.x = local1 + local1 + (local2 - labelRed.width >> 1);
this.icon.x = labelRed.x + local2 + local1;
labelBlue.x = this.icon.x + ICON_WIDTH + local1 + (local2 - labelBlue.width >> 1);
return labelBlue.x + local2 + local1 + local1;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.utils {
import flash.display.BitmapData;
public function disposeBitmapsData(param1:Array) : void {
var local2:BitmapData = null;
var local3:int = 0;
var local4:int = 0;
if(param1 != null) {
local3 = int(param1.length);
local4 = 0;
while(local4 < local3) {
local2 = param1[local4];
local2.dispose();
local4++;
}
param1 = null;
}
}
}
|
package alternativa.tanks.models.weapon.machinegun.sfx {
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class Particle extends PooledObject {
private var _alive:Boolean;
public function Particle(param1:Pool) {
super(param1);
}
public function get alive() : Boolean {
return this._alive;
}
public function set alive(param1:Boolean) : void {
this._alive = param1;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.helper {
import flash.display.Sprite;
import flash.geom.Point;
public class Helper extends Sprite {
public var id:int;
public var groupKey:String;
public var timer:HelperTimer;
public var showDuration:int = 5000;
public var showNum:int = 0;
protected var _showLimit:int = -1;
protected var _size:Point;
protected var _targetPoint:Point;
public function Helper() {
super();
this._targetPoint = new Point();
}
public function draw(param1:Point) : void {
}
public function align(param1:int, param2:int) : void {
}
public function get size() : Point {
return this._size;
}
public function get showLimit() : int {
return this._showLimit;
}
public function get targetPoint() : Point {
return this._targetPoint;
}
public function set targetPoint(param1:Point) : void {
this._targetPoint.x = param1.x;
this._targetPoint.y = param1.y;
}
}
}
|
package alternativa.tanks.help {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperAlign;
public class RankBarHelper extends PanelBubbleHelper {
public function RankBarHelper(param1:Number, param2:Number, param3:Number) {
super(param1,param2,param3);
var local4:ILocaleService = ILocaleService(OSGi.getInstance().getService(ILocaleService));
text = local4.getText(TanksLocale.TEXT_HELP_PANEL_RANK_BAR_HELPER_TEXT);
arrowLehgth = int(local4.getText(TanksLocale.TEXT_HELP_PANEL_RANK_BAR_HELPER_ARROW_LENGTH));
arrowAlign = HelperAlign.TOP_LEFT;
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class PaymentWindow_bitmapError extends BitmapAsset
{
public function PaymentWindow_bitmapError()
{
super();
}
}
}
|
package alternativa.tanks.config.loaders
{
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.objects.Mesh;
public class NormalsCalculator
{
private static const propNames:Array = ["hang_1","hang_2","hang_3","SmHouse008","wall_broke_1","wall_broke_2","Bk_roof1","Bk_roof2","Tree01","Tree02","tube_1","tube_2","tube_3","tube_cor","cliff_3","cliff_1","cliff_2","cliff_4","cliff_inco","cliff_cor","cliff_r2","cliff_ri","Big_Rock04","Big_Rock","Change01","Change02","Corn1","Corn2","Corn3","Corn4","Corn_B","crater","Land02","Land03","Land04","Land05","Land06","Land07","Land08","Land09","Land22","Land33","Line","Med_Rock","rise_g1","rise_g2","rise_g3","rise_g4","rise_g5","rise_g6","Rise_gr1","Rise_gr2","rise_r1","sm_rock1","sm_rock2","up_Brock","Up_Rock","Up_Rock1","Up_Rock2","Up_Rock14"];
private static var map:Object;
public function NormalsCalculator()
{
var _loc1_:String = null;
super();
if(map == null)
{
map = {};
for each(_loc1_ in propNames)
{
map[_loc1_] = true;
}
}
}
public function calculateNormals(param1:Vector.<Object3D>) : void
{
this.clearSmoothingGroups(param1);
Mesh.calculateVerticesNormalsBySmoothingGroupsForMeshList(param1,0.01);
}
private function clearSmoothingGroups(param1:Vector.<Object3D>) : void
{
var _loc2_:Object3D = null;
var _loc3_:Mesh = null;
var _loc4_:Face = null;
for each(_loc2_ in param1)
{
if(map[_loc2_.name] == null)
{
_loc3_ = _loc2_ as Mesh;
for each(_loc4_ in _loc3_.faces)
{
_loc4_.smoothingGroups = 0;
}
}
}
}
}
}
|
package projects.tanks.client.panel.model.bonus.showing.items {
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 BonusItemsShowingModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BonusItemsShowingModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.sfx {
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.shotgun.sfx.ShotgunSFXCC;
public class VectorCodecShotgunSFXCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecShotgunSFXCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ShotgunSFXCC,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.<ShotgunSFXCC> = new Vector.<ShotgunSFXCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ShotgunSFXCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ShotgunSFXCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ShotgunSFXCC> = Vector.<ShotgunSFXCC>(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.tutorialhints {
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.tutorialhints.TutorialHintsCC;
public class VectorCodecTutorialHintsCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTutorialHintsCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TutorialHintsCC,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.<TutorialHintsCC> = new Vector.<TutorialHintsCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TutorialHintsCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TutorialHintsCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TutorialHintsCC> = Vector.<TutorialHintsCC>(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.weapon.railgun {
import alternativa.physics.Body;
import alternativa.physics.collision.IRayCollisionFilter;
import flash.utils.Dictionary;
public class MultibodyCollisionFilter implements IRayCollisionFilter {
private var bodies:Dictionary = new Dictionary();
public function MultibodyCollisionFilter() {
super();
}
public function considerBody(param1:Body) : Boolean {
return this.bodies[param1] == null;
}
public function addBody(param1:Body) : void {
this.bodies[param1] = true;
}
public function clear() : void {
this.bodies = new Dictionary();
}
}
}
|
package alternativa.tanks.models.tank.spawn {
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.events.TankAddedToBattleEvent;
import alternativa.tanks.battle.events.TankUnloadedEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.utils.MathUtils;
import platform.client.fp10.core.type.IGameObject;
public class ReadyToSpawnTask implements LogicUnit {
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var battleService:BattleService;
private var readyTime:int;
private var tank:Tank;
private var battleEventSupport:BattleEventSupport;
public function ReadyToSpawnTask(param1:int, param2:Tank) {
super();
this.readyTime = param1;
this.tank = param2;
this.initBattleEventListeners(battleEventDispatcher);
}
private function initBattleEventListeners(param1:BattleEventDispatcher) : void {
this.battleEventSupport = new BattleEventSupport(param1);
this.battleEventSupport.addEventHandler(TankAddedToBattleEvent,this.onTankAddedToBattle);
this.battleEventSupport.addEventHandler(TankUnloadedEvent,this.onTankUnloaded);
this.battleEventSupport.addEventHandler(BattleFinishEvent,this.onBattleFinished);
this.battleEventSupport.activateHandlers();
}
public function runLogic(param1:int, param2:int) : void {
var local3:IGameObject = null;
var local4:ITankSpawner = null;
this.tank.getSkin().setAlpha(MathUtils.clamp((this.readyTime - param1) / 500,0,1));
if(param1 > this.readyTime) {
this.stop();
local3 = this.tank.getUser();
local4 = ITankSpawner(local3.adapt(ITankSpawner));
local4.readyToSpawn();
}
}
private function onTankUnloaded(param1:TankUnloadedEvent) : void {
if(param1.tank == this.tank) {
this.stop();
}
}
private function onTankAddedToBattle(param1:TankAddedToBattleEvent) : void {
if(param1.tank == this.tank) {
this.stop();
}
}
private function onBattleFinished(param1:BattleFinishEvent) : void {
this.stop();
}
private function stop() : void {
battleService.getBattleRunner().removeLogicUnit(this);
this.battleEventSupport.deactivateHandlers();
}
}
}
|
package alternativa.engine3d.loaders.collada {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
use namespace alternativa3d;
use namespace collada;
public class DaePrimitive extends DaeElement {
private var verticesInput:DaeInput;
private var texCoordsInputs:Vector.<DaeInput>;
private var inputsStride:int;
public function DaePrimitive(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
override protected function parseImplementation() : Boolean {
this.parseInputs();
return true;
}
private function parseInputs() : void {
var local5:DaeInput = null;
var local6:String = null;
var local7:int = 0;
this.texCoordsInputs = new Vector.<DaeInput>();
var local1:XMLList = data.input;
var local2:int = 0;
var local3:int = 0;
var local4:int = int(local1.length());
for(; local3 < local4; local7 = local5.offset,local2 = local7 > local2 ? local7 : local2,local3++) {
local5 = new DaeInput(local1[local3],document);
local6 = local5.semantic;
if(local6 == null) {
continue;
}
switch(local6) {
case "VERTEX":
if(this.verticesInput == null) {
this.verticesInput = local5;
}
break;
case "TEXCOORD":
this.texCoordsInputs.push(local5);
break;
}
}
this.inputsStride = local2 + 1;
}
private function findTexCoordsInput(param1:int) : DaeInput {
var local4:DaeInput = null;
var local2:int = 0;
var local3:int = int(this.texCoordsInputs.length);
while(local2 < local3) {
local4 = this.texCoordsInputs[local2];
if(local4.setNum == param1) {
return local4;
}
local2++;
}
return this.texCoordsInputs.length > 0 ? this.texCoordsInputs[0] : null;
}
private function get type() : String {
return data.localName() as String;
}
public function fillInMesh(param1:Mesh, param2:Vector.<Vertex>, param3:DaeInstanceMaterial = null) : void {
var local6:DaeInput = null;
var local7:Material = null;
var local8:Vector.<Number> = null;
var local11:XML = null;
var local12:Array = null;
var local13:DaeMaterial = null;
var local14:Vertex = null;
var local15:DaeSource = null;
var local16:XMLList = null;
var local17:int = 0;
var local18:int = 0;
var local19:XML = null;
var local20:Array = null;
var local4:XML = data.@count[0];
if(local4 == null) {
document.logger.logNotEnoughDataError(data);
return;
}
var local5:int = parseInt(local4.toString(),10);
if(param3 != null) {
local13 = param3.material;
local13.parse();
if(local13.diffuseTexCoords != null) {
local6 = this.findTexCoordsInput(param3.getBindVertexInputSetNum(local13.diffuseTexCoords));
} else {
local6 = this.findTexCoordsInput(-1);
}
local13.used = true;
local7 = local13.material;
} else {
local6 = this.findTexCoordsInput(-1);
}
if(local6 != null) {
for each(local14 in param2) {
while(local14 != null && local14.alternativa3d::index != -1) {
local14.alternativa3d::index = -2;
local14 = local14.alternativa3d::value;
}
}
}
var local9:int = 1;
var local10:int = 0;
if(local6 != null) {
local15 = local6.prepareSource(2);
if(local15 != null) {
local8 = local15.numbers;
local9 = local15.stride;
local10 = local6.offset;
}
}
switch(this.type) {
case "polygons":
if(data.ph.length() > 0) {
}
local16 = data.p;
local17 = 0;
local18 = int(local16.length());
while(local17 < local18) {
local12 = parseIntsArray(local16[local17]);
this.fillInPolygon(param1,local7,param2,this.verticesInput.offset,local12.length / this.inputsStride,local12,local8,local9,local10);
local17++;
}
break;
case "polylist":
local11 = data.p[0];
if(local11 == null) {
document.logger.logNotEnoughDataError(data);
return;
}
local12 = parseIntsArray(local11);
local19 = data.vcount[0];
if(local19 != null) {
local20 = parseIntsArray(local19);
if(local20.length < local5) {
return;
}
this.fillInPolylist(param1,local7,param2,this.verticesInput.offset,local5,local12,local20,local8,local9,local10);
} else {
this.fillInPolygon(param1,local7,param2,this.verticesInput.offset,local5,local12,local8,local9,local10);
}
break;
case "triangles":
local11 = data.p[0];
if(local11 == null) {
document.logger.logNotEnoughDataError(data);
return;
}
local12 = parseIntsArray(local11);
this.fillInTriangles(param1,local7,param2,this.verticesInput.offset,local5,local12,local8,local9,local10);
break;
}
}
private function applyUV(param1:Mesh, param2:Vertex, param3:Vector.<Number>, param4:int) : Vertex {
var local7:Vertex = null;
var local5:Number = param3[param4];
var local6:Number = 1 - param3[int(param4 + 1)];
if(param2.alternativa3d::index == -1) {
param2.u = local5;
param2.v = local6;
param2.alternativa3d::index = param4;
return param2;
}
if(param2.alternativa3d::index == param4) {
return param2;
}
while(param2.alternativa3d::value != null) {
param2 = param2.alternativa3d::value;
if(param2.alternativa3d::index == param4) {
return param2;
}
}
local7 = new Vertex();
local7.alternativa3d::next = param1.alternativa3d::vertexList;
param1.alternativa3d::vertexList = local7;
local7.x = param2.x;
local7.y = param2.y;
local7.z = param2.z;
local7.u = local5;
local7.v = local6;
param2.alternativa3d::value = local7;
local7.alternativa3d::index = param4;
return local7;
}
private function fillInPolygon(param1:Mesh, param2:Material, param3:Vector.<Vertex>, param4:int, param5:int, param6:Array, param7:Vector.<Number>, param8:int = 1, param9:int = 0) : void {
var local11:Wrapper = null;
var local13:Vertex = null;
var local14:Wrapper = null;
var local10:Face = new Face();
local10.material = param2;
local10.alternativa3d::next = param1.alternativa3d::faceList;
param1.alternativa3d::faceList = local10;
var local12:int = 0;
while(local12 < param5) {
local13 = param3[param6[int(this.inputsStride * local12 + param4)]];
if(param7 != null) {
local13 = this.applyUV(param1,local13,param7,param8 * param6[int(this.inputsStride * local12 + param9)]);
}
local14 = new Wrapper();
local14.alternativa3d::vertex = local13;
if(local11 != null) {
local11.alternativa3d::next = local14;
} else {
local10.alternativa3d::wrapper = local14;
}
local11 = local14;
local12++;
}
}
private function fillInPolylist(param1:Mesh, param2:Material, param3:Vector.<Vertex>, param4:int, param5:int, param6:Array, param7:Array, param8:Vector.<Number> = null, param9:int = 1, param10:int = 0) : void {
var local13:int = 0;
var local14:Face = null;
var local15:Wrapper = null;
var local16:int = 0;
var local17:int = 0;
var local18:Vertex = null;
var local19:Wrapper = null;
var local11:int = 0;
var local12:int = 0;
while(local12 < param5) {
local13 = int(param7[local12]);
if(local13 >= 3) {
local14 = new Face();
local14.material = param2;
local14.alternativa3d::next = param1.alternativa3d::faceList;
param1.alternativa3d::faceList = local14;
local15 = null;
local16 = 0;
while(local16 < local13) {
local17 = this.inputsStride * (local11 + local16);
local18 = param3[param6[int(local17 + param4)]];
if(param8 != null) {
local18 = this.applyUV(param1,local18,param8,param9 * param6[int(local17 + param10)]);
}
local19 = new Wrapper();
local19.alternativa3d::vertex = local18;
if(local15 != null) {
local15.alternativa3d::next = local19;
} else {
local14.alternativa3d::wrapper = local19;
}
local15 = local19;
local16++;
}
local11 += local13;
}
local12++;
}
}
private function fillInTriangles(param1:Mesh, param2:Material, param3:Vector.<Vertex>, param4:int, param5:int, param6:Array, param7:Vector.<Number> = null, param8:int = 1, param9:int = 0) : void {
var local11:int = 0;
var local12:int = 0;
var local13:Vertex = null;
var local14:Vertex = null;
var local15:Vertex = null;
var local16:Face = null;
var local17:int = 0;
var local10:int = 0;
while(local10 < param5) {
local11 = 3 * this.inputsStride * local10;
local12 = local11 + param4;
local13 = param3[param6[int(local12)]];
local14 = param3[param6[int(local12 + this.inputsStride)]];
local15 = param3[param6[int(local12 + 2 * this.inputsStride)]];
if(param7 != null) {
local17 = local11 + param9;
local13 = this.applyUV(param1,local13,param7,param8 * param6[int(local17)]);
local14 = this.applyUV(param1,local14,param7,param8 * param6[int(local17 + this.inputsStride)]);
local15 = this.applyUV(param1,local15,param7,param8 * param6[int(local17 + 2 * this.inputsStride)]);
}
local16 = new Face();
local16.material = param2;
local16.alternativa3d::next = param1.alternativa3d::faceList;
param1.alternativa3d::faceList = local16;
local16.alternativa3d::wrapper = new Wrapper();
local16.alternativa3d::wrapper.alternativa3d::vertex = local13;
local16.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local16.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = local14;
local16.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local16.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = local15;
local10++;
}
}
public function verticesEquals(param1:DaeVertices) : Boolean {
var local2:DaeVertices = document.findVertices(this.verticesInput.source);
if(local2 == null) {
document.logger.logNotFoundError(this.verticesInput.source);
}
return local2 == param1;
}
public function get materialSymbol() : String {
var local1:XML = data.@material[0];
return local1 == null ? null : local1.toString();
}
}
}
|
package alternativa.tanks.models.dom
{
import alternativa.console.ConsoleVarFloat;
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import com.alternativaplatform.projects.tanks.client.models.tank.TankSpawnState;
import com.reygazu.anticheat.variables.SecureBoolean;
public class Point
{
private static const CON_SMOOTHING_FACTOR:ConsoleVarFloat = new ConsoleVarFloat("dom_smoothing_factor",0.95,0,1);
private static const MAX_PROGRESS:Number = 100;
public var pos:Vector3;
private var radius:Number;
private var model:DOMModel;
private var capture:SecureBoolean;
public var id:int;
public var pedestal:Object3D;
private var serverProgress:Number = 0;
public var clientProgress:Number = 0;
private var progressSpeed:Number = 0;
private var updateForced:Boolean;
public function Point(id:int, pos:Vector3, radius:Number, model:DOMModel)
{
this.capture = new SecureBoolean("capture");
super();
this.pos = pos;
this.radius = radius;
this.model = model;
this.id = id;
}
public function drawDebug(scene:Scene3DContainer) : void
{
}
public function tick(time:int, deltaMsec:int, deltaSec:Number, interpolationCoeff:Number) : void
{
var tankPos:Vector3 = null;
var dot:Number = NaN;
if(DOMModel.userTankData == null)
{
return;
}
if(DOMModel.userTankData.spawnState == TankSpawnState.ACTIVE)
{
tankPos = DOMModel.userTankData.tank.state.pos;
dot = this.pos.distanceTo(tankPos);
if(!this.capture.value)
{
if(dot <= this.radius)
{
this.capture.value = true;
this.model.tankCapturingPoint(this,DOMModel.userTankData);
}
}
else if(dot > this.radius)
{
this.capture.value = false;
this.model.tankLeaveCapturingPoint(this,DOMModel.userTankData);
}
}
else if(this.capture.value)
{
this.capture.value = false;
this.model.tankLeaveCapturingPoint(this,DOMModel.userTankData);
}
}
public function readPos(v:Vector3) : void
{
v.x = this.pos.x;
v.y = this.pos.y;
v.z = this.pos.z;
}
}
}
|
package alternativa.tanks.models.weapon.shaft
{
import alternativa.init.Main;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.battlefield.logic.LogicUnit;
import alternativa.tanks.vehicles.tanks.TankSkin;
public class ShaftDeactivationTask implements LogicUnit
{
private static const FOV_SPEED:Number = 5 * 0.001;
private static const ALPHA_SPEED:Number = 5 * 0.001;
private static const DEFAULT_TARGET_FOV:Number = Math.PI / 2;
private var camera:GameCamera;
private var skin:TankSkin;
private var targetFov:Number;
private var battle:BattlefieldModel;
public function ShaftDeactivationTask(param1:GameCamera)
{
super();
this.camera = param1;
this.targetFov = DEFAULT_TARGET_FOV;
this.battle = Main.osgi.getService(IBattleField) as BattlefieldModel;
}
public function setSkin(param1:TankSkin) : void
{
this.skin = param1;
}
public function setTargetFov(param1:Number) : void
{
this.targetFov = param1;
}
public function start() : void
{
this.battle.logicUnits.addLogicUnit(this);
}
public function stop() : void
{
this.battle.logicUnits.removeLogicUnit(this);
}
public function runLogic(param1:int, param2:int) : void
{
this.camera.fov += FOV_SPEED * param2;
if(this.camera.fov > this.targetFov)
{
this.camera.fov = this.targetFov;
}
var _loc3_:Number = this.skin.hullMesh.alpha;
_loc3_ += ALPHA_SPEED * param2;
if(_loc3_ > 1)
{
_loc3_ = 1;
}
this.skin.setAlpha(_loc3_);
if(this.camera.fov == this.targetFov && _loc3_ == 1)
{
this.stop();
}
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.guestform {
import flash.display.Bitmap;
import flash.display.Sprite;
import flash.events.Event;
import flash.geom.ColorTransform;
public class BackgroundImage extends Sprite {
private var background:Sprite;
private var bg:Bitmap;
private var colorTransform:ColorTransform = new ColorTransform(0,0,0);
public function BackgroundImage(param1:Bitmap) {
super();
this.background = new Sprite();
addChild(this.background);
this.bg = param1;
this.background.addChild(this.bg);
this.background.transform.colorTransform = this.colorTransform;
addEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
private function onEnterFrame(param1:Event) : void {
if(this.colorTransform.redMultiplier < 1) {
this.colorTransform.redMultiplier += 0.025;
this.colorTransform.greenMultiplier += 0.025;
this.colorTransform.blueMultiplier += 0.025;
if(this.colorTransform.redMultiplier > 1) {
this.colorTransform.redMultiplier = 1;
this.colorTransform.greenMultiplier = 1;
this.colorTransform.blueMultiplier = 1;
}
this.background.transform.colorTransform = this.colorTransform;
}
}
public function resposition(param1:int, param2:int) : void {
this.bg.x = param1 - this.bg.width >> 1;
this.bg.y = param2 - this.bg.height >> 1;
}
}
}
|
package controls.dropdownlist {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.dropdownlist.DropDownButton_buttonClass.png")]
public class DropDownButton_buttonClass extends BitmapAsset {
public function DropDownButton_buttonClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.shared
{
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.weapon.common.HitInfo;
import alternativa.tanks.physics.CollisionGroup;
public class CommonTargetSystem
{
private static const COLLISION_GROUP:int = CollisionGroup.WEAPON;
private static var matrix:Matrix3 = new Matrix3();
private static var rayDir1:Vector3 = new Vector3();
private static var rayDir2:Vector3 = new Vector3();
private static var intersection:RayIntersection = new RayIntersection();
private var maxDistance:Number;
private var maxAngleUp:Number;
private var numRaysUp:int;
private var maxAngleDown:Number;
private var numRaysDown:int;
private var collisionDetector:ICollisionDetector;
private var targetEvaluator:ICommonTargetEvaluator;
private var maxPriority:Number;
private var bestTarget:Body;
private var hitDistance:Number;
private var bestDirection:Vector3;
private var normal:Vector3;
private var predicate:GunPredicate;
private var rayDir:Vector3;
private var _xAxis:Vector3;
public function CommonTargetSystem(maxDistance:Number, maxAngleUp:Number, numRaysUp:int, maxAngleDown:Number, numRaysDown:int, collisionDetector:ICollisionDetector, targetEvaluator:ICommonTargetEvaluator)
{
this.bestDirection = new Vector3();
this.normal = new Vector3();
this.predicate = new GunPredicate();
this.rayDir = new Vector3();
this._xAxis = new Vector3();
super();
this.maxDistance = maxDistance;
this.maxAngleUp = maxAngleUp;
this.numRaysUp = numRaysUp;
this.maxAngleDown = maxAngleDown;
this.numRaysDown = numRaysDown;
this.collisionDetector = collisionDetector;
this.targetEvaluator = targetEvaluator;
}
public function getTarget(barrelOrigin:Vector3, gunDirection:Vector3, gunRotationAxis:Vector3, shooterBody:Body, hitInfo:HitInfo) : Boolean
{
var body:Body = null;
this.maxPriority = 0;
this.hitDistance = this.maxDistance + 1;
this.bestTarget = null;
this.predicate.shooter = shooterBody;
if(this.collisionDetector.intersectRay(barrelOrigin,gunDirection,COLLISION_GROUP,this.maxDistance,this.predicate,intersection))
{
this.normal.vCopy(intersection.normal);
this.bestDirection.vCopy(gunDirection);
this.hitDistance = intersection.t;
body = intersection.primitive.body;
if(body != null)
{
this.bestTarget = body;
this.maxPriority = this.targetEvaluator.getTargetPriority(body,this.hitDistance,0);
}
}
if(this.numRaysUp > 0)
{
this.checkSector(barrelOrigin,gunDirection,gunRotationAxis,this.numRaysUp,this.maxAngleUp / this.numRaysUp);
}
if(this.numRaysDown > 0)
{
this.checkSector(barrelOrigin,gunDirection,gunRotationAxis,this.numRaysDown,-this.maxAngleDown / this.numRaysDown);
}
this.predicate.shooter = null;
if(this.hitDistance <= this.maxDistance)
{
hitInfo.distance = this.hitDistance;
hitInfo.normal.vCopy(this.normal);
hitInfo.direction.vCopy(this.bestDirection);
hitInfo.position.vCopy(barrelOrigin).vAddScaled(this.hitDistance,this.bestDirection);
hitInfo.body = this.bestTarget;
this.bestTarget = null;
return true;
}
return false;
}
private function checkSector(barrelOrigin:Vector3, gunDirection:Vector3, barrelRotationAxis:Vector3, raysNum:int, angleStep:Number) : void
{
var body:Body = null;
var targetPriority:Number = NaN;
matrix.fromAxisAngle(barrelRotationAxis,angleStep);
if(angleStep < 0)
{
angleStep = -angleStep;
}
rayDir2.vCopy(gunDirection);
var angle:Number = 0;
for(var i:int = 1; i <= raysNum; i++)
{
angle += angleStep;
rayDir1.vCopy(rayDir2);
matrix.transformVector(rayDir1,rayDir2);
if(this.collisionDetector.intersectRay(barrelOrigin,rayDir2,COLLISION_GROUP,this.maxDistance,this.predicate,intersection))
{
body = intersection.primitive.body;
if(body != null)
{
targetPriority = this.targetEvaluator.getTargetPriority(body,intersection.t,angle);
if(targetPriority > this.maxPriority)
{
this.maxPriority = targetPriority;
this.bestTarget = body;
this.bestDirection.vCopy(rayDir2);
this.hitDistance = intersection.t;
}
}
}
}
}
}
}
import alternativa.physics.Body;
import alternativa.physics.collision.IRayCollisionPredicate;
class GunPredicate implements IRayCollisionPredicate
{
public var shooter:Body;
function GunPredicate()
{
super();
}
public function considerBody(body:Body) : Boolean
{
return this.shooter != body;
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_overdriveDictatorIconClass.png")]
public class HudInventoryIcon_overdriveDictatorIconClass extends BitmapAsset {
public function HudInventoryIcon_overdriveDictatorIconClass() {
super();
}
}
}
|
package alternativa.engine3d.core {
public class Clipping {
public static const BOUND_CULLING:int = 0;
public static const FACE_CULLING:int = 1;
public static const FACE_CLIPPING:int = 2;
public function Clipping() {
super();
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.item3d {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.item3d.Item3DCC;
public class CodecItem3DCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_mounted:ICodec;
public function CodecItem3DCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_mounted = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:Item3DCC = new Item3DCC();
local2.mounted = this.codec_mounted.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Item3DCC = Item3DCC(param2);
this.codec_mounted.encode(param1,local3.mounted);
}
}
}
|
package alternativa.tanks.models.battle.jgr.killstreak {
import alternativa.tanks.models.battle.ctf.MessageColor;
import alternativa.tanks.models.battle.gui.BattlefieldGUI;
import alternativa.tanks.models.battle.gui.statistics.ShortUserInfo;
import alternativa.tanks.models.battle.jgr.Juggernaut;
import alternativa.tanks.models.statistics.IClientUserInfo;
import alternativa.tanks.models.tank.bosstate.IBossState;
import alternativa.tanks.services.tankregistry.TankUsersRegistry;
import alternativa.tanks.sfx.Sound3D;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.battlefield.models.battle.jgr.killstreak.IKillStreakModelBase;
import projects.tanks.client.battlefield.models.battle.jgr.killstreak.KillStreakItem;
import projects.tanks.client.battlefield.models.battle.jgr.killstreak.KillStreakModelBase;
import projects.tanks.client.battlefield.models.user.bossstate.BossRelationRole;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
[ModelInfo]
public class KillStreakModel extends KillStreakModelBase implements IKillStreakModelBase, ObjectLoadListener {
[Inject]
public static var usersRegistry:TankUsersRegistry;
[Inject]
public static var battleInfoService:IBattleInfoService;
private static const KILLSTREAK_VOLUME:Number = 0.9;
private var killStreaks:Vector.<KillStreakClientItem> = new Vector.<KillStreakClientItem>();
public function KillStreakModel() {
super();
}
private static function getUserUid(param1:Long) : String {
var local2:ShortUserInfo = null;
if(param1 != null) {
local2 = IClientUserInfo(object.adapt(IClientUserInfo)).getShortUserInfo(param1);
if(local2 != null) {
return local2.uid;
}
}
return null;
}
public function objectLoaded() : void {
var local2:KillStreakItem = null;
var local3:Sound3D = null;
this.killStreaks.length = getInitParam().items.length;
var local1:int = 0;
while(local1 < getInitParam().items.length) {
local2 = getInitParam().items[local1];
local3 = Sound3D.create(local2.sound.sound);
local3.volume = KILLSTREAK_VOLUME;
this.killStreaks[local1] = new KillStreakClientItem(local2.messageToBoss,local2.messageToVictims,local3);
local1++;
}
}
public function killStreakAchived(param1:int) : void {
var local4:String = null;
var local6:Sound3D = null;
var local2:KillStreakClientItem = this.killStreaks[param1];
var local3:BossRelationRole = !battleInfoService.isSpectatorMode() ? IBossState(usersRegistry.getLocalUser().adapt(IBossState)).role() : null;
if(local3 == BossRelationRole.BOSS) {
local4 = local2.messageToBoss != null ? local2.messageToBoss : local2.messageToVictims;
} else {
local4 = local2.messageToVictims;
}
var local5:String = getUserUid(object.adapt(Juggernaut).bossId());
if(local5 != null) {
local4 = local4.replace("%1",local5);
}
this.getGuiModel().showBattleMessage(MessageColor.ORANGE,local4);
if(local2.sound != null) {
local6 = null;
if(local6 != null) {
local6.stop();
}
local2.sound.play(0,0);
}
}
private function getGuiModel() : BattlefieldGUI {
return BattlefieldGUI(object.adapt(BattlefieldGUI));
}
}
}
|
package alternativa.tanks.view.mainview.button {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.mainview.button.DisabledButtonSkin_rightClass.png")]
public class DisabledButtonSkin_rightClass extends BitmapAsset {
public function DisabledButtonSkin_rightClass() {
super();
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.healing
{
public interface IHealingGunModelBase
{
}
}
|
package alternativa.tanks.models.tank.ultimate.wasp.bomb {
import alternativa.math.Vector3;
public interface LocalTankPositionProvider {
function getLocalTankPosition(param1:Vector3) : void;
}
}
|
package alternativa.model
{
import alternativa.types.Long;
public interface IResourceLoadListener
{
function resourceLoaded(param1:Object) : void;
function resourceUnloaded(param1:Long) : void;
}
}
|
package projects.tanks.client.tanksservices.model.clientrestarttime {
public class OnceADayActionCC {
private var _todayRestartTime:int;
public function OnceADayActionCC(param1:int = 0) {
super();
this._todayRestartTime = param1;
}
public function get todayRestartTime() : int {
return this._todayRestartTime;
}
public function set todayRestartTime(param1:int) : void {
this._todayRestartTime = param1;
}
public function toString() : String {
var local1:String = "OnceADayActionCC [";
local1 += "todayRestartTime = " + this.todayRestartTime + " ";
return local1 + "]";
}
}
}
|
package alternativa.engine3d.loaders.collada {
public namespace daeAlternativa3DInstance = "http://alternativaplatform.com/a3d/Instance";
}
|
package alternativa.tanks.models.weapon.shaft {
public class LinearInterpolator {
private var a:Number;
private var b:Number;
public function LinearInterpolator(param1:Number = 0, param2:Number = 1) {
super();
this.a = param1;
this.b = param2;
}
public function setInterval(param1:Number, param2:Number) : void {
this.a = param1;
this.b = param2;
}
public function interpolate(param1:Number) : Number {
return this.a + (this.b - this.a) * param1;
}
}
}
|
package alternativa.tanks.gui.notinclan.clanslist {
import base.DiscreteSprite;
import flash.display.Bitmap;
import flash.display.BitmapData;
public class AcceptIndicator extends DiscreteSprite {
private static var iconClass:Class = AcceptIndicator_iconClass;
private static var iconBitmapData:BitmapData = Bitmap(new iconClass()).bitmapData;
public function AcceptIndicator() {
super();
this.tabChildren = false;
this.tabEnabled = false;
this.buttonMode = this.useHandCursor = true;
var local1:Bitmap = new Bitmap(iconBitmapData);
addChild(local1);
}
}
}
|
package alternativa.gfx.agal {
public class SamplerOption {
public var mask:uint;
public var flag:uint;
public function SamplerOption(param1:uint, param2:uint) {
super();
this.mask = param1;
this.flag = param2;
}
public function apply(param1:int) : int {
param1 &= ~(15 << this.flag);
return param1 | this.mask << this.flag;
}
}
}
|
package projects.tanks.client.garage.models.item.category {
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 ItemCategoryModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ItemCategoryModelServer(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 {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol623")]
public dynamic class ScrollPane_upSkin extends MovieClip {
public function ScrollPane_upSkin() {
super();
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.terminal {
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 TerminalPaymentModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function TerminalPaymentModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import alternativa.types.Long;
import flash.display.BitmapData;
import flash.utils.Dictionary;
public class DeviceIcons {
private static const backgroundIconClass:Class = DeviceIcons_backgroundIconClass;
public static const backgroundIcon:BitmapData = new backgroundIconClass().bitmapData;
private static const acceleratedloadingmechanismIconClass:Class = DeviceIcons_acceleratedloadingmechanismIconClass;
private static const acceleratedloadingmechanismIcon:BitmapData = new acceleratedloadingmechanismIconClass().bitmapData;
private static const adaptedchargingIconClass:Class = DeviceIcons_adaptedchargingIconClass;
private static const adaptedchargingIcon:BitmapData = new adaptedchargingIconClass().bitmapData;
private static const adaptiverechargehammerIconClass:Class = DeviceIcons_adaptiverechargehammerIconClass;
private static const adaptiverechargehammerIcon:BitmapData = new adaptiverechargehammerIconClass().bitmapData;
private static const adaptiverechargerailgunIconClass:Class = DeviceIcons_adaptiverechargerailgunIconClass;
private static const adaptiverechargerailgunIcon:BitmapData = new adaptiverechargerailgunIconClass().bitmapData;
private static const armorpiercingammoIconClass:Class = DeviceIcons_armorpiercingammoIconClass;
private static const armorpiercingammoIcon:BitmapData = new armorpiercingammoIconClass().bitmapData;
private static const assaultammunitionIconClass:Class = DeviceIcons_assaultammunitionIconClass;
private static const assaultammunitionIcon:BitmapData = new assaultammunitionIconClass().bitmapData;
private static const assaultemittersIconClass:Class = DeviceIcons_assaultemittersIconClass;
private static const assaultemittersIcon:BitmapData = new assaultemittersIconClass().bitmapData;
private static const autoturretIconClass:Class = DeviceIcons_autoturretIconClass;
private static const autoturretIcon:BitmapData = new autoturretIconClass().bitmapData;
private static const bfgIconClass:Class = DeviceIcons_bfgIconClass;
private static const bfgIcon:BitmapData = new bfgIconClass().bitmapData;
private static const bfgtwinsIconClass:Class = DeviceIcons_bfgtwinsIconClass;
private static const bfgtwinsIcon:BitmapData = new bfgtwinsIconClass().bitmapData;
private static const broadbandemittersIconClass:Class = DeviceIcons_broadbandemittersIconClass;
private static const broadbandemittersIcon:BitmapData = new broadbandemittersIconClass().bitmapData;
private static const capacitorpowerreductionIconClass:Class = DeviceIcons_capacitorpowerreductionIconClass;
private static const capacitorpowerreductionIcon:BitmapData = new capacitorpowerreductionIconClass().bitmapData;
private static const compacttanksIconClass:Class = DeviceIcons_compacttanksIconClass;
private static const compacttanksIcon:BitmapData = new compacttanksIconClass().bitmapData;
private static const corrosivemixIconClass:Class = DeviceIcons_corrosivemixIconClass;
private static const corrosivemixIcon:BitmapData = new corrosivemixIconClass().bitmapData;
private static const criobombsIconClass:Class = DeviceIcons_criobombsIconClass;
private static const criobombsIcon:BitmapData = new criobombsIconClass().bitmapData;
private static const damagenanobotsIconClass:Class = DeviceIcons_damagenanobotsIconClass;
private static const damagenanobotsIcon:BitmapData = new damagenanobotsIconClass().bitmapData;
private static const deepcoolingIconClass:Class = DeviceIcons_deepcoolingIconClass;
private static const deepcoolingIcon:BitmapData = new deepcoolingIconClass().bitmapData;
private static const destabilizedshellsIconClass:Class = DeviceIcons_destabilizedshellsIconClass;
private static const destabilizedshellsIcon:BitmapData = new destabilizedshellsIconClass().bitmapData;
private static const doublebarrelIconClass:Class = DeviceIcons_doublebarrelIconClass;
private static const doublebarrelIcon:BitmapData = new doublebarrelIconClass().bitmapData;
private static const dragonsbreathIconClass:Class = DeviceIcons_dragonsbreathIconClass;
private static const dragonsbreathIcon:BitmapData = new dragonsbreathIconClass().bitmapData;
private static const fasterhorizontaltrackingrailgunIconClass:Class = DeviceIcons_fasterhorizontaltrackingrailgunIconClass;
private static const fasterhorizontaltrackingrailgunIcon:BitmapData = new fasterhorizontaltrackingrailgunIconClass().bitmapData;
private static const fasterhorizontaltrackingvulcanIconClass:Class = DeviceIcons_fasterhorizontaltrackingvulcanIconClass;
private static const fasterhorizontaltrackingvulcanIcon:BitmapData = new fasterhorizontaltrackingvulcanIconClass().bitmapData;
private static const firebirdhighpressurepumpIconClass:Class = DeviceIcons_firebirdhighpressurepumpIconClass;
private static const firebirdhighpressurepumpIcon:BitmapData = new firebirdhighpressurepumpIconClass().bitmapData;
private static const freezehighpressurepumpIconClass:Class = DeviceIcons_freezehighpressurepumpIconClass;
private static const freezehighpressurepumpIcon:BitmapData = new freezehighpressurepumpIconClass().bitmapData;
private static const freezingshotIconClass:Class = DeviceIcons_freezingshotIconClass;
private static const freezingshotIcon:BitmapData = new freezingshotIconClass().bitmapData;
private static const hammershellsIconClass:Class = DeviceIcons_hammershellsIconClass;
private static const hammershellsIcon:BitmapData = new hammershellsIconClass().bitmapData;
private static const heavycapacitorsIconClass:Class = DeviceIcons_heavycapacitorsIconClass;
private static const heavycapacitorsIcon:BitmapData = new heavycapacitorsIconClass().bitmapData;
private static const highcaliberammoIconClass:Class = DeviceIcons_highcaliberammoIconClass;
private static const highcaliberammoIcon:BitmapData = new highcaliberammoIconClass().bitmapData;
private static const highcapacitydrumIconClass:Class = DeviceIcons_highcapacitydrumIconClass;
private static const highcapacitydrumIcon:BitmapData = new highcapacitydrumIconClass().bitmapData;
private static const hyperspaceprojectilesIconClass:Class = DeviceIcons_hyperspaceprojectilesIconClass;
private static const hyperspaceprojectilesIcon:BitmapData = new hyperspaceprojectilesIconClass().bitmapData;
private static const incendiarybeltIconClass:Class = DeviceIcons_incendiarybeltIconClass;
private static const incendiarybeltIcon:BitmapData = new incendiarybeltIconClass().bitmapData;
private static const incendiarybombsIconClass:Class = DeviceIcons_incendiarybombsIconClass;
private static const incendiarybombsIcon:BitmapData = new incendiarybombsIconClass().bitmapData;
private static const incendiaryshotIconClass:Class = DeviceIcons_incendiaryshotIconClass;
private static const incendiaryshotIcon:BitmapData = new incendiaryshotIconClass().bitmapData;
private static const lightweightcapacitorsIconClass:Class = DeviceIcons_lightweightcapacitorsIconClass;
private static const lightweightcapacitorsIcon:BitmapData = new lightweightcapacitorsIconClass().bitmapData;
private static const lightweightordnanceautoloaderIconClass:Class = DeviceIcons_lightweightordnanceautoloaderIconClass;
private static const lightweightordnanceautoloaderIcon:BitmapData = new lightweightordnanceautoloaderIconClass().bitmapData;
private static const minelayerIconClass:Class = DeviceIcons_minelayerIconClass;
private static const minelayerIcon:BitmapData = new minelayerIconClass().bitmapData;
private static const minusfieldstabilizationIconClass:Class = DeviceIcons_minusfieldstabilizationIconClass;
private static const minusfieldstabilizationIcon:BitmapData = new minusfieldstabilizationIconClass().bitmapData;
private static const modifiedcarriageIconClass:Class = DeviceIcons_modifiedcarriageIconClass;
private static const modifiedcarriageIcon:BitmapData = new modifiedcarriageIconClass().bitmapData;
private static const modifiedfiringrateIconClass:Class = DeviceIcons_modifiedfiringrateIconClass;
private static const modifiedfiringrateIcon:BitmapData = new modifiedfiringrateIconClass().bitmapData;
private static const modulatorsofplasmaIconClass:Class = DeviceIcons_modulatorsofplasmaIconClass;
private static const modulatorsofplasmaIcon:BitmapData = new modulatorsofplasmaIconClass().bitmapData;
private static const plasmatorchIconClass:Class = DeviceIcons_plasmatorchIconClass;
private static const plasmatorchIcon:BitmapData = new plasmatorchIconClass().bitmapData;
private static const plazmacoreacceleratorsIconClass:Class = DeviceIcons_plazmacoreacceleratorsIconClass;
private static const plazmacoreacceleratorsIcon:BitmapData = new plazmacoreacceleratorsIconClass().bitmapData;
private static const precisiontargetingsystemIconClass:Class = DeviceIcons_precisiontargetingsystemIconClass;
private static const precisiontargetingsystemIcon:BitmapData = new precisiontargetingsystemIconClass().bitmapData;
private static const radioexplosionIconClass:Class = DeviceIcons_radioexplosionIconClass;
private static const radioexplosionIcon:BitmapData = new radioexplosionIconClass().bitmapData;
private static const robocrosshairIconClass:Class = DeviceIcons_robocrosshairIconClass;
private static const robocrosshairIcon:BitmapData = new robocrosshairIconClass().bitmapData;
private static const rocketlaunchercycloneIconClass:Class = DeviceIcons_rocketlaunchercycloneIconClass;
private static const rocketlaunchercycloneIcon:BitmapData = new rocketlaunchercycloneIconClass().bitmapData;
private static const rocketlauncherhunterIconClass:Class = DeviceIcons_rocketlauncherhunterIconClass;
private static const rocketlauncherhunterIcon:BitmapData = new rocketlauncherhunterIconClass().bitmapData;
private static const selfcoolingIconClass:Class = DeviceIcons_selfcoolingIconClass;
private static const selfcoolingIcon:BitmapData = new selfcoolingIconClass().bitmapData;
private static const selfheatingIconClass:Class = DeviceIcons_selfheatingIconClass;
private static const selfheatingIcon:BitmapData = new selfheatingIconClass().bitmapData;
private static const shellstabilizationIconClass:Class = DeviceIcons_shellstabilizationIconClass;
private static const shellstabilizationIcon:BitmapData = new shellstabilizationIconClass().bitmapData;
private static const sluggerIconClass:Class = DeviceIcons_sluggerIconClass;
private static const sluggerIcon:BitmapData = new sluggerIconClass().bitmapData;
private static const stableplazmaIconClass:Class = DeviceIcons_stableplazmaIconClass;
private static const stableplazmaIcon:BitmapData = new stableplazmaIconClass().bitmapData;
private static const supercumulativeIconClass:Class = DeviceIcons_supercumulativeIconClass;
private static const supercumulativeIcon:BitmapData = new supercumulativeIconClass().bitmapData;
private static const supportnanobotsIconClass:Class = DeviceIcons_supportnanobotsIconClass;
private static const supportnanobotsIcon:BitmapData = new supportnanobotsIconClass().bitmapData;
private static const thermitemixIconClass:Class = DeviceIcons_thermitemixIconClass;
private static const thermitemixIcon:BitmapData = new thermitemixIconClass().bitmapData;
private static const tripleshotIconClass:Class = DeviceIcons_tripleshotIconClass;
private static const tripleshotIcon:BitmapData = new tripleshotIconClass().bitmapData;
private static const unstableplazmaIconClass:Class = DeviceIcons_unstableplazmaIconClass;
private static const unstableplazmaIcon:BitmapData = new unstableplazmaIconClass().bitmapData;
private static const vampireIconClass:Class = DeviceIcons_vampireIconClass;
private static const vampireIcon:BitmapData = new vampireIconClass().bitmapData;
private static var dictionary:* = new Dictionary();
put("920005770320",firebirdhighpressurepumpIcon);
put("920005132720",compacttanksIcon);
put("920009599260",thermitemixIcon);
put("920009599120",selfheatingIcon);
put("920005132721",freezehighpressurepumpIcon);
put("920005770322",corrosivemixIcon);
put("920009599261",deepcoolingIcon);
put("920009599122",selfcoolingIcon);
put("920009599080",vampireIcon);
put("920009599123",damagenanobotsIcon);
put("920005770324",supportnanobotsIcon);
put("920005132722",broadbandemittersIcon);
put("920009599170",incendiarybeltIcon);
put("920005132723",fasterhorizontaltrackingvulcanIcon);
put("920005770326",modifiedfiringrateIcon);
put("920009599290",criobombsIcon);
put("920009599053",modifiedcarriageIcon);
put("920009599054",minelayerIcon);
put("920009599291",incendiaryshotIcon);
put("920009599274",acceleratedloadingmechanismIcon);
put("920009599230",hyperspaceprojectilesIcon);
put("920009599273",destabilizedshellsIcon);
put("920009599272",capacitorpowerreductionIcon);
put("920009599180",adaptiverechargerailgunIcon);
put("920005770328",fasterhorizontaltrackingrailgunIcon);
put("920005770330",highcaliberammoIcon);
put("920005132724",shellstabilizationIcon);
put("920005351541",null);
put("920009599125",adaptedchargingIcon);
put("920009599277",plasmatorchIcon);
put("920006113432",unstableplazmaIcon);
put("920005132725",minusfieldstabilizationIcon);
put("920009599055",radioexplosionIcon);
put("920009599269",bfgIcon);
put("920009599267",rocketlauncherhunterIcon);
put("920009599268",rocketlaunchercycloneIcon);
put("920009599275",lightweightcapacitorsIcon);
put("920009599292",robocrosshairIcon);
put("920009599276",tripleshotIcon);
put("920005770332",assaultemittersIcon);
put("920005132726",heavycapacitorsIcon);
put("920009599090",adaptiverechargehammerIcon);
put("920009599262",doublebarrelIcon);
put("920009599124",dragonsbreathIcon);
put("920005770334",highcapacitydrumIcon);
put("920005132727",sluggerIcon);
put("920009599153",freezingshotIcon);
put("920009599264",supercumulativeIcon);
put("920009599152",incendiaryshotIcon);
put("920009599265",autoturretIcon);
put("920005770336",precisiontargetingsystemIcon);
put("920005132728",assaultammunitionIcon);
put("920009599271",hammershellsIcon);
put("920005132729",lightweightordnanceautoloaderIcon);
put("920005770338",armorpiercingammoIcon);
put("920009599300",modulatorsofplasmaIcon);
put("920009599263",bfgtwinsIcon);
put("920006113430",stableplazmaIcon);
put("920005132730",plazmacoreacceleratorsIcon);
public function DeviceIcons() {
super();
}
private static function put(param1:String, param2:BitmapData) : * {
dictionary[param1] = param2;
}
public static function getByDeviceId(param1:Long) : BitmapData {
return param1 == null ? null : dictionary[param1.toString()];
}
}
}
|
package projects.tanks.client.battlefield.models.ultimate.effects.hunter {
public interface ITankStunModelBase {
function calm(param1:int) : void;
function stun() : void;
}
}
|
package {
import controls.panel.BaseButton;
[Embed(source="/_assets/assets.swf", symbol="symbol1198")]
public dynamic class MainPanelSoundButton extends BaseButton {
public function MainPanelSoundButton() {
super();
}
}
}
|
package alternativa.tanks.model.challenge
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChallengeCongratulationWindow_safariBitmap extends BitmapAsset
{
public function ChallengeCongratulationWindow_safariBitmap()
{
super();
}
}
}
|
package alternativa.physics {
public class BodyListItem {
private static var poolTop:BodyListItem;
public var body:Body;
public var next:BodyListItem;
public var prev:BodyListItem;
public function BodyListItem(param1:Body) {
super();
this.body = param1;
}
public static function create(param1:Body) : BodyListItem {
var local2:BodyListItem = null;
if(poolTop == null) {
local2 = new BodyListItem(param1);
} else {
local2 = poolTop;
poolTop = local2.next;
local2.next = null;
local2.body = param1;
}
return local2;
}
public static function clearPool() : void {
var local1:BodyListItem = poolTop;
while(local1 != null) {
poolTop = local1.next;
local1.next = null;
local1 = poolTop;
}
}
public function dispose() : void {
this.body = null;
this.prev = null;
this.next = poolTop;
poolTop = this;
}
}
}
|
package projects.tanks.client.panel.model.shop.promo {
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 ShopPromoCodeModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _activatePromoCodeId:Long = Long.getLong(163943865,1887710931);
private var _activatePromoCode_promoCodeCodec:ICodec;
private var model:IModel;
public function ShopPromoCodeModelServer(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._activatePromoCode_promoCodeCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function activatePromoCode(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._activatePromoCode_promoCodeCodec.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._activatePromoCodeId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package forms.friends.list.renderer
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class FriendsAcceptedListRenderer_gradientGreenIconClass extends BitmapAsset
{
public function FriendsAcceptedListRenderer_gradientGreenIconClass()
{
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.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class AndroidPayModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:AndroidPayModelServer;
private var client:IAndroidPayModelBase = IAndroidPayModelBase(this);
private var modelId:Long = Long.getLong(1588065385,-1735921226);
private var _consumeId:Long = Long.getLong(1975169879,-182292227);
private var _consume_tokenCodec:ICodec;
public function AndroidPayModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new AndroidPayModelServer(IModel(this));
this._consume_tokenCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._consumeId:
this.client.consume(String(this._consume_tokenCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.battle.scene3d {
import alternativa.engine3d.containers.KDContainer;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Object3DContainer;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.engine3d.core.Shadow;
import alternativa.engine3d.core.View;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Decal;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
import alternativa.tanks.battle.*;
import alternativa.tanks.battle.hidablegraphicobjects.HidableGraphicObjects;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.tankskin.turret.TurretSkin;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Object3DContainerProxy;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.battle.utils.Queue;
import alternativa.tanks.camera.CameraController;
import alternativa.tanks.camera.DummyCameraController;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.battle.battlefield.map.Billboards;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.utils.TextureMaterialRegistry;
import flash.display.BitmapData;
import flash.display.Stage;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
import projects.tanks.client.battlefield.models.map.DustParams;
import projects.tanks.clients.flash.commons.models.gpu.GPUCapabilities;
public class BattleScene3D {
private static const MAX_TEMPORARY_DECALS:int = 10;
private static const DECAL_FADING_TIME_MS:int = 20000;
private static const _origin3D:Vector3D = new Vector3D();
private static const _direction3D:Vector3D = new Vector3D();
private var rootContainer:Object3DContainer;
private var skyboxContainer:Object3DContainer;
private var mainContainer:Object3DContainer;
private var frontContainer:Object3DContainer;
private var mapContainer:Object3DContainer;
private var mapContainerProxy:Object3DContainerProxy = new Object3DContainerProxy();
private var frontContainerProxy:Object3DContainerProxy;
private const excludedObjects:Dictionary = new Dictionary();
private const shaftRaycastExcludedObjects:Dictionary = new Dictionary();
private var camera:GameCamera;
private var renderGroups:Vector.<RenderGroup> = Vector.<RenderGroup>([new RenderGroup(),new RenderGroup()]);
private var cameraController:CameraController = DummyCameraController.INSTANCE;
private var effects:Vector.<GraphicEffect> = new Vector.<GraphicEffect>();
private var numEffects:int;
private var userTitleRenderer:UserTitleRenderer;
private const temporaryDecals:Queue = new Queue();
private const allDecals:Dictionary = new Dictionary();
private var fadingDecalRenderer:FadingDecalsRenderer;
private const fpsCounter:FPSCounter = new FPSCounter(100);
private var decalFactory:DecalFactory;
private var fog:Fog;
private var ambientShadows:AmbientShadows;
private var lighting:Lighting;
private var performanceController:PerformanceControllerWithThrottling;
public const hidableGraphicObjects:HidableGraphicObjects = new HidableGraphicObjects();
private var stage:Stage;
private var dustEngine:Dust;
private var billboards:Billboards;
private var materialRegistry:TextureMaterialRegistry;
private var shadowMapCorrectionFactor:Number;
private var debugCommands:BattleScene3DDebugCommands;
private var renderingEnabled:Boolean;
private var tanks:Vector.<Tank> = new Vector.<Tank>();
public function BattleScene3D(param1:Stage, param2:TextureMaterialRegistry, param3:Number) {
super();
this.materialRegistry = param2;
this.stage = param1;
this.shadowMapCorrectionFactor = param3;
this.initContainers();
this.createCamera();
this.createFadingDecalsRenderer();
this.billboards = new Billboards();
this.fog = new Fog(this.camera);
this.ambientShadows = new AmbientShadows(this.camera);
this.lighting = new Lighting(this.camera);
}
public function getFrontContainer() : Scene3DContainer {
return this.frontContainerProxy;
}
public function getMapContainer() : Scene3DContainer {
return this.mapContainerProxy;
}
public function setCameraView(param1:View) : void {
this.camera.view = param1;
}
public function addMarker(param1:Number, param2:uint, param3:Number, param4:Number, param5:Number) : void {
}
public function enableObjectHiding() : void {
this.addRenderer(this.hidableGraphicObjects,0);
}
public function initDustEngine(param1:BattleService, param2:DustParams) : void {
this.dustEngine = new Dust(param1);
this.dustEngine.init(param2.dustParticle,this.materialRegistry,param2.dustFarDistance,param2.dustNearDistance,param2.dustSize,param2.alpha,param2.density);
}
public function getDustEngine() : Dust {
return this.dustEngine;
}
public function disableObjectHiding() : void {
this.removeRenderer(this.hidableGraphicObjects,0);
this.hidableGraphicObjects.restore();
}
public function enableAutoQuality(param1:Boolean, param2:String) : void {
if(param1) {
if(this.performanceController == null) {
this.enableAmbientShadows(true);
this.enableDynamicShadows(true);
this.enableFog(true);
this.enableSoftTransparency(true);
this.enableDust(true);
this.enableSSAO(true);
this.enableLighting(true);
this.enableDynamicLighting(true);
this.enableAntialiasing(true);
this.performanceController = new PerformanceControllerWithThrottling();
this.performanceController.start1(this.stage,this.camera,param2);
}
} else if(this.performanceController != null) {
this.performanceController.stop();
this.performanceController = null;
}
}
public function setupFog(param1:int, param2:Number, param3:Number, param4:Number) : void {
this.fog.setup(param1,param2,param3,param4);
}
public function setupDynamicShadows(param1:int, param2:int, param3:Number, param4:Number) : void {
this.lighting.setup(param1,param2,param3,param4);
}
public function enableAmbientShadows(param1:Boolean) : void {
if(GPUCapabilities.gpuEnabled) {
if(param1) {
this.ambientShadows.enable();
} else {
this.ambientShadows.disable();
}
}
}
public function enableDynamicShadows(param1:Boolean) : void {
if(GPUCapabilities.gpuEnabled) {
if(param1) {
this.lighting.enableShadows();
} else {
this.lighting.disableShadows();
}
}
}
public function enableFog(param1:Boolean) : void {
if(GPUCapabilities.gpuEnabled) {
if(param1) {
this.fog.enable();
} else {
this.fog.disable();
}
}
}
public function toggleFog() : void {
this.enableFog(this.camera.fogAlpha == 0);
}
public function setDecalFactory(param1:DecalFactory) : void {
this.decalFactory = param1;
}
public function addDecalsToExclusionSet(param1:Dictionary) : void {
var local2:* = undefined;
for(local2 in this.allDecals) {
param1[local2] = true;
}
}
public function addObjectToExclusion(param1:Object3D) : void {
this.excludedObjects[param1] = true;
}
public function removeObjectFromExclusion(param1:Object3D) : void {
delete this.excludedObjects[param1];
}
public function getExcludedObjects() : Dictionary {
return this.excludedObjects;
}
public function getShaftRaycastExcludedObjects() : Dictionary {
return this.shaftRaycastExcludedObjects;
}
private function initContainers() : void {
this.rootContainer = new Object3DContainer();
this.rootContainer.addChild(this.skyboxContainer = new Object3DContainer());
this.rootContainer.addChild(this.mainContainer = new Object3DContainer());
this.rootContainer.addChild(this.frontContainer = new Object3DContainer());
this.frontContainerProxy = new Object3DContainerProxy(this.frontContainer);
}
private function createCamera() : void {
this.camera = new GameCamera();
this.camera.ssaoRadius = 400;
this.camera.ssaoRange = 1200;
this.camera.ssaoColor = 0;
this.camera.ssaoAlpha = 1.4;
this.camera.addToDebug(Debug.BOUNDS,Object3D);
this.camera.addToDebug(Debug.EDGES,Object3D);
this.rootContainer.addChild(this.camera);
}
public function setSSAOColor(param1:uint) : void {
this.camera.ssaoColor = param1;
}
private function createFadingDecalsRenderer() : void {
if(GPUCapabilities.gpuEnabled) {
this.fadingDecalRenderer = new FadingDecalsRenderer(DECAL_FADING_TIME_MS);
this.addRenderer(this.fadingDecalRenderer,0);
}
}
public function addAmbientShadow(param1:Shadow) : void {
this.ambientShadows.add(param1);
}
public function removeAmbientShadow(param1:Shadow) : void {
this.ambientShadows.remove(param1);
}
public function addTurret(param1:TurretSkin) : void {
this.addObject(param1.getTurret3D());
}
public function removeTurret(param1:TurretSkin) : void {
this.removeObject(param1.getTurret3D());
}
public function setDebug(param1:Boolean) : void {
this.camera.debug = param1;
}
public function isDebug() : Boolean {
return this.camera.debug;
}
public function enableRendering() : void {
this.renderingEnabled = true;
}
public function disableRendering() : void {
this.renderingEnabled = false;
}
public function setUserTitleRenderer(param1:UserTitleRenderer) : void {
this.userTitleRenderer = param1;
}
public function addTank(param1:Tank) : void {
this.tanks.push(param1);
}
public function removeTank(param1:Tank) : void {
var local2:int = int(this.tanks.indexOf(param1));
if(local2 != -1) {
this.tanks.splice(local2,1);
}
}
public function addRenderer(param1:Renderer, param2:int = 0) : void {
var local3:RenderGroup = this.renderGroups[param2];
local3.addRenderer(param1);
}
public function removeRenderer(param1:Renderer, param2:int = 0) : void {
var local3:RenderGroup = this.renderGroups[param2];
local3.removeRenderer(param1);
}
public function addGraphicEffect(param1:GraphicEffect) : void {
if(param1 == null) {
throw new ArgumentError();
}
var local2:* = this.numEffects++;
this.effects[local2] = param1;
param1.addedToScene(this.mapContainerProxy);
}
public function render(param1:int, param2:int) : void {
var local3:Number = NaN;
if(this.renderingEnabled) {
this.fpsCounter.update();
this.ambientShadows.adjustDistances(this.fpsCounter.getFPS());
this.dustEngine.update();
this.renderTanks(param1,param2);
this.cameraController.update(this.camera,param1,param2);
this.camera.calculateAdditionalData();
this.runRenderers(param1,param2);
this.updateEffects(param2);
if(this.userTitleRenderer != null) {
this.userTitleRenderer.renderUserTitles();
}
local3 = this.camera.shadowMap != null ? Number(this.camera.shadowMapStrength) : 0;
if(this.camera.directionalLight != null) {
this.camera.directionalLight.intensity = this.shadowMapCorrectionFactor + local3 * (1 - this.shadowMapCorrectionFactor);
}
this.camera.render();
}
}
private function renderTanks(param1:int, param2:int) : void {
var local3:Tank = null;
for each(local3 in this.tanks) {
local3.render(param1,param2);
}
}
private function updateEffects(param1:int) : void {
var local3:GraphicEffect = null;
var local2:int = 0;
while(local2 < this.numEffects) {
local3 = this.effects[local2];
if(!local3.play(param1,this.camera)) {
local3.destroy();
var local4:* = local2--;
this.effects[local4] = this.effects[--this.numEffects];
this.effects[this.numEffects] = null;
}
local2++;
}
}
public function getCamera() : GameCamera {
return this.camera;
}
public function setSkyBox(param1:Object3D) : void {
if(this.skyboxContainer.numChildren > 0) {
this.skyboxContainer.removeChildAt(0);
}
this.skyboxContainer.addChild(param1);
}
public function enableSSAO(param1:Boolean) : void {
this.camera.ssao = param1;
}
public function setMapContainer(param1:Object3DContainer) : void {
if(this.mapContainer != null) {
this.mainContainer.removeChild(this.mapContainer);
this.mapContainer = null;
}
this.mapContainerProxy.setContainer(param1);
this.mapContainer = param1;
if(this.mapContainer != null) {
this.mainContainer.addChild(this.mapContainer);
this.camera.farClipping = 1.5 * this.getBoundSphereDiameter(this.mapContainer);
}
}
public function getBoundSphereDiameter(param1:Object3D) : Number {
var local2:Number = param1.boundMaxX - param1.boundMinX;
var local3:Number = param1.boundMaxY - param1.boundMinY;
var local4:Number = param1.boundMaxZ - param1.boundMinZ;
return Math.sqrt(local2 * local2 + local3 * local3 + local4 * local4);
}
public function addObject(param1:Object3D) : void {
this.mapContainerProxy.addChild(param1);
if(param1.name != Object3DNames.STATIC && param1.name != Object3DNames.TANK_PART) {
this.shaftRaycastExcludedObjects[param1] = true;
}
}
public function removeObject(param1:Object3D) : void {
this.mapContainerProxy.removeChild(param1);
if(param1.name != Object3DNames.STATIC && param1.name != Object3DNames.TANK_PART) {
delete this.shaftRaycastExcludedObjects[param1];
}
}
public function raycast(param1:Vector3, param2:Vector3, param3:Dictionary, param4:Camera3D = null) : RayIntersectionData {
var local6:Object3D = null;
BattleUtils.copyToVector3D(param1,_origin3D);
BattleUtils.copyToVector3D(param2,_direction3D);
var local5:RayIntersectionData = this.mapContainer.intersectRay(_origin3D,_direction3D,param3,param4);
if(Boolean(local5)) {
local6 = local5.object;
while(local6 != null && !local6.mouseEnabled) {
local6 = local6.parent;
}
local5.object = local6;
}
return local5;
}
public function setSkyBoxVisible(param1:Boolean) : void {
var local2:Object3D = this.getSkyBox();
if(local2 != null) {
local2.visible = param1;
}
}
public function isSkyBoxVisible() : Boolean {
var local1:Object3D = this.getSkyBox();
if(local1 != null) {
return local1.visible;
}
return false;
}
public function addDecal(param1:Vector3, param2:Vector3, param3:Number, param4:TextureMaterial, param5:RotationState = null) : void {
var local6:Decal = this.createDecal(param1,param2,param3,param4,param5);
if(local6 != null) {
this.temporaryDecals.put(local6);
if(this.temporaryDecals.getSize() > MAX_TEMPORARY_DECALS) {
this.fadingDecalRenderer.add(this.temporaryDecals.pop());
}
}
}
public function addPermanentDecal(param1:Vector3, param2:Vector3, param3:Number, param4:TextureMaterial) : Decal {
return this.createDecal(param1,param2,param3,param4);
}
private function createDecal(param1:Vector3, param2:Vector3, param3:Number, param4:TextureMaterial, param5:RotationState = null) : Decal {
var local6:Decal = null;
if(param5 == null) {
param5 = RotationState.USE_RANDOM_ROTATION;
}
if(Boolean(GPUCapabilities.gpuEnabled) && this.mapContainer is KDContainer) {
local6 = this.decalFactory.createDecal(param1,param2,param3,param4,KDContainer(this.mapContainer),param5);
this.mapContainerProxy.addChildAt(local6,0);
this.allDecals[local6] = true;
this.addObjectToExclusion(local6);
this.shaftRaycastExcludedObjects[local6] = true;
return local6;
}
return null;
}
public function removeDecal(param1:Decal) : void {
if(param1 != null && Boolean(GPUCapabilities.gpuEnabled)) {
this.mapContainerProxy.removeChild(param1);
this.removeObjectFromExclusion(param1);
delete this.shaftRaycastExcludedObjects[param1];
delete this.allDecals[param1];
}
}
public function setCameraController(param1:CameraController) : void {
if(this.cameraController != param1) {
if(this.cameraController != null) {
this.cameraController.deactivate();
}
this.cameraController = param1 == null ? DummyCameraController.INSTANCE : param1;
this.cameraController.activate(this.camera);
}
}
public function getCameraController() : CameraController {
return this.cameraController;
}
private function getSkyBox() : Object3D {
if(this.skyboxContainer.numChildren == 0) {
return null;
}
return this.skyboxContainer.getChildAt(0);
}
private function runRenderers(param1:int, param2:int) : void {
var local3:RenderGroup = null;
for each(local3 in this.renderGroups) {
local3.render(param1,param2);
}
}
public function shutdown() : void {
if(this.cameraController != null) {
this.cameraController.deactivate();
}
this.enableAutoQuality(false,"");
this.clearContainer(this.skyboxContainer);
this.clearContainer(this.mainContainer);
this.clearContainer(this.frontContainer);
this.clearContainer(this.rootContainer);
this.hidableGraphicObjects.clear();
}
private function clearContainer(param1:Object3DContainer) : void {
while(param1.numChildren > 0) {
param1.removeChildAt(0);
}
}
public function enableSoftTransparency(param1:Boolean) : void {
this.camera.softTransparency = param1;
}
public function enableDust(param1:Boolean) : void {
this.getDustEngine().enabled = param1;
}
public function toggleDynamicShadows() : void {
this.lighting.toggle();
}
public function addBillboard(param1:Mesh) : void {
this.billboards.add(param1);
}
public function setBillboardImage(param1:BitmapData) : void {
this.billboards.setImage(param1);
}
public function enableLighting(param1:Boolean) : void {
if(GPUCapabilities.gpuEnabled) {
if(param1) {
this.lighting.enableLighting();
} else {
this.lighting.disableLighting();
}
}
}
public function enableDynamicLighting(param1:Boolean) : void {
if(GPUCapabilities.gpuEnabled) {
this.camera.deferredLighting = param1;
}
}
public function enableAntialiasing(param1:Boolean) : void {
if(GPUCapabilities.gpuEnabled) {
this.camera.view.antiAliasEnabled = param1;
}
}
public function getMapMinZ() : Number {
return this.mapContainer == null ? 0 : Number(this.mapContainer.boundMinZ);
}
}
}
|
package alternativa.tanks.models.controlpoints.hud {
import alternativa.math.Vector3;
import alternativa.osgi.service.console.variables.ConsoleVarFloat;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.models.controlpoints.IDominationModel;
import alternativa.tanks.models.controlpoints.sound.KeyPointSoundEffects;
import alternativa.tanks.utils.MathUtils;
import projects.tanks.client.battlefield.models.battle.cp.ControlPointState;
public class KeyPoint implements Renderer, LogicUnit {
private static const CON_SMOOTHING_FACTOR:ConsoleVarFloat = new ConsoleVarFloat("dom_smoothing_factor",0.95,0,1);
private static const MAX_PROGRESS:Number = 100;
private var id:int;
private var name:String;
private var captureState:ControlPointState;
private var position:Vector3;
private var view:KeyPointView;
private var serverProgress:Number = 0;
private var clientProgress:Number = 0;
private var progressSpeed:Number = 0;
private var controlPointsModel:IDominationModel;
private var battleService:BattleService;
private var updateForced:Boolean;
private var soundEffects:KeyPointSoundEffects;
public var tanksCount:int;
public function KeyPoint(param1:int, param2:String, param3:Vector3, param4:BattleService, param5:IDominationModel, param6:KeyPointSoundEffects, param7:KeyPointView) {
super();
this.id = param1;
this.name = param2;
this.view = param7;
this.position = param3;
this.controlPointsModel = param5;
this.soundEffects = param6;
this.battleService = param4;
this.updateForced = false;
param4.getBattleScene3D().addRenderer(this,0);
param7.addToScene(param4.getBattleScene3D(),param3);
}
public function setCaptureState(param1:ControlPointState) : void {
this.captureState = param1;
this.updateForced = false;
if(this.captureState == ControlPointState.NEUTRAL) {
this.view.becomeNeutral();
if(this.tanksCount == 0) {
this.serverProgress = 0;
this.clientProgress = 0;
this.progressSpeed = 0;
}
} else {
if(this.captureState == ControlPointState.BLUE) {
this.view.becomeBlue();
this.serverProgress = MAX_PROGRESS;
} else {
this.view.becomeRed();
this.serverProgress = -MAX_PROGRESS;
}
this.clientProgress = this.serverProgress;
this.progressSpeed = 0;
}
}
public function getCaptureState() : ControlPointState {
return this.captureState;
}
public function setServerProgressData(param1:Number, param2:Number) : void {
this.serverProgress = param1;
this.progressSpeed = param2;
}
public function readPosition(param1:Vector3) : void {
param1.copy(this.position);
param1.z += KeyPointView.CIRCLE_ASCENSION;
}
public function getPosition() : Vector3 {
return this.position;
}
public function getName() : String {
return this.name;
}
public function getClientProgress() : Number {
return this.clientProgress;
}
public function reset() : void {
this.tanksCount = 0;
this.serverProgress = 0;
this.clientProgress = 0;
this.progressSpeed = 0;
this.captureState = ControlPointState.NEUTRAL;
this.view.becomeNeutral();
this.soundEffects.stopSound();
}
public function render(param1:int, param2:int) : void {
this.view.update(this.clientProgress,this.battleService.getBattleScene3D().getCamera());
}
public function runLogic(param1:int, param2:int) : void {
this.updateServerProgress(param2);
this.udpateClientProgress();
this.updateSound();
}
private function updateServerProgress(param1:int) : void {
if(this.progressSpeed != 0) {
this.serverProgress += this.progressSpeed * param1 / 1000;
if(!this.updateForced && this.reachedMaximumProgress()) {
this.controlPointsModel.forceUpdatePoint(this.id);
this.updateForced = true;
}
}
}
private function udpateClientProgress() : void {
var local1:Number = MathUtils.clamp(this.clientProgress + (this.serverProgress - this.clientProgress) * CON_SMOOTHING_FACTOR.value,-MAX_PROGRESS,MAX_PROGRESS);
if(this.tanksCount == 0 && this.clientProgress * local1 <= 0) {
this.serverProgress = 0;
this.clientProgress = 0;
this.progressSpeed = 0;
} else {
this.clientProgress = local1;
}
}
private function reachedMaximumProgress() : Boolean {
return Math.abs(this.serverProgress) >= MAX_PROGRESS;
}
private function updateSound() : void {
var local1:Number = this.clientProgress * this.progressSpeed;
if(local1 > 0 || this.clientProgress == 0 && this.progressSpeed != 0) {
this.soundEffects.playActivationSound(this.position);
} else if(local1 < 0) {
this.soundEffects.playDeactivationSound(this.position);
} else {
this.soundEffects.stopSound();
}
}
}
}
|
package assets.icons {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol530")]
public class IconGarageMod extends MovieClip {
public function IconGarageMod(param1:int = 0) {
super();
gotoAndStop(param1 + 1);
}
public function set mod(param1:int) : void {
gotoAndStop(param1 + 1);
}
}
}
|
package forms.base {
import base.DiscreteSprite;
import forms.TankWindowWithHeader;
public class BaseForm extends DiscreteSprite {
private var _window:TankWindowWithHeader;
public function BaseForm(param1:int, param2:int) {
super();
this._window = new TankWindowWithHeader();
this._window.width = param1;
this._window.height = param2;
addChild(this._window);
}
public function get window() : TankWindowWithHeader {
return this._window;
}
}
}
|
package mx.core {
import flash.display.Bitmap;
import flash.display.BitmapData;
import mx.utils.NameUtil;
use namespace mx_internal;
public class FlexBitmap extends Bitmap {
mx_internal static const VERSION:String = "4.5.0.19786";
public function FlexBitmap(bitmapData:BitmapData = null, pixelSnapping:String = "auto", smoothing:Boolean = false) {
super(bitmapData,pixelSnapping,smoothing);
try {
name = NameUtil.createUniqueName(this);
}
catch(e:Error) {
}
}
override public function toString() : String {
return NameUtil.displayObjectToString(this);
}
}
}
|
package _codec.projects.tanks.client.panel.model.bonus.showing.items {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.panel.model.bonus.showing.items.BonusItemCC;
public class CodecBonusItemCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_count:ICodec;
private var codec_resource:ICodec;
public function CodecBonusItemCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_count = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_resource = param1.getCodec(new TypeCodecInfo(ImageResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BonusItemCC = new BonusItemCC();
local2.count = this.codec_count.decode(param1) as int;
local2.resource = this.codec_resource.decode(param1) as ImageResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BonusItemCC = BonusItemCC(param2);
this.codec_count.encode(param1,local3.count);
this.codec_resource.encode(param1,local3.resource);
}
}
}
|
package alternativa.tanks.services {
import alternativa.types.Long;
import flash.events.Event;
import projects.tanks.client.chat.models.news.showing.NewsItemData;
public class NewsServiceEvent extends Event {
public static const NEWS_ITEM_IS_SENT:String = "NewsServiceEvent.NEWS_ITEM_IS_SENT";
public static const NEWS_ITEM_IS_REMOVED:String = "NewsServiceEvent.NEWS_ITEM_IS_REMOVED";
private var newsItem:NewsItemData;
private var newsId:Long;
public function NewsServiceEvent(param1:String) {
super(param1,true,false);
}
public function getNewsItem() : NewsItemData {
return this.newsItem;
}
public function setNewsItem(param1:NewsItemData) : void {
this.newsItem = param1;
}
public function getNewsId() : Long {
return this.newsId;
}
public function setNewsId(param1:Long) : void {
this.newsId = param1;
}
}
}
|
package controls.panel {
import controls.Label;
import flash.display.DisplayObject;
import flash.display.Graphics;
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.events.TimerEvent;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
import flash.utils.Timer;
[Embed(source="/_assets/assets.swf", symbol="symbol663")]
public class Indicators extends MovieClip {
public var CR:MovieClip;
public var C1:MovieClip;
public var C2:MovieClip;
public var kdicon:MovieClip;
public var L:MovieClip;
public var N:MovieClip;
public var R:MovieClip;
public var playerInfo:Label = new Label();
public var scoreLabel:Label = new Label();
public var kdRatio:Label = new Label();
public var crystalInfo:Label = new Label();
public var kd_icon:MovieClip;
private var _width:int;
private var progressBar:Sprite = new Sprite();
private var b_left:MovieClip;
private var b_name:MovieClip;
private var b_conn1:MovieClip;
private var b_ind:MovieClip;
private var b_conn2:MovieClip;
private var b_money:MovieClip;
private var b_conn3:MovieClip;
private var b_crystal:MovieClip;
private var b_right:MovieClip;
private var _buyXPButton:DisplayObject;
private var timer:Timer = new Timer(50);
private var redZone:Sprite = null;
private var _progress:int;
private var _nprogress:int;
private var _oprogress:int;
public function Indicators() {
super();
this.b_left = getChildByName("L") as MovieClip;
this.b_name = getChildByName("N") as MovieClip;
this.b_conn1 = getChildByName("C1") as MovieClip;
this.b_conn2 = getChildByName("C2") as MovieClip;
this.b_crystal = getChildByName("CR") as MovieClip;
this.b_right = getChildByName("R") as MovieClip;
this.kd_icon = getChildByName("kdicon") as MovieClip;
addChild(this.progressBar);
addChild(this.playerInfo);
addChild(this.scoreLabel);
addChild(this.kdRatio);
addChild(this.crystalInfo);
this.progressBar.x = 5;
this.progressBar.y = 5;
this.playerInfo.x = 6;
this.playerInfo.autoSize = TextFieldAutoSize.NONE;
this.scoreLabel.autoSize = TextFieldAutoSize.NONE;
this.scoreLabel.align = TextFormatAlign.RIGHT;
this.scoreLabel.width = 200;
this.scoreLabel.size = this.kdRatio.size = this.playerInfo.size = this.crystalInfo.size = 12;
this.scoreLabel.color = this.kdRatio.color = this.playerInfo.color = this.crystalInfo.color = 1244928;
this.scoreLabel.y = this.kdRatio.y = this.playerInfo.y = this.crystalInfo.y = 4;
this.scoreLabel.height = this.crystalInfo.height = this.playerInfo.height = 18;
this.crystalInfo.align = TextFormatAlign.RIGHT;
this.crystalInfo.autoSize = TextFieldAutoSize.NONE;
this.crystalInfo.width = 59;
this.redZone = new Sprite();
this.timer = new Timer(50);
this.timer.addEventListener(TimerEvent.TIMER,this.hideRedZone);
this.progressBar.addChild(this.redZone);
this.redZone.alpha = 0;
}
public function get progress() : int {
return this._progress;
}
public function set progress(param1:int) : void {
var local2:Graphics = this.progressBar.graphics;
var local3:int = this.b_name.width + 4;
this._progress = param1;
local2.clear();
local2.beginFill(1244928,0.2);
local2.drawRect(0,0,local3 / 10000 * this._progress,16);
local2.endFill();
}
public function set newprogress(param1:int) : void {
this._nprogress = param1;
this._oprogress = this._progress;
var local2:Graphics = this.redZone.graphics;
var local3:int = this.b_name.width + 4;
this.redZone.alpha = 1;
local2.clear();
if(this._nprogress >= this._oprogress) {
local2.beginFill(16763904,1);
local2.drawRect(local3 / 10000 * this._oprogress,0,local3 / 10000 * (param1 - this._oprogress),16);
local2.endFill();
} else {
local2.beginFill(16763904,1);
local2.drawRect(0,0,local3,16);
local2.endFill();
}
this.timer.stop();
this.timer.start();
}
private function hideRedZone(param1:TimerEvent) : void {
var local2:DisplayObject = this.redZone;
local2.alpha -= 0.03;
if(local2.alpha <= 0) {
this.timer.stop();
}
}
override public function set width(param1:Number) : void {
var local2:int = 0;
this._width = param1;
if(Boolean(this._buyXPButton) && this._buyXPButton.visible) {
local2 = int(this._width - 184 - this._buyXPButton.width);
} else {
local2 = int(this._width - 180);
}
this.b_name.width = local2;
this.b_conn1.x = this.b_name.width + this.b_left.width;
if(Boolean(this._buyXPButton) && this._buyXPButton.visible) {
this._buyXPButton.x = this.b_conn1.x + this.b_conn1.width + 1;
this.b_conn2.x = this._buyXPButton.x + this._buyXPButton.width + 11;
} else {
this.b_conn2.x = this.b_conn1.x + this.b_conn1.width + 11;
}
this.b_crystal.width = 67;
this.b_crystal.x = this.b_conn2.x + this.b_conn2.width;
this.b_right.x = this.b_crystal.x + this.b_crystal.width;
this.crystalInfo.x = this.b_crystal.x - 2;
this.kdRatio.x = int(this.b_conn1.x - this.kdRatio.textWidth - 3);
this.kd_icon.x = int(this.b_conn1.x - this.kdRatio.textWidth - 10);
this.scoreLabel.x = this.kd_icon.x - 205;
this.playerInfo.width = this.b_name.width - this.kdRatio.width - this.kd_icon.width - 5;
this.progress = this._progress;
}
public function get buyXPButton() : DisplayObject {
return this._buyXPButton;
}
public function set buyXPButton(param1:DisplayObject) : void {
this._buyXPButton = param1;
addChild(this._buyXPButton);
this.width = this._width;
}
}
}
|
package alternativa.tanks.newbieservice {
public interface NewbieUserService {
function get isNewbieUser() : Boolean;
function set isNewbieUser(param1:Boolean) : void;
}
}
|
package alternativa.tanks.service.battlecreate {
import flash.events.IEventDispatcher;
public interface IBattleCreateFormService extends IEventDispatcher {
function showForm() : void;
function hideForm() : void;
function get battleCreationDisabled() : Boolean;
function set battleCreationDisabled(param1:Boolean) : void;
}
}
|
package projects.tanks.client.panel.model.shopabonement {
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 ActiveShopAbonementsModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ActiveShopAbonementsModelServer;
private var client:IActiveShopAbonementsModelBase = IActiveShopAbonementsModelBase(this);
private var modelId:Long = Long.getLong(865583325,1347608741);
public function ActiveShopAbonementsModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ActiveShopAbonementsModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ShopAbonementsCC,false)));
}
protected function getInitParam() : ShopAbonementsCC {
return ShopAbonementsCC(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 com.lorentz.SVG.display {
import com.lorentz.SVG.data.text.SVGDrawnText;
import com.lorentz.SVG.display.base.SVGTextContainer;
import com.lorentz.SVG.utils.DisplayUtils;
import com.lorentz.SVG.utils.SVGUtil;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.geom.Rectangle;
public class SVGTSpan extends SVGTextContainer {
private var _svgDx:String;
public function get svgDx():String {
return _svgDx;
}
public function set svgDx(value:String):void {
if(_svgDx != value){
_svgDx = value;
invalidateRender();
}
}
private var _svgDy:String;
public function get svgDy():String {
return _svgDy;
}
public function set svgDy(value:String):void {
if(_svgDy != value){
_svgDy = value;
invalidateRender();
}
}
public function SVGTSpan(){
super("tspan");
}
private var _start:Number = 0;
private var _end:Number = 0;
override protected function render():void {
super.render();
while(content.numChildren > 0)
content.removeChildAt(0);
if(this.numTextElements == 0)
return;
var direction:String = getDirectionFromStyles() || "lr";
var textDirection:String = direction;
if(svgX)
textOwner.currentX = getViewPortUserUnit(svgX, SVGUtil.WIDTH);
if(svgY)
textOwner.currentY = getViewPortUserUnit(svgY, SVGUtil.HEIGHT);
_start = textOwner.currentX;
_renderObjects = new Vector.<DisplayObject>();
if(svgDx)
textOwner.currentX += getViewPortUserUnit(svgDx, SVGUtil.WIDTH);
if(svgDy)
textOwner.currentY += getViewPortUserUnit(svgDy, SVGUtil.HEIGHT);
var fillTextsSprite:Sprite;
if(hasComplexFill)
{
fillTextsSprite = new Sprite();
content.addChild(fillTextsSprite);
} else {
fillTextsSprite = content;
}
for(var i:int = 0; i < numTextElements; i++){
var textElement:Object = getTextElementAt(i);
if(textElement is String){
var drawnText:SVGDrawnText = createTextSprite( textElement as String, document.textDrawer );
if((drawnText.direction || direction) == "lr"){
drawnText.displayObject.x = textOwner.currentX - drawnText.startX;
drawnText.displayObject.y = textOwner.currentY - drawnText.startY - drawnText.baseLineShift;
textOwner.currentX += drawnText.textWidth;
} else {
drawnText.displayObject.x = textOwner.currentX - drawnText.textWidth - drawnText.startX;
drawnText.displayObject.y = textOwner.currentY - drawnText.startY - drawnText.baseLineShift;
textOwner.currentX -= drawnText.textWidth;
}
if(drawnText.direction)
textDirection = drawnText.direction;
fillTextsSprite.addChild(drawnText.displayObject);
_renderObjects.push(drawnText.displayObject);
} else if(textElement is SVGTextContainer) {
var tspan:SVGTextContainer = textElement as SVGTextContainer;
if(tspan.hasOwnFill()){
textOwner.textContainer.addChild(tspan);
} else
fillTextsSprite.addChild(tspan);
tspan.invalidateRender();
tspan.validate();
_renderObjects.push(tspan);
}
}
_end = textOwner.currentX;
if(svgX)
doAnchorAlign(textDirection, _start, _end);
if(hasComplexFill && fillTextsSprite.numChildren > 0){
var bounds:Rectangle = DisplayUtils.safeGetBounds(fillTextsSprite, content);
bounds.inflate(2, 2);
var fill:Sprite = new Sprite();
beginFill(fill.graphics);
fill.graphics.drawRect(bounds.x, bounds.y, bounds.width, bounds.height);
fill.mask = fillTextsSprite;
fillTextsSprite.cacheAsBitmap = true;
fill.cacheAsBitmap = true;
content.addChildAt(fill, 0);
_renderObjects.push(fill);
}
}
override public function clone():Object {
var c:SVGTSpan = super.clone() as SVGTSpan;
c.svgX = svgX;
c.svgY = svgY;
c.svgDx = svgDx;
c.svgDy = svgDy;
return c;
}
}
}
|
package alternativa.gfx.agal {
public class SamplerRepeat extends SamplerOption {
private static const SAMPLER_REPEAT_SHIFT:uint = 20;
public static const CLAMP:SamplerRepeat = new SamplerRepeat(0);
public static const REPEAT:SamplerRepeat = new SamplerRepeat(1);
public static const WRAP:SamplerRepeat = REPEAT;
public function SamplerRepeat(param1:uint) {
super(param1,SAMPLER_REPEAT_SHIFT);
}
}
}
|
package alternativa.tanks.models.weapon.common {
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
[ModelInterface]
public interface IWeaponCommonModel {
function getCommonData() : WeaponCommonData;
function storeTank(param1:Tank) : void;
function getTank() : Tank;
function getGunParams(param1:int = 0) : AllGlobalGunParams;
}
}
|
package projects.tanks.client.panel.model.shop.challenges.toclient {
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 ChallengeShopItemsModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ChallengeShopItemsModelServer(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 controls.base
{
import controls.ColorButton;
public class ColorButtonBase extends ColorButton
{
public function ColorButtonBase()
{
super();
}
override public function configUI() : void
{
super.configUI();
_label.sharpness = 40;
_label.thickness = 70;
}
}
}
|
package alternativa.protocol.info {
import alternativa.protocol.ICodecInfo;
public class CollectionCodecInfo extends CodecInfo {
private var _elementCodec:ICodecInfo;
private var _level:int;
public function CollectionCodecInfo(param1:ICodecInfo, param2:Boolean, param3:int) {
super(param2);
this._elementCodec = param1;
this._level = param3;
}
public function get level() : int {
return this._level;
}
public function get elementCodec() : ICodecInfo {
return this._elementCodec;
}
override public function toString() : String {
return "[CollectionCodecInfo " + super.toString() + " element=" + this.elementCodec.toString() + " level=" + this.level + "]";
}
}
}
|
package alternativa.tanks.controller.events.logging {
import flash.events.Event;
public class RegistrationUXNavigationFinishEvent extends Event {
public static const NAVIGATION_FINISH:String = "RegistrationUXNavigationFinishEvent";
public function RegistrationUXNavigationFinishEvent() {
super(NAVIGATION_FINISH);
}
}
}
|
package alternativa.protocol.codec
{
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
public interface ICodec
{
function encode(param1:IDataOutput, param2:Object, param3:NullMap, param4:Boolean) : void;
function decode(param1:IDataInput, param2:NullMap, param3:Boolean) : Object;
}
}
|
package alternativa.tanks.model.item.container.gui.opening {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.item.container.gui.opening.ContainerOpenDialog_Star.jpg")]
public class ContainerOpenDialog_Star extends BitmapAsset {
public function ContainerOpenDialog_Star() {
super();
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _01547ee4d3c4958823b2fea0587533b8bb6b29b2e7bcdb0235135fa28086b020_flash_display_Sprite extends Sprite {
public function _01547ee4d3c4958823b2fea0587533b8bb6b29b2e7bcdb0235135fa28086b020_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package alternativa.tanks.view.battlelist.forms {
import alternativa.tanks.service.money.IMoneyListener;
import alternativa.tanks.service.money.IMoneyService;
import assets.Diamond;
import controls.base.BigButtonBase;
import controls.base.LabelBase;
import controls.buttons.ButtonStates;
import flash.events.Event;
import flash.filters.DropShadowFilter;
public class BattleBigButton extends BigButtonBase implements IMoneyListener {
[Inject]
public static var moneyService:IMoneyService;
private var diamond:Diamond = new Diamond();
private var costLabel:LabelBase = new LabelBase();
private var _cost:int = 0;
public function BattleBigButton() {
super();
addChild(this.diamond);
addChild(this.costLabel);
this.diamond.visible = this.costLabel.visible = false;
label = "";
addEventListener(Event.ADDED_TO_STAGE,this.onAddToStage);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
this.diamond.filters = this.costLabel.filters = [new DropShadowFilter(1,45,0,0.7,1,1,1)];
}
private function onRemoveFromStage(param1:Event) : void {
moneyService.removeListener(this);
}
private function onAddToStage(param1:Event) : void {
moneyService.addListener(this);
this.updateColor();
}
public function crystalsChanged(param1:int) : void {
this.updateColor();
}
override public function set width(param1:Number) : void {
super.width = param1;
_info.width = _label.width = _width - 4;
if(_icon.bitmapData != null) {
_icon.x = 6;
_icon.y = int(25 - _icon.height / 2);
_label.width = _width - 8 - _icon.width;
_label.x = _icon.width + 4;
_label.y = this._cost == 0 ? 16 : 6;
}
if(this._cost > 0) {
this.diamond.visible = this.costLabel.visible = true;
this.diamond.x = _icon.width + 4 + (_label.width - _label.textWidth) / 2;
this.diamond.y = 26;
this.costLabel.y = 22;
this.costLabel.text = String(this._cost);
this.costLabel.x = this.diamond.x + this.diamond.width;
this.updateColor();
} else {
this.diamond.visible = this.costLabel.visible = false;
}
}
private function updateColor() : void {
if(this._cost > moneyService.crystal) {
this.costLabel.color = 16731648;
} else {
this.costLabel.color = 16777215;
}
}
public function set cost(param1:int) : void {
this._cost = param1;
this.width = _width;
}
override protected function onStateChanged() : void {
super.onStateChanged();
var local1:int = getState() == ButtonStates.DOWN ? 1 : 0;
_label.y = (this._cost == 0 ? 16 : 6) + local1;
this.diamond.y = 26;
this.costLabel.y = 22 + local1;
}
}
}
|
package _codec.platform.client.core.general.resourcelocale.format {
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 flash.utils.ByteArray;
import platform.client.core.general.resourcelocale.format.ImagePair;
public class CodecImagePair implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_key:ICodec;
private var codec_value:ICodec;
public function CodecImagePair() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_key = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_value = param1.getCodec(new TypeCodecInfo(ByteArray,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ImagePair = new ImagePair();
local2.key = this.codec_key.decode(param1) as String;
local2.value = this.codec_value.decode(param1) as ByteArray;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ImagePair = ImagePair(param2);
this.codec_key.encode(param1,local3.key);
this.codec_value.encode(param1,local3.value);
}
}
}
|
package projects.tanks.client.garage.models.item.kit {
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 GarageKitModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:GarageKitModelServer;
private var client:IGarageKitModelBase = IGarageKitModelBase(this);
private var modelId:Long = Long.getLong(1215266592,-1320571870);
public function GarageKitModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new GarageKitModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(GarageKitCC,false)));
}
protected function getInitParam() : GarageKitCC {
return GarageKitCC(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 alternativa.tanks.help.achievements {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.BubbleHelper;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperAlign;
public class FirstBattleFightHelper extends BubbleHelper {
public function FirstBattleFightHelper() {
super();
var local1:ILocaleService = ILocaleService(OSGi.getInstance().getService(ILocaleService));
text = local1.getText(TanksLocale.TEXT_HELP_PANEL_ACHIEVEMENTS_FIRST_BATTLE_TEXT);
arrowLehgth = int(local1.getText(TanksLocale.TEXT_HELP_PANEL_ACHIEVEMENTS_FIRST_BATTLE_ARROW_LENGTH));
arrowAlign = HelperAlign.TOP_RIGHT;
_showLimit = 3;
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_11 extends BitmapAsset
{
public function BigRangIcon_rang_11()
{
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank02.png")]
public class PremiumRankBitmaps_bitmapBigRank02 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank02() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.rankupbonus.alert {
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.rankupbonus.alert.RankUpBonusAlertItem;
public class CodecRankUpBonusAlertItem implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_accruedBonusCrystals:ICodec;
private var codec_alertPictureUrl:ICodec;
public function CodecRankUpBonusAlertItem() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_accruedBonusCrystals = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_alertPictureUrl = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:RankUpBonusAlertItem = new RankUpBonusAlertItem();
local2.accruedBonusCrystals = this.codec_accruedBonusCrystals.decode(param1) as int;
local2.alertPictureUrl = this.codec_alertPictureUrl.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:RankUpBonusAlertItem = RankUpBonusAlertItem(param2);
this.codec_accruedBonusCrystals.encode(param1,local3.accruedBonusCrystals);
this.codec_alertPictureUrl.encode(param1,local3.alertPictureUrl);
}
}
}
|
package com.alternativaplatform.projects.tanks.client.commons.types
{
public class TankState
{
public var health:int;
public var position:Vector3d;
public var orientation:Vector3d;
public var turretAngle:int;
public var control:int;
public function TankState()
{
super();
}
}
}
|
package projects.tanks.client.garage.models.item.premium {
public interface IPremiumItemModelBase {
}
}
|
package alternativa.tanks.service.money
{
public interface IMoneyService
{
function addListener(param1:IMoneyListener) : void;
function removeListener(param1:IMoneyListener) : void;
function get crystal() : int;
}
}
|
package projects.tanks.client.battlefield.models.user.device {
public interface ITankDeviceModelBase {
}
}
|
package alternativa.tanks.gui.battle {
public class NotificationPatterns {
public static const YOUR_PLACE_REPLACE_PATTERN:String = "{your_place}";
public static const PLACES_REPLACE_PATTERN:String = "{places}";
public static const CRYSTALS_REPLACE_PATTERN:String = "{crystals}";
public static const STARS_REPLACE_PATTER:String = "{stars}";
public function NotificationPatterns() {
super();
}
}
}
|
package alternativa.tanks.model.challenge.greenpanel.black
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BlackPack_bg extends BitmapAsset
{
public function BlackPack_bg()
{
super();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.