code
stringlengths 57
237k
|
|---|
package alternativa.tanks.models.dom.sfx
{
import alternativa.engine3d.materials.TextureMaterial;
public class BeamProperties
{
public var beamMaterial:TextureMaterial;
public var beamTipMaterial:TextureMaterial;
public var beamWidth:Number;
public var unitLength:Number;
public var animationSpeed:Number;
public var uRange:Number;
public var alpha:Number;
public function BeamProperties(param1:TextureMaterial, param2:TextureMaterial, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number)
{
super();
this.beamMaterial = param1;
this.beamTipMaterial = param2;
this.beamWidth = param3;
this.unitLength = param4;
this.animationSpeed = param5;
this.uRange = param6;
this.alpha = param7;
}
}
}
|
package projects.tanks.client.panel.model.shop.clientlayoutkit {
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 KitBundleViewModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function KitBundleViewModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.battlefield.models.inventory.item {
public class InventoryItemCC {
private var _alternativeSlotItem:Boolean;
private var _count:int;
private var _itemIndex:int;
public function InventoryItemCC(param1:Boolean = false, param2:int = 0, param3:int = 0) {
super();
this._alternativeSlotItem = param1;
this._count = param2;
this._itemIndex = param3;
}
public function get alternativeSlotItem() : Boolean {
return this._alternativeSlotItem;
}
public function set alternativeSlotItem(param1:Boolean) : void {
this._alternativeSlotItem = param1;
}
public function get count() : int {
return this._count;
}
public function set count(param1:int) : void {
this._count = param1;
}
public function get itemIndex() : int {
return this._itemIndex;
}
public function set itemIndex(param1:int) : void {
this._itemIndex = param1;
}
public function toString() : String {
var local1:String = "InventoryItemCC [";
local1 += "alternativeSlotItem = " + this.alternativeSlotItem + " ";
local1 += "count = " + this.count + " ";
local1 += "itemIndex = " + this.itemIndex + " ";
return local1 + "]";
}
}
}
|
package alternativa.utils {
public interface ICircularStringBuffer {
function add(param1:String) : void;
function clear() : void;
function get size() : int;
function get capacity() : int;
function set capacity(param1:int) : void;
function getIterator(param1:int) : IStringBufferIterator;
}
}
|
package alternativa.tanks.models.sfx
{
import alternativa.engine3d.lights.OmniLight;
import alternativa.tanks.sfx.Object3DPositionProvider;
import alternativa.tanks.utils.objectpool.ObjectPool;
public final class OmniStreamLightEffect extends StreamLightEffect
{
public function OmniStreamLightEffect(param1:ObjectPool)
{
super(param1,new OmniLight(0,0,0));
}
public function init(param1:Object3DPositionProvider, param2:LightAnimation, param3:LightAnimation) : void
{
this.positionProvider = param1;
this.startTime = param2.getLiveTime();
this.loopTime = param3.getLiveTime();
this.startAnimation = param2;
this.loopAnimation = param3;
this.random = loopTime / 4;
starting = true;
currentTime = 0;
alive = true;
fading = false;
fadeTime = 0;
}
}
}
|
package alternativa.tanks.models.sfx.smoke {
import platform.client.fp10.core.type.IGameObject;
[ModelInterface]
public interface HullSmoke {
function controlChanged(param1:IGameObject, param2:int) : void;
}
}
|
package alternativa.engine3d.core {
import alternativa.engine3d.alternativa3d;
use namespace alternativa3d;
public class Wrapper {
alternativa3d static var collector:Wrapper;
alternativa3d var next:Wrapper;
alternativa3d var vertex:Vertex;
public function Wrapper() {
super();
}
alternativa3d static function create() : Wrapper {
var local1:Wrapper = null;
if(alternativa3d::collector != null) {
local1 = alternativa3d::collector;
alternativa3d::collector = alternativa3d::collector.alternativa3d::next;
local1.alternativa3d::next = null;
return local1;
}
return new Wrapper();
}
alternativa3d function create() : Wrapper {
var local1:Wrapper = null;
if(alternativa3d::collector != null) {
local1 = alternativa3d::collector;
alternativa3d::collector = alternativa3d::collector.alternativa3d::next;
local1.alternativa3d::next = null;
return local1;
}
return new Wrapper();
}
}
}
|
package alternativa.tanks.battle {
public class NotSpectatorModeError extends Error {
public function NotSpectatorModeError() {
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_nitroBgdClass.png")]
public class HudInventoryIcon_nitroBgdClass extends BitmapAsset {
public function HudInventoryIcon_nitroBgdClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.users.model.friends {
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.users.model.friends.FriendsCC;
public class CodecFriendsCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_acceptedLimit:ICodec;
private var codec_incomingLimit:ICodec;
private var codec_local:ICodec;
public function CodecFriendsCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_acceptedLimit = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_incomingLimit = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_local = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:FriendsCC = new FriendsCC();
local2.acceptedLimit = this.codec_acceptedLimit.decode(param1) as int;
local2.incomingLimit = this.codec_incomingLimit.decode(param1) as int;
local2.local = this.codec_local.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:FriendsCC = FriendsCC(param2);
this.codec_acceptedLimit.encode(param1,local3.acceptedLimit);
this.codec_incomingLimit.encode(param1,local3.incomingLimit);
this.codec_local.encode(param1,local3.local);
}
}
}
|
package alternativa.tanks.models.weapons.shell {
import alternativa.math.Vector3;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ShellWeaponListenerAdapt implements ShellWeaponListener {
private var object:IGameObject;
private var impl:ShellWeaponListener;
public function ShellWeaponListenerAdapt(param1:IGameObject, param2:ShellWeaponListener) {
super();
this.object = param1;
this.impl = param2;
}
public function onShot(param1:int, param2:int, param3:Vector3) : void {
var barrelIndex:int = param1;
var shotId:int = param2;
var direction:Vector3 = param3;
try {
Model.object = this.object;
this.impl.onShot(barrelIndex,shotId,direction);
}
finally {
Model.popObject();
}
}
public function onDummyShot(param1:int) : void {
var barrelIndex:int = param1;
try {
Model.object = this.object;
this.impl.onDummyShot(barrelIndex);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.gui.chat {
import controls.statassets.*;
import flash.display.BitmapData;
public class ChatLineHighlightPrivate extends StatLineBase {
private static const cornerBitmapClass:Class = ChatLineHighlightPrivate_cornerBitmapClass;
private static const cornerBitmapData:BitmapData = new cornerBitmapClass().bitmapData;
public function ChatLineHighlightPrivate() {
super();
tl = cornerBitmapData;
px = new BitmapData(1,1,false,3313951);
}
}
}
|
package alternativa.tanks.model.item.buyable {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IBuyableEvents implements IBuyable {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IBuyableEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getPriceWithoutDiscount() : int {
var result:int = 0;
var i:int = 0;
var m:IBuyable = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IBuyable(this.impl[i]);
result = int(m.getPriceWithoutDiscount());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getPrice() : int {
var result:int = 0;
var i:int = 0;
var m:IBuyable = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IBuyable(this.impl[i]);
result = int(m.getPrice());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function isBuyable() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:IBuyable = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IBuyable(this.impl[i]);
result = Boolean(m.isBuyable());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package forms
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
import controls.panel.BaseButton;
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.events.MouseEvent;
import forms.buttons.MainPanelChallengeButton;
import forms.buttons.MainPanelDonateButton;
import forms.buttons.MainPanelFriendsButton;
import forms.buttons.MainPanelRatingButton;
import forms.buttons.MainPanelSocialNetsButton;
import forms.buttons.MainPanelSpinsButton;
import forms.events.MainButtonBarEvents;
public class ButtonBar extends Sprite
{
public var battlesButton:MainPanelBattlesButton;
public var garageButton:MainPanelGarageButton;
public var statButton:MainPaneHallButton;
public var socialNetsButton:MainPanelSocialNetsButton;
public var bugsButton:MainPanelBugButton;
public var settingsButton:MainPanelConfigButton;
public var soundButton:MainPanelSoundButton;
public var helpButton:MainPanelHelpButton;
public var closeButton:MainPanelCloseButton;
public var addButton:BaseButton;
public var donateButton:MainPanelDonateButton;
public var ratingButton:MainPanelRatingButton;
public var challengeButton:MainPanelChallengeButton;
public var friendsButton:MainPanelFriendsButton;
public var spinsButton:MainPanelSpinsButton;
private var _soundOn:Boolean = true;
private var soundIcon:MovieClip;
public var isTester:Boolean = false;
public function ButtonBar()
{
this.battlesButton = new MainPanelBattlesButton();
this.garageButton = new MainPanelGarageButton();
this.statButton = new MainPaneHallButton();
this.socialNetsButton = new MainPanelSocialNetsButton();
this.bugsButton = new MainPanelBugButton();
this.settingsButton = new MainPanelConfigButton();
this.soundButton = new MainPanelSoundButton();
this.helpButton = new MainPanelHelpButton();
this.closeButton = new MainPanelCloseButton();
this.donateButton = new MainPanelDonateButton();
this.ratingButton = new MainPanelRatingButton();
this.challengeButton = new MainPanelChallengeButton();
this.friendsButton = new MainPanelFriendsButton();
this.spinsButton = new MainPanelSpinsButton();
super();
var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
addChild(this.battlesButton);
this.battlesButton.type = 4;
this.battlesButton.label = localeService.getText(TextConst.MAIN_PANEL_BUTTON_BATTLES);
this.battlesButton.addEventListener(MouseEvent.CLICK,this.listClick);
addChild(this.garageButton);
this.garageButton.type = 5;
this.garageButton.label = localeService.getText(TextConst.MAIN_PANEL_BUTTON_GARAGE);
this.garageButton.addEventListener(MouseEvent.CLICK,this.listClick);
addChild(this.friendsButton);
this.friendsButton.type = 15;
this.friendsButton.addEventListener(MouseEvent.CLICK,this.listClick);
addChild(this.socialNetsButton);
this.socialNetsButton.type = 14;
this.socialNetsButton.addEventListener(MouseEvent.CLICK,this.listClick);
addChild(this.spinsButton);
this.spinsButton.type = 13;
this.spinsButton.addEventListener(MouseEvent.CLICK,this.listClick);
this.bugsButton.type = 11;
this.bugsButton.addEventListener(MouseEvent.CLICK,this.listClick);
addChild(this.settingsButton);
this.settingsButton.type = 7;
this.settingsButton.addEventListener(MouseEvent.CLICK,this.listClick);
addChild(this.soundButton);
this.soundButton.type = 8;
this.soundButton.addEventListener(MouseEvent.CLICK,this.listClick);
this.soundIcon = this.soundButton.getChildByName("icon") as MovieClip;
addChild(this.helpButton);
this.helpButton.type = 9;
this.helpButton.addEventListener(MouseEvent.CLICK,this.listClick);
addChild(this.closeButton);
this.closeButton.type = 10;
this.closeButton.addEventListener(MouseEvent.CLICK,this.listClick);
addChild(this.donateButton);
this.donateButton.label = localeService.getText(TextConst.MAIN_PANEL_BUTTON_SHOP);
this.donateButton.addEventListener(MouseEvent.CLICK,this.listClick);
addChild(this.ratingButton);
this.ratingButton.label = localeService.getText(TextConst.MAIN_PANEL_BUTTON_RATING);
this.ratingButton.type = 2;
this.ratingButton.addEventListener(MouseEvent.CLICK,this.listClick);
addChild(this.challengeButton);
this.challengeButton.label = localeService.getText(TextConst.MAIN_PANEL_BUTTON_CHALLENGE);
this.challengeButton.type = 3;
this.challengeButton.addEventListener(MouseEvent.CLICK,this.listClick);
this.draw();
}
public function draw() : void
{
this.ratingButton.x = this.donateButton.x + this.donateButton.width + 5;
this.challengeButton.x = this.ratingButton.x + this.ratingButton.width + 5;
this.battlesButton.x = this.challengeButton.x + this.challengeButton.width + 5;
this.garageButton.x = this.battlesButton.x + this.battlesButton.width;
this.friendsButton.x = this.garageButton.x + this.garageButton.width + 5;
this.spinsButton.x = this.friendsButton.x + this.friendsButton.width + 2;
this.socialNetsButton.x = this.spinsButton.x + this.spinsButton.width;
this.settingsButton.x = this.socialNetsButton.x + this.socialNetsButton.width + 1;
this.soundButton.x = this.settingsButton.x + this.settingsButton.width;
this.helpButton.x = this.soundButton.x + this.soundButton.width;
this.closeButton.x = this.helpButton.x + this.helpButton.width + 11;
this.soundIcon.gotoAndStop(!!this.soundOn ? 1 : 2);
}
public function set soundOn(value:Boolean) : void
{
this._soundOn = value;
this.draw();
}
public function get soundOn() : Boolean
{
return this._soundOn;
}
public function listClick(e:MouseEvent) : void
{
var target:BaseButton = null;
var trget:BaseButton = null;
var i:int = 0;
if(e.currentTarget as BaseButton != null)
{
target = e.currentTarget as BaseButton;
if(target.enable)
{
dispatchEvent(new MainButtonBarEvents(target.type));
}
if(target == this.soundButton)
{
this.soundOn = !this.soundOn;
}
if(target == this.battlesButton || target == this.garageButton || target == this.statButton)
{
for(i = 0; i < 3; i++)
{
trget = getChildAt(i) as BaseButton;
trget.enable = target != trget;
}
}
}
}
}
}
|
package alternativa.tanks.models.weapon.angles.verticals.autoaiming {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class VerticalAutoAimingEvents implements VerticalAutoAiming {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function VerticalAutoAimingEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getElevationAngleUp() : Number {
var result:Number = NaN;
var i:int = 0;
var m:VerticalAutoAiming = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = VerticalAutoAiming(this.impl[i]);
result = Number(m.getElevationAngleUp());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getNumRaysUp() : int {
var result:int = 0;
var i:int = 0;
var m:VerticalAutoAiming = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = VerticalAutoAiming(this.impl[i]);
result = int(m.getNumRaysUp());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getElevationAngleDown() : Number {
var result:Number = NaN;
var i:int = 0;
var m:VerticalAutoAiming = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = VerticalAutoAiming(this.impl[i]);
result = Number(m.getElevationAngleDown());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getNumRaysDown() : int {
var result:int = 0;
var i:int = 0;
var m:VerticalAutoAiming = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = VerticalAutoAiming(this.impl[i]);
result = int(m.getNumRaysDown());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getMaxAngle() : Number {
var result:Number = NaN;
var i:int = 0;
var m:VerticalAutoAiming = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = VerticalAutoAiming(this.impl[i]);
result = Number(m.getMaxAngle());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.panel.model.referrals {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
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 ReferralsModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ReferralsModelServer;
private var client:IReferralsModelBase = IReferralsModelBase(this);
private var modelId:Long = Long.getLong(1896158207,-814003948);
private var _updateDataId:Long = Long.getLong(1620265453,-1623297132);
private var _updateData_dataCodec:ICodec;
public function ReferralsModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ReferralsModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ReferralsModelCC,false)));
this._updateData_dataCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(ReferralIncomeData,false),false,1));
}
protected function getInitParam() : ReferralsModelCC {
return ReferralsModelCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._updateDataId:
this.client.updateData(this._updateData_dataCodec.decode(param2) as Vector.<ReferralIncomeData>);
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.panel.model.shop.featuring {
public class ShopItemFeaturingCC {
private var _hiddenInOriginalCategory:Boolean;
private var _locatedInFeaturingCategory:Boolean;
private var _position:int;
public function ShopItemFeaturingCC(param1:Boolean = false, param2:Boolean = false, param3:int = 0) {
super();
this._hiddenInOriginalCategory = param1;
this._locatedInFeaturingCategory = param2;
this._position = param3;
}
public function get hiddenInOriginalCategory() : Boolean {
return this._hiddenInOriginalCategory;
}
public function set hiddenInOriginalCategory(param1:Boolean) : void {
this._hiddenInOriginalCategory = param1;
}
public function get locatedInFeaturingCategory() : Boolean {
return this._locatedInFeaturingCategory;
}
public function set locatedInFeaturingCategory(param1:Boolean) : void {
this._locatedInFeaturingCategory = param1;
}
public function get position() : int {
return this._position;
}
public function set position(param1:int) : void {
this._position = param1;
}
public function toString() : String {
var local1:String = "ShopItemFeaturingCC [";
local1 += "hiddenInOriginalCategory = " + this.hiddenInOriginalCategory + " ";
local1 += "locatedInFeaturingCategory = " + this.locatedInFeaturingCategory + " ";
local1 += "position = " + this.position + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.tank.spawn.spawnhandlers.ready2spawn {
import alternativa.tanks.models.tank.ITankModel;
import platform.client.fp10.core.type.AutoClosable;
import platform.client.fp10.core.type.IGameObject;
public class RemoteReadyToSpawnHandler implements ReadyToSpawnHandler, AutoClosable {
private var gameObject:IGameObject;
public function RemoteReadyToSpawnHandler(param1:IGameObject) {
super();
this.gameObject = param1;
}
public function handleReadyToSpawn() : void {
var local1:ITankModel = ITankModel(this.gameObject.adapt(ITankModel));
local1.removeTankFromBattle();
}
[Obfuscation(rename="false")]
public function close() : void {
this.gameObject = null;
}
}
}
|
package alternativa.tanks.models.battlefield.effects.graffiti
{
import flash.display.BitmapData;
public class TexturesManager
{
[Embed(source="940.png")]
private static const graffiti_default:Class;
[Embed(source="770.png")]
private static const graffiti_boo:Class;
[Embed(source="753.png")]
private static const graffiti_fireball:Class;
[Embed(source="1152.png")]
private static const graffiti_firegraff:Class;
[Embed(source="1046.png")]
private static const graffiti_fart:Class;
[Embed(source="782.png")]
private static const graffiti_gg:Class;
[Embed(source="845.png")]
private static const graffiti_glhf:Class;
[Embed(source="979.png")]
private static const graffiti_heart:Class;
[Embed(source="924.png")]
private static const graffiti_music:Class;
[Embed(source="1007.png")]
private static const graffiti_swag:Class;
[Embed(source="1168.png")]
private static const graffiti_subwaytank:Class;
[Embed(source="1099.png")]
private static const graffiti_money:Class;
public function TexturesManager()
{
super();
}
public static function getBD(id:String) : BitmapData
{
switch(id)
{
case "graffiti_boo":
return new graffiti_boo().bitmapData;
case "graffiti_fireball":
return new graffiti_fireball().bitmapData;
case "graffiti_firegraff":
return new graffiti_firegraff().bitmapData;
case "graffiti_fart":
return new graffiti_fart().bitmapData;
case "graffiti_gg":
return new graffiti_gg().bitmapData;
case "graffiti_glhf":
return new graffiti_glhf().bitmapData;
case "graffiti_heart":
return new graffiti_heart().bitmapData;
case "graffiti_music":
return new graffiti_music().bitmapData;
case "graffiti_swag":
return new graffiti_swag().bitmapData;
case "graffiti_subwaytank":
return new graffiti_subwaytank().bitmapData;
case "graffiti_money":
return new graffiti_money().bitmapData;
default:
return new graffiti_default().bitmapData;
}
}
}
}
|
package alternativa.tanks.model.item.dm {
[ModelInterface]
public interface IBattleDMItem {
function getUsersCount() : int;
}
}
|
package alternativa.init
{
import alternativa.osgi.bundle.Bundle;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.osgi.service.console.ConsoleService;
import alternativa.osgi.service.console.DummyConsoleService;
import alternativa.osgi.service.console.IConsoleService;
import alternativa.osgi.service.debug.DebugService;
import alternativa.osgi.service.debug.IDebugService;
import alternativa.osgi.service.dump.DumpService;
import alternativa.osgi.service.dump.IDumpService;
import alternativa.osgi.service.dump.dumper.BundleDumper;
import alternativa.osgi.service.dump.dumper.ServiceDumper;
import alternativa.osgi.service.focus.FocusService;
import alternativa.osgi.service.focus.IFocusService;
import alternativa.osgi.service.loader.ILoaderService;
import alternativa.osgi.service.loader.LoaderService;
import alternativa.osgi.service.loaderParams.ILoaderParamsService;
import alternativa.osgi.service.loaderParams.LoaderParamsService;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.osgi.service.locale.LocaleService;
import alternativa.osgi.service.mainContainer.IMainContainerService;
import alternativa.osgi.service.mainContainer.MainContainerService;
import alternativa.osgi.service.network.INetworkService;
import alternativa.osgi.service.network.NetworkService;
import alternativa.osgi.service.storage.IStorageService;
import alternativa.osgi.service.storage.StorageService;
import flash.display.DisplayObjectContainer;
import flash.display.Stage;
import flash.net.SharedObject;
import flash.system.ApplicationDomain;
import flash.utils.Dictionary;
public class OSGi
{
private static var instance:OSGi;
private const REGEXP_TRIM:RegExp = /^\s*(.*?)\s*$/;
private var bundles:Dictionary;
private var _bundleList:Vector.<Bundle>;
private var services:Dictionary;
private var _serviceList:Vector.<Object>;
public function OSGi()
{
super();
this.services = new Dictionary(false);
this.bundles = new Dictionary(false);
this._bundleList = new Vector.<Bundle>();
this._serviceList = new Vector.<Object>();
}
public static function init(debug:Boolean, _stage:Stage, container:DisplayObjectContainer, server:String, ports:Array, proxyHost:String, proxyPort:int, resources:String, log:Object, sharedObject:SharedObject, language:String, loaderParams:Object) : OSGi
{
container.focusRect = false;
instance = new OSGi();
instance.registerService(ILoaderParamsService,new LoaderParamsService(loaderParams));
if(debug)
{
instance.registerService(IConsoleService,new ConsoleService(log));
instance.registerService(IDebugService,new DebugService());
}
else
{
instance.registerService(IConsoleService,new DummyConsoleService());
}
instance.registerService(IFocusService,new FocusService(_stage));
instance.registerService(IMainContainerService,new MainContainerService(_stage,container));
instance.registerService(INetworkService,new NetworkService(server,ports,resources,proxyHost,proxyPort));
instance.registerService(IStorageService,new StorageService(sharedObject));
var dumpService:IDumpService = new DumpService(instance);
instance.registerService(IDumpService,dumpService);
instance.registerService(ILoaderService,new LoaderService());
instance.registerService(ILocaleService,new LocaleService(language));
dumpService.registerDumper(new BundleDumper(instance));
dumpService.registerDumper(new ServiceDumper(instance));
return instance;
}
public static function get osgi() : OSGi
{
return instance;
}
public function installBundle(manifest:String) : Bundle
{
var consoleService:IConsoleService = this.getService(IConsoleService) as IConsoleService;
var bundle:Bundle = this.parseManifest(manifest);
if(bundle != null)
{
if(this.bundles[bundle.name] != null)
{
throw new Error("Bundle [" + bundle.name + "] already installed");
}
this.bundles[bundle.name] = bundle;
this._bundleList.push(bundle);
if(bundle.activator != null)
{
bundle.activator.start(this);
}
else if(consoleService != null)
{
consoleService.writeToConsoleChannel("OSGI","Bundle activator = null");
}
}
else if(consoleService != null)
{
consoleService.writeToConsoleChannel("OSGI","Bundle = null");
}
if(consoleService != null)
{
consoleService.writeToConsoleChannel("OSGI","Bundle " + bundle.name + " installed");
}
return bundle;
}
private function parseManifest(manifest:String) : Bundle
{
var s:String = null;
var parts:Array = null;
var value:String = null;
var activatorClass:Class = null;
var activator:IBundleActivator = null;
var manifestStrings:Array = manifest.split(/\r*\n/);
var manifestParams:Dictionary = new Dictionary(false);
for(var i:int = 0; i < manifestStrings.length; i++)
{
s = manifestStrings[i].replace(this.REGEXP_TRIM,"$1");
if(s.length != 0)
{
parts = s.split(/\s*:\s*/,2);
value = parts[1].replace(this.REGEXP_TRIM,"$1");
manifestParams[parts[0]] = value;
}
}
var name:String = manifestParams["Bundle-Name"];
var activatorClassName:String = manifestParams["Bundle-Activator"];
if(ApplicationDomain.currentDomain.hasDefinition(activatorClassName))
{
activatorClass = Class(ApplicationDomain.currentDomain.getDefinition(activatorClassName));
activator = IBundleActivator(new activatorClass());
}
if(name != "" && name != null)
{
return new Bundle(name,activator,manifestParams);
}
throw new Error("Manifest not valid");
}
public function uninstallBundle(bundle:Bundle) : void
{
var consoleService:IConsoleService = this.getService(IConsoleService) as IConsoleService;
if(bundle == null)
{
throw new Error("OSGi ERROR: uninstall NULL bundle");
}
if(bundle.activator != null)
{
bundle.activator.stop(this);
}
this._bundleList.splice(this._bundleList.indexOf(bundle),1);
delete this.bundles[bundle.name];
if(consoleService != null)
{
consoleService.writeToConsoleChannel("OSGI","Bundle " + bundle.name + " uninstalled");
}
}
public function registerService(serviceInterface:Class, serviceImplementation:Object) : void
{
var consoleService:IConsoleService = this.getService(IConsoleService) as IConsoleService;
if(this.services[serviceInterface] == null)
{
this.services[serviceInterface] = serviceImplementation;
this._serviceList.push(serviceImplementation);
if(consoleService != null)
{
consoleService.writeToConsoleChannel("OSGI","Service " + serviceInterface + " registered");
}
}
else
{
this.services[serviceInterface] = serviceImplementation;
}
}
public function unregisterService(serviceInterface:Class) : void
{
var consoleService:IConsoleService = this.getService(IConsoleService) as IConsoleService;
this._serviceList.splice(this._serviceList.indexOf(this.services[serviceInterface]),1);
delete this.services[serviceInterface];
if(consoleService != null)
{
consoleService.writeToConsoleChannel("OSGI","Service " + serviceInterface + " unregistered");
}
}
public function getService(serviceInterface:Class) : Object
{
return this.services[serviceInterface];
}
public function get bundleList() : Vector.<Bundle>
{
return this._bundleList;
}
public function get serviceList() : Vector.<Object>
{
return this._serviceList;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.mine {
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
import alternativa.osgi.service.dump.IDumpService;
import alternativa.osgi.service.dump.IDumper;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.events.StateCorrectionEvent;
import alternativa.tanks.battle.events.TankAddedToBattleEvent;
import alternativa.tanks.battle.events.TankLoadedEvent;
import alternativa.tanks.battle.events.TankUnloadedEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.battle.battlefield.BattleSfx;
import alternativa.tanks.models.sfx.lighting.LightingSfx;
import alternativa.tanks.models.weapon.WeaponConst;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.sfx.AnimatedLightEffect;
import alternativa.tanks.sfx.AnimatedSpriteEffect;
import alternativa.tanks.sfx.LightAnimation;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.GraphicsUtils;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.types.Long;
import alternativa.utils.TextureMaterialRegistry;
import flash.media.Sound;
import flash.utils.Dictionary;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import platform.client.fp10.core.resource.types.TextureResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.battle.battlefield.mine.BattleMine;
import projects.tanks.client.battlefield.models.battle.battlefield.mine.BattleMinesModelBase;
import projects.tanks.client.battlefield.models.battle.battlefield.mine.IBattleMinesModelBase;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
[ModelInfo]
public class BattleMinesModel extends BattleMinesModelBase implements IBattleMinesModelBase, ObjectLoadListener, ObjectUnloadListener, IDumper, IMineCallback, IBattleMinesModel {
[Inject]
public static var textureMaterialRegistry:TextureMaterialRegistry;
[Inject]
public static var battleService:BattleService;
[Inject]
public static var dumperService:IDumpService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
private static const MAIN_EXPLOSION_ORIGIN_X:Number = 0.5;
private static const MAIN_EXPLOSION_ORIGIN_Y:Number = 0.772;
private static const IDLE_EXPLOSION_ORIGIN_X:Number = 0.5;
private static const IDLE_EXPLOSION_ORIGIN_Y:Number = 0.9;
private static const MAIN_EXPLOSION_SCALE:Number = 3;
private static const IDLE_EXPLOSION_SCALE:Number = 3;
private static const MINE_ACTIVATION_SOUND_VOLUME:Number = 0.3;
private static const DECAL_RADIUS:Number = 200;
private static const projectionOrigin:Vector3 = new Vector3();
private var mineModelData:MineModelData = new MineModelData();
private var minesByUser:Dictionary = new Dictionary();
private var minesOnField:Dictionary = new Dictionary();
private var mineProximityRadius:Number;
private var deferredMines:Vector.<BattleMine>;
private var redMineMaterial:TextureMaterial;
private var blueMineMaterial:TextureMaterial;
private var friendlyMineMaterial:TextureMaterial;
private var enemyMineMaterial:TextureMaterial;
private var referenceMesh:Mesh;
private var mainExplosionAnimation:TextureAnimation;
private var mainExplosionFrameSize:FrameSize = new FrameSize();
private var idleExplosionAnimation:TextureAnimation;
private var idleExplosionFrameSize:FrameSize = new FrameSize();
private var explosionMarkMaterial:TextureMaterial;
private var mineArmedSound:Sound;
private var explosionSound:Sound;
private var deactivationSound:Sound;
private var impactForce:Number;
private var battleObject:IGameObject;
private var battleEventSupport:BattleEventSupport;
private var loadedTanks:Dictionary = new Dictionary();
private var localTank:Tank;
private var minDistanceFromBase:Number;
private var explosionLightAnimation:LightAnimation;
public function BattleMinesModel() {
super();
MineExplosionCameraEffect.initVars();
this.initBattleEventListeners();
}
private static function addExplosionEffect(param1:Vector3, param2:TextureAnimation, param3:FrameSize, param4:Number, param5:Number) : void {
var local6:int = 50;
var local7:ObjectPool = battleService.getObjectPool();
var local8:StaticObject3DPositionProvider = StaticObject3DPositionProvider(local7.getObject(StaticObject3DPositionProvider));
local8.init(param1,local6);
var local9:AnimatedSpriteEffect = AnimatedSpriteEffect(local7.getObject(AnimatedSpriteEffect));
local9.init(param3.width,param3.height,param2,0,local8,param4,param5);
battleService.getBattleScene3D().addGraphicEffect(local9);
}
private static function addSound3DEffect(param1:Sound, param2:Vector3, param3:Number) : void {
var local4:Sound3D = null;
if(param1 != null) {
local4 = Sound3D.create(param1,param3);
battleService.getBattleRunner().getSoundManager().addEffect(Sound3DEffect.create(param2,local4,0));
}
}
private static function getExplosionAnimation(param1:MultiframeTextureResource, param2:int, param3:FrameSize) : TextureAnimation {
var local4:TextureAnimation = GraphicsUtils.getTextureAnimationFromResource(textureMaterialRegistry,param1);
local4.material.resolution = param2;
param3.height = param1.frameHeight * param2;
param3.width = param1.frameWidth * param2;
return local4;
}
private static function getTextureMaterial(param1:TextureResource) : TextureMaterial {
return textureMaterialRegistry.getMaterial(param1.data);
}
private function initBattleEventListeners() : void {
this.battleEventSupport = new BattleEventSupport(battleEventDispatcher);
this.battleEventSupport.addEventHandler(BattleFinishEvent,this.onBattleFinish);
this.battleEventSupport.addEventHandler(TankLoadedEvent,this.onTankLoaded);
this.battleEventSupport.addEventHandler(TankUnloadedEvent,this.onTankUnloaded);
this.battleEventSupport.addEventHandler(TankAddedToBattleEvent,this.onTankAddedToBattle);
this.battleEventSupport.activateHandlers();
}
public function getMinDistanceFromBase() : Number {
return this.minDistanceFromBase;
}
[Obfuscation(rename="false")]
public function objectLoaded() : void {
this.battleObject = object;
dumperService.registerDumper(this);
this.mineModelData.armedFlashDuration = 100;
this.mineModelData.armedFlashFadeDuration = 300;
this.mineModelData.flashChannelOffset = 204;
this.mineModelData.farRadius = BattleUtils.toClientScale(getInitParam().farVisibilityRadius);
this.mineModelData.nearRadius = BattleUtils.toClientScale(getInitParam().nearVisibilityRadius);
this.mineProximityRadius = BattleUtils.toClientScale(getInitParam().radius);
this.impactForce = getInitParam().impactForce;
this.mineArmedSound = getInitParam().activateSound.sound;
this.explosionSound = getInitParam().explosionSound.sound;
this.deactivationSound = getInitParam().deactivateSound.sound;
this.minDistanceFromBase = BattleUtils.toClientScale(getInitParam().minDistanceFromBase);
this.initReferenceMesh(Tanks3DSResource(getInitParam().model3ds));
this.mainExplosionAnimation = getExplosionAnimation(getInitParam().mainExplosionTexture,MAIN_EXPLOSION_SCALE,this.mainExplosionFrameSize);
this.idleExplosionAnimation = getExplosionAnimation(getInitParam().idleExplosionTexture,IDLE_EXPLOSION_SCALE,this.idleExplosionFrameSize);
this.explosionMarkMaterial = getTextureMaterial(getInitParam().explosionMarkTexture);
this.redMineMaterial = getTextureMaterial(getInitParam().redMineTexture);
this.blueMineMaterial = getTextureMaterial(getInitParam().blueMineTexture);
this.friendlyMineMaterial = getTextureMaterial(getInitParam().friendlyMineTexture);
this.enemyMineMaterial = getTextureMaterial(getInitParam().enemyMineTexture);
var local1:LightingSfx = BattleSfx(object.adapt(BattleSfx)).getLightingSfx();
this.explosionLightAnimation = local1.createAnimation("explosion");
this.initMines(getInitParam().battleMines);
}
[Obfuscation(rename="false")]
public function objectUnloaded() : void {
dumperService.unregisterDumper(this.dumperName);
this._removeAllMines();
this.mineArmedSound = null;
this.mainExplosionAnimation = null;
this.idleExplosionAnimation = null;
this.redMineMaterial = null;
this.blueMineMaterial = null;
this.friendlyMineMaterial = null;
this.enemyMineMaterial = null;
this.battleObject = null;
this.localTank = null;
this.explosionMarkMaterial = null;
this.loadedTanks = new Dictionary();
}
private function initMines(param1:Vector.<BattleMine>) : void {
var local2:int = 0;
var local3:int = 0;
if(param1.length != 0) {
if(this.deferredMines == null) {
this.deferredMines = new Vector.<BattleMine>();
}
local2 = int(param1.length);
local3 = 0;
while(local3 < local2) {
this.deferredMines.push(param1[local3]);
local3++;
}
}
}
[Obfuscation(rename="false")]
public function putMine(param1:Long, param2:Number, param3:Number, param4:Number, param5:Long) : void {
var local6:Tank = this.loadedTanks[param5];
if(local6 == null) {
if(this.deferredMines == null) {
this.deferredMines = new Vector.<BattleMine>();
}
} else {
this.addMine(param1,this.mineProximityRadius,new Vector3(param2,param3,param4),param5,local6.teamType,this.getMineMaterial(local6),false);
}
}
[Obfuscation(rename="false")]
public function activateMine(param1:Long) : void {
var local3:BattleMine = null;
var local2:ProximityMine = this.minesOnField[param1];
if(local2 != null) {
local2.arm();
addSound3DEffect(this.mineArmedSound,local2.position,MINE_ACTIVATION_SOUND_VOLUME);
} else {
for each(local3 in this.deferredMines) {
if(local3.mineId == param1) {
local3.activated = true;
return;
}
}
}
}
[Obfuscation(rename="false")]
public function removeAllMines(param1:Long) : void {
var local3:ProximityMine = null;
var local4:ProximityMine = null;
var local2:UserMinesList = this.minesByUser[param1];
if(local2 != null) {
local3 = local2.head;
while(local3 != null) {
local4 = local3;
local3 = local3.next;
this.playEffectAndRemoveMine(local4,local2);
}
}
}
[Obfuscation(rename="false")]
public function removeMines(param1:Long, param2:Vector.<Long>) : void {
var local4:Long = null;
var local5:ProximityMine = null;
var local3:UserMinesList = this.minesByUser[param1];
for each(local4 in param2) {
local5 = this.minesOnField[local4];
if(local5 != null) {
this.playEffectAndRemoveMine(local5,local3);
}
}
}
private function playEffectAndRemoveMine(param1:ProximityMine, param2:UserMinesList) : void {
addExplosionEffect(param1.position,this.idleExplosionAnimation,this.idleExplosionFrameSize,IDLE_EXPLOSION_ORIGIN_X,IDLE_EXPLOSION_ORIGIN_Y);
addSound3DEffect(this.deactivationSound,param1.position,0.1);
this.removeMine(param1,param2);
}
[Obfuscation(rename="false")]
public function explodeMine(param1:Long, param2:Long, param3:Boolean) : void {
var local5:UserMinesList = null;
var local6:Tank = null;
var local4:ProximityMine = this.minesOnField[param1];
if(local4 != null) {
local5 = this.minesByUser[local4.ownerId];
if(local5 != null) {
addExplosionEffect(local4.position,this.mainExplosionAnimation,this.mainExplosionFrameSize,MAIN_EXPLOSION_ORIGIN_X,MAIN_EXPLOSION_ORIGIN_Y);
this.addLightingEffect(local4.position,this.explosionLightAnimation);
this.addExplosionMark(local4);
addSound3DEffect(this.explosionSound,local4.position,0.5);
local6 = this.loadedTanks[param2];
if(!param3 && local6 != null) {
local6.applyWeaponHit(local4.position,local4.groundNormal,WeaponConst.BASE_IMPACT_FORCE.getNumber() * this.impactForce);
}
this.removeMine(local4,local5);
}
}
}
public function getMinePosition(param1:Long) : Vector3 {
var local2:ProximityMine = this.minesOnField[param1];
return local2.position;
}
private function addLightingEffect(param1:Vector3, param2:LightAnimation) : void {
var local3:StaticObject3DPositionProvider = StaticObject3DPositionProvider(battleService.getObjectPool().getObject(StaticObject3DPositionProvider));
var local4:AnimatedLightEffect = AnimatedLightEffect(battleService.getObjectPool().getObject(AnimatedLightEffect));
local3.init(param1,50);
local4.init(local3,param2);
battleService.addGraphicEffect(local4);
}
private function addExplosionMark(param1:ProximityMine) : void {
projectionOrigin.copy(param1.position);
projectionOrigin.addScaled(100,param1.groundNormal);
battleService.getBattleScene3D().addDecal(param1.position,projectionOrigin,DECAL_RADIUS,this.explosionMarkMaterial);
}
[Obfuscation(rename="false")]
public function dump(param1:Array) : String {
var local3:ProximityMine = null;
var local2:String = "=== Mines ===\n";
if(this.deferredMines != null) {
local2 += "Deferred:\n" + this.deferredMines.join("\n") + "\n";
}
local2 += "On field:\n";
for each(local3 in this.minesOnField) {
local2 += local3 + "\n";
}
return local2;
}
[Obfuscation(rename="false")]
public function get dumperName() : String {
return "mines";
}
public function onTouchMine(param1:ProximityMine) : void {
battleEventDispatcher.dispatchEvent(StateCorrectionEvent.MANDATORY_UPDATE);
}
private function addMine(param1:Long, param2:Number, param3:Vector3, param4:Long, param5:BattleTeam, param6:Material, param7:Boolean) : void {
var local9:UserMinesList = null;
var local10:ProximityMine = null;
var local8:RayHit = new RayHit();
if(battleService.getBattleRunner().getCollisionDetector().raycastStatic(param3,Vector3.DOWN,CollisionGroup.STATIC,10000000000,null,local8)) {
local9 = this.minesByUser[param4];
if(local9 == null) {
local9 = new UserMinesList();
this.minesByUser[param4] = local9;
}
local10 = ProximityMine.create(param1,param4,param2,this.referenceMesh,param6,param5,this.mineModelData,this);
local10.setPosition(local8.position,local8.normal);
if(param7) {
local10.arm();
}
local9.addMine(local10);
this.minesOnField[param1] = local10;
local10.addToGame();
}
}
private function _removeAllMines() : void {
var local1:* = undefined;
var local2:ProximityMine = null;
var local3:UserMinesList = null;
for(local1 in this.minesOnField) {
local2 = this.minesOnField[local1];
local2.removeFromGame();
delete this.minesOnField[local1];
}
for(local1 in this.minesByUser) {
local3 = this.minesByUser[local1];
local3.clearMines();
delete this.minesByUser[local1];
}
this.deferredMines = null;
}
private function initReferenceMesh(param1:Tanks3DSResource) : void {
this.referenceMesh = Mesh(param1.objects[0]);
if(this.referenceMesh.sorting != Sorting.AVERAGE_Z) {
this.referenceMesh.sorting = Sorting.AVERAGE_Z;
this.referenceMesh.calculateFacesNormals(true);
}
}
private function removeMine(param1:ProximityMine, param2:UserMinesList) : void {
delete this.minesOnField[param1.id];
param1.removeFromGame();
param2.removeMine(param1);
}
private function getMineMaterial(param1:Tank) : Material {
switch(param1.teamType) {
case BattleTeam.NONE:
return param1 == this.localTank ? this.friendlyMineMaterial : this.enemyMineMaterial;
case BattleTeam.BLUE:
return this.blueMineMaterial;
case BattleTeam.RED:
return this.redMineMaterial;
default:
return this.enemyMineMaterial;
}
}
private function onTankLoaded(param1:TankLoadedEvent) : void {
this.loadedTanks[param1.tank.getUser().id] = param1.tank;
if(param1.isLocal) {
this.localTank = param1.tank;
}
}
private function onTankUnloaded(param1:TankUnloadedEvent) : void {
delete this.loadedTanks[param1.tank.getUser().id];
}
private function onTankAddedToBattle(param1:TankAddedToBattleEvent) : void {
if(param1.tank == this.localTank) {
this.addReadyMinesToField();
} else {
this.addOwnerMinesToField(param1.tank);
}
}
private function addReadyMinesToField() : void {
var local1:int = 0;
var local2:BattleMine = null;
var local3:Tank = null;
var local4:Vector3 = null;
if(this.deferredMines != null) {
local1 = 0;
while(local1 < this.deferredMines.length) {
local2 = this.deferredMines[local1];
local3 = this.loadedTanks[local2.ownerId];
if(local3 != null) {
this.deferredMines.splice(local1,1);
local1--;
local4 = BattleUtils.getVector3(local2.position);
this.addMine(local2.mineId,this.mineProximityRadius,local4,local2.ownerId,local3.teamType,this.getMineMaterial(local3),local2.activated);
}
local1++;
}
}
}
private function addOwnerMinesToField(param1:Tank) : void {
var local2:int = 0;
var local3:BattleMine = null;
var local4:Vector3 = null;
if(this.deferredMines != null) {
local2 = 0;
while(local2 < this.deferredMines.length) {
local3 = this.deferredMines[local2];
if(local3.ownerId == param1.getUser().id) {
this.deferredMines.splice(local2,1);
local2--;
local4 = BattleUtils.getVector3(local3.position);
this.addMine(local3.mineId,this.mineProximityRadius,local4,local3.ownerId,param1.teamType,this.getMineMaterial(param1),local3.activated);
}
local2++;
}
}
}
[Obfuscation(rename="false")]
private function onBattleFinish(param1:BattleFinishEvent) : void {
this._removeAllMines();
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_def_ACTIVE_LEFT.png")]
public dynamic class button_def_ACTIVE_LEFT extends BitmapData {
public function button_def_ACTIVE_LEFT(param1:int = 4, param2:int = 29) {
super(param1,param2);
}
}
}
|
package controls.chat
{
import fl.containers.ScrollPane;
import fl.controls.ScrollPolicy;
import flash.display.Sprite;
import flash.events.Event;
import forms.events.LoginFormEvent;
public class ChatOutput extends ScrollPane
{
private const numMessages:int = 80;
private var _cont:Sprite;
private var __width:Number;
public var firstFill:Boolean = true;
public var deltaWidth:int = 9;
public var selfName:String;
private var oldLine:ChatOutputLine;
public function ChatOutput()
{
this._cont = new Sprite();
super();
this.source = this._cont;
this.horizontalScrollPolicy = ScrollPolicy.OFF;
this.focusEnabled = false;
addEventListener(LoginFormEvent.SHOW_RULES,this.showRules);
}
private function showRules(e:Event) : void
{
}
public function addLine(rang:int, chatPermissions:int, name:String, text:String, rangTo:int = 0, chatPermissionsTo:int = 0, nameTo:String = "", system:Boolean = false, html:Boolean = false, _systemColor:uint = 8454016) : void
{
var line:ChatOutputLine = null;
var maxScroll:Boolean = this.verticalScrollPosition + 5 > this.maxVerticalScrollPosition || this.firstFill;
if(this._cont.numChildren > this.numMessages)
{
this.shiftMessages();
this.oldLine = null;
line = new ChatOutputLine(this.__width,rang,chatPermissions,name,text,rangTo,chatPermissionsTo,nameTo,system,html,_systemColor);
}
else
{
line = new ChatOutputLine(this.__width,rang,chatPermissions,name,text,rangTo,chatPermissionsTo,nameTo,system,html,_systemColor);
}
var curY:int = int(this._cont.height + 0.5);
line.self = line._userNameTo == this.selfName;
line.y = curY;
this._cont.addChild(line);
this.update();
if(maxScroll)
{
this.verticalScrollPosition = this.maxVerticalScrollPosition;
}
}
public function scrollDown() : void
{
this.verticalScrollPosition = this.maxVerticalScrollPosition;
}
public function selectUser(name:String) : void
{
var element:ChatOutputLine = null;
for(var i:int = 0; i < this._cont.numChildren; i++)
{
element = this._cont.getChildAt(i) as ChatOutputLine;
element.light = element.username == name && name != "";
element.self = element._userNameTo == this.selfName && name != "";
}
}
private function shiftMessages() : void
{
this.oldLine = this._cont.getChildAt(0) as ChatOutputLine;
var shift:Number = this.oldLine.height + this.oldLine.y;
this._cont.removeChild(this.oldLine);
for(var i:int = 0; i < this._cont.numChildren; i++)
{
this._cont.getChildAt(i).y = this._cont.getChildAt(i).y - shift;
}
}
override public function setSize(width:Number, height:Number) : void
{
super.setSize(width,height);
this.__width = width - this.deltaWidth;
this.resizeLines();
}
private function resizeLines() : void
{
var element:ChatOutputLine = null;
var i:int = 0;
var cash:Array = new Array();
var curY:int = 0;
var nofirstTime:Boolean = this._cont.numChildren > 0;
while(this._cont.numChildren > 0)
{
element = this._cont.getChildAt(i) as ChatOutputLine;
element.width = this.__width;
cash.push(element);
this._cont.removeChildAt(0);
}
for(i = 0; i < cash.length; i++)
{
element = cash[i];
curY = int(this._cont.height + 0.5);
element.y = curY;
this._cont.addChild(element);
}
if(nofirstTime)
{
this.update();
}
}
public function cleanOutUsersMessages(uid:String) : void
{
var line:ChatOutputLine = null;
var linesToDelete:Array = new Array();
for(var i:int = 0; i < this._cont.numChildren; i++)
{
line = this._cont.getChildAt(i) as ChatOutputLine;
if(line._userName == uid || uid == "")
{
linesToDelete.push(line);
}
}
for(i = 0; i < linesToDelete.length; i++)
{
this._cont.removeChild(linesToDelete[i]);
}
this.resizeLines();
this.update();
}
public function cleanOutMessages(msg:String) : void
{
var line:ChatOutputLine = null;
var linesToDelete:Array = new Array();
for(var i:int = 0; i < this._cont.numChildren; i++)
{
line = this._cont.getChildAt(i) as ChatOutputLine;
if(line.output.text == msg)
{
linesToDelete.push(line);
}
}
for(i = 0; i < linesToDelete.length; i++)
{
this._cont.removeChild(linesToDelete[i]);
}
this.resizeLines();
this.update();
}
}
}
|
package alternativa.tanks.model.useremailandpassword {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IUserEmailAndPasswordAdapt implements IUserEmailAndPassword {
private var object:IGameObject;
private var impl:IUserEmailAndPassword;
public function IUserEmailAndPasswordAdapt(param1:IGameObject, param2:IUserEmailAndPassword) {
super();
this.object = param1;
this.impl = param2;
}
public function changeEmail(param1:String) : void {
var email:String = param1;
try {
Model.object = this.object;
this.impl.changeEmail(email);
}
finally {
Model.popObject();
}
}
public function getEmail() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getEmail();
}
finally {
Model.popObject();
}
return result;
}
public function sendChangeInstruction() : void {
try {
Model.object = this.object;
this.impl.sendChangeInstruction();
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.user {
import flash.events.Event;
public class UserInfoLabelUpdaterEvent extends Event {
public static const CHANGE_RANK:String = "UserLabelUpdaterEvent.CHANGE_RANK";
public static const CHANGE_UID:String = "UserLabelUpdaterEvent.CHANGE_UID";
public static const CHANGE_ONLINE:String = "UserLabelUpdaterEvent.CHANGE_STATUS";
public static const CHANGE_BATTLE_LINK:String = "UserLabelUpdaterEvent.CHANGE_BATTLE_LINK";
public function UserInfoLabelUpdaterEvent(param1:String, param2:Boolean = false, param3:Boolean = false) {
super(param1,param2,param3);
}
}
}
|
package alternativa.tanks.gui.shop.payment.item {
import alternativa.tanks.gui.shop.shopitems.item.base.ButtonItemSkin;
public class PaymentItemSkin extends ButtonItemSkin {
private static const normalStateClass:Class = PaymentItemSkin_normalStateClass;
private static const overStateClass:Class = PaymentItemSkin_overStateClass;
public static const SKIN:PaymentItemSkin = new PaymentItemSkin();
public function PaymentItemSkin() {
super();
normalState = new normalStateClass().bitmapData;
overState = new overStateClass().bitmapData;
}
}
}
|
package alternativa.tanks.gui.shopitems.item.kits.description.panel
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class KitPackageDescriptionPanelBitmaps_bitmapBackgroundPixel extends BitmapAsset
{
public function KitPackageDescriptionPanelBitmaps_bitmapBackgroundPixel()
{
super();
}
}
}
|
package alternativa.tanks.view.battleinfo.renderer {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battleinfo.renderer.CellRed_cellRedCenter.png")]
public class CellRed_cellRedCenter extends BitmapAsset {
public function CellRed_cellRedCenter() {
super();
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_plazmacoreacceleratorsIconClass.png")]
public class DeviceIcons_plazmacoreacceleratorsIconClass extends BitmapAsset {
public function DeviceIcons_plazmacoreacceleratorsIconClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.gauss {
import alternativa.math.Vector3;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.battle.objects.tank.ClientTankState;
import alternativa.tanks.battle.objects.tank.LocalWeapon;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.weapon.WeaponForces;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapon.gauss.state.GaussState;
import alternativa.tanks.models.weapon.gauss.state.IGaussState;
import alternativa.tanks.models.weapon.gauss.state.IdleState;
import alternativa.tanks.models.weapon.gauss.state.ModeSelectionState;
import alternativa.tanks.models.weapon.gauss.state.PowerShotState;
import alternativa.tanks.models.weapon.gauss.state.ReloadPauseState;
import alternativa.tanks.models.weapon.gauss.state.ReloadState;
import alternativa.tanks.models.weapon.gauss.state.SimpleShotState;
import alternativa.tanks.models.weapon.gauss.state.StunnedState;
import alternativa.tanks.models.weapon.gauss.state.TargetSelectionState;
import alternativa.tanks.models.weapon.gauss.state.Transition;
import alternativa.tanks.models.weapon.gauss.state.TransitionNotFoundError;
import alternativa.tanks.models.weapon.gauss.state.targetselection.LockResult;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.RocketTargetPoint;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.aim.AimWeaponStatus;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.aim.RocketLauncherAim;
import alternativa.tanks.models.weapon.shared.SimpleWeaponController;
import alternativa.tanks.models.weapons.targeting.TargetingResult;
import alternativa.tanks.models.weapons.targeting.TargetingSystem;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.types.Long;
import flash.utils.Dictionary;
import projects.tanks.client.battlefield.models.tankparts.weapon.gauss.GaussCC;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class LocalGaussWeapon extends CommonGaussWeapon implements Weapon, LocalWeapon, LogicUnit, AimWeaponStatus {
private static var shotId:int = 0;
private static const rayHit:RayHit = new RayHit();
private var triggerPulled:Boolean = false;
private var gaussData:GaussCC;
private var states:Dictionary;
private var currentState:IGaussState;
private var transitions:Vector.<Transition>;
private var controller:SimpleWeaponController;
private var _weaponStatus:Number = 1;
private var _buffed:Boolean;
private var callback:GaussWeaponCallback;
private var targetingSystem:TargetingSystem;
private var secondaryHitPoint:Vector3 = new Vector3();
private var target:RocketTargetPoint = new RocketTargetPoint();
private var aim:RocketLauncherAim;
public function LocalGaussWeapon(param1:WeaponObject, param2:GaussCC, param3:TargetingSystem, param4:WeaponForces) {
this.callback = GaussWeaponCallback(param1.getObject().adapt(GaussWeaponCallback));
super(param1,param2,this.callback);
this.gaussData = param2;
this.primaryWeaponForces = param4;
this.targetingSystem = param3;
this.controller = new SimpleWeaponController();
this.controller.setWeapon(this);
}
override public function init(param1:WeaponPlatform) : void {
super.init(param1);
this.weaponPlatform = param1;
this.aim = new RocketLauncherAim(this.target,this,effects);
this.initStateMachine();
this.controller.init();
}
public function processEvent(param1:GaussEventType, param2:* = undefined) : void {
var local3:Transition = null;
for each(local3 in this.transitions) {
if(local3.eventType == param1 && local3.state == this.currentState) {
this.currentState = local3.newState;
this.currentState.enter(battleService.getPhysicsTime(),param1,param2);
return;
}
}
throw new TransitionNotFoundError(this.currentState,param1);
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.GAUSS_RESISTANCE;
}
private function createTransition(param1:GaussState, param2:GaussEventType, param3:GaussState) : Transition {
return new Transition(param2,this.states[param1],this.states[param3]);
}
private function initStateMachine() : void {
this.states = new Dictionary();
this.states[GaussState.IDLE] = new IdleState(this);
this.states[GaussState.RELOAD] = new ReloadState(this);
this.states[GaussState.STUNNED] = new StunnedState(this);
this.states[GaussState.POWER_SHOT] = new PowerShotState(this);
this.states[GaussState.SIMPLE_SHOT] = new SimpleShotState(this);
this.states[GaussState.RELOAD_PAUSE] = new ReloadPauseState(this);
this.states[GaussState.MODE_SELECTION] = new ModeSelectionState(this);
this.states[GaussState.TARGET_SELECTION] = new TargetSelectionState(this);
this.currentState = this.states[GaussState.IDLE];
this.transitions = Vector.<Transition>([this.createTransition(GaussState.IDLE,GaussEventType.ACTIVATED,GaussState.MODE_SELECTION),this.createTransition(GaussState.IDLE,GaussEventType.STUNNED,GaussState.STUNNED),this.createTransition(GaussState.STUNNED,GaussEventType.STUN_EXPIRED,GaussState.IDLE),this.createTransition(GaussState.MODE_SELECTION,GaussEventType.TARGET_SEARCH_STARTED,GaussState.TARGET_SELECTION),this.createTransition(GaussState.MODE_SELECTION,GaussEventType.SIMPLE_SHOT,GaussState.SIMPLE_SHOT),this.createTransition(GaussState.MODE_SELECTION,GaussEventType.STUNNED,GaussState.STUNNED),this.createTransition(GaussState.TARGET_SELECTION,GaussEventType.TARGET_LOCKED,GaussState.POWER_SHOT),this.createTransition(GaussState.TARGET_SELECTION,GaussEventType.DEACTIVATED,GaussState.IDLE),this.createTransition(GaussState.TARGET_SELECTION,GaussEventType.BUFFED,GaussState.IDLE),this.createTransition(GaussState.TARGET_SELECTION,GaussEventType.STUNNED,GaussState.STUNNED),this.createTransition(GaussState
.SIMPLE_SHOT,GaussEventType.RELOAD,GaussState.RELOAD),this.createTransition(GaussState.POWER_SHOT,GaussEventType.RELOAD,GaussState.RELOAD),this.createTransition(GaussState.RELOAD,GaussEventType.RELOAD_COMPLETED,GaussState.IDLE),this.createTransition(GaussState.RELOAD,GaussEventType.BUFF_EXPIRED,GaussState.IDLE),this.createTransition(GaussState.RELOAD,GaussEventType.STUNNED,GaussState.RELOAD_PAUSE),this.createTransition(GaussState.RELOAD_PAUSE,GaussEventType.STUN_EXPIRED,GaussState.RELOAD)]);
}
public function set weaponStatus(param1:Number) : void {
this._weaponStatus = param1;
}
public function isTriggerPulled() : Boolean {
return this.triggerPulled;
}
public function destroy() : void {
this.controller.destroy();
weaponPlatform = null;
battleService.getBattleRunner().removeLogicUnit(this);
}
public function activate() : void {
battleService.getBattleRunner().addLogicUnit(this);
}
public function deactivate() : void {
battleService.getBattleRunner().removeLogicUnit(this);
}
public function stun() : void {
if(this.isTargetSelection()) {
this.stopAiming();
}
this.hideAim();
this.processEvent(GaussEventType.STUNNED);
}
private function isTargetSelection() : Boolean {
return this.currentState == this.states[GaussState.TARGET_SELECTION];
}
private function isIdle() : Boolean {
return this.currentState == this.states[GaussState.IDLE];
}
private function isReload() : Boolean {
return this.currentState == this.states[GaussState.RELOAD];
}
public function calm(param1:int) : void {
this.processEvent(GaussEventType.STUN_EXPIRED);
}
public function reset() : void {
this.hideAim();
if(!this.isIdle()) {
this.currentState = this.states[GaussState.IDLE];
}
this.currentState.enter(battleService.getPhysicsTime(),GaussEventType.RESET,null);
effects.reset();
}
public function getStatus() : Number {
return this._weaponStatus;
}
public function fullyRecharge() : void {
if(!this.isTargetSelection()) {
this._weaponStatus = 1;
}
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
if(this.isReload()) {
ReloadState(this.states[GaussState.RELOAD]).setReloadDuration(param2);
}
}
public function pullTrigger() : void {
this.triggerPulled = true;
}
public function releaseTrigger() : void {
this.triggerPulled = false;
}
public function runLogic(param1:int, param2:int) : void {
if(enabled || this.isReload()) {
this.currentState.update(param1,param2);
}
}
public function getTime() : int {
return battleService.getPhysicsTime();
}
public function isShotAllowed() : Boolean {
return true;
}
public function isBuffed() : Boolean {
return this._buffed;
}
private function barrelCollidesWithStatic(param1:Vector3, param2:Vector3, param3:Number) : Boolean {
return battleService.getBattleRunner().getCollisionDetector().raycastStatic(param1,param2,CollisionGroup.STATIC,param3,null,rayHit);
}
public function getPrimaryReloadDuration() : int {
return weaponObject.getReloadTimeMS();
}
public function lockTarget(param1:LockResult, param2:Long = null) : Boolean {
var local3:TargetingResult = null;
var local4:RayHit = null;
var local5:Tank = null;
var local6:Long = null;
var local7:Vector3 = null;
weaponPlatform.getAllGunParams(gunParams);
if(!this.isCollideStatic() && BattleUtils.isTurretAboveGround(weaponPlatform.getBody(),gunParams)) {
local3 = this.targetingSystem.target(gunParams);
if(local3.hasTankHit()) {
local4 = local3.getSingleHit();
local5 = local4.shape.body.tank;
local6 = local5.getUser().id;
if((param2 == null || param2 == local6) && local5.state == ClientTankState.ACTIVE && !local5.isSameTeam(weaponPlatform.teamType)) {
local7 = this.getTargetLocalPoint(local4,local5);
this.target.setTank(local5);
this.target.setLocalPoint(local7);
param1.update(local6,local4.position,local7);
return true;
}
}
}
this.target.markAsLost();
return false;
}
private function getTargetLocalPoint(param1:RayHit, param2:Tank) : Vector3 {
var local3:Vector3 = BattleUtils.tmpVector;
local3.copy(param1.position);
BattleUtils.globalToLocal(param2.getBody(),local3);
return local3;
}
public function getMaxLockRegainTimeMs() : int {
return this.gaussData.aimingGracePeriod;
}
public function getTargetLockDurationMs() : int {
return this.gaussData.aimingTime;
}
private function isCollideStatic() : Boolean {
return this.barrelCollidesWithStatic(gunParams.barrelOrigin,gunParams.direction,weaponPlatform.getBarrelLength());
}
public function doPrimaryShot() : void {
if(!battleService.isBattleActive()) {
return;
}
weaponPlatform.getAllGunParams(gunParams);
effects.playSoundEffect(sfxData.primaryShotSound,gunParams.muzzlePosition);
if(!BattleUtils.isTurretAboveGround(weaponPlatform.getBody(),gunParams)) {
this.callback.doDummyShot();
weaponPlatform.getBody().addWorldForceScaled(gunParams.muzzlePosition,gunParams.direction,-primaryWeaponForces.getRecoilForce());
return;
}
var local1:Vector3 = this.targetingSystem.target(gunParams).getDirection();
this.callback.doPrimaryShot(++shotId,local1);
effects.playCommonShotEffect(gunParams.muzzlePosition,local1,primaryWeaponForces);
getShell().addToGame(gunParams,local1,weaponPlatform.getBody(),false,shotId);
}
public function doSecondaryShot() : void {
effects.playTargetLockSoundEffect();
if(!battleService.isBattleActive() || !this.target.hasTarget()) {
return;
}
weaponPlatform.getAllGunParams(gunParams);
var local1:Tank = this.target.getTank();
this.callback.doSecondaryShot(local1.user,local1.getBody().state.position,this.target.getLocalPoint());
this.secondaryHitPoint.copy(this.target.getLocalPoint());
BattleUtils.localToGlobal(local1.getBody(),this.secondaryHitPoint);
var local2:Vector3 = new Vector3().copy(this.secondaryHitPoint).subtract(gunParams.muzzlePosition).normalize();
effects.playCommonShotEffect(gunParams.muzzlePosition,local2,secondaryWeaponForces);
effects.playPowerShotEffect(local1.getBody(),this.secondaryHitPoint);
local1.applyWeaponHit(this.secondaryHitPoint,gunParams.direction,secondaryWeaponForces.getImpactForce());
applySecondarySplashImpact(this.secondaryHitPoint,local1.getBody());
}
public function getPowerShotReloadDurationMs() : Number {
return this.gaussData.powerShotReloadDurationMs;
}
override public function disable(param1:Boolean) : void {
super.disable(param1);
if(this.isTargetSelection()) {
this.stopAiming();
this._weaponStatus = 1;
this.currentState = this.states[GaussState.IDLE];
}
this.hideAim();
}
public function showAim() : void {
this.aim.show();
}
public function hideAim() : void {
this.target.resetTarget();
this.aim.hide();
}
public function startAiming() : void {
this.callback.doStartAiming();
effects.playOpenEffect();
}
public function stopAiming() : void {
this.callback.doStopAiming();
effects.playHideEffect();
}
public function setBuffedMode(param1:Boolean) : void {
this._buffed = param1;
if(!param1 && this.isReload()) {
this.processEvent(GaussEventType.BUFF_EXPIRED);
}
}
}
}
|
package alternativa.tanks.gui.chat {
import assets.stat.hall_NORMAL;
import controls.statassets.StatLineBase;
import flash.display.BitmapData;
public class ChatLineHighlightNormal extends StatLineBase {
public function ChatLineHighlightNormal() {
super();
tl = new hall_NORMAL(1,1);
px = new BitmapData(1,1,false,543488);
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.kits.description.panel {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.shop.shopitems.item.kits.description.panel.KitPackageDescriptionPanelBitmaps_bitmapLeftBottomCorner.png")]
public class KitPackageDescriptionPanelBitmaps_bitmapLeftBottomCorner extends BitmapAsset {
public function KitPackageDescriptionPanelBitmaps_bitmapLeftBottomCorner() {
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.ultimate.effects.juggernaut {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.ultimate.effects.juggernaut.JuggernautUltimateCC;
public class VectorCodecJuggernautUltimateCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecJuggernautUltimateCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(JuggernautUltimateCC,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.<JuggernautUltimateCC> = new Vector.<JuggernautUltimateCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = JuggernautUltimateCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:JuggernautUltimateCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<JuggernautUltimateCC> = Vector.<JuggernautUltimateCC>(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.battle.objects.tank {
import alternativa.math.Matrix3;
import alternativa.physics.Body;
import projects.tanks.client.battlefield.models.user.tank.commands.TurretControlType;
public interface WeaponMount {
function reset() : void;
function updatePhysics(param1:Body) : void;
function interpolate(param1:Number, param2:int) : void;
function rotate(param1:Number, param2:Matrix3) : void;
function isRotating() : Boolean;
function getTurretInterpolatedDirection() : Number;
function getTurretPhysicsDirection() : Number;
function setTurretPhysicsDirection(param1:Number) : void;
function getTurretRealControlType() : TurretControlType;
function getTurretRealControlInput() : Number;
function getTurretTurnSpeedNumber() : int;
function setTurretControlState(param1:TurretControlType, param2:Number, param3:int) : void;
function getBarrelInterpolatedElevation() : Number;
function setBarrelElevation(param1:Number) : void;
function setMaxTurnSpeed(param1:Number, param2:Boolean) : void;
function getTurnAcceleration() : Number;
function setTurnAcceleration(param1:Number) : void;
function setGyroscopePower(param1:Number) : void;
function lock(param1:int) : void;
function unlock(param1:int) : void;
}
}
|
package forms.events
{
import flash.events.Event;
public class StatListEvent extends Event
{
public static const UPDATE_STAT:String = "StatListUpdate";
public static const UPDATE_SORT:String = "StatListUpdateSort";
public var beginPosition:int = 0;
public var numRow:int = 0;
public var sortField:int;
public function StatListEvent(type:String, begin:int, num:int, sort:int = 1)
{
super(type,true,false);
this.beginPosition = begin;
this.numRow = num;
this.sortField = sort;
}
}
}
|
package alternativa.tanks.view.battlelist.battleitem {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battlelist.battleitem.BattleTypeIcon_formatClass.png")]
public class BattleTypeIcon_formatClass extends BitmapAsset {
public function BattleTypeIcon_formatClass() {
super();
}
}
}
|
package forms {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.locale.ILocaleService;
import base.DiscreteSprite;
import controls.TankWindow;
import controls.base.LabelBase;
import filters.Filters;
import flash.display.Bitmap;
import flash.text.TextFormat;
import resources.windowheaders.background.BackgroundHeader;
public class TankWindowWithHeader extends DiscreteSprite {
[Inject]
public static var localeService:ILocaleService;
private static const HEADER_BACKGROUND_HEIGHT:int = 25;
private static const HEADER_BACKGROUND_INNER_HEIGHT:int = 22;
private const GAP_11:int = 11;
private var label:* = new LabelBase();
private var window:TankWindow;
private var headerBackground:Bitmap;
public function TankWindowWithHeader(param1:String = null) {
super();
this.window = new TankWindow();
addChild(this.window);
this.initHeaderStyle();
if(param1 != null) {
this.setHeader(param1);
}
}
public static function createWindow(param1:String, param2:int = -1, param3:int = -1) : TankWindowWithHeader {
var local4:TankWindowWithHeader = new TankWindowWithHeader(localeService.getText(param1));
local4.width = param2;
local4.height = param3;
return local4;
}
private function initHeaderStyle() : void {
var local1:String = ILocaleService(OSGi.getInstance().getService(ILocaleService)).language;
if(local1 == "fa") {
this.label.setTextFormat(new TextFormat("IRANYekan"));
} else if(local1 == "cn") {
this.label.setTextFormat(new TextFormat("simsun"));
}
this.label.filters = Filters.SHADOW_FILTERS;
this.label.size = 16;
this.label.color = 12632256;
this.label.bold = true;
}
private function setHeader(param1:String) : void {
this.label.htmlText = param1;
if(this.label.width > this.label.height) {
if(this.label.width + 2 * this.GAP_11 < BackgroundHeader.shortBackgroundHeader.width) {
this.headerBackground = new Bitmap(BackgroundHeader.shortBackgroundHeader);
} else {
this.headerBackground = new Bitmap(BackgroundHeader.longBackgroundHeader);
}
} else {
this.headerBackground = new Bitmap(BackgroundHeader.verticalBackgroundHeader);
}
addChild(this.headerBackground);
addChild(this.label);
this.resize();
}
public function setHeaderId(param1:String) : void {
this.setHeader(localeService.getText(param1));
}
override public function set width(param1:Number) : void {
this.window.width = param1;
this.resize();
}
override public function get width() : Number {
return this.window.width;
}
override public function set height(param1:Number) : void {
this.window.height = param1;
this.resize();
}
override public function get height() : Number {
return this.window.height;
}
private function resize() : void {
if(this.headerBackground != null) {
if(this.label.width > this.label.height) {
this.headerBackground.x = this.window.width - this.headerBackground.width >> 1;
this.headerBackground.y = -HEADER_BACKGROUND_HEIGHT;
this.label.x = this.window.width - this.label.width >> 1;
this.label.y = 5 - (HEADER_BACKGROUND_INNER_HEIGHT + this.label.height >> 1);
} else {
this.headerBackground.x = -HEADER_BACKGROUND_HEIGHT;
this.headerBackground.y = this.window.height - this.headerBackground.height >> 1;
this.label.x = 5 - (HEADER_BACKGROUND_INNER_HEIGHT + this.label.width >> 1);
this.label.y = this.window.height - this.label.height >> 1;
}
}
}
}
}
|
package projects.tanks.client.battlefield.models.effects.activationsfx {
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 TankEffectSFXModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function TankEffectSFXModelServer(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 com.alternativaplatform.projects.tanks.client.models.tank
{
import scpacker.Base;
public class TankModelBase extends Base
{
public function TankModelBase()
{
super();
}
}
}
|
package alternativa.tanks.model.achievement
{
public class Achievement
{
public static const FIRST_PURCHASE:Achievement = new Achievement(0,"FIRST_PURCHASE");
public static const SET_EMAIL:Achievement = new Achievement(1,"SET_EMAIL");
private var _value:int;
private var _name:String;
public function Achievement(value:int, name:String)
{
super();
this._value = value;
this._name = name;
}
public static function get values() : Vector.<Achievement>
{
var values:Vector.<Achievement> = new Vector.<Achievement>();
values.push(FIRST_PURCHASE);
values.push(SET_EMAIL);
return values;
}
public static function getById(id:int) : Achievement
{
if(id == 0)
{
return FIRST_PURCHASE;
}
return SET_EMAIL;
}
public function toString() : String
{
return "Achievement [" + this._name + "]";
}
public function get value() : int
{
return this._value;
}
public function get name() : String
{
return this._name;
}
}
}
|
package scpacker.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksI_coldload8 extends BitmapAsset
{
public function GTanksI_coldload8()
{
super();
}
}
}
|
package alternativa.tanks.models.tank {
import flash.utils.getTimer;
public class IdleKickTime {
private var kickTime:uint;
public function IdleKickTime() {
super();
}
public function reset(param1:uint) : void {
this.kickTime = getTimer() + param1;
}
public function getTimeLeft() : uint {
return this.kickTime - getTimer();
}
}
}
|
package alternativa.tanks.battle {
import alternativa.physics.Body;
import alternativa.tanks.models.battle.commonflag.CommonFlag;
public interface CTFTargetEvaluator extends TeamDMTargetEvaluator {
function setFlagCarrier(param1:CommonFlag, param2:Body) : void;
}
}
|
package platform.client.fp10.core.protocol.codec {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import platform.client.fp10.core.network.command.SpaceOpenedCommand;
public class SpaceOpenedCommandCodec implements ICodec {
public function SpaceOpenedCommandCodec() {
super();
}
public function init(param1:IProtocol) : void {
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local3:SpaceOpenedCommand = SpaceOpenedCommand(param2);
param1.writer.writeByte(3);
param1.writer.writeBytes(local3.hash);
param1.writer.writeInt(local3.spaceId.high);
param1.writer.writeInt(local3.spaceId.low);
}
public function decode(param1:ProtocolBuffer) : Object {
return null;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.map {
import alternativa.tanks.engine3d.IndexedTextureConstructor;
import alternativa.utils.TextureMaterialRegistry;
import alternativa.utils.textureutils.ITextureConstructorListener;
import alternativa.utils.textureutils.TextureConstructor;
import flash.display.BitmapData;
import flash.events.Event;
import flash.events.EventDispatcher;
public class MapTexturesBuilder extends EventDispatcher implements ITextureConstructorListener {
private var materialRegistry:TextureMaterialRegistry;
private var maxBatchSize:int;
private var totalCounter:int;
private var lastCollectionIndex:int;
private var texturedPropsCollections:Vector.<TexturedPropsCollection>;
private var constructors:Vector.<IndexedTextureConstructor>;
private var killed:Boolean;
private var textures:Vector.<BitmapData> = new Vector.<BitmapData>();
public function MapTexturesBuilder(param1:TextureMaterialRegistry, param2:int) {
super();
this.materialRegistry = param1;
this.maxBatchSize = param2;
}
public function destroy() : void {
var local1:BitmapData = null;
this.killed = true;
this.texturedPropsCollections = null;
this.constructors = null;
for each(local1 in this.textures) {
local1.dispose();
}
this.textures = null;
}
public function run(param1:Vector.<TexturedPropsCollection>) : void {
this.texturedPropsCollections = param1.concat();
this.totalCounter = 0;
this.lastCollectionIndex = 0;
this.createTextureConstructors();
this.runConstructors();
}
private function createTextureConstructors() : void {
this.constructors = new Vector.<IndexedTextureConstructor>(this.maxBatchSize);
var local1:int = 0;
while(local1 < this.maxBatchSize) {
this.constructors[local1] = new IndexedTextureConstructor();
local1++;
}
}
private function runConstructors() : void {
var local1:IndexedTextureConstructor = null;
for each(local1 in this.constructors) {
this.runConstructor(local1);
}
}
private function runConstructor(param1:IndexedTextureConstructor) : void {
var local2:TexturedPropsCollection = null;
if(this.lastCollectionIndex < this.texturedPropsCollections.length) {
param1.index = this.lastCollectionIndex;
local2 = this.texturedPropsCollections[this.lastCollectionIndex++];
param1.createTexture(local2.getTextureData(),this);
}
}
[Obfuscation(rename="false")]
public function onTextureReady(param1:TextureConstructor) : void {
var local2:IndexedTextureConstructor = IndexedTextureConstructor(param1);
if(this.killed) {
local2.disposeTexture();
} else {
this.textures.push(local2.texture);
this.assignMaterialToProps(local2);
++this.totalCounter;
if(this.totalCounter == this.texturedPropsCollections.length) {
this.complete();
} else {
this.runConstructor(local2);
}
}
}
private function assignMaterialToProps(param1:IndexedTextureConstructor) : void {
var local2:TexturedPropsCollection = this.texturedPropsCollections[param1.index];
local2.setMaterial(this.materialRegistry.getMaterial(param1.texture));
}
private function complete() : void {
this.texturedPropsCollections = null;
this.constructors = null;
dispatchEvent(new Event(Event.COMPLETE));
}
public function getTextures() : Vector.<BitmapData> {
return this.textures;
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapBigRank09.png")]
public class DefaultRanksBitmaps_bitmapBigRank09 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapBigRank09() {
super();
}
}
}
|
package scpacker.gui.en
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksIEN_coldload2 extends BitmapAsset
{
public function GTanksIEN_coldload2()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.user.device {
import alternativa.types.Long;
public class TankDeviceCC {
private var _deviceId:Long;
public function TankDeviceCC(param1:Long = null) {
super();
this._deviceId = param1;
}
public function get deviceId() : Long {
return this._deviceId;
}
public function set deviceId(param1:Long) : void {
this._deviceId = param1;
}
public function toString() : String {
var local1:String = "TankDeviceCC [";
local1 += "deviceId = " + this.deviceId + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.service.delaymountcategory {
import controls.timer.CountDownTimer;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.garage.models.item.delaymount.DelayMountCategoryCC;
public interface IDelayMountCategoryService {
function getDownTimer(param1:IGameObject) : CountDownTimer;
function createTimers(param1:DelayMountCategoryCC) : void;
function destroyTimers() : void;
function resetTimers() : void;
}
}
|
package projects.tanks.client.battlefield.models.bonus.battle.goldbonus {
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 GoldBonusesModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function GoldBonusesModelServer(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 com.alternativaplatform.client.models.core.community.chat.types
{
public class UserChat
{
public var uid:String;
public var rankIndex:int;
public var chatPermissions:int;
public function UserChat()
{
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_overdriveWaspIconClass.png")]
public class HudInventoryIcon_overdriveWaspIconClass extends BitmapAsset {
public function HudInventoryIcon_overdriveWaspIconClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.rankupbonus.alert {
public class RankUpBonusAlertItem {
private var _accruedBonusCrystals:int;
private var _alertPictureUrl:String;
public function RankUpBonusAlertItem(param1:int = 0, param2:String = null) {
super();
this._accruedBonusCrystals = param1;
this._alertPictureUrl = param2;
}
public function get accruedBonusCrystals() : int {
return this._accruedBonusCrystals;
}
public function set accruedBonusCrystals(param1:int) : void {
this._accruedBonusCrystals = param1;
}
public function get alertPictureUrl() : String {
return this._alertPictureUrl;
}
public function set alertPictureUrl(param1:String) : void {
this._alertPictureUrl = param1;
}
public function toString() : String {
var local1:String = "RankUpBonusAlertItem [";
local1 += "accruedBonusCrystals = " + this.accruedBonusCrystals + " ";
local1 += "alertPictureUrl = " + this.alertPictureUrl + " ";
return local1 + "]";
}
}
}
|
package _codec.platform.client.core.general.socialnetwork.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.core.general.socialnetwork.types.LoginParameters;
public class VectorCodecLoginParametersLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecLoginParametersLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(LoginParameters,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.<LoginParameters> = new Vector.<LoginParameters>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = LoginParameters(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:LoginParameters = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<LoginParameters> = Vector.<LoginParameters>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.model.payment.shop.lootbox {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class LootBoxPackageAdapt implements LootBoxPackage {
private var object:IGameObject;
private var impl:LootBoxPackage;
public function LootBoxPackageAdapt(param1:IGameObject, param2:LootBoxPackage) {
super();
this.object = param1;
this.impl = param2;
}
public function getCount() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getCount());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.view.mainview.button {
import alternativa.osgi.service.locale.ILocaleService;
import base.DiscreteSprite;
import controls.base.ThreeLineBigButton;
import controls.labels.MouseDisabledLabel;
import filters.Filters;
import flash.display.Sprite;
import forms.ranks.SmallRankIcon;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.UserPropertiesServiceEvent;
public class LockedByRankButton extends ThreeLineBigButton {
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var localeService:ILocaleService;
private var rankRow:Sprite = new DiscreteSprite();
private var rankLabel:MouseDisabledLabel = new MouseDisabledLabel();
private var rankIcon:SmallRankIcon = new SmallRankIcon();
private var unlockRank:int;
public function LockedByRankButton(param1:int) {
this.unlockRank = param1;
super();
if(this.shouldBeLockedByRank()) {
disabledState.setSkin(new DisabledButtonSkin());
this.rankLabel.sharpness = -100;
this.rankLabel.thickness = 100;
this.rankLabel.text = localeService.getText(TanksLocale.TEXT_GARAGE_BUY_BUTTON_RANK_LABEL);
this.rankLabel.color = 16731648;
this.rankLabel.filters = Filters.SHADOW_FILTERS;
this.rankRow.addChild(this.rankLabel);
this.rankIcon.y = 3;
this.rankIcon.init(false,param1);
this.rankIcon.x = this.rankLabel.x + this.rankLabel.width + 1;
this.rankIcon.filters = Filters.SHADOW_FILTERS;
this.rankRow.addChild(this.rankIcon);
this.rankRow.width = this.rankLabel.width + this.rankIcon.width + 5;
this.rankRow.x = 60 - this.rankRow.width / 2;
addChild(this.rankRow);
userPropertiesService.addEventListener(UserPropertiesServiceEvent.UPDATE_RANK,this.updateRank);
this.lockByRank();
} else {
this.unlockByRank();
}
}
public function unlockIfPossible() : void {
if(!this.shouldBeLockedByRank()) {
this.unlockByRank();
}
}
private function lockByRank() : void {
enabled = false;
showInTwoRows(captionLabel,this.rankRow);
}
private function unlockByRank() : void {
this.rankRow.visible = false;
enabled = true;
showInOneRow(captionLabel);
}
private function updateRank(param1:UserPropertiesServiceEvent) : void {
if(!this.shouldBeLockedByRank()) {
userPropertiesService.removeEventListener(UserPropertiesServiceEvent.UPDATE_RANK,this.updateRank);
this.unlockByRank();
}
}
private function shouldBeLockedByRank() : Boolean {
return this.unlockRank > userPropertiesService.rank;
}
}
}
|
package alternativa.tanks.view.layers {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.loader.ILoaderWindowService;
import alternativa.tanks.service.IRegistrationUXService;
import alternativa.tanks.view.StandAloneCaptchaForm;
import alternativa.tanks.view.forms.ChangeEmailAndPasswordForm;
import alternativa.tanks.view.forms.ChangeUidForm;
import alternativa.tanks.view.forms.ExternalRegistrationForm;
import alternativa.tanks.view.forms.InviteForm;
import alternativa.tanks.view.forms.LinkExternalLoginForm;
import alternativa.tanks.view.forms.LinkPartnerLoginForm;
import alternativa.tanks.view.forms.LoginForm;
import alternativa.tanks.view.forms.PartnersRegistrationForm;
import alternativa.tanks.view.forms.PasswordRestoreForm;
import alternativa.tanks.view.forms.RegistrationForm;
import alternativa.tanks.view.forms.primivites.Alert;
import flash.display.Bitmap;
import flash.display.DisplayObject;
import flash.display.Sprite;
import forms.events.AlertEvent;
import org.robotlegs.core.IInjector;
import platform.clients.fp10.libraries.alternativapartners.service.IPartnerService;
import projects.tanks.client.entrance.model.entrance.emailconfirm.ConfirmEmailStatus;
import projects.tanks.client.entrance.model.entrance.logging.RegistrationUXScreen;
import projects.tanks.clients.flash.commons.services.timeunit.ITimeUnitService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import services.alertservice.AlertAnswer;
public class EntranceView extends Sprite {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var partnerService:IPartnerService;
[Inject]
public static var timeUnitService:ITimeUnitService;
[Inject]
public static var registrationUXService:IRegistrationUXService;
[Inject]
public static var loaderWindowService:ILoaderWindowService;
[Inject]
public var injector:IInjector;
private var alert:Alert;
private var _currentView:DisplayObject;
private var _rememberCallsign:String = "";
private var _rememberPassword:String = "";
private var _rememberVerificationPassword:String = "";
private var _emailText:String = "";
public function EntranceView() {
super();
}
public function showChangeUidAndPasswordForm() : void {
var local1:Boolean = true;
this.changeViewTo(new ChangeUidForm(local1));
}
public function showChangeUidForm() : void {
var local1:Boolean = false;
this.changeViewTo(new ChangeUidForm(local1));
}
public function showInviteForm() : void {
this.changeViewTo(new InviteForm());
}
public function showLoginForm(param1:String, param2:Boolean, param3:Boolean, param4:String = null) : void {
registrationUXService.logNavigationStart(RegistrationUXScreen.LOGIN);
var local5:LoginForm = this.injector.instantiate(LoginForm);
local5.callsign = param1;
if(Boolean(param4)) {
local5.password = param4;
}
local5.enableRegistration = param2;
this.changeViewTo(local5);
if(param3) {
local5.showCaptchaSection();
}
}
public function showAlertServerIsHalt() : void {
this.removeAllForms();
alertService.showAlert(localeService.getText(TanksLocale.TEXT_SERVER_IS_RESTARTING_LOGIN_TEXT),Vector.<String>([localeService.getText(AlertAnswer.OK)]));
}
public function showAlertServerIsFrozen() : void {
this.removeAllForms();
alertService.showAlert(localeService.getText(TanksLocale.TEXT_SERVER_FROZEN_ALERT_TEXT),Vector.<String>([localeService.getText(AlertAnswer.OK)]));
}
public function showExternalLoginForm(param1:String, param2:String, param3:Boolean) : void {
var local4:LinkExternalLoginForm = this.injector.instantiate(LinkExternalLoginForm);
local4.callsign = param2;
local4.socialNetworkId = param1;
this.changeViewTo(local4);
if(param3) {
local4.showCaptchaSection();
}
loaderWindowService.hideForcibly();
}
public function showExternalRegistrationForm(param1:String) : void {
this.injector.mapValue(EntranceView,this);
var local2:ExternalRegistrationForm = this.injector.instantiate(ExternalRegistrationForm);
this.injector.injectInto(local2);
this.changeViewTo(local2);
this.injector.unmap(EntranceView);
loaderWindowService.hideForcibly();
}
public function showRegistrationForm(param1:Bitmap, param2:Boolean, param3:Boolean, param4:Boolean, param5:Boolean, param6:Boolean) : void {
registrationUXService.logNavigationStart(RegistrationUXScreen.MAIN);
this.injector.mapValue(EntranceView,this);
var local7:RegistrationForm = new RegistrationForm(param6,param2,param3,param1,param4,param5,this._rememberCallsign,this._rememberPassword,this._rememberVerificationPassword,this._emailText);
this.injector.injectInto(local7);
this.changeViewTo(local7);
this.injector.unmap(EntranceView);
}
public function showChangeEmailAndPassword(param1:String) : void {
var local2:ChangeEmailAndPasswordForm = this.injector.instantiate(ChangeEmailAndPasswordForm);
local2.email = param1;
this.changeViewTo(local2);
}
public function showRecoveryHashIsWrongAlert() : void {
this.alert = new Alert();
var local1:String = localeService.getText(TanksLocale.TEXT_SETTINGS_CHANGE_PASSWORD_WRONG_LINK_TEXT);
this.alert.showAlert(local1,Vector.<String>([AlertAnswer.OK]));
this.changeViewTo(this.alert);
this.alert.addEventListener(AlertEvent.ALERT_BUTTON_PRESSED,this.onWrongChangePasswordAlertButtonPressed);
}
private function onWrongChangePasswordAlertButtonPressed(param1:AlertEvent) : void {
this.alert.removeEventListener(AlertEvent.ALERT_BUTTON_PRESSED,this.onWrongChangePasswordAlertButtonPressed);
this.showLoginForm("",true,false);
}
public function showRestorePasswordForm() : void {
this.changeViewTo(this.injector.instantiate(PasswordRestoreForm));
}
public function showStandAloneCaptcha() : void {
this.changeViewTo(this.injector.instantiate(StandAloneCaptchaForm));
}
public function showPartnersRegistrationForm(param1:Bitmap, param2:Boolean) : void {
registrationUXService.logNavigationStart(RegistrationUXScreen.PARTNER);
this.injector.mapValue(EntranceView,this);
var local3:PartnersRegistrationForm = new PartnersRegistrationForm(param1,param2);
this.injector.injectInto(local3);
this.changeViewTo(local3);
this.injector.unmap(EntranceView);
}
public function showPartnerLoginForm(param1:Bitmap, param2:Boolean) : void {
registrationUXService.logNavigationStart(RegistrationUXScreen.LOGIN);
this.injector.mapValue(EntranceView,this);
var local3:LinkPartnerLoginForm = new LinkPartnerLoginForm(param1);
this.injector.injectInto(local3);
this.changeViewTo(local3);
if(param2) {
local3.showCaptchaSection();
}
this.injector.unmap(EntranceView);
}
private function changeViewTo(param1:DisplayObject) : void {
var local2:RegistrationForm = null;
if(Boolean(this._currentView)) {
local2 = this._currentView as RegistrationForm;
if(local2 != null) {
this._rememberCallsign = local2.callsign;
this._rememberPassword = local2.password;
this._rememberVerificationPassword = local2.verificationPassword;
this._emailText = local2.emailText;
}
removeChild(this._currentView);
}
this._currentView = param1;
addChild(this._currentView);
}
public function removeAllForms() : void {
while(numChildren > 0) {
removeChildAt(0);
}
}
public function get currentView() : DisplayObject {
return this._currentView;
}
public function showConfirmEmailStatusAlert(param1:ConfirmEmailStatus) : void {
this.alert = new Alert();
switch(param1) {
case ConfirmEmailStatus.ERROR:
this.alert = new Alert(Alert.ERROR_CONFIRM_EMAIL);
break;
case ConfirmEmailStatus.OK:
this.alert = new Alert(Alert.ALERT_CONFIRM_EMAIL);
break;
case ConfirmEmailStatus.OK_EXISTS:
this.alert = new Alert(Alert.ALERT_CONFIRM_EMAIL);
}
this.alert.addEventListener(AlertEvent.ALERT_BUTTON_PRESSED,this.goToLoginAfterAlertClosed);
this.changeViewTo(this.alert);
}
public function showErrorWindow(param1:int) : void {
addChild(new Alert(param1));
}
public function showBlockAlert(param1:String) : void {
this.alert = new Alert();
if(!partnerService.isRunningInsidePartnerEnvironment()) {
this.alert.addEventListener(AlertEvent.ALERT_BUTTON_PRESSED,this.goToLoginAfterAlertClosed);
this.alert.showAlert(param1,Vector.<String>([AlertAnswer.OK]));
} else {
this.alert.showAlert(param1,Vector.<String>([]));
}
this.changeViewTo(this.alert);
loaderWindowService.hideForcibly();
}
private function goToLoginAfterAlertClosed(param1:AlertEvent) : void {
this.alert.removeEventListener(AlertEvent.ALERT_BUTTON_PRESSED,this.goToLoginAfterAlertClosed);
this.showLoginForm("",true,false);
}
public function showKickAlert(param1:String, param2:int, param3:int, param4:int) : void {
this.alert = new Alert();
var local5:String = localeService.getText(TanksLocale.TEXT_YOU_WERE_KICKED_LOGIN_TEXT);
local5 = local5.replace("{0}",param1);
local5 = local5.replace("{1}",timeUnitService.getLocalizedTimeString(param2,param3,param4));
if(!partnerService.isRunningInsidePartnerEnvironment()) {
this.alert.addEventListener(AlertEvent.ALERT_BUTTON_PRESSED,this.goToLoginAfterAlertClosed);
this.alert.showAlert(local5,Vector.<String>([AlertAnswer.OK]));
} else {
this.alert.showAlert(local5,Vector.<String>([]));
}
this.changeViewTo(this.alert);
loaderWindowService.hideForcibly();
}
}
}
|
package alternativa.tanks.models.weapon.terminator {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.objects.tank.tankskin.terminator.TerminatorTurretSkin;
import alternativa.tanks.models.weapon.rocketlauncher.RocketLauncherObject;
import alternativa.tanks.models.weapons.discrete.DiscreteWeaponObject;
import platform.client.fp10.core.type.IGameObject;
public class TerminatorObject extends DiscreteWeaponObject {
private var _rocketLauncherObject:RocketLauncherObject;
public function TerminatorObject(param1:IGameObject) {
super(param1);
this._rocketLauncherObject = new RocketLauncherObject(param1);
}
public function getSkin() : TerminatorTurretSkin {
return TerminatorSkin(object.adapt(TerminatorSkin)).getSkin();
}
public function get rocketLauncherObject() : RocketLauncherObject {
return this._rocketLauncherObject;
}
public function primaryShot(param1:int, param2:Vector3, param3:Vector.<Body>, param4:Vector.<Vector3>, param5:int) : * {
Terminator(object.adapt(Terminator)).primaryShot(param1,param2,param3,param4,param5);
}
public function primaryDummyShot(param1:int, param2:int) : * {
Terminator(object.adapt(Terminator)).primaryDummyShot(param1,param2);
}
public function primaryCharge(param1:int, param2:int) : * {
Terminator(object.adapt(Terminator)).primaryCharge(param1,param2);
}
public function secondaryOpen(param1:int) : * {
Terminator(object.adapt(Terminator)).secondaryOpen(param1);
}
public function secondaryHide(param1:int) : * {
Terminator(object.adapt(Terminator)).secondaryHide(param1);
}
}
}
|
package controls.scroller.green
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ScrollSkinGreen_trackBottom extends BitmapAsset
{
public function ScrollSkinGreen_trackBottom()
{
super();
}
}
}
|
package projects.tanks.client.achievements.osgi {
import _codec.projects.tanks.client.achievements.model.CodecAchievement;
import _codec.projects.tanks.client.achievements.model.VectorCodecAchievementLevel1;
import _codec.projects.tanks.client.achievements.model.panel.CodecAchievementCC;
import _codec.projects.tanks.client.achievements.model.panel.VectorCodecAchievementCCLevel1;
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.client.achievements.model.Achievement;
import projects.tanks.client.achievements.model.panel.AchievementCC;
public class Activator implements IBundleActivator {
public static var osgi:OSGi;
public function Activator() {
super();
}
public function start(param1:OSGi) : void {
var local4:ICodec = null;
osgi = param1;
var local2:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local2.register(Long.getLong(1524513374,287342893),Long.getLong(623988280,-1549577978));
local2.register(Long.getLong(1524513374,287342893),Long.getLong(392903733,700779252));
var local3:IProtocol = IProtocol(osgi.getService(IProtocol));
local4 = new CodecAchievement();
local3.registerCodec(new EnumCodecInfo(Achievement,false),local4);
local3.registerCodec(new EnumCodecInfo(Achievement,true),new OptionalCodecDecorator(local4));
local4 = new CodecAchievementCC();
local3.registerCodec(new TypeCodecInfo(AchievementCC,false),local4);
local3.registerCodec(new TypeCodecInfo(AchievementCC,true),new OptionalCodecDecorator(local4));
local4 = new VectorCodecAchievementLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(Achievement,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(Achievement,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecAchievementLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(Achievement,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(Achievement,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecAchievementCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(AchievementCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(AchievementCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecAchievementCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(AchievementCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(AchievementCC,true),true,1),new OptionalCodecDecorator(local4));
}
public function stop(param1:OSGi) : void {
}
}
}
|
package alternativa.tanks.model.shop.items.base
{
public class GreenShopItemSkin extends ButtonItemSkin
{
[Embed(source="1130.png")]
private static const normalStateClass:Class;
[Embed(source="775.png")]
private static const overStateClass:Class;
public function GreenShopItemSkin()
{
super();
normalState = new normalStateClass().bitmapData;
overState = new overStateClass().bitmapData;
}
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased.flag {
import alternativa.types.Long;
import projects.tanks.client.battlefield.types.Vector3d;
public class ClientFlag {
private var _fallingData:ClientFlagFlyingData;
private var _flagCarrierId:Long;
private var _flagId:int;
private var _flagPosition:Vector3d;
private var _state:FlagState;
public function ClientFlag(param1:ClientFlagFlyingData = null, param2:Long = null, param3:int = 0, param4:Vector3d = null, param5:FlagState = null) {
super();
this._fallingData = param1;
this._flagCarrierId = param2;
this._flagId = param3;
this._flagPosition = param4;
this._state = param5;
}
public function get fallingData() : ClientFlagFlyingData {
return this._fallingData;
}
public function set fallingData(param1:ClientFlagFlyingData) : void {
this._fallingData = param1;
}
public function get flagCarrierId() : Long {
return this._flagCarrierId;
}
public function set flagCarrierId(param1:Long) : void {
this._flagCarrierId = param1;
}
public function get flagId() : int {
return this._flagId;
}
public function set flagId(param1:int) : void {
this._flagId = param1;
}
public function get flagPosition() : Vector3d {
return this._flagPosition;
}
public function set flagPosition(param1:Vector3d) : void {
this._flagPosition = param1;
}
public function get state() : FlagState {
return this._state;
}
public function set state(param1:FlagState) : void {
this._state = param1;
}
public function toString() : String {
var local1:String = "ClientFlag [";
local1 += "fallingData = " + this.fallingData + " ";
local1 += "flagCarrierId = " + this.flagCarrierId + " ";
local1 += "flagId = " + this.flagId + " ";
local1 += "flagPosition = " + this.flagPosition + " ";
local1 += "state = " + this.state + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.battlefield.models.ultimate.effects.juggernaut {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import platform.client.fp10.core.type.IGameObject;
public class JuggernautUltimateModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:JuggernautUltimateModelServer;
private var client:IJuggernautUltimateModelBase = IJuggernautUltimateModelBase(this);
private var modelId:Long = Long.getLong(206621166,86427501);
private var _showUltimateUsedId:Long = Long.getLong(967672650,-338860941);
private var _showUltimateUsed_tanksPushedCodec:ICodec;
public function JuggernautUltimateModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new JuggernautUltimateModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(JuggernautUltimateCC,false)));
this._showUltimateUsed_tanksPushedCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(IGameObject,false),false,1));
}
protected function getInitParam() : JuggernautUltimateCC {
return JuggernautUltimateCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._showUltimateUsedId:
this.client.showUltimateUsed(this._showUltimateUsed_tanksPushedCodec.decode(param2) as Vector.<IGameObject>);
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.types {
import platform.client.fp10.core.resource.types.SoundResource;
public class BattlefieldSounds {
private var _battleFinishSound:SoundResource;
private var _killSound:SoundResource;
public function BattlefieldSounds(param1:SoundResource = null, param2:SoundResource = null) {
super();
this._battleFinishSound = param1;
this._killSound = param2;
}
public function get battleFinishSound() : SoundResource {
return this._battleFinishSound;
}
public function set battleFinishSound(param1:SoundResource) : void {
this._battleFinishSound = param1;
}
public function get killSound() : SoundResource {
return this._killSound;
}
public function set killSound(param1:SoundResource) : void {
this._killSound = param1;
}
public function toString() : String {
var local1:String = "BattlefieldSounds [";
local1 += "battleFinishSound = " + this.battleFinishSound + " ";
local1 += "killSound = " + this.killSound + " ";
return local1 + "]";
}
}
}
|
package controls.buttons.h71px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h71px.GreyHugeButtonSkin_rightDownClass.png")]
public class GreyHugeButtonSkin_rightDownClass extends BitmapAsset {
public function GreyHugeButtonSkin_rightDownClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.user.bossstate {
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 BossStateModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BossStateModelServer(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.panel.model.profile.userproperties {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import projects.tanks.client.panel.model.profile.userproperties.UserPropertiesCC;
import projects.tanks.client.users.model.userbattlestatistics.rank.RankBounds;
public class CodecUserPropertiesCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_canUseGroup:ICodec;
private var codec_crystals:ICodec;
private var codec_crystalsRating:ICodec;
private var codec_daysFromLastVisit:ICodec;
private var codec_daysFromRegistration:ICodec;
private var codec_gearScore:ICodec;
private var codec_goldsTakenRating:ICodec;
private var codec_hasSpectatorPermissions:ICodec;
private var codec_id:ICodec;
private var codec_rank:ICodec;
private var codec_rankBounds:ICodec;
private var codec_registrationTimestamp:ICodec;
private var codec_score:ICodec;
private var codec_scoreRating:ICodec;
private var codec_uid:ICodec;
private var codec_userProfileUrl:ICodec;
private var codec_userRating:ICodec;
public function CodecUserPropertiesCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_canUseGroup = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_crystals = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_crystalsRating = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_daysFromLastVisit = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_daysFromRegistration = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_gearScore = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_goldsTakenRating = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_hasSpectatorPermissions = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_id = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_rank = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_rankBounds = param1.getCodec(new TypeCodecInfo(RankBounds,false));
this.codec_registrationTimestamp = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_score = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_scoreRating = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_uid = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_userProfileUrl = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_userRating = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:UserPropertiesCC = new UserPropertiesCC();
local2.canUseGroup = this.codec_canUseGroup.decode(param1) as Boolean;
local2.crystals = this.codec_crystals.decode(param1) as int;
local2.crystalsRating = this.codec_crystalsRating.decode(param1) as int;
local2.daysFromLastVisit = this.codec_daysFromLastVisit.decode(param1) as int;
local2.daysFromRegistration = this.codec_daysFromRegistration.decode(param1) as int;
local2.gearScore = this.codec_gearScore.decode(param1) as int;
local2.goldsTakenRating = this.codec_goldsTakenRating.decode(param1) as int;
local2.hasSpectatorPermissions = this.codec_hasSpectatorPermissions.decode(param1) as Boolean;
local2.id = this.codec_id.decode(param1) as Long;
local2.rank = this.codec_rank.decode(param1) as int;
local2.rankBounds = this.codec_rankBounds.decode(param1) as RankBounds;
local2.registrationTimestamp = this.codec_registrationTimestamp.decode(param1) as int;
local2.score = this.codec_score.decode(param1) as int;
local2.scoreRating = this.codec_scoreRating.decode(param1) as int;
local2.uid = this.codec_uid.decode(param1) as String;
local2.userProfileUrl = this.codec_userProfileUrl.decode(param1) as String;
local2.userRating = this.codec_userRating.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:UserPropertiesCC = UserPropertiesCC(param2);
this.codec_canUseGroup.encode(param1,local3.canUseGroup);
this.codec_crystals.encode(param1,local3.crystals);
this.codec_crystalsRating.encode(param1,local3.crystalsRating);
this.codec_daysFromLastVisit.encode(param1,local3.daysFromLastVisit);
this.codec_daysFromRegistration.encode(param1,local3.daysFromRegistration);
this.codec_gearScore.encode(param1,local3.gearScore);
this.codec_goldsTakenRating.encode(param1,local3.goldsTakenRating);
this.codec_hasSpectatorPermissions.encode(param1,local3.hasSpectatorPermissions);
this.codec_id.encode(param1,local3.id);
this.codec_rank.encode(param1,local3.rank);
this.codec_rankBounds.encode(param1,local3.rankBounds);
this.codec_registrationTimestamp.encode(param1,local3.registrationTimestamp);
this.codec_score.encode(param1,local3.score);
this.codec_scoreRating.encode(param1,local3.scoreRating);
this.codec_uid.encode(param1,local3.uid);
this.codec_userProfileUrl.encode(param1,local3.userProfileUrl);
this.codec_userRating.encode(param1,local3.userRating);
}
}
}
|
package projects.tanks.clients.fp10.TanksLauncher.service {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.logging.LogService;
import flash.events.TimerEvent;
import flash.external.ExternalInterface;
import flash.utils.Dictionary;
import flash.utils.Timer;
import flash.utils.getTimer;
import projects.tanks.clients.fp10.TanksLauncher.TanksLauncher;
public class TrackerService {
private static var actions:Dictionary;
private var commands:Vector.<TrackerCommand>;
private var timer:Timer;
private var available:Boolean = false;
public function TrackerService() {
super();
this.available = ExternalInterface.available && ExternalInterface.call("checkGALoaded");
if(this.available) {
this.commands = new Vector.<TrackerCommand>();
this.timer = new Timer(100);
this.timer.addEventListener(TimerEvent.TIMER,this.timer_timerHandler);
actions = new Dictionary();
}
}
public function trackPageView(param1:String) : void {
var local2:int = 0;
if(this.available) {
local2 = getTimer() / 100;
actions[param1] = local2;
this.commands.push(new TrackerCommand("GATrackPageView","/" + param1));
this.timer.start();
}
LogService(OSGi.getInstance().getService(LogService)).getLogger(TanksLauncher.LOG_CHANNEL).debug("trackPageView=",[param1]);
}
public function trackEvent(param1:String, param2:String, param3:String) : void {
var local5:int = 0;
if(this.available) {
local5 = getTimer() / 100;
actions[param2] = local5;
this.commands.push(new TrackerCommand("GATrackEvent",param1,param2,param3));
this.timer.start();
}
var local4:* = "trackEvent(" + param1 + ", " + param2 + ", " + param3 + ")";
LogService(OSGi.getInstance().getService(LogService)).getLogger(TanksLauncher.LOG_CHANNEL).debug(local4);
}
public function trackEventValue(param1:String, param2:String, param3:String, param4:Number) : void {
var local5:int = 0;
if(this.available) {
local5 = getTimer() / 100;
actions[param2] = local5;
this.commands.push(new TrackerCommand("GATrackEvent",param1,param2,param4.toFixed(2)));
this.timer.start();
}
}
public function trackEventAfter(param1:String, param2:String, param3:String) : void {
var local4:int = 0;
if(this.available) {
local4 = getTimer() / 100;
if(actions[param3] != null) {
this.trackEventValue(param1,param2,null,int((local4 - actions[param3]) / 10));
} else {
this.trackEvent(param1,param2,param3 + " action not logged");
}
}
}
private function timer_timerHandler(param1:TimerEvent) : void {
var local3:TrackerCommand = null;
var local4:Boolean = false;
if(this.commands.length > 0) {
if(this.available) {
local3 = this.commands.shift();
switch(local3.arguments.length) {
case 4:
local4 = ExternalInterface.call(local3.command,local3.arguments[0],local3.arguments[1],local3.arguments[2],local3.arguments[3]);
break;
case 3:
local4 = ExternalInterface.call(local3.command,local3.arguments[0],local3.arguments[1],local3.arguments[2]);
break;
default:
local4 = ExternalInterface.call(local3.command,local3.arguments[0]);
}
}
} else {
this.timer.stop();
}
}
}
}
class TrackerCommand {
private var _command:String;
private var _arguments:Array;
public function TrackerCommand(param1:String, ... rest) {
super();
this._command = param1;
this._arguments = rest;
}
public function get command() : String {
return this._command;
}
public function set command(param1:String) : void {
this._command = param1;
}
public function get arguments() : Array {
return this._arguments;
}
public function set arguments(param1:Array) : void {
this._arguments = param1;
}
}
|
package alternativa.tanks.model.achievement
{
public class State
{
public static const BATTLES_LIST:State = new State();
public static const GARAGE:State = new State();
public static const BATTLE:State = new State();
public function State()
{
super();
}
}
}
|
package alternativa.tanks.models.clan.permission {
import alternativa.tanks.gui.clanmanagement.ClanActionsManager;
import alternativa.tanks.gui.clanmanagement.ClanPermissionsManager;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.client.clans.clan.permissions.ClanPermission;
import projects.tanks.client.clans.clan.permissions.ClanPermissionsModelBase;
import projects.tanks.client.clans.clan.permissions.IClanPermissionsModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
[ModelInfo]
public class ClanPermissionsModel extends ClanPermissionsModelBase implements IClanPermissionsModel, IClanPermissionsModelBase, ObjectLoadListener {
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
public function ClanPermissionsModel() {
super();
}
public function objectLoaded() : void {
clanUserInfoService.actions = getInitParam().actions;
ClanPermissionsManager.permissionsModel = object.adapt(IClanPermissionsModel) as IClanPermissionsModel;
}
public function updateActions(param1:Vector.<ClanAction>) : void {
clanUserInfoService.actions = param1;
ClanActionsManager.updateActions();
}
public function setPosition(param1:Long, param2:ClanPermission) : void {
server.setPermissionForUser(param1,param2);
}
}
}
|
package alternativa.tanks.models.statistics {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.models.battle.gui.chat.BattleChat;
import alternativa.tanks.models.battle.gui.gui.statistics.field.score.BattleStatistics;
import alternativa.tanks.models.battle.gui.gui.statistics.fps.FPSText;
import alternativa.tanks.models.battle.gui.gui.statistics.messages.BattleMessages;
import alternativa.tanks.models.battlemessages.BattlefieldMessages;
import alternativa.tanks.service.panel.IPanelView;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.services.battlegui.BattleGUIService;
import alternativa.tanks.services.battleinput.BattleInputService;
import alternativa.tanks.services.spectatorservice.SpectatorService;
import alternativa.tanks.utils.BitMask;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
import platform.client.fp10.core.type.AutoClosable;
public class SpectatorScreenLayouts implements AutoClosable {
[Inject]
public static var display:IDisplay;
[Inject]
public static var panelView:IPanelView;
[Inject]
public static var settingsService:ISettingsService;
[Inject]
public static var spectatorService:SpectatorService;
[Inject]
public static var battleInput:BattleInputService;
[Inject]
public static var guiService:BattleGUIService;
private static const LAYOUT_SWITCH_KEY:uint = Keyboard.BACKSLASH;
private static const SCORE_BAR:int = 1;
private static const FPS:int = 1 << 1;
private static const CHAT:int = 1 << 2;
private static const BATTLE_MESSAGES:int = 1 << 3;
private static const BATTLEFIELD_MESSAGES:int = 1 << 4;
private static const FIELD_STATISTICS:int = 1 << 5;
private static const USER_TITLES:int = 1 << 6;
private static const GUI:int = 1 << 7;
private static const layouts:Array = [GUI | BATTLE_MESSAGES | BATTLEFIELD_MESSAGES | FIELD_STATISTICS | USER_TITLES | CHAT | SCORE_BAR | FPS,GUI | BATTLE_MESSAGES | BATTLEFIELD_MESSAGES | FIELD_STATISTICS | USER_TITLES | CHAT,GUI | BATTLE_MESSAGES | BATTLEFIELD_MESSAGES | FIELD_STATISTICS | USER_TITLES,USER_TITLES,0];
private var chat:BattleChat;
private var battleMessages:BattleMessages;
private var fieldStatistics:BattleStatistics;
private var battlefieldMessages:BattlefieldMessages;
private var fpsIndicator:FPSText;
private var layoutIndex:int;
public function SpectatorScreenLayouts(param1:BattleChat, param2:BattleMessages, param3:BattlefieldMessages, param4:BattleStatistics, param5:FPSText) {
super();
this.chat = param1;
this.battleMessages = param2;
this.battlefieldMessages = param3;
this.fieldStatistics = param4;
this.fpsIndicator = param5;
this.layoutIndex = 0;
this.applyLayout(this.layoutIndex);
display.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
}
private function onKeyDown(param1:KeyboardEvent) : void {
if(!battleInput.isInputLocked() && param1.keyCode == LAYOUT_SWITCH_KEY) {
this.toggleLayout();
}
}
private function toggleLayout() : void {
this.layoutIndex = (this.layoutIndex + 1) % layouts.length;
this.applyLayout(this.layoutIndex);
}
private function applyLayout(param1:int) : void {
var local2:BitMask = null;
local2 = new BitMask(layouts[param1]);
panelView.getPanel().visible = local2.hasAnyBit(SCORE_BAR);
this.fpsIndicator.visible = local2.hasAnyBit(FPS) && Boolean(settingsService.showFPS);
this.chat.visible = local2.hasAnyBit(CHAT);
this.battleMessages.visible = local2.hasAnyBit(BATTLE_MESSAGES);
this.battlefieldMessages.visible = local2.hasAnyBit(BATTLEFIELD_MESSAGES);
this.fieldStatistics.visible = local2.hasAnyBit(FIELD_STATISTICS);
spectatorService.setUserTitlesVisible(local2.hasAnyBit(USER_TITLES));
guiService.getGuiContainer().visible = local2.hasAnyBit(GUI);
}
[Obfuscation(rename="false")]
public function close() : void {
display.stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
panelView.getPanel().visible = true;
this.fpsIndicator.visible = true;
this.chat = null;
this.battleMessages = null;
this.battlefieldMessages = null;
this.fieldStatistics = null;
this.fpsIndicator = null;
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_shotgunResistanceClass.png")]
public class ResistancesIcons_shotgunResistanceClass extends BitmapAsset {
public function ResistancesIcons_shotgunResistanceClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.usercountry {
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.usercountry.CountryInfo;
public class VectorCodecCountryInfoLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecCountryInfoLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(CountryInfo,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.<CountryInfo> = new Vector.<CountryInfo>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = CountryInfo(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:CountryInfo = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<CountryInfo> = Vector.<CountryInfo>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.tank.configuration {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class TankConfigurationAdapt implements TankConfiguration {
private var object:IGameObject;
private var impl:TankConfiguration;
public function TankConfigurationAdapt(param1:IGameObject, param2:TankConfiguration) {
super();
this.object = param1;
this.impl = param2;
}
public function getHullObject() : IGameObject {
var result:IGameObject = null;
try {
Model.object = this.object;
result = this.impl.getHullObject();
}
finally {
Model.popObject();
}
return result;
}
public function getWeaponObject() : IGameObject {
var result:IGameObject = null;
try {
Model.object = this.object;
result = this.impl.getWeaponObject();
}
finally {
Model.popObject();
}
return result;
}
public function getColoringObject() : IGameObject {
var result:IGameObject = null;
try {
Model.object = this.object;
result = this.impl.getColoringObject();
}
finally {
Model.popObject();
}
return result;
}
public function hasDrone() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.hasDrone());
}
finally {
Model.popObject();
}
return result;
}
public function getDrone() : IGameObject {
var result:IGameObject = null;
try {
Model.object = this.object;
result = this.impl.getDrone();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.events.Event;
import flash.media.SoundChannel;
public class MobileSound3DEffect extends PooledObject implements ISound3DEffect {
private static const soundPosition:Vector3 = new Vector3();
private var sound:Sound3D;
private var playbackDelay:int;
private var startTime:int;
private var loops:int;
private var object:Object3D;
private var channel:SoundChannel;
private var alive:Boolean;
private var time:int;
private var actualVolume:Number;
private var volumeFadeSpeed:Number;
private var listener:ISoundEffectDestructionListener;
public function MobileSound3DEffect(param1:Pool) {
super(param1);
}
public function shortInit(param1:Sound3D, param2:Object3D, param3:ISoundEffectDestructionListener = null) : void {
this.init(param1,param2,0,1,0,param3);
}
public function init(param1:Sound3D, param2:Object3D, param3:int = 0, param4:int = 1, param5:int = 0, param6:ISoundEffectDestructionListener = null) : void {
this.sound = param1;
this.object = param2;
this.playbackDelay = param3;
this.loops = param4;
this.startTime = param5;
this.listener = param6;
this.alive = true;
this.time = 0;
this.actualVolume = param1.volume;
this.volumeFadeSpeed = 0;
}
public function play(param1:int, param2:GameCamera) : void {
if(!this.alive) {
return;
}
if(this.time < this.playbackDelay) {
this.time += param1;
return;
}
if(!this.sound.isPlaying()) {
this.channel = this.sound.play(this.startTime,this.loops);
if(this.channel != null) {
this.channel.addEventListener(Event.SOUND_COMPLETE,this.onSoundComplete);
}
}
soundPosition.x = this.object.x;
soundPosition.y = this.object.y;
soundPosition.z = this.object.z;
if(this.volumeFadeSpeed > 0) {
this.actualVolume -= this.volumeFadeSpeed * param1;
if(this.actualVolume <= 0) {
this.volumeFadeSpeed = 0;
this.actualVolume = 0;
}
this.sound.volume = this.actualVolume;
}
this.sound.checkVolume(param2.position,soundPosition,param2.xAxis);
}
public function destroy() : void {
this.removeListenerAndStopSound();
Sound3D.destroy(this.sound);
this.object = null;
this.sound = null;
if(this.listener != null) {
this.listener.onSoundEffectDestroyed(this);
this.listener = null;
}
recycle();
}
public function kill() : void {
this.alive = false;
}
public function set enabled(param1:Boolean) : void {
if(!param1) {
this.removeListenerAndStopSound();
}
}
public function readPosition(param1:Vector3) : void {
param1.x = this.object.x;
param1.y = this.object.y;
param1.z = this.object.z;
}
public function get numSounds() : int {
return this.alive ? 1 : 0;
}
public function fade(param1:int) : void {
this.volumeFadeSpeed = this.actualVolume / param1;
}
private function onSoundComplete(param1:Event) : void {
this.removeListenerAndStopSound();
this.alive = false;
}
private function removeListenerAndStopSound() : void {
if(this.channel != null) {
this.channel.removeEventListener(Event.SOUND_COMPLETE,this.onSoundComplete);
this.channel = null;
}
this.sound.stop();
if(this.loops <= 1) {
this.alive = false;
}
}
}
}
|
package alternativa.tanks.model.garage.availableupgrades {
import projects.tanks.client.panel.model.garage.availableupgrades.AvailableUpgradeItem;
import projects.tanks.client.panel.model.garage.availableupgrades.AvailableUpgradesModelBase;
import projects.tanks.client.panel.model.garage.availableupgrades.IAvailableUpgradesModelBase;
[ModelInfo]
public class AvailableUpgradesModel extends AvailableUpgradesModelBase implements IAvailableUpgradesModelBase {
public function AvailableUpgradesModel() {
super();
}
public function updateAvailableUpgrade(param1:Vector.<AvailableUpgradeItem>) : void {
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Byte;
import alternativa.types.Float;
import projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation.ArtilleryElevatingBarrelCC;
public class CodecArtilleryElevatingBarrelCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_control:ICodec;
private var codec_elevation:ICodec;
public function CodecArtilleryElevatingBarrelCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_control = param1.getCodec(new TypeCodecInfo(Byte,false));
this.codec_elevation = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ArtilleryElevatingBarrelCC = new ArtilleryElevatingBarrelCC();
local2.control = this.codec_control.decode(param1) as int;
local2.elevation = this.codec_elevation.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ArtilleryElevatingBarrelCC = ArtilleryElevatingBarrelCC(param2);
this.codec_control.encode(param1,local3.control);
this.codec_elevation.encode(param1,local3.elevation);
}
}
}
|
package alternativa.tanks.gui.socialnetwork.vk {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.socialnetwork.vk.VkGroupReminderWindow_VkGroupEnteringReminderBitmapDataClass.png")]
public class VkGroupReminderWindow_VkGroupEnteringReminderBitmapDataClass extends BitmapAsset {
public function VkGroupReminderWindow_VkGroupEnteringReminderBitmapDataClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.user.configuration {
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 TankConfigurationModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:TankConfigurationModelServer;
private var client:ITankConfigurationModelBase = ITankConfigurationModelBase(this);
private var modelId:Long = Long.getLong(772311175,935242478);
public function TankConfigurationModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new TankConfigurationModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(TankConfigurationCC,false)));
}
protected function getInitParam() : TankConfigurationCC {
return TankConfigurationCC(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.gui.friends {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.FriendsWindowStateBigButton_ButtonOverLeft.png")]
public class FriendsWindowStateBigButton_ButtonOverLeft extends BitmapAsset {
public function FriendsWindowStateBigButton_ButtonOverLeft() {
super();
}
}
}
|
package alternativa.tanks.gui.payment.forms.paymentstatus {
import base.DiscreteSprite;
public class PaymentStatusForm extends DiscreteSprite {
private static const WIDTH:int = 270;
private var line:PaymentStatusLine;
public function PaymentStatusForm(param1:String) {
super();
this.line = new PaymentStatusLine(param1);
this.line.x = WIDTH - this.line.width >> 1;
addChild(this.line);
}
public function showProgressWorking() : void {
this.line.showProgressWorking();
}
public function showProgressDone() : void {
this.line.showProgressDone();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.premium {
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.tanksservices.model.notifier.premium.IPremiumNotifierModelBase;
import projects.tanks.client.tanksservices.model.notifier.premium.PremiumNotifierModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.premium.PremiumService;
[ModelInfo]
public class PremiumNotifierModel extends PremiumNotifierModelBase implements IPremiumNotifierModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var premiumService:PremiumService;
public function PremiumNotifierModel() {
super();
}
public function updateTimeLeft(param1:int) : void {
premiumService.updateTimeLeft(param1);
}
public function objectLoaded() : void {
premiumService.updateTimeLeft(getInitParam().lifeTimeInSeconds);
}
public function objectUnloaded() : void {
premiumService.destroy();
}
}
}
|
package controls.buttons.h30px {
import controls.buttons.FixedHeightButton;
public class GrayFrameMediumPanel extends FixedHeightButton {
public function GrayFrameMediumPanel() {
super(new GrayFrameMediumLabelSkin());
labelSize = H30ButtonSkin.DEFAULT_LABEL_SIZE;
labelHeight = H30ButtonSkin.DEFAULT_LABEL_HEIGHT;
labelPositionY = H30ButtonSkin.DEFAULT_LABEL_Y;
width = H30ButtonSkin.DEFAULT_BUTTON_WIDTH;
enabled = true;
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.customname {
import alternativa.tanks.gui.shop.shopitems.item.details.ShopItemDetails;
import controls.base.LabelBase;
import forms.ColorConstants;
import platform.client.fp10.core.type.IGameObject;
public class DetailsViewWithDescription extends ShopItemDetails {
private static const WIDTH:int = 250;
public function DetailsViewWithDescription(param1:IGameObject, param2:String) {
super(param1);
this.addDescription(param2);
}
private function addDescription(param1:String) : void {
var local2:LabelBase = null;
local2 = new LabelBase();
local2.multiline = true;
local2.wordWrap = true;
local2.color = ColorConstants.GREEN_TEXT;
local2.htmlText = param1;
local2.mouseWheelEnabled = false;
local2.width = WIDTH;
addChild(local2);
}
}
}
|
package projects.tanks.client.battleservice.model.performance {
public interface IPerformanceModelBase {
}
}
|
package alternativa.tanks.model.item.buyable {
import alternativa.tanks.model.item.category.IItemCategory;
import alternativa.tanks.model.item.discount.IDiscount;
import projects.tanks.client.commons.types.ItemCategoryEnum;
import projects.tanks.client.garage.models.item.buyable.BuyableModelBase;
import projects.tanks.client.garage.models.item.buyable.IBuyableModelBase;
import projects.tanks.client.garage.models.item.droppablegold.IDroppableGoldItemModelBase;
[ModelInfo]
public class BuyableModel extends BuyableModelBase implements IBuyableModelBase, IBuyable {
public function BuyableModel() {
super();
}
public function getPriceWithoutDiscount() : int {
return getInitParam().priceWithoutDiscount;
}
public function getPrice() : int {
if(object.hasModel(IDroppableGoldItemModelBase)) {
return 0;
}
var local1:IDiscount = IDiscount(object.adapt(IDiscount));
return local1.applyDiscount(getInitParam().priceWithoutDiscount);
}
public function isBuyable() : Boolean {
var local1:ItemCategoryEnum = IItemCategory(object.adapt(IItemCategory)).getCategory();
return getInitParam().buyable || local1 == ItemCategoryEnum.CONTAINER;
}
}
}
|
package alternativa.tanks.controller.events.partners {
import flash.events.Event;
public class FinishPartnerRegisterEvent extends Event {
public static const FINISH_REGISTRATION:String = "FinishPartnerRegisterEvent.FINISH_REGISTRATION";
public var uid:String;
public function FinishPartnerRegisterEvent(param1:String) {
super(FINISH_REGISTRATION);
this.uid = param1;
}
override public function clone() : Event {
return new FinishPartnerRegisterEvent(this.uid);
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p21 extends BitmapAsset
{
public function RangIconNormal_p21()
{
super();
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.upgradeable {
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.upgradeable.UpgradeParamsCC;
import projects.tanks.client.garage.models.item.upgradeable.types.UpgradeParamsData;
public class CodecUpgradeParamsCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_currentLevel:ICodec;
private var codec_itemData:ICodec;
private var codec_remainingTimeInMS:ICodec;
private var codec_speedUpDiscount:ICodec;
private var codec_timeDiscount:ICodec;
private var codec_upgradeDiscount:ICodec;
public function CodecUpgradeParamsCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_currentLevel = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_itemData = param1.getCodec(new TypeCodecInfo(UpgradeParamsData,false));
this.codec_remainingTimeInMS = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_speedUpDiscount = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_timeDiscount = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_upgradeDiscount = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:UpgradeParamsCC = new UpgradeParamsCC();
local2.currentLevel = this.codec_currentLevel.decode(param1) as int;
local2.itemData = this.codec_itemData.decode(param1) as UpgradeParamsData;
local2.remainingTimeInMS = this.codec_remainingTimeInMS.decode(param1) as int;
local2.speedUpDiscount = this.codec_speedUpDiscount.decode(param1) as int;
local2.timeDiscount = this.codec_timeDiscount.decode(param1) as int;
local2.upgradeDiscount = this.codec_upgradeDiscount.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:UpgradeParamsCC = UpgradeParamsCC(param2);
this.codec_currentLevel.encode(param1,local3.currentLevel);
this.codec_itemData.encode(param1,local3.itemData);
this.codec_remainingTimeInMS.encode(param1,local3.remainingTimeInMS);
this.codec_speedUpDiscount.encode(param1,local3.speedUpDiscount);
this.codec_timeDiscount.encode(param1,local3.timeDiscount);
this.codec_upgradeDiscount.encode(param1,local3.upgradeDiscount);
}
}
}
|
package alternativa.tanks.models.weapon.gauss {
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.weapon.WeaponForces;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapon.gauss.sfx.GaussShell;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapon.gauss.GaussCC;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class RemoteGaussWeapon extends CommonGaussWeapon implements Weapon {
private var secondaryHitPoint:Vector3 = new Vector3();
public function RemoteGaussWeapon(param1:WeaponObject, param2:GaussCC, param3:WeaponForces) {
super(param1,param2);
this.weaponObject = param1;
this.primaryWeaponForces = param3;
}
override public function init(param1:WeaponPlatform) : void {
super.init(param1);
this.weaponPlatform = param1;
}
public function destroy() : void {
}
public function activate() : void {
}
public function deactivate() : void {
}
public function stun() : void {
}
public function calm(param1:int) : void {
}
public function reset() : void {
effects.reset();
}
public function getStatus() : Number {
return 0;
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.GAUSS_RESISTANCE;
}
public function fullyRecharge() : void {
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
}
public function dummyShot() : void {
weaponPlatform.getAllGunParams(gunParams);
weaponPlatform.getBody().addWorldForceScaled(gunParams.muzzlePosition,gunParams.direction,-primaryWeaponForces.getRecoilForce());
effects.playSoundEffect(sfxData.primaryShotSound,gunParams.muzzlePosition);
}
public function primaryShot(param1:int, param2:Vector3) : void {
weaponPlatform.getAllGunParams(gunParams);
effects.playCommonShotEffect(gunParams.muzzlePosition,param2,primaryWeaponForces);
var local3:GaussShell = getShell();
local3.addToGame(gunParams,param2,weaponPlatform.getBody(),true,param1);
effects.playSoundEffect(sfxData.primaryShotSound,gunParams.muzzlePosition);
}
public function startAiming() : void {
effects.playOpenEffect();
}
public function stopAiming() : void {
effects.playHideEffect();
}
public function secondaryHitTargetCommand(param1:IGameObject, param2:Vector3) : void {
var local3:ITankModel = ITankModel(param1.adapt(ITankModel));
weaponPlatform.getAllGunParams(gunParams);
var local4:Tank = local3.getTank();
this.secondaryHitPoint.copy(param2);
BattleUtils.localToGlobal(local4.getBody(),this.secondaryHitPoint);
var local5:Vector3 = new Vector3().copy(this.secondaryHitPoint).subtract(gunParams.muzzlePosition).normalize();
effects.playCommonShotEffect(gunParams.muzzlePosition,local5,secondaryWeaponForces);
effects.playPowerShotEffect(local4.getBody(),this.secondaryHitPoint);
local4.applyWeaponHit(this.secondaryHitPoint,gunParams.direction,secondaryWeaponForces.getImpactForce());
applySecondarySplashImpact(this.secondaryHitPoint,local4.getBody());
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank02.png")]
public class PremiumRankBitmaps_bitmapSmallRank02 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank02() {
super();
}
}
}
|
package alternativa.tanks.gui.tables {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.tables.KitInfoTable_upgradeSelectionLeftClass.png")]
public class KitInfoTable_upgradeSelectionLeftClass extends BitmapAsset {
public function KitInfoTable_upgradeSelectionLeftClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.properties {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.properties.ItemPropertiesCC;
public class VectorCodecItemPropertiesCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecItemPropertiesCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ItemPropertiesCC,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.<ItemPropertiesCC> = new Vector.<ItemPropertiesCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ItemPropertiesCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ItemPropertiesCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ItemPropertiesCC> = Vector.<ItemPropertiesCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.client.battleservice.model.statistics {
import alternativa.types.Long;
import projects.tanks.client.battleservice.model.createparams.BattleLimits;
public class StatisticsModelCC {
private var _battleName:String;
private var _equipmentConstraintsMode:String;
private var _fund:int;
private var _limits:BattleLimits;
private var _mapName:String;
private var _matchBattle:Boolean;
private var _maxPeopleCount:int;
private var _modeName:String;
private var _parkourMode:Boolean;
private var _running:Boolean;
private var _spectator:Boolean;
private var _suspiciousUserIds:Vector.<Long>;
private var _timeLeft:int;
private var _valuableRound:Boolean;
public function StatisticsModelCC(param1:String = null, param2:String = null, param3:int = 0, param4:BattleLimits = null, param5:String = null, param6:Boolean = false, param7:int = 0, param8:String = null, param9:Boolean = false, param10:Boolean = false, param11:Boolean = false, param12:Vector.<Long> = null, param13:int = 0, param14:Boolean = false) {
super();
this._battleName = param1;
this._equipmentConstraintsMode = param2;
this._fund = param3;
this._limits = param4;
this._mapName = param5;
this._matchBattle = param6;
this._maxPeopleCount = param7;
this._modeName = param8;
this._parkourMode = param9;
this._running = param10;
this._spectator = param11;
this._suspiciousUserIds = param12;
this._timeLeft = param13;
this._valuableRound = param14;
}
public function get battleName() : String {
return this._battleName;
}
public function set battleName(param1:String) : void {
this._battleName = param1;
}
public function get equipmentConstraintsMode() : String {
return this._equipmentConstraintsMode;
}
public function set equipmentConstraintsMode(param1:String) : void {
this._equipmentConstraintsMode = param1;
}
public function get fund() : int {
return this._fund;
}
public function set fund(param1:int) : void {
this._fund = param1;
}
public function get limits() : BattleLimits {
return this._limits;
}
public function set limits(param1:BattleLimits) : void {
this._limits = param1;
}
public function get mapName() : String {
return this._mapName;
}
public function set mapName(param1:String) : void {
this._mapName = param1;
}
public function get matchBattle() : Boolean {
return this._matchBattle;
}
public function set matchBattle(param1:Boolean) : void {
this._matchBattle = param1;
}
public function get maxPeopleCount() : int {
return this._maxPeopleCount;
}
public function set maxPeopleCount(param1:int) : void {
this._maxPeopleCount = param1;
}
public function get modeName() : String {
return this._modeName;
}
public function set modeName(param1:String) : void {
this._modeName = param1;
}
public function get parkourMode() : Boolean {
return this._parkourMode;
}
public function set parkourMode(param1:Boolean) : void {
this._parkourMode = param1;
}
public function get running() : Boolean {
return this._running;
}
public function set running(param1:Boolean) : void {
this._running = param1;
}
public function get spectator() : Boolean {
return this._spectator;
}
public function set spectator(param1:Boolean) : void {
this._spectator = param1;
}
public function get suspiciousUserIds() : Vector.<Long> {
return this._suspiciousUserIds;
}
public function set suspiciousUserIds(param1:Vector.<Long>) : void {
this._suspiciousUserIds = param1;
}
public function get timeLeft() : int {
return this._timeLeft;
}
public function set timeLeft(param1:int) : void {
this._timeLeft = param1;
}
public function get valuableRound() : Boolean {
return this._valuableRound;
}
public function set valuableRound(param1:Boolean) : void {
this._valuableRound = param1;
}
public function toString() : String {
var local1:String = "StatisticsModelCC [";
local1 += "battleName = " + this.battleName + " ";
local1 += "equipmentConstraintsMode = " + this.equipmentConstraintsMode + " ";
local1 += "fund = " + this.fund + " ";
local1 += "limits = " + this.limits + " ";
local1 += "mapName = " + this.mapName + " ";
local1 += "matchBattle = " + this.matchBattle + " ";
local1 += "maxPeopleCount = " + this.maxPeopleCount + " ";
local1 += "modeName = " + this.modeName + " ";
local1 += "parkourMode = " + this.parkourMode + " ";
local1 += "running = " + this.running + " ";
local1 += "spectator = " + this.spectator + " ";
local1 += "suspiciousUserIds = " + this.suspiciousUserIds + " ";
local1 += "timeLeft = " + this.timeLeft + " ";
local1 += "valuableRound = " + this.valuableRound + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.service.socialnetwork {
import flash.events.Event;
public class SocialNetworkServiceEvent extends Event {
public static const CREATE_LINK:String = "SocialNetworkServiceEvent.CREATE_LINK";
public static const UNLINK:String = "SocialNetworkServiceEvent.UNLINK";
public static const LINK_SUCCESS:String = "SocialNetworkServiceEvent.LINK_SUCCESS";
public static const UNLINK_SUCCESS:String = "SocialNetworkServiceEvent.UNLINK_SUCCESS";
public var socialNetworkId:String;
public function SocialNetworkServiceEvent(param1:String, param2:String) {
this.socialNetworkId = param2;
super(param1);
}
}
}
|
package alternativa.init {
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.tanks.model.matchmaking.invitewindow.InviteWindowService;
import alternativa.tanks.model.matchmaking.invitewindow.InviteWindowServiceImpl;
import alternativa.tanks.service.battle.BattleUserInfoService;
import alternativa.tanks.service.battle.IBattleUserInfoService;
import alternativa.tanks.service.battlecreate.BattleCreateFormService;
import alternativa.tanks.service.battlecreate.IBattleCreateFormService;
import alternativa.tanks.service.battleinfo.BattleInfoFormService;
import alternativa.tanks.service.battleinfo.IBattleInfoFormService;
import alternativa.tanks.service.battlelist.BattleListFormService;
import alternativa.tanks.service.battlelist.IBattleListFormService;
import alternativa.tanks.service.matchmaking.MatchmakingFormService;
import alternativa.tanks.service.matchmaking.MatchmakingFormServiceImpl;
import alternativa.tanks.service.matchmaking.MatchmakingGroupFormService;
import alternativa.tanks.service.matchmaking.MatchmakingGroupInviteService;
public class BattleSelectModelActivator implements IBundleActivator {
public function BattleSelectModelActivator() {
super();
}
public function start(param1:OSGi) : void {
param1.registerService(IBattleCreateFormService,new BattleCreateFormService());
param1.registerService(IBattleListFormService,new BattleListFormService());
param1.registerService(IBattleInfoFormService,new BattleInfoFormService());
param1.registerService(IBattleUserInfoService,new BattleUserInfoService());
var local2:MatchmakingFormServiceImpl = new MatchmakingFormServiceImpl();
param1.registerService(MatchmakingFormService,local2);
param1.registerService(MatchmakingGroupFormService,local2);
param1.registerService(MatchmakingGroupInviteService,local2);
param1.registerService(InviteWindowService,new InviteWindowServiceImpl());
}
public function stop(param1:OSGi) : void {
}
}
}
|
package projects.tanks.clients.flash.commons.models.challenge.shopitems {
import platform.client.fp10.core.type.IGameObject;
public class ChallengeShopItemsServiceImpl implements ChallengeShopItems {
private var _battlePass:IGameObject;
private var _starsBundle:IGameObject;
public function ChallengeShopItemsServiceImpl() {
super();
}
public function get battlePass() : IGameObject {
return this._battlePass;
}
public function set battlePass(param1:IGameObject) : void {
this._battlePass = param1;
}
public function get starsBundle() : IGameObject {
return this._starsBundle;
}
public function set starsBundle(param1:IGameObject) : void {
this._starsBundle = param1;
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.promo {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.shop.shopitems.item.promo.ShopPromoCodeButton_promoCodePreviewClass.png")]
public class ShopPromoCodeButton_promoCodePreviewClass extends BitmapAsset {
public function ShopPromoCodeButton_promoCodePreviewClass() {
super();
}
}
}
|
package alternativa.tanks.servermodels.login {
[ModelInterface]
public interface ILogin {
function login(param1:String, param2:String, param3:Boolean) : void;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.