code stringlengths 57 237k |
|---|
package utils.tweener.core {
public class SimpleTimeline extends TweenCore {
protected var _firstChild:TweenCore;
protected var _lastChild:TweenCore;
public var autoRemoveChildren:Boolean;
public function SimpleTimeline(param1:Object = null) {
super(0,param1);
}
public function insert(param1:TweenCore, param2:* = 0) : TweenCore {
var local3:SimpleTimeline = param1.timeline;
if(!param1.cachedOrphan && Boolean(local3)) {
local3.remove(param1,true);
}
param1.timeline = this;
param1.cachedStartTime = Number(param2) + param1.delay;
if(param1.gc) {
param1.setEnabled(true,true);
}
if(param1.cachedPaused && local3 != this) {
param1.cachedPauseTime = param1.cachedStartTime + (this.rawTime - param1.cachedStartTime) / param1.cachedTimeScale;
}
if(Boolean(this._lastChild)) {
this._lastChild.nextNode = param1;
} else {
this._firstChild = param1;
}
param1.prevNode = this._lastChild;
this._lastChild = param1;
param1.nextNode = null;
param1.cachedOrphan = false;
return param1;
}
public function remove(param1:TweenCore, param2:Boolean = false) : void {
if(param1.cachedOrphan) {
return;
}
if(!param2) {
param1.setEnabled(false,true);
}
if(Boolean(param1.nextNode)) {
param1.nextNode.prevNode = param1.prevNode;
} else if(this._lastChild == param1) {
this._lastChild = param1.prevNode;
}
if(Boolean(param1.prevNode)) {
param1.prevNode.nextNode = param1.nextNode;
} else if(this._firstChild == param1) {
this._firstChild = param1.nextNode;
}
param1.cachedOrphan = true;
}
override public function renderTime(param1:Number, param2:Boolean = false, param3:Boolean = false) : void {
var local5:Number = NaN;
var local6:TweenCore = null;
var local4:TweenCore = this._firstChild;
this.cachedTotalTime = param1;
this.cachedTime = param1;
while(Boolean(local4)) {
local6 = local4.nextNode;
if(local4.active || param1 >= local4.cachedStartTime && !local4.cachedPaused && !local4.gc) {
if(!local4.cachedReversed) {
local4.renderTime((param1 - local4.cachedStartTime) * local4.cachedTimeScale,param2,false);
} else {
local5 = local4.cacheIsDirty ? local4.totalDuration : local4.cachedTotalDuration;
local4.renderTime(local5 - (param1 - local4.cachedStartTime) * local4.cachedTimeScale,param2,false);
}
}
local4 = local6;
}
}
public function get rawTime() : Number {
return this.cachedTotalTime;
}
}
}
|
package alternativa.tanks.model.quest.challenge.stars {
import flash.events.Event;
public class StarsChangedEvent extends Event {
public static const STARS_CHANGED:String = "StarsChangedEvent.STARS_CHANGED";
public function StarsChangedEvent() {
super(STARS_CHANGED);
}
}
}
|
package projects.tanks.clients.flash.resources.resource.loaders {
import mx.core.ByteArrayAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.flash.resources.resource.loaders.BatchTextureLoader_redSquareClass.bin", mimeType="application/octet-stream")]
public class BatchTextureLoader_redSquareClass extends ByteArrayAsset {
public function BatchTextureLoader_redSquareClass() {
super();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.utils {
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class PieceWordDeclensionUtil {
[Inject]
public static var localeService:ILocaleService;
private static const NOMINATIVE_ONE_DECLENSION:String = "NominativeOneDeclension";
private static const NOMINATIVE_MANY_DECLENSION:String = "NominativeManyDeclension";
private static const GENITIVE_MANY_DECLENSION:String = "GenitiveManyDeclension";
public function PieceWordDeclensionUtil() {
super();
}
public static function getLocalizedDeclension(param1:int) : String {
var local2:String = param1 + " ";
if(localeService.language == "ru") {
switch(determineRussianWordFormType(param1)) {
case NOMINATIVE_ONE_DECLENSION:
local2 += localeService.getText(TanksLocale.TEXT_PIECE_1);
break;
case NOMINATIVE_MANY_DECLENSION:
local2 += localeService.getText(TanksLocale.TEXT_PIECE_2);
break;
case GENITIVE_MANY_DECLENSION:
local2 += localeService.getText(TanksLocale.TEXT_PIECE_3);
}
} else {
local2 += param1 == 1 ? localeService.getText(TanksLocale.TEXT_PIECE_1) : localeService.getText(TanksLocale.TEXT_PIECE_2);
}
return local2;
}
private static function determineRussianWordFormType(param1:int) : String {
var local3:int = 0;
var local2:String = NOMINATIVE_ONE_DECLENSION;
if(param1 % 100 >= 10 && param1 % 100 <= 20) {
local2 = GENITIVE_MANY_DECLENSION;
} else {
local3 = param1 % 10;
if(local3 == 1) {
local2 = NOMINATIVE_ONE_DECLENSION;
} else if(local3 >= 2 && local3 <= 4) {
local2 = NOMINATIVE_MANY_DECLENSION;
} else {
local2 = GENITIVE_MANY_DECLENSION;
}
}
return local2;
}
}
}
|
package {
import controls.panel.BaseButton;
[Embed(source="/_assets/assets.swf", symbol="symbol1335")]
public dynamic class MainPanelBuyXPButton extends BaseButton {
public function MainPanelBuyXPButton() {
super();
}
}
}
|
package scpacker.gui.combo
{
import assets.windowinner.bitmaps.WindowInnerBottom;
import assets.windowinner.bitmaps.WindowInnerLeft;
import assets.windowinner.bitmaps.WindowInnerRight;
import assets.windowinner.bitmaps.WindowInnerTop;
import assets.windowinner.elemets.WindowInnerBottomLeftCorner;
import assets.windowinner.elemets.WindowInnerBottomRightCorner;
import assets.windowinner.elemets.WindowInnerTopLeftCorner;
import assets.windowinner.elemets.WindowInnerTopRightCorner;
import flash.display.BitmapData;
import flash.display.Graphics;
import flash.display.Shape;
import flash.display.Sprite;
public class DPLBackground extends Sprite
{
[Embed(source="1123.png")]
private static const b:Class;
private var bgBMP:BitmapData;
private var _width:int = 0;
private var _height:int = 0;
private var tl:WindowInnerTopLeftCorner;
private var tr:WindowInnerTopRightCorner;
private var bl:WindowInnerBottomLeftCorner;
private var br:WindowInnerBottomRightCorner;
private var topBMP:WindowInnerTop;
private var bottomBMP:WindowInnerBottom;
private var leftBMP:WindowInnerLeft;
private var rightBMP:WindowInnerRight;
private var bg:Sprite;
private var top:Shape;
private var bottom:Shape;
private var left:Shape;
private var right:Shape;
public function DPLBackground(param1:int, param2:int)
{
this.bgBMP = new b().bitmapData;
this.tl = new WindowInnerTopLeftCorner();
this.tr = new WindowInnerTopRightCorner();
this.bl = new WindowInnerBottomLeftCorner();
this.br = new WindowInnerBottomRightCorner();
this.topBMP = new WindowInnerTop(0,0);
this.bottomBMP = new WindowInnerBottom(0,0);
this.leftBMP = new WindowInnerLeft(0,0);
this.rightBMP = new WindowInnerRight(0,0);
this.bg = new Sprite();
this.top = new Shape();
this.bottom = new Shape();
this.left = new Shape();
this.right = new Shape();
super();
this._width = param1;
this._height = param2;
addChild(this.bg);
addChild(this.top);
addChild(this.bottom);
addChild(this.left);
addChild(this.right);
addChild(this.tl);
addChild(this.tr);
addChild(this.bl);
addChild(this.br);
this.draw();
}
protected function draw() : void
{
var _loc1_:Graphics = null;
_loc1_ = this.bg.graphics;
_loc1_.clear();
_loc1_.beginBitmapFill(this.bgBMP);
_loc1_.drawRect(1,1,this._width - 2,this._height - 2);
_loc1_.endFill();
_loc1_ = this.top.graphics;
_loc1_.clear();
_loc1_.beginBitmapFill(this.topBMP);
_loc1_.drawRect(0,0,this._width - 12,6);
_loc1_.endFill();
this.top.x = 6;
_loc1_ = this.bottom.graphics;
_loc1_.clear();
_loc1_.beginBitmapFill(this.bottomBMP);
_loc1_.drawRect(0,0,this._width - 12,6);
_loc1_.endFill();
this.bottom.x = 6;
this.bottom.y = this._height - 6;
_loc1_ = this.left.graphics;
_loc1_.clear();
_loc1_.beginBitmapFill(this.leftBMP);
_loc1_.drawRect(0,0,6,this._height - 12);
_loc1_.endFill();
this.left.x = 0;
this.left.y = 6;
_loc1_ = this.right.graphics;
_loc1_.clear();
_loc1_.beginBitmapFill(this.rightBMP);
_loc1_.drawRect(0,0,6,this._height - 12);
_loc1_.endFill();
this.right.x = this._width - 6;
this.right.y = 6;
this.tl.x = 0;
this.tl.y = 0;
this.tr.x = this._width - this.tr.width;
this.tr.y = 0;
this.bl.x = 0;
this.bl.y = this._height - this.bl.height;
this.br.x = this._width - this.br.width;
this.br.y = this._height - this.br.height;
}
override public function set width(param1:Number) : void
{
if(this._width == int(param1))
{
return;
}
this._width = param1;
this.draw();
}
override public function get width() : Number
{
return this._width;
}
override public function set height(param1:Number) : void
{
if(this._height == int(param1))
{
return;
}
this._height = param1;
this.draw();
}
override public function get height() : Number
{
return this._height;
}
public function setSize(param1:int, param2:int) : void
{
this._width = param1;
this._height = param2;
this.draw();
}
}
}
|
package alternativa.gfx.agal {
public class SamplerDim extends SamplerOption {
private static const SAMPLER_TEXTURE_TYPE_SHIFT:int = 12;
public static const D2:SamplerDim = new SamplerDim(0);
public static const CUBE:SamplerDim = new SamplerDim(1);
public static const D3:SamplerDim = new SamplerDim(2);
public function SamplerDim(param1:uint) {
super(param1,SAMPLER_TEXTURE_TYPE_SHIFT);
}
}
}
|
package alternativa.tanks.gui.settings.controls {
import flash.display.DisplayObject;
public class GridLayout {
private var topX:int;
private var topY:int;
private var columnWidth:int;
private var rowHeight:int;
private var rowMargin:int;
public function GridLayout(param1:int, param2:int, param3:int, param4:int) {
super();
this.topX = param1;
this.topY = param2;
this.columnWidth = param3;
this.rowHeight = param4;
}
public function layout(param1:Array) : int {
var local2:int = 0;
var local4:Array = null;
var local5:int = 0;
var local6:DisplayObject = null;
var local3:int = 0;
while(local3 < param1.length) {
local4 = param1[local3];
local5 = 0;
while(local5 < local4.length) {
if(local4[local5] != null) {
local6 = local4[local5];
local6.x = this.topX + local5 * this.columnWidth;
local6.y = this.topY + local3 * this.rowHeight + this.rowMargin * local3;
local2 = local6.y + local6.height;
}
local5++;
}
local3++;
}
return local2;
}
public function getRowMargin() : int {
return this.rowMargin;
}
public function setRowMargin(param1:int) : void {
this.rowMargin = param1;
}
}
}
|
package alternativa.tanks.sfx
{
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class StaticObject3DPositionProvider extends PooledObject implements Object3DPositionProvider
{
private static const toCamera:Vector3 = new Vector3();
private var position:Vector3;
private var offsetToCamera:Number;
public function StaticObject3DPositionProvider(param1:ObjectPool)
{
this.position = new Vector3();
super(param1);
}
public function init(param1:Vector3, param2:Number) : void
{
this.position.copyFrom(param1);
this.offsetToCamera = param2;
}
public function initPosition(param1:Object3D) : void
{
param1.x = this.position.x;
param1.y = this.position.y;
param1.z = this.position.z;
}
public function updateObjectPosition(param1:Object3D, param2:GameCamera, param3:int) : void
{
toCamera.x = param2.x - this.position.x;
toCamera.y = param2.y - this.position.y;
toCamera.z = param2.z - this.position.z;
toCamera.vNormalize();
param1.x = this.position.x + this.offsetToCamera * toCamera.x;
param1.y = this.position.y + this.offsetToCamera * toCamera.y;
param1.z = this.position.z + this.offsetToCamera * toCamera.z;
}
public function destroy() : void
{
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.partners.steam {
import flash.utils.ByteArray;
import flash.utils.getDefinitionByName;
public class SteamWorks {
private var instance:Object;
public function SteamWorks() {
super();
var local1:Class = getDefinitionByName("com.amanitadesign.steam.FRESteamWorks") as Class;
this.instance = new local1();
}
public function addEventListener(param1:String, param2:Function) : void {
this.instance.addEventListener(param1,param2);
}
public function removeEventListener(param1:String, param2:Function) : void {
this.instance.removeEventListener(param1,param2);
}
public function init() : Boolean {
return this.instance.init();
}
public function getAuthSessionTicket(param1:ByteArray) : uint {
return this.instance.getAuthSessionTicket(param1);
}
public function getAppID() : int {
return this.instance.getAppID();
}
public function getUserID() : String {
return this.instance.getUserID();
}
public function getCurrentGameLanguage() : String {
return this.instance.getCurrentGameLanguage();
}
public function microTxnResult() : Object {
return this.instance.microTxnResult();
}
}
}
|
package alternativa.tanks.models.weapon.streamweapon {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class StreamWeaponReconfiguredListenerEvents implements StreamWeaponReconfiguredListener {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function StreamWeaponReconfiguredListenerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function streamWeaponReconfigured(param1:IGameObject, param2:Number) : void {
var i:int = 0;
var m:StreamWeaponReconfiguredListener = null;
var user:IGameObject = param1;
var dischargeRate:Number = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = StreamWeaponReconfiguredListener(this.impl[i]);
m.streamWeaponReconfigured(user,dischargeRate);
i++;
}
}
finally {
Model.popObject();
}
}
public function streamWeaponDistanceChanged(param1:IGameObject, param2:Number) : void {
var i:int = 0;
var m:StreamWeaponReconfiguredListener = null;
var user:IGameObject = param1;
var newDistance:Number = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = StreamWeaponReconfiguredListener(this.impl[i]);
m.streamWeaponDistanceChanged(user,newDistance);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.weapon
{
import alternativa.object.ClientObject;
public interface IWeapon
{
function ownerLoaded(param1:ClientObject) : void;
function ownerUnloaded(param1:ClientObject) : void;
function ownerDisabled(param1:ClientObject) : void;
function update(param1:int, param2:int) : Number;
function reset() : void;
function enable() : void;
function disable() : void;
function stop() : void;
function getTurretRotationAccel(param1:ClientObject) : Number;
function getTurretRotationSpeed(param1:ClientObject) : Number;
function getWeaponController() : IWeaponController;
}
}
|
package projects.tanks.client.battlefield.models.user.temperature {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class TankTemperatureModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:TankTemperatureModelServer;
private var client:ITankTemperatureModelBase = ITankTemperatureModelBase(this);
private var modelId:Long = Long.getLong(1044732133,1674200214);
private var _setTemperatureId:Long = Long.getLong(2076898112,-371208995);
private var _setTemperature_valueCodec:ICodec;
public function TankTemperatureModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new TankTemperatureModelServer(IModel(this));
this._setTemperature_valueCodec = this._protocol.getCodec(new TypeCodecInfo(Float,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._setTemperatureId:
this.client.setTemperature(Number(this._setTemperature_valueCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.tank {
import platform.client.fp10.core.type.IGameObject;
public class TankSet {
private var _hull:IGameObject;
private var _turret:IGameObject;
private var _drone:IGameObject;
private var _maxHealth:int;
public function TankSet(param1:IGameObject, param2:IGameObject, param3:IGameObject, param4:int) {
super();
this._hull = param1;
this._turret = param2;
this._maxHealth = param4;
this._drone = param3;
}
public function get hull() : IGameObject {
return this._hull;
}
public function get turret() : IGameObject {
return this._turret;
}
public function get drone() : IGameObject {
return this._drone;
}
public function get maxHealth() : int {
return this._maxHealth;
}
public function eq(param1:TankSet) : Boolean {
return this._hull == param1._hull && this._turret == param1._turret && this._drone == param1._drone;
}
public function eqParts(param1:IGameObject, param2:IGameObject, param3:IGameObject) : Boolean {
return this._hull == param1 && this._turret == param2 && this._drone == param3;
}
public function toString() : String {
return "TankSet{_hull=" + String(this._hull) + ",_turret=" + String(this._turret) + ",_drone=" + String(this._drone) + ",_maxHealth=" + String(this._maxHealth) + "}";
}
}
}
|
package controls {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.TankWindowInner_leftClass.png")]
public class TankWindowInner_leftClass extends BitmapAsset {
public function TankWindowInner_leftClass() {
super();
}
}
}
|
package alternativa.engine3d.loaders.collada {
import alternativa.engine3d.animation.keys.NumberTrack;
import alternativa.engine3d.animation.keys.Track;
import alternativa.engine3d.animation.keys.TransformTrack;
import flash.geom.Matrix3D;
use namespace collada;
public class DaeSampler extends DaeElement {
private var times:Vector.<Number>;
private var values:Vector.<Number>;
private var timesStride:int;
private var valuesStride:int;
public function DaeSampler(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
override protected function parseImplementation() : Boolean {
var local2:DaeSource = null;
var local3:DaeSource = null;
var local6:DaeInput = null;
var local7:String = null;
var local1:XMLList = data.input;
var local4:int = 0;
var local5:int = int(local1.length());
for(; local4 < local5; local4++) {
local6 = new DaeInput(local1[local4],document);
local7 = local6.semantic;
if(local7 == null) {
continue;
}
switch(local7) {
case "INPUT":
local2 = local6.prepareSource(1);
if(local2 != null) {
this.times = local2.numbers;
this.timesStride = local2.stride;
}
break;
case "OUTPUT":
local3 = local6.prepareSource(1);
if(local3 != null) {
this.values = local3.numbers;
this.valuesStride = local3.stride;
}
break;
}
}
return true;
}
public function parseNumbersTrack(param1:String, param2:String) : NumberTrack {
var local3:NumberTrack = null;
var local4:int = 0;
var local5:int = 0;
if(this.times != null && this.values != null && this.timesStride > 0) {
local3 = new NumberTrack(param1,param2);
local4 = this.times.length / this.timesStride;
local5 = 0;
while(local5 < local4) {
local3.addKey(this.times[int(this.timesStride * local5)],this.values[int(this.valuesStride * local5)]);
local5++;
}
return local3;
}
return null;
}
public function parseTransformationTrack(param1:String) : Track {
var local2:TransformTrack = null;
var local3:int = 0;
var local4:int = 0;
var local5:int = 0;
var local6:Matrix3D = null;
if(this.times != null && this.values != null && this.timesStride != 0) {
local2 = new TransformTrack(param1);
local3 = this.times.length / this.timesStride;
local4 = 0;
while(local4 < local3) {
local5 = this.valuesStride * local4;
local6 = new Matrix3D(Vector.<Number>([this.values[local5],this.values[local5 + 4],this.values[local5 + 8],this.values[local5 + 12],this.values[local5 + 1],this.values[local5 + 5],this.values[local5 + 9],this.values[local5 + 13],this.values[local5 + 2],this.values[local5 + 6],this.values[local5 + 10],this.values[local5 + 14],this.values[local5 + 3],this.values[local5 + 7],this.values[local5 + 11],this.values[local5 + 15]]));
local2.addKey(this.times[local4 * this.timesStride],local6);
local4++;
}
return local2;
}
return null;
}
public function parsePointsTracks(param1:String, param2:String, param3:String, param4:String) : Vector.<Track> {
var local5:NumberTrack = null;
var local6:NumberTrack = null;
var local7:NumberTrack = null;
var local8:int = 0;
var local9:int = 0;
var local10:int = 0;
var local11:Number = NaN;
if(this.times != null && this.values != null && this.timesStride != 0) {
local5 = new NumberTrack(param1,param2);
local5.object = param1;
local6 = new NumberTrack(param1,param3);
local6.object = param1;
local7 = new NumberTrack(param1,param4);
local7.object = param1;
local8 = this.times.length / this.timesStride;
local9 = 0;
while(local9 < local8) {
local10 = local9 * this.valuesStride;
local11 = this.times[local9 * this.timesStride];
local5.addKey(local11,this.values[local10]);
local6.addKey(local11,this.values[local10 + 1]);
local7.addKey(local11,this.values[local10 + 2]);
local9++;
}
return Vector.<Track>([local5,local6,local7]);
}
return null;
}
}
}
|
package alternativa.tanks.gui.friends.list.renderer.background {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.list.renderer.background.UserOfflineCellSelected_centerIconClass.png")]
public class UserOfflineCellSelected_centerIconClass extends BitmapAsset {
public function UserOfflineCellSelected_centerIconClass() {
super();
}
}
}
|
package projects.tanks.client.chat.models {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class CommunicationPanelModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:CommunicationPanelModelServer;
private var client:ICommunicationPanelModelBase = ICommunicationPanelModelBase(this);
private var modelId:Long = Long.getLong(849948908,-833351099);
public function CommunicationPanelModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new CommunicationPanelModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.map.mapinfo {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.BattleMode;
import projects.tanks.client.battleservice.model.map.params.MapTheme;
public class IMapInfoAdapt implements IMapInfo {
private var object:IGameObject;
private var impl:IMapInfo;
public function IMapInfoAdapt(param1:IGameObject, param2:IMapInfo) {
super();
this.object = param1;
this.impl = param2;
}
public function getName() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getName();
}
finally {
Model.popObject();
}
return result;
}
public function getMapId() : Long {
var result:Long = null;
try {
Model.object = this.object;
result = this.impl.getMapId();
}
finally {
Model.popObject();
}
return result;
}
public function getMaxPeople() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getMaxPeople());
}
finally {
Model.popObject();
}
return result;
}
public function getMaxRank() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getMaxRank());
}
finally {
Model.popObject();
}
return result;
}
public function getMinRank() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getMinRank());
}
finally {
Model.popObject();
}
return result;
}
public function getThemeName() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getThemeName();
}
finally {
Model.popObject();
}
return result;
}
public function getTheme() : MapTheme {
var result:MapTheme = null;
try {
Model.object = this.object;
result = this.impl.getTheme();
}
finally {
Model.popObject();
}
return result;
}
public function getDefaultTheme() : MapTheme {
var result:MapTheme = null;
try {
Model.object = this.object;
result = this.impl.getDefaultTheme();
}
finally {
Model.popObject();
}
return result;
}
public function getSupportedBattleModes() : Vector.<BattleMode> {
var result:Vector.<BattleMode> = null;
try {
Model.object = this.object;
result = this.impl.getSupportedBattleModes();
}
finally {
Model.popObject();
}
return result;
}
public function isEnabled() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.isEnabled());
}
finally {
Model.popObject();
}
return result;
}
public function hasMatchmakingMark() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.hasMatchmakingMark());
}
finally {
Model.popObject();
}
return result;
}
public function getPreviewResource() : ImageResource {
var result:ImageResource = null;
try {
Model.object = this.object;
result = this.impl.getPreviewResource();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.weapon.shaft.sfx
{
import alternativa.engine3d.materials.Material;
import alternativa.tanks.engine3d.TextureAnimation;
import flash.media.Sound;
public class ShaftSFXData
{
public var zoomModeSound:Sound;
public var targetingSound:Sound;
public var shotSound:Sound;
public var explosionSound:Sound;
public var trailMaterial:Material;
public var trailLength:Number = 500;
public var explosionAnimation:TextureAnimation;
public var muzzleFlashAnimation:TextureAnimation;
public function ShaftSFXData()
{
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.types.TankState;
public class VectorCodecTankStateLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTankStateLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TankState,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.<TankState> = new Vector.<TankState>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TankState(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TankState = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TankState> = Vector.<TankState>(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.engine3d.controllers {
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import flash.display.InteractiveObject;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.geom.Matrix3D;
import flash.geom.Point;
import flash.geom.Vector3D;
import flash.ui.Keyboard;
import flash.utils.getTimer;
public class SimpleObjectController {
public static const ACTION_FORWARD:String = "ACTION_FORWARD";
public static const ACTION_BACK:String = "ACTION_BACK";
public static const ACTION_LEFT:String = "ACTION_LEFT";
public static const ACTION_RIGHT:String = "ACTION_RIGHT";
public static const ACTION_UP:String = "ACTION_UP";
public static const ACTION_DOWN:String = "ACTION_DOWN";
public static const ACTION_PITCH_UP:String = "ACTION_PITCH_UP";
public static const ACTION_PITCH_DOWN:String = "ACTION_PITCH_DOWN";
public static const ACTION_YAW_LEFT:String = "ACTION_YAW_LEFT";
public static const ACTION_YAW_RIGHT:String = "ACTION_YAW_RIGHT";
public static const ACTION_ACCELERATE:String = "ACTION_ACCELERATE";
public static const ACTION_MOUSE_LOOK:String = "ACTION_MOUSE_LOOK";
public var speed:Number;
public var speedMultiplier:Number;
public var mouseSensitivity:Number;
public var maxPitch:Number = 1e+22;
public var minPitch:Number = -1e+22;
private var eventSource:InteractiveObject;
private var _object:Object3D;
private var _up:Boolean;
private var _down:Boolean;
private var _forward:Boolean;
private var _back:Boolean;
private var _left:Boolean;
private var _right:Boolean;
private var _accelerate:Boolean;
private var displacement:Vector3D = new Vector3D();
private var mousePoint:Point = new Point();
private var mouseLook:Boolean;
private var objectTransform:Vector.<Vector3D>;
private var time:int;
private var actionBindings:Object = {};
protected var keyBindings:Object = {};
private var _vin:Vector.<Number> = new Vector.<Number>(3);
private var _vout:Vector.<Number> = new Vector.<Number>(3);
public function SimpleObjectController(param1:InteractiveObject, param2:Object3D, param3:Number, param4:Number = 3, param5:Number = 1) {
super();
this.eventSource = param1;
this.object = param2;
this.speed = param3;
this.speedMultiplier = param4;
this.mouseSensitivity = param5;
this.actionBindings[ACTION_FORWARD] = this.moveForward;
this.actionBindings[ACTION_BACK] = this.moveBack;
this.actionBindings[ACTION_LEFT] = this.moveLeft;
this.actionBindings[ACTION_RIGHT] = this.moveRight;
this.actionBindings[ACTION_UP] = this.moveUp;
this.actionBindings[ACTION_DOWN] = this.moveDown;
this.actionBindings[ACTION_ACCELERATE] = this.accelerate;
this.setDefaultBindings();
this.enable();
}
public function enable() : void {
this.eventSource.addEventListener(KeyboardEvent.KEY_DOWN,this.onKey);
this.eventSource.addEventListener(KeyboardEvent.KEY_UP,this.onKey);
this.eventSource.addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
this.eventSource.addEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
}
public function disable() : void {
this.eventSource.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKey);
this.eventSource.removeEventListener(KeyboardEvent.KEY_UP,this.onKey);
this.eventSource.removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
this.eventSource.removeEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
this.stopMouseLook();
}
private function onMouseDown(param1:MouseEvent) : void {
this.startMouseLook();
}
private function onMouseUp(param1:MouseEvent) : void {
this.stopMouseLook();
}
public function startMouseLook() : void {
this.mousePoint.x = this.eventSource.mouseX;
this.mousePoint.y = this.eventSource.mouseY;
this.mouseLook = true;
}
public function stopMouseLook() : void {
this.mouseLook = false;
}
private function onKey(param1:KeyboardEvent) : void {
var local2:Function = this.keyBindings[param1.keyCode];
if(local2 != null) {
local2.call(this,param1.type == KeyboardEvent.KEY_DOWN);
}
}
public function get object() : Object3D {
return this._object;
}
public function set object(param1:Object3D) : void {
this._object = param1;
this.updateObjectTransform();
}
public function updateObjectTransform() : void {
if(this._object != null) {
this.objectTransform = this._object.matrix.decompose();
}
}
public function update() : void {
var local3:Number = NaN;
var local4:Number = NaN;
var local5:Vector3D = null;
var local6:Number = NaN;
var local7:Matrix3D = null;
if(this._object == null) {
return;
}
var local1:Number = this.time;
this.time = getTimer();
local1 = 0.001 * (this.time - local1);
if(local1 > 0.1) {
local1 = 0.1;
}
var local2:Boolean = false;
if(this.mouseLook) {
local3 = this.eventSource.mouseX - this.mousePoint.x;
local4 = this.eventSource.mouseY - this.mousePoint.y;
this.mousePoint.x = this.eventSource.mouseX;
this.mousePoint.y = this.eventSource.mouseY;
local5 = this.objectTransform[1];
local5.x -= local4 * Math.PI / 180 * this.mouseSensitivity;
if(local5.x > this.maxPitch) {
local5.x = this.maxPitch;
}
if(local5.x < this.minPitch) {
local5.x = this.minPitch;
}
local5.z -= local3 * Math.PI / 180 * this.mouseSensitivity;
local2 = true;
}
this.displacement.x = this._right ? 1 : (this._left ? -1 : 0);
this.displacement.y = this._forward ? 1 : (this._back ? -1 : 0);
this.displacement.z = this._up ? 1 : (this._down ? -1 : 0);
if(this.displacement.lengthSquared > 0) {
if(this._object is Camera3D) {
local6 = this.displacement.z;
this.displacement.z = this.displacement.y;
this.displacement.y = -local6;
}
this.deltaTransformVector(this.displacement);
if(this._accelerate) {
this.displacement.scaleBy(this.speedMultiplier * this.speed * local1 / this.displacement.length);
} else {
this.displacement.scaleBy(this.speed * local1 / this.displacement.length);
}
(this.objectTransform[0] as Vector3D).incrementBy(this.displacement);
local2 = true;
}
if(local2) {
local7 = new Matrix3D();
local7.recompose(this.objectTransform);
this._object.matrix = local7;
}
}
public function setObjectPos(param1:Vector3D) : void {
var local2:Vector3D = null;
if(this._object != null) {
local2 = this.objectTransform[0];
local2.x = param1.x;
local2.y = param1.y;
local2.z = param1.z;
}
}
public function setObjectPosXYZ(param1:Number, param2:Number, param3:Number) : void {
var local4:Vector3D = null;
if(this._object != null) {
local4 = this.objectTransform[0];
local4.x = param1;
local4.y = param2;
local4.z = param3;
}
}
public function lookAt(param1:Vector3D) : void {
this.lookAtXYZ(param1.x,param1.y,param1.z);
}
public function lookAtXYZ(param1:Number, param2:Number, param3:Number) : void {
if(this._object == null) {
return;
}
var local4:Vector3D = this.objectTransform[0];
var local5:Number = param1 - local4.x;
var local6:Number = param2 - local4.y;
var local7:Number = param3 - local4.z;
local4 = this.objectTransform[1];
local4.x = Math.atan2(local7,Math.sqrt(local5 * local5 + local6 * local6));
if(this._object is Camera3D) {
local4.x -= 0.5 * Math.PI;
}
local4.y = 0;
local4.z = -Math.atan2(local5,local6);
var local8:Matrix3D = this._object.matrix;
local8.recompose(this.objectTransform);
this._object.matrix = local8;
}
private function deltaTransformVector(param1:Vector3D) : void {
this._vin[0] = param1.x;
this._vin[1] = param1.y;
this._vin[2] = param1.z;
this._object.matrix.transformVectors(this._vin,this._vout);
var local2:Vector3D = this.objectTransform[0];
param1.x = this._vout[0] - local2.x;
param1.y = this._vout[1] - local2.y;
param1.z = this._vout[2] - local2.z;
}
public function moveForward(param1:Boolean) : void {
this._forward = param1;
}
public function moveBack(param1:Boolean) : void {
this._back = param1;
}
public function moveLeft(param1:Boolean) : void {
this._left = param1;
}
public function moveRight(param1:Boolean) : void {
this._right = param1;
}
public function moveUp(param1:Boolean) : void {
this._up = param1;
}
public function moveDown(param1:Boolean) : void {
this._down = param1;
}
public function accelerate(param1:Boolean) : void {
this._accelerate = param1;
}
public function bindKey(param1:uint, param2:String) : void {
var local3:Function = this.actionBindings[param2];
if(local3 != null) {
this.keyBindings[param1] = local3;
}
}
public function bindKeys(param1:Array) : void {
var local2:int = 0;
while(local2 < param1.length) {
this.bindKey(param1[local2],param1[local2 + 1]);
local2 += 2;
}
}
public function unbindKey(param1:uint) : void {
delete this.keyBindings[param1];
}
public function unbindAll() : void {
var local1:String = null;
for(local1 in this.keyBindings) {
delete this.keyBindings[local1];
}
}
public function setDefaultBindings() : void {
this.bindKey(87,ACTION_FORWARD);
this.bindKey(83,ACTION_BACK);
this.bindKey(65,ACTION_LEFT);
this.bindKey(68,ACTION_RIGHT);
this.bindKey(69,ACTION_UP);
this.bindKey(67,ACTION_DOWN);
this.bindKey(Keyboard.SHIFT,ACTION_ACCELERATE);
this.bindKey(Keyboard.UP,ACTION_FORWARD);
this.bindKey(Keyboard.DOWN,ACTION_BACK);
this.bindKey(Keyboard.LEFT,ACTION_LEFT);
this.bindKey(Keyboard.RIGHT,ACTION_RIGHT);
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.billboard.billboardimage {
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 BillboardImageModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BillboardImageModelServer;
private var client:IBillboardImageModelBase = IBillboardImageModelBase(this);
private var modelId:Long = Long.getLong(1692209065,-740073254);
public function BillboardImageModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BillboardImageModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(BillboardImageCC,false)));
}
protected function getInitParam() : BillboardImageCC {
return BillboardImageCC(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 projects.tanks.clients.flash.commons.services.serverhalt {
public interface IServerHaltService {
function setServerHalt(param1:Boolean) : void;
function get isServerHalt() : Boolean;
}
}
|
package projects.tanks.clients.fp10.Prelauncher.storage {
public class DisplayState {
public var x:int;
public var y:int;
public var width:int;
public var height:int;
public var fullscreen:Boolean;
public function DisplayState(x:int, y:int, width:int, height:int, fullscreen:Boolean) {
super();
this.x = x;
this.y = y;
this.width = width;
this.height = height;
this.fullscreen = fullscreen;
}
}
}
|
package platform.client.fp10.core.network.connection {
import platform.client.fp10.core.network.ICommandSender;
public interface IConnection extends ICommandSender {
function connect(param1:ConnectionConnectParameters) : void;
function close(param1:ConnectionCloseStatus, param2:String = null) : void;
function closeConnectionOnTransportError() : void;
}
}
|
package scpacker.test.usertitles
{
import alternativa.math.Vector3;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.tank.TankData;
public interface UserTitlesRender
{
function render() : void;
function setBattlefield(param1:IBattleField) : void;
function setLocalData(param1:TankData) : void;
function updateTitle(param1:TankData, param2:Vector3) : void;
function configurateTitle(param1:TankData) : void;
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.formatbattle {
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.tanksservices.model.formatbattle.EquipmentConstraintsNamingModelBase;
import projects.tanks.client.tanksservices.model.formatbattle.IEquipmentConstraintsNamingModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.BattleFormatUtil;
[ModelInfo]
public class EquipmentConstraintsNamingModel extends EquipmentConstraintsNamingModelBase implements IEquipmentConstraintsNamingModelBase, ObjectLoadListener {
[Inject]
public static var battleFormatUtil:BattleFormatUtil;
public function EquipmentConstraintsNamingModel() {
super();
}
public function objectLoaded() : void {
battleFormatUtil.init(getInitParam());
}
}
}
|
package projects.tanks.client.garage.models.garagepreview {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class GaragePreviewModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:GaragePreviewModelServer;
private var client:IGaragePreviewModelBase = IGaragePreviewModelBase(this);
private var modelId:Long = Long.getLong(868501559,1837500388);
private var _setHasBatteriesId:Long = Long.getLong(1619306003,844016486);
private var _setHasBatteries_hasBatteriesCodec:ICodec;
public function GaragePreviewModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new GaragePreviewModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(GaragePreviewModelCC,false)));
this._setHasBatteries_hasBatteriesCodec = this._protocol.getCodec(new TypeCodecInfo(Boolean,false));
}
protected function getInitParam() : GaragePreviewModelCC {
return GaragePreviewModelCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._setHasBatteriesId:
this.client.setHasBatteries(Boolean(this._setHasBatteries_hasBatteriesCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.payment.shop.featuring {
import projects.tanks.client.panel.model.shop.featuring.IShopItemFeaturingModelBase;
import projects.tanks.client.panel.model.shop.featuring.ShopItemFeaturingModelBase;
[ModelInfo]
public class ShopItemFeaturingModel extends ShopItemFeaturingModelBase implements IShopItemFeaturingModelBase, ShopItemFeaturing {
public function ShopItemFeaturingModel() {
super();
}
public function isLocatedInFeaturingCategory() : Boolean {
return getInitParam().locatedInFeaturingCategory;
}
public function isHiddenInOriginalCategory() : Boolean {
return getInitParam().hiddenInOriginalCategory;
}
public function getPosition() : int {
return getInitParam().position;
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.score {
import controls.Label;
import controls.resultassets.WhiteFrame;
import flash.display.GradientType;
import flash.display.Graphics;
import flash.display.Shape;
import flash.display.SpreadMethod;
import flash.display.Sprite;
import flash.geom.Matrix;
import flash.text.TextFieldAutoSize;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class TeamScoreFieldBase extends Sprite {
private static const LABEL_Y:int = 6;
protected static const BG_COLOR_RED:uint = 9249024;
protected static const FONT_COLOR_RED:uint = 16742221;
protected static const BG_COLOR_BLUE:uint = 16256;
protected static const FONT_COLOR_BLUE:uint = 4760319;
protected var _scoreRed:int;
protected var _scoreBlue:int;
protected var labelRed:Label;
protected var labelBlue:Label;
private var background:Shape;
protected var border:WhiteFrame;
public function TeamScoreFieldBase() {
super();
addChild(this.background = new Shape());
addChild(this.border = new WhiteFrame());
this.labelRed = this.createLabel(FONT_COLOR_RED);
this.labelBlue = this.createLabel(FONT_COLOR_BLUE);
}
public function setScore(param1:int, param2:int) : void {
this._scoreRed = param1;
this.labelRed.text = param1.toString();
this._scoreBlue = param2;
this.labelBlue.text = param2.toString();
this.update();
}
public function setTeamScore(param1:BattleTeam, param2:int) : void {
switch(param1) {
case BattleTeam.RED:
this.scoreRed = param2;
break;
case BattleTeam.BLUE:
this.scoreBlue = param2;
}
this.update();
}
public function set scoreRed(param1:int) : void {
this._scoreRed = param1;
this.labelRed.text = param1.toString();
this.update();
}
public function set scoreBlue(param1:int) : void {
this._scoreBlue = param1;
this.labelBlue.text = param1.toString();
this.update();
}
public function update() : void {
this.updateBgAndBorder(this.calculateWidth());
}
protected function calculateWidth() : int {
return 0;
}
private function updateBgAndBorder(param1:int) : void {
this.border.width = param1;
var local2:String = GradientType.LINEAR;
var local3:Array = [BG_COLOR_RED,BG_COLOR_BLUE];
var local4:Array = [1,1];
var local5:int = 8 / param1 * 255;
var local6:Array = [127 - local5,127 + local5];
var local7:int = 2;
var local8:Matrix = new Matrix();
local8.createGradientBox(param1 - local7,this.border.height - local7,0,0,0);
var local9:String = SpreadMethod.PAD;
var local10:Graphics = this.background.graphics;
local10.clear();
local10.beginGradientFill(local2,local3,local4,local6,local8,local9);
local10.drawRect(local7,local7,param1 - 2 * local7,this.border.height - local7 - 1);
local10.endFill();
}
private function createLabel(param1:uint) : Label {
var local2:Label = new Label();
local2.color = param1;
local2.size = 18;
local2.bold = true;
local2.autoSize = TextFieldAutoSize.CENTER;
local2.y = LABEL_Y;
addChild(local2);
return local2;
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.score {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.field.score.RugbyScoreIndicator_flagBlueLostClass.png")]
public class RugbyScoreIndicator_flagBlueLostClass extends BitmapAsset {
public function RugbyScoreIndicator_flagBlueLostClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.freeze {
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 FreezeSFXModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function FreezeSFXModelServer(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.warfare.models.tankparts.weapon.plasma
{
public interface IPlasmaModelBase
{
}
}
|
package platform.client.fp10.core.model {
[ModelInterface]
public interface ObjectLoadListener {
function objectLoaded() : void;
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.common.charging {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class WeaponChargingCommunicationModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _finishChargingId:Long = Long.getLong(455112152,894450320);
private var _finishCharging_clientTimeCodec:ICodec;
private var _startChargingId:Long = Long.getLong(1417898718,-827646215);
private var _startCharging_clientTimeCodec:ICodec;
private var model:IModel;
public function WeaponChargingCommunicationModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._finishCharging_clientTimeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._startCharging_clientTimeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
}
public function finishCharging(param1:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._finishCharging_clientTimeCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._finishChargingId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function startCharging(param1:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._startCharging_clientTimeCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._startChargingId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.lights.SpotLight;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.utils.objectpool.Pool;
public final class SpotStreamLightEffect extends StreamLightEffect {
private var targetPositionProvider:Object3DPositionProvider;
private var targetObject:Object3D;
public function SpotStreamLightEffect(param1:Pool) {
super(param1,new SpotLight(0,0,0,Math.PI / 3,Math.PI / 2));
this.targetObject = new Object3D();
}
public function init(param1:Object3DPositionProvider, param2:Object3DPositionProvider, param3:LightAnimation, param4:LightAnimation) : void {
this.positionProvider = param1;
this.targetPositionProvider = param2;
this.startTime = param3.getLiveTime();
this.loopTime = param4.getLiveTime();
this.startAnimation = param3;
this.loopAnimation = param4;
this.random = loopTime / 4;
starting = true;
currentTime = 0;
alive = true;
fading = false;
fadeTime = 0;
}
override public function play(param1:int, param2:GameCamera) : Boolean {
var local3:Boolean = super.play(param1,param2);
this.targetPositionProvider.updateObjectPosition(this.targetObject,param2,param1);
var local4:SpotLight = SpotLight(light);
local4.lookAt(this.targetObject.x,this.targetObject.y,this.targetObject.z);
return local3;
}
override public function addedToScene(param1:Scene3DContainer) : void {
super.addedToScene(param1);
param1.addChild(this.targetObject);
}
override public function destroy() : void {
container.removeChild(this.targetObject);
this.targetPositionProvider.destroy();
this.targetPositionProvider = null;
super.destroy();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank05.png")]
public class PremiumRankBitmaps_bitmapBigRank05 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank05() {
super();
}
}
}
|
package alternativa.tanks.display.usertitle
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ProgressBarSkin_hpRightBlueCls extends BitmapAsset
{
public function ProgressBarSkin_hpRightBlueCls()
{
super();
}
}
}
|
package alternativa.tanks.models.sfx.shoot.railgun
{
import flash.geom.ColorTransform;
public class RailgunShootSFXData
{
public var colorTransform:ColorTransform;
public function RailgunShootSFXData()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.shaft.quickshot
{
import alternativa.math.Vector3;
import alternativa.tanks.models.tank.TankData;
public class ShaftShotResult
{
public var targets:Array;
public var hitPoints:Array;
public var dir:Vector3;
public function ShaftShotResult()
{
this.targets = [];
this.hitPoints = [];
this.dir = new Vector3();
super();
}
public function toJSON() : String
{
var obj:Object = new Object();
obj.targets = this.targets;
obj.hitPoints = this.hitPoints;
obj.dir = this.dir;
return JSON.stringify(obj,function(key:*, v:*):*
{
var vector:* = undefined;
var tank:* = undefined;
if(v is Vector3)
{
vector = v as Vector3;
return {
"x":vector.x,
"y":vector.y,
"z":vector.z
};
}
if(v is TankData)
{
tank = v as TankData;
return {"target_id":tank.userName};
}
return v;
});
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import base.DiscreteSprite;
import controls.TankWindowInner;
import controls.windowinner.WindowInner;
import fl.containers.ScrollPane;
import fl.controls.ScrollPolicy;
import flash.display.Sprite;
import flash.text.AntiAliasType;
import flash.text.TextFieldAutoSize;
import utils.ScrollStyleUtils;
public class ClanDescriptionPanel extends DiscreteSprite {
private static const FRAME:int = 7;
private var descriptionInner:WindowInner;
private var description:ClanDescriptionText = new ClanDescriptionText();
private var scrollPane:ScrollPane = new ScrollPane();
private var scrollContainer:Sprite = new Sprite();
private var _width:int;
private var _height:int;
public function ClanDescriptionPanel(param1:String) {
super();
this.descriptionInner = new WindowInner(0,0,TankWindowInner.GREEN);
addChild(this.descriptionInner);
this.description.autoSize = TextFieldAutoSize.LEFT;
this.description.antiAliasType = AntiAliasType.ADVANCED;
this.description.multiline = true;
this.description.wordWrap = true;
if(param1 != null) {
this.description.text = param1;
}
this.scrollContainer.addChild(this.description);
this.descriptionInner.addChild(this.scrollPane);
ScrollStyleUtils.setGreenStyle(this.scrollPane);
this.scrollPane.horizontalScrollPolicy = ScrollPolicy.OFF;
this.scrollPane.verticalScrollPolicy = ScrollPolicy.ON;
this.scrollPane.source = this.scrollContainer;
this.scrollPane.update();
this.scrollPane.focusEnabled = false;
this.onResize();
}
public function onResize() : void {
this.descriptionInner.x = 0;
this.descriptionInner.y = 0;
this.descriptionInner.width = this.width;
this.descriptionInner.height = this.height;
this.scrollPane.x = FRAME;
this.scrollPane.y = 3;
this.scrollContainer.x = 0;
this.scrollContainer.y = 0;
this.description.x = 0;
this.description.y = 0;
if(this.scrollContainer.height < this.height) {
this.scrollPane.verticalScrollPolicy = ScrollPolicy.OFF;
this.description.width = this.descriptionInner.width - 2 * FRAME;
} else {
this.scrollPane.verticalScrollPolicy = ScrollPolicy.ON;
this.description.width = this.descriptionInner.width - 2 * FRAME - 5;
}
this.scrollPane.setSize(this.descriptionInner.width - 2,this.descriptionInner.height - FRAME);
this.scrollPane.update();
}
public function setDescriptionText(param1:String) : void {
if(param1 != null) {
this.description.text = param1;
}
this.onResize();
}
override public function get width() : Number {
return this._width;
}
override public function set width(param1:Number) : void {
this._width = param1;
this.onResize();
}
override public function get height() : Number {
return this._height;
}
override public function set height(param1:Number) : void {
this._height = param1;
this.onResize();
}
}
}
|
package alternativa.tanks.model.payment.modes.platbox {
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.gui.payment.forms.mobile.PhoneNumberValidationEvent;
import alternativa.tanks.gui.payment.forms.platbox.PlatBoxForm;
import alternativa.tanks.model.payment.category.PayModeView;
import alternativa.tanks.model.payment.paymentstate.PaymentWindowService;
import alternativa.tanks.service.paymentcomplete.PaymentCompleteEvent;
import alternativa.tanks.service.paymentcomplete.PaymentCompleteService;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.panel.model.payment.modes.platbox.IPlatBoxPaymentModelBase;
import projects.tanks.client.panel.model.payment.modes.platbox.PlatBoxPaymentModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.model.payment.PayModeProceed;
[ModelInfo]
public class PlatBoxPaymentModel extends PlatBoxPaymentModelBase implements IPlatBoxPaymentModelBase, ObjectLoadListener, PayModeView, PayModeProceed, ObjectUnloadListener {
[Inject]
public static var paymentWindowService:PaymentWindowService;
[Inject]
public static var paymentCompleteService:PaymentCompleteService;
public function PlatBoxPaymentModel() {
super();
}
private static function onPaymentComplete(param1:PaymentCompleteEvent) : void {
if(paymentWindowService.getChosenPayMode() == object) {
paymentWindowService.switchToBeginning();
}
}
public function objectLoaded() : void {
putData(PayModeForm,new PlatBoxForm(object));
this.view.addEventListener(PhoneNumberValidationEvent.VALIDATE,getFunctionWrapper(this.onPhoneValidation));
paymentCompleteService.addEventListener(PaymentCompleteEvent.COMPLETED,getFunctionWrapper(onPaymentComplete));
}
public function objectUnloaded() : void {
this.view.removeEventListener(PhoneNumberValidationEvent.VALIDATE,getFunctionWrapper(this.onPhoneValidation));
paymentCompleteService.removeEventListener(PaymentCompleteEvent.COMPLETED,getFunctionWrapper(onPaymentComplete));
this.view.destroy();
clearData(PayModeForm);
}
public function getView() : PayModeForm {
return PayModeForm(this.view);
}
public function paymentInited() : void {
this.view.showPaymentInitialized();
}
public function proceedPayment() : void {
server.initPayment(this.view.phoneNumber(),paymentWindowService.getChosenItem().id);
this.view.showPaymentProgress();
}
private function onPhoneValidation(param1:PhoneNumberValidationEvent) : void {
if(paymentWindowService.getChosenPayMode() == object) {
server.checkNumber(param1.getPhoneNumber());
}
}
public function phoneIsInvalid(param1:String) : void {
this.view.showPhoneIsInvalid(param1);
}
public function phoneIsValid(param1:String) : void {
this.view.showPhoneIsValid(param1);
}
private function get view() : PlatBoxForm {
return PlatBoxForm(getData(PayModeForm));
}
public function paymentError() : void {
this.view.activate();
}
}
}
|
package alternativa.physics.collision
{
public interface ICollisionPredicate
{
function considerCollision(param1:CollisionPrimitive) : Boolean;
}
}
|
package alternativa.tanks.model.challenge.greenpanel.green
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GreenPack_left_top extends BitmapAsset
{
public function GreenPack_left_top()
{
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.bonus.battle {
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.bonus.battle.BonusSpawnData;
public class VectorCodecBonusSpawnDataLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBonusSpawnDataLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BonusSpawnData,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.<BonusSpawnData> = new Vector.<BonusSpawnData>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BonusSpawnData(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BonusSpawnData = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BonusSpawnData> = Vector.<BonusSpawnData>(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.bonuses {
import alternativa.types.Long;
import flash.utils.Dictionary;
public class BonusCache {
private static const parachuteCache:ObjectCache = new ObjectCache();
private static const cordsCache:ObjectCache = new ObjectCache();
private static var boxCaches:Dictionary = new Dictionary();
public function BonusCache() {
super();
}
public static function isParachuteCacheEmpty() : Boolean {
return parachuteCache.isEmpty();
}
public static function getParachute() : Parachute {
return Parachute(parachuteCache.get());
}
public static function putParachute(param1:Parachute) : void {
parachuteCache.put(param1);
}
public static function isCordsCacheEmpty() : Boolean {
return cordsCache.isEmpty();
}
public static function getCords() : Cords {
return Cords(cordsCache.get());
}
public static function putCords(param1:Cords) : void {
cordsCache.put(param1);
}
public static function isBonusMeshCacheEmpty(param1:Long) : Boolean {
return getBonusMeshCache(param1).isEmpty();
}
public static function getBonusMesh(param1:Long) : BonusMesh {
return BonusMesh(getBonusMeshCache(param1).get());
}
public static function putBonusMesh(param1:BonusMesh) : void {
getBonusMeshCache(param1.getObjectId()).put(param1);
}
public static function clear() : void {
parachuteCache.clear();
cordsCache.clear();
clearBoxCaches();
}
private static function getBonusMeshCache(param1:Long) : ObjectCache {
var local2:ObjectCache = boxCaches[param1];
if(local2 == null) {
local2 = new ObjectCache();
boxCaches[param1] = local2;
}
return local2;
}
private static function clearBoxCaches() : void {
var local1:* = undefined;
var local2:ObjectCache = null;
for(local1 in boxCaches) {
local2 = boxCaches[local1];
local2.clear();
delete boxCaches[local1];
}
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_26 extends BitmapAsset
{
public function BigRangIcon_rang_26()
{
super();
}
}
}
|
package alternativa.tanks.view.battlelist.modefilter {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battlelist.modefilter.BattleModeIcons_tdmIconClass.png")]
public class BattleModeIcons_tdmIconClass extends BitmapAsset {
public function BattleModeIcons_tdmIconClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.videoads {
public interface IVideoAdsModelBase {
function disable() : void;
function enable() : void;
}
}
|
package com.alternativaplatform.projects.tanks.client.garage.effects.effectableitem
{
public interface IEffectableItemModelBase
{
}
}
|
package alternativa.tanks.models.battle.battlefield {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class BattlefieldEventsEvents implements BattlefieldEvents {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function BattlefieldEventsEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function onBattleLoaded() : void {
var i:int = 0;
var m:BattlefieldEvents = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattlefieldEvents(this.impl[i]);
m.onBattleLoaded();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.gui {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.model.bonus.showing.detach.BonusDetach;
import assets.icons.GarageItemBackground;
import controls.TankWindowInner;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.geom.Point;
import forms.TankWindowWithHeader;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.bonus.showing.items.BonusItemCC;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
public class CongratulationsWindowWithBanner extends DialogWindow {
[Inject]
public static var localeService:ILocaleService;
private static const tileClass:Class = CongratulationsWindowWithBanner_tileClass;
private static const tileBitmapData:BitmapData = new tileClass().bitmapData;
private const WINDOW_MARGIN:int = 12;
private const MARGIN:int = 9;
private const BUTTON_SIZE:Point;
private const SPACE:int = 8;
private var window:TankWindowWithHeader;
private var inner:TankWindowInner;
private var closeButton:DefaultButtonBase;
private var messageLabel:LabelBase;
private var windowSize:Point;
private var windowWidth:int = 450;
private var bannerBmp:Bitmap;
private var itemsContainer:Sprite;
private var _gameObject:IGameObject;
public function CongratulationsWindowWithBanner(param1:IGameObject, param2:String, param3:Vector.<BonusItemCC>) {
var local5:int = 0;
var local10:PreviewBonusItem = null;
var local11:LabelBase = null;
this.BUTTON_SIZE = new Point(104,33);
super();
this._gameObject = param1;
var local4:GarageItemBackground = new GarageItemBackground(GarageItemBackground.ENGINE_NORMAL);
if(param3.length == 1) {
local5 = 1;
} else if(param3.length < 5) {
local5 = 2;
} else {
local5 = 3;
}
this.windowWidth = local4.width + this.WINDOW_MARGIN * 2 + this.MARGIN * 2 + (local4.width + this.SPACE) * (local5 - 1);
var local6:Sprite = new Sprite();
this.itemsContainer = new Sprite();
this.bannerBmp = new Bitmap(tileBitmapData);
local6.addChild(this.bannerBmp);
local6.y = this.WINDOW_MARGIN + this.MARGIN;
local6.x = this.windowWidth - local6.width >> 1;
this.messageLabel = new LabelBase();
this.messageLabel.wordWrap = true;
this.messageLabel.multiline = true;
this.messageLabel.text = param2;
this.messageLabel.size = 12;
this.messageLabel.color = 5898034;
this.messageLabel.x = this.WINDOW_MARGIN * 2;
this.messageLabel.y = local6.y + local6.height + this.MARGIN;
this.messageLabel.width = this.windowWidth - this.WINDOW_MARGIN * 4;
this.windowSize = new Point(this.windowWidth,local6.height + this.messageLabel.height + this.BUTTON_SIZE.y + this.WINDOW_MARGIN * 3 + this.MARGIN * 4);
this.window = TankWindowWithHeader.createWindow(TanksLocale.TEXT_HEADER_CONGRATULATION,this.windowSize.x,this.windowSize.y);
addChild(this.window);
this.inner = new TankWindowInner(0,0,TankWindowInner.GREEN);
addChild(this.inner);
this.inner.x = this.WINDOW_MARGIN;
this.inner.y = this.WINDOW_MARGIN;
this.inner.width = this.windowSize.x - this.WINDOW_MARGIN * 2;
this.inner.height = this.windowSize.y - this.WINDOW_MARGIN - this.MARGIN * 2 - this.BUTTON_SIZE.y + 2;
addChild(this.messageLabel);
addChild(this.itemsContainer);
var local7:int = param3.length % local5;
var local8:int = (local5 - local7) * (local4.width + this.SPACE) >> 1;
var local9:int = 0;
while(local9 < param3.length) {
local4 = new GarageItemBackground(GarageItemBackground.ENGINE_NORMAL);
this.itemsContainer.addChild(local4);
local10 = new PreviewBonusItem(param3[local9].resource,local4.width,local4.height);
this.itemsContainer.addChild(local10);
local4.x = (local9 >= param3.length - local7 ? local8 : 0) + int(local9 % local5) * (local4.width + this.SPACE);
local4.y = (local4.height + this.SPACE) * int(local9 / local5);
local10.x = local4.x;
local10.y = local4.y;
local11 = new LabelBase();
this.itemsContainer.addChild(local11);
local11.size = 16;
local11.color = 5898034;
local11.text = "×" + param3[local9].count.toString();
local11.x = local4.x + local4.width - local11.width - 15;
local11.y = local4.y + local4.height - local11.height - 10;
local9++;
}
this.windowSize.y += this.itemsContainer.height;
this.closeButton = new DefaultButtonBase();
addChild(this.closeButton);
this.closeButton.label = localeService.getText(TanksLocale.TEXT_FREE_BONUSES_WINDOW_BUTTON_CLOSE_TEXT);
this.closeButton.y = this.windowSize.y - this.MARGIN - this.BUTTON_SIZE.y - 2;
this.placeItems();
addChild(local6);
this.window.height = this.windowSize.y;
this.window.width = this.windowSize.x;
this.closeButton.addEventListener(MouseEvent.CLICK,this.closeBonusWindow);
dialogService.enqueueDialog(this);
}
private function placeItems() : void {
this.messageLabel.width = this.windowWidth - this.WINDOW_MARGIN * 4;
this.itemsContainer.y = this.messageLabel.y + this.messageLabel.height + this.WINDOW_MARGIN;
this.itemsContainer.x = this.windowSize.x - this.itemsContainer.width >> 1;
this.inner.width = this.windowSize.x - this.WINDOW_MARGIN * 2;
this.inner.height = this.windowSize.y - this.WINDOW_MARGIN - this.MARGIN * 2 - this.BUTTON_SIZE.y + 2;
this.closeButton.x = this.windowSize.x - this.BUTTON_SIZE.x >> 1;
}
private function closeBonusWindow(param1:MouseEvent = null) : void {
this.destroy();
}
public function destroy() : void {
var local1:BonusDetach = null;
this.closeButton.removeEventListener(MouseEvent.CLICK,this.closeBonusWindow);
dialogService.removeDialog(this);
if(this._gameObject != null) {
local1 = new BonusDetach(this._gameObject);
local1.detach();
this._gameObject = null;
}
}
override protected function cancelKeyPressed() : void {
this.closeBonusWindow();
}
override protected function confirmationKeyPressed() : void {
this.closeBonusWindow();
}
}
}
|
package _codec.projects.tanks.client.battleservice {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.battleservice.BattleMode;
public class CodecBattleMode implements ICodec {
public function CodecBattleMode() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BattleMode = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = BattleMode.DM;
break;
case 1:
local2 = BattleMode.TDM;
break;
case 2:
local2 = BattleMode.CTF;
break;
case 3:
local2 = BattleMode.CP;
break;
case 4:
local2 = BattleMode.AS;
break;
case 5:
local2 = BattleMode.RUGBY;
break;
case 6:
local2 = BattleMode.SUR;
break;
case 7:
local2 = BattleMode.JGR;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package alternativa.tanks.models.tank.support {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventListener;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.events.TankUnloadedEvent;
import alternativa.tanks.battle.events.death.TankDeadEvent;
import alternativa.tanks.battle.events.reload.ReloadActivateEvent;
import alternativa.tanks.battle.events.reload.ReloadDeactivateEvent;
import alternativa.tanks.battle.events.reload.ReloadScheduledEvent;
import alternativa.tanks.models.battle.gui.indicators.ReloaderIndicator;
import flash.events.Event;
import flash.utils.getTimer;
import platform.client.fp10.core.type.AutoClosable;
import platform.client.fp10.core.type.IGameObject;
public class TankReloaderSupport implements AutoClosable, BattleEventListener, LogicUnit {
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var display:IDisplay;
[Inject]
public static var battleService:BattleService;
private static const ADDITIONAL_DELAY_TIME_MS:int = 900;
private var _user:IGameObject;
private var _idleTimeoutEndTime:int;
private var _reloaderIndicator:ReloaderIndicator;
public function TankReloaderSupport(param1:IGameObject) {
super();
this._user = param1;
this.init();
}
private function init() : void {
this._reloaderIndicator = new ReloaderIndicator();
display.stage.addEventListener(Event.ACTIVATE,this.onActivate);
display.stage.addEventListener(Event.DEACTIVATE,this.onDeactivate);
battleEventDispatcher.addBattleEventListener(ReloadScheduledEvent,this);
battleEventDispatcher.addBattleEventListener(BattleFinishEvent,this);
battleEventDispatcher.addBattleEventListener(TankUnloadedEvent,this);
battleEventDispatcher.addBattleEventListener(TankDeadEvent,this);
}
private function onActivate(param1:Event) : void {
this._reloaderIndicator.visible = true;
}
private function onDeactivate(param1:Event) : void {
this._reloaderIndicator.visible = false;
}
public function handleBattleEvent(param1:Object) : void {
if(param1 is ReloadScheduledEvent) {
this.showIndicator(ReloadScheduledEvent(param1).suicideDelayMS + ADDITIONAL_DELAY_TIME_MS);
} else if(param1 is BattleFinishEvent) {
this.hideIndicator();
} else if(param1 is TankUnloadedEvent) {
this.onTankUnload(TankUnloadedEvent(param1));
} else if(param1 is TankDeadEvent) {
this.onTankDead(TankDeadEvent(param1));
}
}
private function showIndicator(param1:int) : void {
this._idleTimeoutEndTime = getTimer() + param1;
this._reloaderIndicator.show(param1 / 1000);
battleService.getBattleRunner().addLogicUnit(this);
battleEventDispatcher.dispatchEvent(new ReloadActivateEvent());
}
private function hideIndicator() : void {
battleService.getBattleRunner().removeLogicUnit(this);
this._reloaderIndicator.hide();
battleEventDispatcher.dispatchEvent(new ReloadDeactivateEvent());
}
public function runLogic(param1:int, param2:int) : void {
this._reloaderIndicator.seconds = Math.max((this._idleTimeoutEndTime - param1) / 1000,0);
}
private function onTankUnload(param1:TankUnloadedEvent) : void {
if(this._user == param1.tank.getUser()) {
this.hideIndicator();
}
}
private function onTankDead(param1:TankDeadEvent) : void {
if(this._user == param1.victim) {
this.hideIndicator();
}
}
[Obfuscation(rename="false")]
public function close() : void {
display.stage.removeEventListener(Event.ACTIVATE,this.onActivate);
display.stage.removeEventListener(Event.DEACTIVATE,this.onDeactivate);
battleEventDispatcher.removeBattleEventListener(ReloadScheduledEvent,this);
battleEventDispatcher.removeBattleEventListener(BattleFinishEvent,this);
battleEventDispatcher.removeBattleEventListener(TankUnloadedEvent,this);
battleEventDispatcher.removeBattleEventListener(TankDeadEvent,this);
this._reloaderIndicator.destroy();
this._reloaderIndicator = null;
this._user = null;
}
}
}
|
package controls.scroller.red
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ScrollSkinRed_thumbTop extends BitmapAsset
{
public function ScrollSkinRed_thumbTop()
{
super();
}
}
}
|
package alternativa.tanks.models.tank.spawn {
[ModelInterface]
public interface ITankSpawner {
function getIncarnationId() : int;
function readyToSpawn() : void;
function setLocal() : void;
function setRemote() : void;
function setReadyToPlace() : void;
}
}
|
package assets.window.bitmaps {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.window.bitmaps.WindowBGTile.jpg")]
public class WindowBGTile extends BitmapData {
public function WindowBGTile(param1:int, param2:int, param3:Boolean = true, param4:uint = 0) {
super(param1,param2,param3,param4);
}
}
}
|
package alternativa.tanks.display.usertitle
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class EffectIndicator_iconPowerCls extends BitmapAsset
{
public function EffectIndicator_iconPowerCls()
{
super();
}
}
}
|
package controls.scroller.blue {
public class ScrollSkinBlue {
public static const thumbTop:Class = ScrollSkinBlue_thumbTop;
public static const thumbMiddle:Class = ScrollSkinBlue_thumbMiddle;
public static const track:Class = ScrollSkinBlue_track;
public static const trackTop:Class = ScrollSkinBlue_trackTop;
public static const trackBottom:Class = ScrollSkinBlue_trackBottom;
public function ScrollSkinBlue() {
super();
}
}
}
|
package controls.scroller.red
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ScrollSkinRed_thumbMiddle extends BitmapAsset
{
public function ScrollSkinRed_thumbMiddle()
{
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import alternativa.tanks.models.inventory.InventoryItemType;
import flash.display.Bitmap;
public class UltimateIcon extends InventoryIcons {
private var ultimateIndex:int;
public function UltimateIcon(param1:int) {
this.ultimateIndex = param1;
super(InventoryItemType.ULTIMATE);
}
override protected function getNeutralIcon(param1:int) : * {
return new Bitmap(HudInventoryIcon.getUltimateIcon(this.ultimateIndex));
}
override protected function getEffectIcon(param1:int) : Bitmap {
return new Bitmap(HudInventoryIcon.getUltimateIcon(this.ultimateIndex));
}
override protected function getCooldownIcon(param1:int) : Bitmap {
return new Bitmap(HudInventoryIcon.getUltimateIcon(this.ultimateIndex));
}
}
}
|
package alternativa.tanks.service.socialnetwork {
import flash.events.EventDispatcher;
import flash.utils.Dictionary;
public class SocialNetworkPanelService extends EventDispatcher implements ISocialNetworkPanelService {
private var _passwordCreated:Boolean;
private var _snEnabled:Dictionary = new Dictionary();
private var _snLinkExists:Dictionary = new Dictionary();
public function SocialNetworkPanelService() {
super();
}
public function get passwordCreated() : Boolean {
return this._passwordCreated;
}
public function set passwordCreated(param1:Boolean) : void {
this._passwordCreated = param1;
}
public function setSnEnabledInCurrentLocale(param1:String, param2:Boolean) : void {
this._snEnabled[param1] = param2;
}
public function snEnabledInCurrentLocale(param1:String) : Boolean {
if(Boolean(this._snEnabled[param1])) {
return this._snEnabled[param1];
}
return false;
}
public function setSnLinkExists(param1:String, param2:Boolean) : void {
this._snLinkExists[param1] = param2;
}
public function snLinkExists(param1:String) : Boolean {
if(Boolean(this._snLinkExists[param1])) {
return this._snLinkExists[param1];
}
return false;
}
public function createLink(param1:String) : void {
dispatchEvent(new SocialNetworkServiceEvent(SocialNetworkServiceEvent.CREATE_LINK,param1));
}
public function unlink(param1:String) : void {
dispatchEvent(new SocialNetworkServiceEvent(SocialNetworkServiceEvent.UNLINK,param1));
}
public function linkSuccess(param1:String) : void {
this._snLinkExists[param1] = true;
dispatchEvent(new SocialNetworkServiceEvent(SocialNetworkServiceEvent.LINK_SUCCESS,param1));
}
public function unlinkSucces(param1:String) : void {
this._snLinkExists[param1] = false;
dispatchEvent(new SocialNetworkServiceEvent(SocialNetworkServiceEvent.UNLINK_SUCCESS,param1));
}
}
}
|
package projects.tanks.client.battlefield.models.ultimate.effects.hornet {
public interface IHornetUltimateModelBase {
function showUltimateRadarIsTurnedOff() : void;
function showUltimateRadarIsTurnedOn() : void;
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.table {
public class TableConst {
public static const CALLSIGN_WIDTH:int = 180;
public static const SCORE_WIDTH:int = 50;
public static const KILLS_WIDTH:int = 80;
public static const DEATHS_WIDTH:int = 80;
public static const RATIO_WIDTH:int = 70;
public static const REWARD_WIDTH:int = 70;
public static const BONUS_REWARD_WIDTH:int = 70;
public static const ROW_HEIGHT:int = 20;
public static const LABELS_OFFSET:int = 15;
public static const TABLE_MARGIN:int = 7;
public static const LAST_COLUMN_EXTRA_WIDTH:int = 2;
public function TableConst() {
super();
}
}
}
|
package alternativa.tanks.model.item.container.resource {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.garage.models.item.container.resources.ContainerResourceCC;
public class ContainerResourceEvents implements ContainerResource {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ContainerResourceEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getResources() : ContainerResourceCC {
var result:ContainerResourceCC = null;
var i:int = 0;
var m:ContainerResource = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ContainerResource(this.impl[i]);
result = m.getResources();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.battle.utils {
import alternativa.tanks.battle.BattleRunnerProvider;
import alternativa.tanks.battle.DeferredAction;
import alternativa.tanks.battle.PhysicsController;
public class PhysicsControllerDeferredAction extends BattleRunnerProvider implements DeferredAction {
private var controller:PhysicsController;
private var add:Boolean;
public function PhysicsControllerDeferredAction(param1:PhysicsController, param2:Boolean) {
super();
this.controller = param1;
this.add = param2;
}
public function execute() : void {
if(this.add) {
getBattleRunner().addPhysicsController(this.controller);
} else {
getBattleRunner().removePhysicsController(this.controller);
}
}
}
}
|
package alternativa.tanks.sfx {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Sprite3D;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import projects.tanks.client.battlefield.types.Vector3d;
public class CrystalBonusEffect extends PooledObject implements GraphicEffect {
private var sprite:Sprite3D;
private var delay:int;
private var time:int;
private var maxHeight:Number;
private var visibleHeight:Number;
private var heightSpeed:Number;
private var x:Number;
private var y:Number;
private var z:Number;
private var startPosition:Vector3d;
private var container:Scene3DContainer;
public function CrystalBonusEffect(param1:Pool) {
super(param1);
this.sprite = new Sprite3D(10,10);
}
public function init(param1:int, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Number, param11:Vector3d, param12:TextureMaterial, param13:String) : void {
this.delay = param1;
this.sprite.width = param2;
this.sprite.height = param3;
this.sprite.calculateBounds();
this.sprite.rotation = param4;
this.maxHeight = param5;
this.visibleHeight = param6;
this.heightSpeed = param7;
this.x = param8;
this.y = param9;
this.z = param10;
this.startPosition = param11;
param12.resolution = 1;
this.sprite.material = param12;
this.sprite.softAttenuation = 150;
this.sprite.depthMapAlphaThreshold = 2;
this.sprite.shadowMapAlphaThreshold = 2;
this.sprite.useShadowMap = false;
this.sprite.useLight = false;
this.sprite.blendMode = param13;
this.sprite.alpha = 0;
this.time = 0;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.sprite);
}
public function play(param1:int, param2:GameCamera) : Boolean {
var local3:Number = NaN;
if(this.z >= this.maxHeight) {
return false;
}
this.sprite.x = this.startPosition.x + this.x;
this.sprite.y = this.startPosition.y + this.y;
this.sprite.z = this.startPosition.z + this.z;
this.time += param1;
if(this.time >= this.delay) {
this.z += this.maxHeight * this.heightSpeed * param1 * 0.001;
if(this.z < this.visibleHeight) {
this.sprite.alpha = this.z / this.visibleHeight;
} else {
local3 = (this.z - this.visibleHeight) / (this.maxHeight - this.visibleHeight);
this.sprite.alpha = 1 - local3 * local3 * local3 * local3 * local3 * local3 * local3 * local3;
}
if(this.sprite.alpha < 0) {
this.sprite.alpha = 0;
}
if(this.sprite.alpha > 1) {
this.sprite.alpha = 1;
}
} else {
this.sprite.alpha = 0;
}
return true;
}
public function destroy() : void {
this.container.removeChild(this.sprite);
this.container = null;
this.sprite.material = null;
recycle();
}
public function kill() : void {
this.z = this.maxHeight;
this.sprite.alpha = 0;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher.RocketLauncherCC;
public class VectorCodecRocketLauncherCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRocketLauncherCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(RocketLauncherCC,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.<RocketLauncherCC> = new Vector.<RocketLauncherCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = RocketLauncherCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:RocketLauncherCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<RocketLauncherCC> = Vector.<RocketLauncherCC>(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.gui.upgrade {
import alternativa.tanks.model.item.properties.ItemPropertyValue;
import alternativa.tanks.model.item.upgradable.UpgradableItemParams;
import alternativa.tanks.model.item.upgradable.UpgradableItemPropertyValue;
import alternativa.tanks.service.item.ItemService;
import platform.client.fp10.core.type.IGameObject;
public class UpgradeColors {
[Inject]
public static var itemService:ItemService;
public static const GREEN:int = 65291;
public static const WHITE:int = 16777215;
public static const GOLD:int = 16580352;
public static const LIGHT_GREEN:int = 8847108;
public function UpgradeColors() {
super();
}
public static function getColorForItem(param1:IGameObject, param2:ItemPropertyValue) : int {
if(itemService.isUpgradableItem(param1)) {
return getColor(itemService.getUpgradableItemParams(param1),UpgradableItemPropertyValue(param2));
}
return WHITE;
}
public static function getColor(param1:UpgradableItemParams, param2:UpgradableItemPropertyValue) : int {
return getColorForLevel(param1,param2,param1.getLevel());
}
public static function getNextColor(param1:UpgradableItemParams, param2:UpgradableItemPropertyValue) : int {
return getColorForLevel(param1,param2,param1.getLevel() + 1);
}
private static function getColorForLevel(param1:UpgradableItemParams, param2:UpgradableItemPropertyValue, param3:int) : int {
if(param2.isUpgradable()) {
return getColorForUpgradableItem(param1,param3);
}
return UpgradeColors.GOLD;
}
private static function getColorForUpgradableItem(param1:UpgradableItemParams, param2:int) : int {
if(param1.getLevelsCount() == param2) {
return GOLD;
}
if(param2 > 0) {
return LIGHT_GREEN;
}
return WHITE;
}
}
}
|
package alternativa.tanks.display.usertitle
{
import flash.display.Bitmap;
import flash.display.BitmapData;
public class ProgressBarSkin
{
[Embed(source="1049.png")]
private static var hpLeftDmCls:Class;
private static var hpLeftDm:BitmapData = Bitmap(new hpLeftDmCls()).bitmapData;
[Embed(source="1177.png")]
private static var hpRightDmCls:Class;
private static var hpRightDm:BitmapData = Bitmap(new hpRightDmCls()).bitmapData;
[Embed(source="840.png")]
private static var hpLeftBgDmCls:Class;
private static var hpLeftBgDm:BitmapData = Bitmap(new hpLeftBgDmCls()).bitmapData;
[Embed(source="1155.png")]
private static var hpRightBgDmCls:Class;
private static var hpRightBgDm:BitmapData = Bitmap(new hpRightBgDmCls()).bitmapData;
[Embed(source="1209.png")]
private static var hpLeftBlueCls:Class;
private static var hpLeftBlue:BitmapData = Bitmap(new hpLeftBlueCls()).bitmapData;
[Embed(source="851.png")]
private static var hpRightBlueCls:Class;
private static var hpRightBlue:BitmapData = Bitmap(new hpRightBlueCls()).bitmapData;
[Embed(source="1026.png")]
private static var hpLeftBgBlueCls:Class;
private static var hpLeftBgBlue:BitmapData = Bitmap(new hpLeftBgBlueCls()).bitmapData;
[Embed(source="823.png")]
private static var hpRightBgBlueCls:Class;
private static var hpRightBgBlue:BitmapData = Bitmap(new hpRightBgBlueCls()).bitmapData;
[Embed(source="1098.png")]
private static var hpLeftRedCls:Class;
private static var hpLeftRed:BitmapData = Bitmap(new hpLeftRedCls()).bitmapData;
[Embed(source="1028.png")]
private static var hpRightRedCls:Class;
private static var hpRightRed:BitmapData = Bitmap(new hpRightRedCls()).bitmapData;
[Embed(source="1001.png")]
private static var hpLeftBgRedCls:Class;
private static var hpLeftBgRed:BitmapData = Bitmap(new hpLeftBgRedCls()).bitmapData;
[Embed(source="839.png")]
private static var hpRightBgRedCls:Class;
private static var hpRightBgRed:BitmapData = Bitmap(new hpRightBgRedCls()).bitmapData;
[Embed(source="1068.png")]
private static var weaponLeftCls:Class;
private static var weaponLeft:BitmapData = Bitmap(new weaponLeftCls()).bitmapData;
[Embed(source="886.png")]
private static var weaponRightCls:Class;
private static var weaponRight:BitmapData = Bitmap(new weaponRightCls()).bitmapData;
[Embed(source="1051.png")]
private static var weaponLeftBgCls:Class;
private static var weaponLeftBg:BitmapData = Bitmap(new weaponLeftBgCls()).bitmapData;
[Embed(source="841.png")]
private static var weaponRightBgCls:Class;
private static var weaponRightBg:BitmapData = Bitmap(new weaponRightBgCls()).bitmapData;
[Embed(source="962.png")]
private static var barShadowCls:Class;
private static var barShadow:BitmapData = Bitmap(new barShadowCls()).bitmapData;
[Embed(source="994.png")]
private static var barShadowLeftCls:Class;
private static var barShadowLeft:BitmapData = Bitmap(new barShadowLeftCls()).bitmapData;
[Embed(source="1050.png")]
private static var barShadowRightCls:Class;
private static var barShadowRight:BitmapData = Bitmap(new barShadowRightCls()).bitmapData;
private static const COLOR_DM:uint = 4964125;
private static const COLOR_DM_BG:uint = 2448911;
private static const COLOR_TEAM_BLUE:uint = 4691967;
private static const COLOR_TEAM_BLUE_BG:uint = 2181375;
private static const COLOR_TEAM_RED:uint = 15741974;
private static const COLOR_TEAM_RED_BG:uint = 10556937;
private static const COLOR_WEAPON_BAR:uint = 14207247;
private static const COLOR_WEAPON_BAR_BG:uint = 7758340;
public static const HEALTHBAR_DM:ProgressBarSkin = new ProgressBarSkin(COLOR_DM,COLOR_DM_BG,hpLeftDm,hpLeftBgDm,hpRightDm,hpRightBgDm,barShadow,barShadowLeft,barShadowRight);
public static const HEALTHBAR_BLUE:ProgressBarSkin = new ProgressBarSkin(COLOR_TEAM_BLUE,COLOR_TEAM_BLUE_BG,hpLeftBlue,hpLeftBgBlue,hpRightBlue,hpRightBgBlue,barShadow,barShadowLeft,barShadowRight);
public static const HEALTHBAR_RED:ProgressBarSkin = new ProgressBarSkin(COLOR_TEAM_RED,COLOR_TEAM_RED_BG,hpLeftRed,hpLeftBgRed,hpRightRed,hpRightBgRed,barShadow,barShadowLeft,barShadowRight);
public static const WEAPONBAR:ProgressBarSkin = new ProgressBarSkin(COLOR_WEAPON_BAR,COLOR_WEAPON_BAR_BG,weaponLeft,weaponLeftBg,weaponRight,weaponRightBg,barShadow,barShadowLeft,barShadowRight);
public var color:uint;
public var bgColor:uint;
public var leftTipFg:BitmapData;
public var leftTipBg:BitmapData;
public var rightTipFg:BitmapData;
public var rightTipBg:BitmapData;
public var shadowLeftTip:BitmapData;
public var shadowRightTip:BitmapData;
public var shadow:BitmapData;
public function ProgressBarSkin(color:uint, bgColor:uint, leftTipFg:BitmapData, leftTipBg:BitmapData, rightTipFg:BitmapData, rightTipBg:BitmapData, shadow:BitmapData, shadowLeftTip:BitmapData, shadowRightTip:BitmapData)
{
super();
this.color = color;
this.bgColor = bgColor;
this.leftTipFg = leftTipFg;
this.leftTipBg = leftTipBg;
this.rightTipFg = rightTipFg;
this.rightTipBg = rightTipBg;
this.shadow = shadow;
this.shadowLeftTip = shadowLeftTip;
this.shadowRightTip = shadowRightTip;
}
}
}
|
package _codec.projects.tanks.client.panel.model.quest.common.specification {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.panel.model.quest.common.specification.QuestLevel;
public class CodecQuestLevel implements ICodec {
public function CodecQuestLevel() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:QuestLevel = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = QuestLevel.EASY;
break;
case 1:
local2 = QuestLevel.NORMAL;
break;
case 2:
local2 = QuestLevel.HARD;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package alternativa.tanks.model.map.mapinfo {
import alternativa.types.Long;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.battleservice.BattleMode;
import projects.tanks.client.battleservice.model.map.params.MapTheme;
[ModelInterface]
public interface IMapInfo {
function getName() : String;
function getMapId() : Long;
function getMaxPeople() : int;
function getMaxRank() : int;
function getMinRank() : int;
function getThemeName() : String;
function getTheme() : MapTheme;
function getDefaultTheme() : MapTheme;
function getSupportedBattleModes() : Vector.<BattleMode>;
function isEnabled() : Boolean;
function hasMatchmakingMark() : Boolean;
function getPreviewResource() : ImageResource;
}
}
|
package alternativa.tanks.model.news
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class NewsIcons_fight extends BitmapAsset
{
public function NewsIcons_fight()
{
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes.terminal {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.payment.modes.terminal.TerminalInstance;
import projects.tanks.client.panel.model.payment.modes.terminal.TerminalPaymentCC;
public class CodecTerminalPaymentCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_terminals:ICodec;
private var codec_text:ICodec;
private var codec_withCalculator:ICodec;
public function CodecTerminalPaymentCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_terminals = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(TerminalInstance,false),false,1));
this.codec_text = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_withCalculator = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:TerminalPaymentCC = new TerminalPaymentCC();
local2.terminals = this.codec_terminals.decode(param1) as Vector.<TerminalInstance>;
local2.text = this.codec_text.decode(param1) as String;
local2.withCalculator = this.codec_withCalculator.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:TerminalPaymentCC = TerminalPaymentCC(param2);
this.codec_terminals.encode(param1,local3.terminals);
this.codec_text.encode(param1,local3.text);
this.codec_withCalculator.encode(param1,local3.withCalculator);
}
}
}
|
package alternativa.tanks.camera.controllers.spectator {
import alternativa.tanks.utils.BitMask;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
import flash.utils.Dictionary;
public class UserInputImpl implements UserInput, KeyboardHandler {
public static const BIT_FORWARD:int = 0;
public static const BIT_BACK:int = 1;
public static const BIT_LEFT:int = 2;
public static const BIT_RIGHT:int = 3;
public static const BIT_UP:int = 4;
public static const BIT_DOWN:int = 5;
public static const BIT_ACCELERATION:int = 6;
public static const BIT_YAW_LEFT:int = 7;
public static const BIT_YAW_RIGHT:int = 8;
public static const BIT_PITCH_UP:int = 9;
public static const BIT_PITCH_DOWN:int = 10;
private static const ROTATION_MASK:int = 1 << BIT_PITCH_DOWN | 1 << BIT_PITCH_UP | 1 << BIT_YAW_LEFT | 1 << BIT_YAW_RIGHT;
private var keyMap:Dictionary = new Dictionary();
private var controlBits:BitMask = new BitMask();
public function UserInputImpl() {
super();
this.keyMap[Keyboard.W] = BIT_FORWARD;
this.keyMap[Keyboard.S] = BIT_BACK;
this.keyMap[Keyboard.A] = BIT_LEFT;
this.keyMap[Keyboard.D] = BIT_RIGHT;
this.keyMap[Keyboard.Q] = BIT_DOWN;
this.keyMap[Keyboard.E] = BIT_UP;
this.keyMap[Keyboard.SHIFT] = BIT_ACCELERATION;
this.keyMap[Keyboard.LEFT] = BIT_YAW_LEFT;
this.keyMap[Keyboard.RIGHT] = BIT_YAW_RIGHT;
this.keyMap[Keyboard.UP] = BIT_PITCH_UP;
this.keyMap[Keyboard.DOWN] = BIT_PITCH_DOWN;
}
public function getForwardDirection() : int {
return this.getDirection(BIT_FORWARD,BIT_BACK);
}
public function getSideDirection() : int {
return this.getDirection(BIT_RIGHT,BIT_LEFT);
}
public function getVerticalDirection() : int {
return this.getDirection(BIT_UP,BIT_DOWN);
}
public function isAccelerated() : Boolean {
return this.controlBits.getBitValue(BIT_ACCELERATION) == 1;
}
public function handleKeyDown(param1:KeyboardEvent) : void {
if(this.keyMap[param1.keyCode] != null) {
this.controlBits.setBit(this.keyMap[param1.keyCode]);
}
}
public function handleKeyUp(param1:KeyboardEvent) : void {
if(this.keyMap[param1.keyCode] != null) {
this.controlBits.clearBit(this.keyMap[param1.keyCode]);
}
}
public function getYawDirection() : int {
return this.getDirection(BIT_YAW_LEFT,BIT_YAW_RIGHT);
}
public function getPitchDirection() : int {
return this.getDirection(BIT_PITCH_UP,BIT_PITCH_DOWN);
}
public function isRotating() : Boolean {
return this.controlBits.hasAnyBit(ROTATION_MASK);
}
private function getDirection(param1:int, param2:int) : int {
return this.controlBits.getBitValue(param1) - this.controlBits.getBitValue(param2);
}
public function reset() : void {
this.controlBits.clear();
}
}
}
|
package alternativa.tanks.models.battlemessages {
internal class StateAlpha implements MessageState {
private var message:Message;
private var transitionTime:int;
private var timeLeft:int;
private var alpha1:Number;
private var alpha2:Number;
private var deltaAlpha:Number;
public function StateAlpha(param1:Message, param2:int, param3:Number, param4:Number) {
super();
this.message = param1;
this.transitionTime = param2;
this.alpha1 = param3;
this.alpha2 = param4;
this.deltaAlpha = param4 - param3;
}
public function init() : void {
this.message.setAlpha(this.alpha1);
this.timeLeft = this.transitionTime;
}
public function update(param1:int) : Boolean {
if(this.timeLeft <= 0) {
return false;
}
this.timeLeft -= param1;
if(this.timeLeft < 0) {
this.timeLeft = 0;
}
this.message.setAlpha(this.alpha2 - this.deltaAlpha * this.timeLeft / this.transitionTime);
return true;
}
public function setDurationInMs(param1:int) : void {
this.transitionTime = param1;
}
}
}
|
package alternativa.engine3d.animation {
import alternativa.engine3d.alternativa3d;
use namespace alternativa3d;
public class AnimationCouple extends AnimationNode {
private var _left:AnimationNode;
private var _right:AnimationNode;
public var balance:Number = 0.5;
public function AnimationCouple() {
super();
}
override alternativa3d function update(param1:Number, param2:Number) : void {
var local3:Number = this.balance <= 0 ? 0 : (this.balance >= 1 ? 1 : this.balance);
if(this._left == null) {
this._right.alternativa3d::update(param1 * speed,param2);
} else if(this._right == null) {
this._left.alternativa3d::update(param1 * speed,param2);
} else {
this._left.alternativa3d::update(param1 * speed,(1 - local3) * param2);
this._right.alternativa3d::update(param1 * speed,local3 * param2);
}
}
override alternativa3d function setController(param1:AnimationController) : void {
this.alternativa3d::controller = param1;
if(this._left != null) {
this._left.alternativa3d::setController(param1);
}
if(this._right != null) {
this._right.alternativa3d::setController(param1);
}
}
override alternativa3d function addNode(param1:AnimationNode) : void {
super.alternativa3d::addNode(param1);
param1.alternativa3d::_isActive = true;
}
override alternativa3d function removeNode(param1:AnimationNode) : void {
if(this._left == param1) {
this._left = null;
} else {
this._right = null;
}
super.alternativa3d::removeNode(param1);
}
public function get left() : AnimationNode {
return this._left;
}
public function set left(param1:AnimationNode) : void {
if(param1 != this._left) {
if(param1.alternativa3d::_parent == this) {
throw new Error("Animation already exist in blender");
}
if(this._left != null) {
this.alternativa3d::removeNode(this._left);
}
this._left = param1;
if(param1 != null) {
this.alternativa3d::addNode(param1);
}
}
}
public function get right() : AnimationNode {
return this._right;
}
public function set right(param1:AnimationNode) : void {
if(param1 != this._right) {
if(param1.alternativa3d::_parent == this) {
throw new Error("Animation already exist in blender");
}
if(this._right != null) {
this.alternativa3d::removeNode(this._right);
}
this._right = param1;
if(param1 != null) {
this.alternativa3d::addNode(param1);
}
}
}
}
}
|
package alternativa.tanks.model.banner
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.object.ClientObject;
import alternativa.resource.ImageResource;
import alternativa.service.IResourceService;
import alternativa.types.Long;
import flash.display.BitmapData;
import flash.utils.Dictionary;
import projects.tanks.client.banners.BannerModelBase;
import projects.tanks.client.banners.IBannerModelBase;
public class BannerModel extends BannerModelBase implements IBannerModelBase, IBanner
{
private var bd:Dictionary;
private var url:Dictionary;
public function BannerModel()
{
super();
_interfaces.push(IModel,IBannerModelBase,IBanner);
this.bd = new Dictionary();
this.url = new Dictionary();
}
public function initObject(clientObject:ClientObject, resourceID:Long, url:String) : void
{
Main.writeVarsToConsoleChannel("BannerModel","initObject resourceID: %1, url: %2",resourceID,url);
this.url[clientObject] = url;
var resource:ImageResource = (Main.osgi.getService(IResourceService) as IResourceService).getResource(resourceID) as ImageResource;
this.bd[clientObject] = resource.data;
}
public function getBannerBd(bannerObject:ClientObject) : BitmapData
{
return this.bd[bannerObject];
}
public function getBannerURL(bannerObject:ClientObject) : String
{
return this.url[bannerObject];
}
public function click(bannerObject:ClientObject) : void
{
Main.writeVarsToConsoleChannel("BannerModel","click bannerObjectId: %1",bannerObject.id);
}
}
}
|
package alternativa.tanks.models.battlefield.gui.chat
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import alternativa.tanks.model.panel.IBattleSettings;
import alternativa.tanks.model.panel.IPanelListener;
import alternativa.tanks.model.user.IUserDataListener;
import alternativa.tanks.models.battlefield.IUserStat;
import alternativa.types.Long;
import flash.display.DisplayObjectContainer;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
import projects.tanks.client.battlefield.gui.models.chat.ChatModelBase;
import projects.tanks.client.battlefield.gui.models.chat.IChatModelBase;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
import specter.utils.KeyboardBinder;
public class ChatModel extends ChatModelBase implements IChatModelBase, IObjectLoadListener, IPanelListener, IChatBattle
{
private var userStat:IUserStat;
private var bfClientObject:ClientObject;
private var contentLayer:DisplayObjectContainer;
private var teamOnly:Boolean;
private var battleChat:BattleChat;
private var uiLockCount:int;
private var messagesBuf:Vector.<String>;
private var keyBinder:KeyboardBinder;
private var currentBufMsg:int = -1;
public function ChatModel()
{
this.messagesBuf = new Vector.<String>();
super();
_interfaces.push(IModel,IChatModelBase,IObjectLoadListener,IUserDataListener,IPanelListener);
this.contentLayer = Main.contentUILayer;
this.battleChat = new BattleChat();
Main.osgi.registerService(IChatBattle,this);
}
public function objectLoaded(object:ClientObject) : void
{
this.bfClientObject = object;
this.battleChat.clear();
this.contentLayer.addChild(this.battleChat);
this.battleChat.addEventListener(BattleChatEvent.SEND_MESSAGE,this.onSendMessage);
this.battleChat.addEventListener(BattleChatEvent.CHAT_EXIT,this.onChatClosed);
Main.stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
var modelService:IModelService = Main.osgi.getService(IModelService) as IModelService;
this.battleChat.alwaysShow = this.getSettings().showBattleChat;
this.keyBinder = new KeyboardBinder(this.battleChat.input);
this.keyBinder.bind("UP",this.processBufUp);
this.keyBinder.bind("DOWN",this.processBufDown);
this.keyBinder.enable();
}
public function objectUnloaded(object:ClientObject) : void
{
this.battleChat.removeEventListener(BattleChatEvent.SEND_MESSAGE,this.onSendMessage);
this.battleChat.removeEventListener(BattleChatEvent.CHAT_EXIT,this.onChatClosed);
this.battleChat.clear();
this.contentLayer.removeChild(this.battleChat);
Main.stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
this.bfClientObject = null;
this.keyBinder.unbindAll();
this.keyBinder.disable();
}
public function bugReportOpened() : void
{
this.updateUILock(1);
}
public function bugReportClosed() : void
{
this.updateUILock(-1);
}
public function friendsOpened() : void
{
this.updateUILock(1);
}
public function friendsClosed() : void
{
this.updateUILock(-1);
}
public function exchangeOpened() : void
{
this.updateUILock(1);
}
public function exchangeClosed() : void
{
this.updateUILock(-1);
}
public function onCloseGame() : void
{
this.updateUILock(1);
}
public function onCloseGameExit() : void
{
this.updateUILock(-1);
}
public function settingsAccepted() : void
{
this.updateUILock(-1);
this.battleChat.alwaysShow = this.getSettings().showBattleChat;
}
public function settingsOpened() : void
{
this.updateUILock(1);
}
public function settingsCanceled() : void
{
this.updateUILock(-1);
}
public function setMuteSound(mute:Boolean) : void
{
}
private function onKeyUp(e:KeyboardEvent) : void
{
switch(e.keyCode)
{
case Keyboard.ENTER:
this.teamOnly = e.ctrlKey;
this.battleChat.openChat();
break;
case 84:
if(!this.battleChat.chatOpened)
{
this.teamOnly = true;
this.battleChat.openChat();
}
}
}
private function onChatClosed(e:BattleChatEvent) : void
{
this.currentBufMsg = -1;
}
private function onSendMessage(e:BattleChatEvent) : void
{
this.sendMessage(this.bfClientObject,e.message,this.teamOnly);
}
private function sendMessage(cl:ClientObject, msg:String, team:Boolean) : void
{
if(this.messagesBuf.length == 0 || this.messagesBuf[this.messagesBuf.length - 1] != msg)
{
this.messagesBuf.push(msg);
}
this.currentBufMsg = -1;
var reg:RegExp = /;/g;
var reg2:RegExp = /~/g;
msg = msg.replace(reg," ").replace(reg2," ");
Network(Main.osgi.getService(INetworker)).send("battle;chat;" + msg + ";" + team);
}
private function processBufUp(isKeyDown:Boolean) : void
{
if(!isKeyDown || this.messagesBuf.length == 0 || !this.battleChat.chatOpened)
{
return;
}
this.currentBufMsg = Math.min(this.currentBufMsg + 1,this.messagesBuf.length - 1);
this.battleChat.input.text = this.messagesBuf[this.messagesBuf.length - 1 - this.currentBufMsg];
}
private function processBufDown(isKeyDown:Boolean) : void
{
if(!isKeyDown || this.messagesBuf.length == 0 || !this.battleChat.chatOpened)
{
return;
}
this.currentBufMsg = Math.max(this.currentBufMsg - 1,0);
this.battleChat.input.text = this.messagesBuf[this.messagesBuf.length - 1 - this.currentBufMsg];
}
public function addMessage(clientObject:ClientObject, userId:Long, message:String, type:BattleTeamType, teamOnly:Boolean, nick:String = null, rank:int = 0, chat_level:int = 0) : void
{
var messageLabel:String = type != BattleTeamType.NONE && teamOnly ? "[TEAM]" : null;
var userName:String = nick;
var userRank:int = rank;
this.battleChat.addUserMessage(messageLabel,userName,userRank,chat_level,type,message + "\n");
}
public function addSpectatorMessage(message:String) : void
{
this.battleChat.addSpectatorMessage(message + "\n");
}
public function addSystemMessage(clientObject:ClientObject, message:String) : void
{
this.battleChat.addSystemMessage(message);
}
private function updateUILock(delta:int) : void
{
this.uiLockCount += delta;
if(this.bfClientObject != null)
{
if(this.uiLockCount > 0)
{
this.battleChat.closeChat();
this.battleChat.locked = true;
}
else
{
this.battleChat.locked = false;
}
}
}
private function getSettings() : IBattleSettings
{
return IBattleSettings(Main.osgi.getService(IBattleSettings));
}
}
}
import alternativa.types.Long;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
class ExpectingMessage
{
public var messageLabel:String;
public var userID:Long;
public var message:String;
public var type:BattleTeamType;
function ExpectingMessage(messageLabel:String, userID:Long, type:BattleTeamType, message:String)
{
super();
this.messageLabel = messageLabel;
this.userID = userID;
this.message = message;
this.type = type;
}
}
|
package alternativa.tanks.model.news
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class NewsIcons_magazine extends BitmapAsset
{
public function NewsIcons_magazine()
{
super();
}
}
}
|
package alternativa.engine3d.core
{
import alternativa.engine3d.alternativa3d;
import flash.display.Sprite;
use namespace alternativa3d;
public class Debug
{
public static const BOUNDS:int = 8;
public static const EDGES:int = 16;
public static const NODES:int = 128;
public static const LIGHTS:int = 256;
public static const BONES:int = 512;
private static const boundVertexList:Vertex = Vertex.createList(8);
private static const nodeVertexList:Vertex = Vertex.createList(4);
public function Debug()
{
super();
}
alternativa3d static function drawEdges(param1:Camera3D, param2:Face, param3:int) : void
{
var _loc6_:Number = NaN;
var _loc9_:Wrapper = null;
var _loc10_:Vertex = null;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc4_:Number = param1.viewSizeX;
var _loc5_:Number = param1.viewSizeY;
var _loc7_:Sprite = param1.view.canvas;
_loc7_.graphics.lineStyle(0,param3);
var _loc8_:Face = param2;
while(_loc8_ != null)
{
_loc9_ = _loc8_.wrapper;
_loc10_ = _loc9_.vertex;
_loc6_ = 1 / _loc10_.cameraZ;
_loc11_ = _loc10_.cameraX * _loc4_ * _loc6_;
_loc12_ = _loc10_.cameraY * _loc5_ * _loc6_;
_loc7_.graphics.moveTo(_loc11_,_loc12_);
_loc9_ = _loc9_.next;
while(_loc9_ != null)
{
_loc10_ = _loc9_.vertex;
_loc6_ = 1 / _loc10_.cameraZ;
_loc7_.graphics.lineTo(_loc10_.cameraX * _loc4_ * _loc6_,_loc10_.cameraY * _loc5_ * _loc6_);
_loc9_ = _loc9_.next;
}
_loc7_.graphics.lineTo(_loc11_,_loc12_);
_loc8_ = _loc8_.processNext;
}
}
alternativa3d static function drawBounds(param1:Camera3D, param2:Object3D, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:int = -1, param10:Number = 1) : void
{
var _loc11_:Vertex = null;
var _loc23_:Number = NaN;
var _loc12_:Vertex = boundVertexList;
_loc12_.x = param3;
_loc12_.y = param4;
_loc12_.z = param5;
var _loc13_:Vertex = _loc12_.next;
_loc13_.x = param6;
_loc13_.y = param4;
_loc13_.z = param5;
var _loc14_:Vertex = _loc13_.next;
_loc14_.x = param3;
_loc14_.y = param7;
_loc14_.z = param5;
var _loc15_:Vertex = _loc14_.next;
_loc15_.x = param6;
_loc15_.y = param7;
_loc15_.z = param5;
var _loc16_:Vertex = _loc15_.next;
_loc16_.x = param3;
_loc16_.y = param4;
_loc16_.z = param8;
var _loc17_:Vertex = _loc16_.next;
_loc17_.x = param6;
_loc17_.y = param4;
_loc17_.z = param8;
var _loc18_:Vertex = _loc17_.next;
_loc18_.x = param3;
_loc18_.y = param7;
_loc18_.z = param8;
var _loc19_:Vertex = _loc18_.next;
_loc19_.x = param6;
_loc19_.y = param7;
_loc19_.z = param8;
_loc11_ = _loc12_;
while(_loc11_ != null)
{
_loc11_.cameraX = param2.ma * _loc11_.x + param2.mb * _loc11_.y + param2.mc * _loc11_.z + param2.md;
_loc11_.cameraY = param2.me * _loc11_.x + param2.mf * _loc11_.y + param2.mg * _loc11_.z + param2.mh;
_loc11_.cameraZ = param2.mi * _loc11_.x + param2.mj * _loc11_.y + param2.mk * _loc11_.z + param2.ml;
if(_loc11_.cameraZ <= 0)
{
return;
}
_loc11_ = _loc11_.next;
}
var _loc20_:Number = param1.viewSizeX;
var _loc21_:Number = param1.viewSizeY;
_loc11_ = _loc12_;
while(_loc11_ != null)
{
_loc23_ = 1 / _loc11_.cameraZ;
_loc11_.cameraX = _loc11_.cameraX * _loc20_ * _loc23_;
_loc11_.cameraY = _loc11_.cameraY * _loc21_ * _loc23_;
_loc11_ = _loc11_.next;
}
var _loc22_:Sprite = param1.view.canvas;
_loc22_.graphics.lineStyle(0,param9 < 0 ? (param2.culling > 0 ? uint(uint(16776960)) : uint(uint(65280))) : uint(uint(param9)),param10);
_loc22_.graphics.moveTo(_loc12_.cameraX,_loc12_.cameraY);
_loc22_.graphics.lineTo(_loc13_.cameraX,_loc13_.cameraY);
_loc22_.graphics.lineTo(_loc15_.cameraX,_loc15_.cameraY);
_loc22_.graphics.lineTo(_loc14_.cameraX,_loc14_.cameraY);
_loc22_.graphics.lineTo(_loc12_.cameraX,_loc12_.cameraY);
_loc22_.graphics.moveTo(_loc16_.cameraX,_loc16_.cameraY);
_loc22_.graphics.lineTo(_loc17_.cameraX,_loc17_.cameraY);
_loc22_.graphics.lineTo(_loc19_.cameraX,_loc19_.cameraY);
_loc22_.graphics.lineTo(_loc18_.cameraX,_loc18_.cameraY);
_loc22_.graphics.lineTo(_loc16_.cameraX,_loc16_.cameraY);
_loc22_.graphics.moveTo(_loc12_.cameraX,_loc12_.cameraY);
_loc22_.graphics.lineTo(_loc16_.cameraX,_loc16_.cameraY);
_loc22_.graphics.moveTo(_loc13_.cameraX,_loc13_.cameraY);
_loc22_.graphics.lineTo(_loc17_.cameraX,_loc17_.cameraY);
_loc22_.graphics.moveTo(_loc15_.cameraX,_loc15_.cameraY);
_loc22_.graphics.lineTo(_loc19_.cameraX,_loc19_.cameraY);
_loc22_.graphics.moveTo(_loc14_.cameraX,_loc14_.cameraY);
_loc22_.graphics.lineTo(_loc18_.cameraX,_loc18_.cameraY);
}
alternativa3d static function drawKDNode(param1:Camera3D, param2:Object3D, param3:int, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Number, param11:Number) : void
{
var _loc12_:Vertex = null;
var _loc20_:Number = NaN;
var _loc13_:Vertex = nodeVertexList;
var _loc14_:Vertex = _loc13_.next;
var _loc15_:Vertex = _loc14_.next;
var _loc16_:Vertex = _loc15_.next;
if(param3 == 0)
{
_loc13_.x = param4;
_loc13_.y = param6;
_loc13_.z = param10;
_loc14_.x = param4;
_loc14_.y = param9;
_loc14_.z = param10;
_loc15_.x = param4;
_loc15_.y = param9;
_loc15_.z = param7;
_loc16_.x = param4;
_loc16_.y = param6;
_loc16_.z = param7;
}
else if(param3 == 1)
{
_loc13_.x = param8;
_loc13_.y = param4;
_loc13_.z = param10;
_loc14_.x = param5;
_loc14_.y = param4;
_loc14_.z = param10;
_loc15_.x = param5;
_loc15_.y = param4;
_loc15_.z = param7;
_loc16_.x = param8;
_loc16_.y = param4;
_loc16_.z = param7;
}
else
{
_loc13_.x = param5;
_loc13_.y = param6;
_loc13_.z = param4;
_loc14_.x = param8;
_loc14_.y = param6;
_loc14_.z = param4;
_loc15_.x = param8;
_loc15_.y = param9;
_loc15_.z = param4;
_loc16_.x = param5;
_loc16_.y = param9;
_loc16_.z = param4;
}
_loc12_ = _loc13_;
while(_loc12_ != null)
{
_loc12_.cameraX = param2.ma * _loc12_.x + param2.mb * _loc12_.y + param2.mc * _loc12_.z + param2.md;
_loc12_.cameraY = param2.me * _loc12_.x + param2.mf * _loc12_.y + param2.mg * _loc12_.z + param2.mh;
_loc12_.cameraZ = param2.mi * _loc12_.x + param2.mj * _loc12_.y + param2.mk * _loc12_.z + param2.ml;
if(_loc12_.cameraZ <= 0)
{
return;
}
_loc12_ = _loc12_.next;
}
var _loc17_:Number = param1.viewSizeX;
var _loc18_:Number = param1.viewSizeY;
_loc12_ = _loc13_;
while(_loc12_ != null)
{
_loc20_ = 1 / _loc12_.cameraZ;
_loc12_.cameraX = _loc12_.cameraX * _loc17_ * _loc20_;
_loc12_.cameraY = _loc12_.cameraY * _loc18_ * _loc20_;
_loc12_ = _loc12_.next;
}
var _loc19_:Sprite = param1.view.canvas;
_loc19_.graphics.lineStyle(0,param3 == 0 ? uint(uint(16711680)) : (param3 == 1 ? uint(uint(65280)) : uint(uint(255))),param11);
_loc19_.graphics.moveTo(_loc13_.cameraX,_loc13_.cameraY);
_loc19_.graphics.lineTo(_loc14_.cameraX,_loc14_.cameraY);
_loc19_.graphics.lineTo(_loc15_.cameraX,_loc15_.cameraY);
_loc19_.graphics.lineTo(_loc16_.cameraX,_loc16_.cameraY);
_loc19_.graphics.lineTo(_loc13_.cameraX,_loc13_.cameraY);
}
alternativa3d static function drawBone(param1:Camera3D, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:int) : void
{
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc13_:Number = NaN;
var _loc14_:Number = NaN;
var _loc15_:Sprite = null;
var _loc8_:Number = param4 - param2;
var _loc9_:Number = param5 - param3;
var _loc10_:Number = Math.sqrt(_loc8_ * _loc8_ + _loc9_ * _loc9_);
if(_loc10_ > 0.001)
{
_loc8_ /= _loc10_;
_loc9_ /= _loc10_;
_loc11_ = _loc9_ * param6;
_loc12_ = -_loc8_ * param6;
_loc13_ = -_loc9_ * param6;
_loc14_ = _loc8_ * param6;
if(_loc10_ > param6 * 2)
{
_loc10_ = param6;
}
else
{
_loc10_ /= 2;
}
_loc15_ = param1.view.canvas;
_loc15_.graphics.lineStyle(1,param7);
_loc15_.graphics.beginFill(param7,0.6);
_loc15_.graphics.moveTo(param2,param3);
_loc15_.graphics.lineTo(param2 + _loc8_ * _loc10_ + _loc11_,param3 + _loc9_ * _loc10_ + _loc12_);
_loc15_.graphics.lineTo(param4,param5);
_loc15_.graphics.lineTo(param2 + _loc8_ * _loc10_ + _loc13_,param3 + _loc9_ * _loc10_ + _loc14_);
_loc15_.graphics.lineTo(param2,param3);
_loc15_.graphics.endFill();
}
}
}
}
|
package forms.payment
{
import controls.Label;
import controls.statassets.StatLineBackgroundNormal;
import controls.statassets.StatLineBackgroundSelected;
import fl.controls.listClasses.CellRenderer;
import fl.controls.listClasses.ListData;
import flash.display.Bitmap;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
import utils.TextUtils;
public class PaymentListRenderer extends CellRenderer
{
private static var _withSMSText:Boolean = false;
private var nicon:DisplayObject;
private var sicon:DisplayObject;
public function PaymentListRenderer()
{
super();
}
override public function set data(value:Object) : void
{
_data = value;
_withSMSText = _data.smsText !== "";
var nr:DisplayObject = new StatLineBackgroundNormal();
var sl:DisplayObject = new StatLineBackgroundSelected();
this.nicon = this.myIcon(_data);
setStyle("upSkin",nr);
setStyle("downSkin",nr);
setStyle("overSkin",nr);
setStyle("selectedUpSkin",sl);
setStyle("selectedOverSkin",sl);
setStyle("selectedDownSkin",sl);
}
override public function set listData(value:ListData) : void
{
_listData = value;
label = _listData.label;
if(this.nicon != null)
{
setStyle("icon",this.nicon);
}
}
private function myIcon(data:Object) : Sprite
{
var cont:Sprite = null;
cont = new Sprite();
var number:Label = new Label();
var smsText:Label = new Label();
var smsTextBmp:Bitmap = new Bitmap();
var cost:Label = new Label();
var crystals:Label = new Label();
var roubles:Label = new Label();
var subwidth:int = !!_withSMSText ? int(int(60)) : int(int((_width - 72) / 2));
number.autoSize = TextFieldAutoSize.NONE;
number.align = TextFormatAlign.CENTER;
number.size = 13;
number.height = 20;
number.x = -5;
number.width = 70;
number.text = _data.number;
cont.addChild(number);
cost.autoSize = TextFieldAutoSize.NONE;
cost.align = TextFormatAlign.RIGHT;
cost.size = 13;
cost.height = 20;
cost.text = _data.cost;
cost.x = 72;
cost.width = int(subwidth) - 7;
cont.addChild(cost);
if(_withSMSText)
{
smsText.autoSize = TextFieldAutoSize.NONE;
smsText.align = TextFormatAlign.LEFT;
smsText.size = 12;
smsText.height = 20;
smsTextBmp.x = 72;
smsText.width = _width - 170;
smsText.text = _data.smsText;
smsTextBmp.bitmapData = TextUtils.getTextInCells(smsText,12,18,5898034);
cont.addChild(smsTextBmp);
cost.x = smsText.width + 74;
}
crystals.autoSize = TextFieldAutoSize.NONE;
crystals.align = TextFormatAlign.RIGHT;
crystals.size = 13;
crystals.height = 20;
crystals.x = cost.x + cost.width + 2;
crystals.width = int(_width - crystals.x - 12);
crystals.text = _data.crystals;
cont.addChild(crystals);
return cont;
}
override protected function drawBackground() : void
{
var styleName:String = !!enabled ? mouseState : "disabled";
if(selected)
{
styleName = "selected" + styleName.substr(0,1).toUpperCase() + styleName.substr(1);
}
styleName += "Skin";
var bg:DisplayObject = background;
background = getDisplayObjectInstance(getStyleValue(styleName));
addChildAt(background,0);
if(bg != null && bg != background)
{
removeChild(bg);
}
}
override protected function drawLayout() : void
{
super.drawLayout();
}
override protected function drawIcon() : void
{
var oldIcon:DisplayObject = icon;
var styleName:String = !!enabled ? mouseState : "disabled";
if(selected)
{
styleName = "selected" + styleName.substr(0,1).toUpperCase() + styleName.substr(1);
}
styleName += "Icon";
var iconStyle:Object = getStyleValue(styleName);
if(iconStyle == null)
{
iconStyle = getStyleValue("icon");
}
if(iconStyle != null)
{
icon = getDisplayObjectInstance(iconStyle);
}
if(icon != null)
{
addChildAt(icon,1);
}
if(oldIcon != null && oldIcon != icon && oldIcon.parent == this)
{
removeChild(oldIcon);
}
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_darkClass.png")]
public class HudInventoryIcon_darkClass extends BitmapAsset {
public function HudInventoryIcon_darkClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.engine {
public interface IEngineModelBase {
}
}
|
package platform.client.fp10.core.resource {
import alternativa.types.Long;
import flash.utils.ByteArray;
public interface IResourceLocalStorageInternal {
function getResourceData(param1:Long, param2:int, param3:String) : ByteArray;
function setResourceData(param1:Long, param2:int, param3:ByteArray, param4:String, param5:String) : void;
function clearResourceData(param1:Long) : void;
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.splash {
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 SplashModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function SplashModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.pointbased.ctf {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.battle.pointbased.ctf.CaptureTheFlagCC;
public class VectorCodecCaptureTheFlagCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecCaptureTheFlagCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(CaptureTheFlagCC,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.<CaptureTheFlagCC> = new Vector.<CaptureTheFlagCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = CaptureTheFlagCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:CaptureTheFlagCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<CaptureTheFlagCC> = Vector.<CaptureTheFlagCC>(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.battlefield.gui.models.inventory.item
{
import scpacker.Base;
public class InventoryItemModelBase extends Base
{
public function InventoryItemModelBase()
{
super();
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.clanmanagement.ClanStateButton_ButtonOverCenter.png")]
public class ClanStateButton_ButtonOverCenter extends BitmapAsset {
public function ClanStateButton_ButtonOverCenter() {
super();
}
}
}
|
package projects.tanks.clients.flash.commons.services.serverhalt {
public class ServerHaltService implements IServerHaltService {
private var _isServerHalt:Boolean;
public function ServerHaltService() {
super();
}
public function setServerHalt(param1:Boolean) : void {
this._isServerHalt = param1;
}
public function get isServerHalt() : Boolean {
return this._isServerHalt;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.artillery {
public interface IWeaponRotationLimitModelBase {
}
}
|
package alternativa.tanks.battle.objects.tank.controllers {
public interface ChassisControlListener {
function onChassisControlChanged(param1:int, param2:Boolean) : void;
}
}
|
package alternativa.tanks.models.battle.commonflag {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.BSP;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.physics.Body;
import alternativa.physics.BodyState;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.CTFTargetEvaluator;
import alternativa.tanks.battle.TeamDMTargetEvaluator;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.events.BattleRestartEvent;
import alternativa.tanks.battle.events.LocalTankActivationEvent;
import alternativa.tanks.battle.events.LocalTankKilledEvent;
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.ClientTankState;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.scene3d.BattleScene3D;
import alternativa.tanks.models.battle.battlefield.BattleUserInfoService;
import alternativa.tanks.models.battle.battlefield.mine.IBattleMinesModel;
import alternativa.tanks.models.battle.ctf.CTFCommonTargetEvaluator;
import alternativa.tanks.models.battle.ctf.CTFRailgunTargetEvaluator;
import alternativa.tanks.models.battle.ctf.FlagPickupTimeoutTask;
import alternativa.tanks.models.battle.rugby.explosion.BallExplosion;
import alternativa.tanks.models.battle.tdm.TDMHealingGunTargetEvaluator;
import alternativa.tanks.models.inventory.IInventoryModel;
import alternativa.tanks.models.inventory.InventoryItemType;
import alternativa.tanks.models.inventory.InventoryLock;
import alternativa.tanks.models.weapon.ricochet.CTFRicochetTargetEvaluator;
import alternativa.tanks.service.settings.keybinding.GameActionEnum;
import alternativa.tanks.services.battleinput.BattleInputService;
import alternativa.tanks.services.battleinput.GameActionListener;
import alternativa.types.Long;
import alternativa.utils.TextureMaterialRegistry;
import flash.display.BitmapData;
import flash.utils.Dictionary;
import flash.utils.getTimer;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.StubBitmapData;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.battle.pointbased.ClientTeamPoint;
import projects.tanks.client.battlefield.models.battle.pointbased.IPointBasedBattleModelBase;
import projects.tanks.client.battlefield.models.battle.pointbased.PointBasedBattleModelBase;
import projects.tanks.client.battlefield.models.battle.pointbased.flag.ClientFlag;
import projects.tanks.client.battlefield.models.battle.pointbased.flag.ClientFlagFlyingData;
import projects.tanks.client.battlefield.models.battle.pointbased.flag.FlagState;
import projects.tanks.client.battlefield.types.Vector3d;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
[ModelInfo]
public class PointBasedBattleModel extends PointBasedBattleModelBase implements IPointBasedBattleModelBase, ICommonFlagModeModel, ObjectLoadPostListener, ObjectUnloadListener, IFlagBaseTrigerEvents, GameActionListener {
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var battleService:BattleService;
[Inject]
public static var materialRegistry:TextureMaterialRegistry;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var userInfoService:BattleUserInfoService;
[Inject]
public static var battleInputLockService:BattleInputService;
[Inject]
public static var battleInputService:BattleInputService;
private static const FLAG_PICKUP_LOCK_DURATION:int = 5000;
private static const BALL_PICKUP_LOCK_DURATION:int = 200;
private static const TEAM_POINT_EQUIVALENT_RADIUS:int = 200;
private var dropCommandSent:Boolean;
private var battleMinesModel:IBattleMinesModel;
private var inventoryModel:IInventoryModel;
private var flags:Dictionary;
private var basePointDatas:Dictionary;
private var battleEventSupport:BattleEventSupport;
private var loadedTanks:Dictionary;
private var localTank:Tank;
private var triggers:Vector.<FlagBaseTrigger>;
private var targetEvaluators:Vector.<TeamDMTargetEvaluator>;
private var battleObject:IGameObject;
private var ballTouchedServerFunction:Function;
public function PointBasedBattleModel() {
super();
this.battleEventSupport = new BattleEventSupport(battleEventDispatcher);
this.battleEventSupport.addEventHandler(BattleFinishEvent,this.onBattleFinish);
this.battleEventSupport.addEventHandler(BattleRestartEvent,this.onBattleRestart);
this.battleEventSupport.addEventHandler(TankLoadedEvent,this.onTankLoaded);
this.battleEventSupport.addEventHandler(TankUnloadedEvent,this.onTankUnloaded);
this.battleEventSupport.addEventHandler(TankAddedToBattleEvent,this.onTankAddedToBattle);
this.battleEventSupport.addEventHandler(LocalTankActivationEvent,this.onLocalTankActivated);
this.battleEventSupport.addEventHandler(LocalTankKilledEvent,this.onLocalTankDie);
}
private static function createPedestal(param1:Tanks3DSResource) : Object3D {
var local2:Mesh = Mesh(param1.objects[0]);
var local3:BSP = new BSP();
local3.createTree(local2);
var local4:BitmapData = param1.getTextureForObject(0);
if(local4 == null) {
local4 = new StubBitmapData(16776960);
}
var local5:TextureMaterial = materialRegistry.getMaterial(local4);
local5.resolution = 1;
local3.setMaterialToAllFaces(local5);
return local3;
}
private function ballTouchedImpl(param1:int) : void {
server.ballTouched(param1);
}
public function objectLoadedPost() : void {
var local1:ClientTeamPoint = null;
var local2:CommonFlag = null;
this.battleObject = object;
this.loadedTanks = new Dictionary();
this.triggers = new Vector.<FlagBaseTrigger>();
this.flags = new Dictionary();
this.basePointDatas = new Dictionary();
this.ballTouchedServerFunction = getFunctionWrapper(this.ballTouchedImpl);
for each(local1 in getInitParam().teamPoints) {
this.basePointDatas[local1.id] = local1;
}
this.inventoryModel = IInventoryModel(object.adapt(IInventoryModel));
this.battleMinesModel = IBattleMinesModel(object.adapt(IBattleMinesModel));
battleInputService.addGameActionListener(this);
this.battleEventSupport.activateHandlers();
this.initTargetEvaluators();
IFlagModeInitilizer(object.event(IFlagModeInitilizer)).init(getInitParam().flags,getInitParam().teamPoints);
if(battleInfoService.running) {
for each(local2 in this.flags) {
if(local2.carrier != null) {
FlagNotification(object.adapt(FlagNotification)).guiShowFlagCarried(local2);
}
}
}
}
public function objectUnloaded() : void {
var local1:CommonFlag = null;
battleInputService.removeGameActionListener(this);
for each(local1 in this.flags) {
local1.dispose();
}
this.flags = null;
this.localTank = null;
this.loadedTanks = null;
this.triggers = null;
this.flags = null;
this.basePointDatas = null;
this.battleEventSupport.deactivateHandlers();
this.targetEvaluators = null;
battleService.setCommonTargetEvaluator(null);
battleService.setHealingGunTargetEvaluator(null);
battleService.setRailgunTargetEvaluator(null);
this.battleObject = null;
}
public function flagTaken(param1:int, param2:Long) : void {
var local5:CommonFlag = null;
var local3:CommonFlag = this.getFlag(param1);
local3.stopFalling();
var local4:Tank = this.loadedTanks[param2];
if(local4 == null) {
return;
}
if(this.localTank != null && this.localTank == local4) {
this.setLocalFlagCarrier(local3,param2,local4);
} else {
this.setRemoteFlagCarrier(local3,param2,local4);
}
if(this.localTank != null || Boolean(battleInfoService.isSpectatorMode())) {
this.disableFlagPickup(local3);
if(this.localTank != null && local4 == this.localTank) {
for each(local5 in this.flags) {
if(local3 != local5 && local3.teamType == local5.teamType) {
this.disableFlagPickup(local5);
}
}
}
FlagNotification(object.adapt(FlagNotification)).notifyFlagTaken(local3,local4);
}
FlagNotification(object.adapt(FlagNotification)).guiShowFlagCarried(local3);
}
private function handleDropIfLocal(param1:CommonFlag, param2:int) : void {
if(this.localTank != null) {
if(this.localTank.isSameTeam(param1.teamType)) {
this.setFlagCarrierForEvaluators(param1,null);
}
if(param1.carrier == this.localTank) {
if(this.dropCommandSent) {
this.dropCommandSent = false;
battleService.getBattleRunner().addLogicUnit(new FlagPickupTimeoutTask(this,param1,getTimer() + param2));
this.disableFlagPickup(param1);
}
} else {
this.enableFlagPickupWithoutCheck(param1);
}
}
}
public function flagDelivered(param1:int, param2:int, param3:Long) : void {
var local5:Tank = null;
var local4:CommonFlag = this.getFlag(param1);
this.returnFlag(local4);
if(this.localTank != null || Boolean(battleInfoService.isSpectatorMode())) {
local5 = this.loadedTanks[param3];
if(local5 != null) {
FlagNotification(object.adapt(FlagNotification)).notifyFlagDelivered(local4,local5);
}
}
}
public function onEnterFlagBaseZone() : void {
this.inventoryModel.lockItem(InventoryItemType.MINE,InventoryLock.FORCED,true);
}
public function onLeaveFlagBaseZone() : void {
this.inventoryModel.lockItem(InventoryItemType.MINE,InventoryLock.FORCED,false);
}
public function onFlagTouch(param1:CommonFlag) : void {
if(param1.registerTouch()) {
this.sendFullMoveCommand();
this.ballTouchedServerFunction.apply(null,[param1.id]);
}
}
public function sendFullMoveCommand() : void {
this.battleEventSupport.dispatchEvent(StateCorrectionEvent.MANDATORY_UPDATE);
}
public function onPickupTimeoutPassed(param1:CommonFlag) : void {
this.tryToEnableFlagPickup(param1);
}
public function onGameAction(param1:GameActionEnum, param2:Boolean) : void {
if(param1 == GameActionEnum.DROP_FLAG && param2) {
this.sendDropFlagCommand();
}
}
private function sendDropFlagCommand() : void {
var flag:CommonFlag = null;
if(Boolean(battleService.isBattleActive()) && this.localTank != null && !this.dropCommandSent) {
flag = this.getFlagWithCarrier(this.localTank);
if(flag != null) {
object = this.battleObject;
try {
this.dropCommandSent = true;
this.sendFullMoveCommand();
server.dropFlagCommand();
}
finally {
Model.popObject();
}
}
}
}
private function getFlagWithCarrier(param1:Tank) : CommonFlag {
var local2:CommonFlag = null;
for each(local2 in this.flags) {
if(local2.carrier == param1) {
return local2;
}
}
return null;
}
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 {
var local3:CommonFlag = null;
var local4:Body = null;
var local5:BodyState = null;
var local6:Vector3 = null;
var local2:Tank = param1.tank;
for each(local3 in this.flags) {
if(local3.carrier == local2) {
local4 = local2.getBody();
local5 = local4.state;
local6 = local5.position;
if(battleInfoService.running) {
object = this.battleObject;
FlagNotification(object.adapt(FlagNotification)).notifyFlagDropped(local3);
popObject();
}
local3.dropAt(local6);
break;
}
}
delete this.loadedTanks[local2.getUser().id];
}
private function onTankAddedToBattle(param1:TankAddedToBattleEvent) : void {
var local2:CommonFlag = null;
for each(local2 in this.flags) {
if(local2.state == FlagState.CARRIED && local2.carrierId == param1.tank.getUser().id) {
this.setRemoteFlagCarrier(local2,local2.carrierId,param1.tank);
this.disableFlagPickup(local2);
break;
}
}
}
private function onLocalTankActivated(param1:Object) : void {
var local2:TeamDMTargetEvaluator = null;
this.enableFlagsPickup();
for each(local2 in this.targetEvaluators) {
local2.setLocalTeamType(this.localTank.teamType);
}
}
private function onLocalTankDie(param1:Object) : void {
this.disableFlagsPickup();
}
private function onBattleRestart(param1:Object) : void {
var local2:CommonFlag = null;
var local3:FlagBaseTrigger = null;
for each(local2 in this.flags) {
this.returnFlag(local2);
}
for each(local3 in this.triggers) {
local3.reset();
}
}
private function onBattleFinish(param1:Object) : void {
this.dropCommandSent = false;
this.disableFlagsPickup();
}
private function enableFlagsPickup() : void {
var local1:CommonFlag = null;
for each(local1 in this.flags) {
this.tryToEnableFlagPickup(local1);
}
}
private function disableFlagsPickup() : void {
var local1:CommonFlag = null;
for each(local1 in this.flags) {
this.disableFlagPickup(local1);
}
}
private function tryToEnableFlagPickup(param1:CommonFlag) : void {
if(this.localTank != null && this.localTank.state == ClientTankState.ACTIVE && Boolean(battleService.isBattleActive()) && param1.state != FlagState.CARRIED && param1.state != FlagState.EXILED) {
this.enableFlagPickupWithoutCheck(param1);
}
}
private function enableFlagPickupWithoutCheck(param1:CommonFlag) : void {
battleService.getBattleRunner().addTrigger(param1);
}
private function disableFlagPickup(param1:CommonFlag) : void {
battleService.getBattleRunner().removeTrigger(param1);
}
private function setLocalFlagCarrier(param1:CommonFlag, param2:Long, param3:Tank) : void {
param1.setLocalCarrier(param2,param3);
this.setupEvaluators(param1,param3);
}
private function setRemoteFlagCarrier(param1:CommonFlag, param2:Long, param3:Tank) : void {
param1.setRemoteCarrier(param2,param3);
this.setupEvaluators(param1,param3);
}
private function setupEvaluators(param1:CommonFlag, param2:Tank) : void {
if(param2 != null && this.localTank != null && param2.teamType != this.localTank.teamType) {
this.setFlagCarrierForEvaluators(param1,param2.getBody());
}
}
private function initTargetEvaluators() : void {
this.targetEvaluators = new Vector.<TeamDMTargetEvaluator>();
var local1:CTFCommonTargetEvaluator = new CTFCommonTargetEvaluator();
battleService.setCommonTargetEvaluator(local1);
this.targetEvaluators.push(local1);
var local2:TDMHealingGunTargetEvaluator = new TDMHealingGunTargetEvaluator();
battleService.setHealingGunTargetEvaluator(local2);
this.targetEvaluators.push(local2);
var local3:CTFRailgunTargetEvaluator = new CTFRailgunTargetEvaluator();
battleService.setRailgunTargetEvaluator(local3);
this.targetEvaluators.push(local3);
var local4:CTFRicochetTargetEvaluator = new CTFRicochetTargetEvaluator();
battleService.setRicochetTargetEvaluator(local4);
this.targetEvaluators.push(local4);
}
private function setFlagCarrierForEvaluators(param1:CommonFlag, param2:Body) : void {
var local3:TeamDMTargetEvaluator = null;
for each(local3 in this.targetEvaluators) {
if(local3 is CTFTargetEvaluator) {
CTFTargetEvaluator(local3).setFlagCarrier(param1,param2);
}
}
}
private function getFlag(param1:int) : CommonFlag {
return this.flags[param1];
}
public function initFlag(param1:CommonFlag, param2:ClientFlag) : void {
var local4:Tank = null;
param1.setTriggerCallback(this);
param1.returnToBase();
this.flags[param2.flagId] = param1;
var local3:BattleScene3D = battleService.getBattleScene3D();
param1.addToScene();
local3.addRenderer(param1,1);
local3.hidableGraphicObjects.add(param1);
param1.ballTouchedFunction = this.onFlagTouch;
if(battleInfoService.running) {
if(param2.flagCarrierId != null) {
local4 = this.loadedTanks[param2.flagCarrierId];
this.setRemoteFlagCarrier(param1,param2.flagCarrierId,local4);
} else if(param2.flagPosition != null && param2.state != FlagState.EXILED && param2.state != FlagState.AT_BASE) {
if(param2.fallingData.falling) {
if(param2.state == FlagState.DROPPED) {
this.dropFlyingFlag(param2.flagId,0,param2.fallingData);
} else {
this.throwFlyingFlag(param2.flagId,param2.fallingData);
}
} else {
param1.dropAt(Vector3.fromVector3d(param2.flagPosition));
FlagNotification(object.adapt(FlagNotification)).guiShowFlagDropped(param1);
}
}
}
}
public function createBasePoint(param1:ClientTeamPoint, param2:Tanks3DSResource) : Object3D {
var local3:Object3D = createPedestal(param2);
var local4:Vector3 = BattleUtils.getVector3(param1.flagBasePosition);
local3.x = local4.x;
local3.y = local4.y;
local3.z = local4.z;
battleService.getBattleScene3D().addObject(local3);
this.addMineProtectedZone(local4);
this.addTouchTrigger(local4);
return local3;
}
public function getFlags() : Vector.<ClientFlag> {
return getInitParam().flags;
}
public function getPoints() : Vector.<ClientTeamPoint> {
return getInitParam().teamPoints;
}
public function getLocalTank() : Tank {
return this.localTank;
}
public function exileFlag(param1:int) : void {
this.dropCommandSent = false;
var local2:CommonFlag = this.getFlag(param1);
if(local2.state != FlagState.EXILED) {
BattleUtils.tmpVector.copy(local2.getIndicatorPosition());
FlagNotification(object.adapt(FlagNotification)).notifyFlagDropped(local2);
local2.returnToBase();
this.disableFlagPickup(local2);
if(battleInfoService.running) {
BallExplosion(object.adapt(BallExplosion)).createExplosionEffects(BattleUtils.tmpVector);
FlagNotification(object.adapt(FlagNotification)).notifyReadyToFaceOff();
}
}
}
public function addMineProtectedZone(param1:Vector3) : void {
this.addTrigger(param1,this.battleMinesModel.getMinDistanceFromBase(),this);
}
public function addTouchTrigger(param1:Vector3) : void {
this.addTrigger(param1,TEAM_POINT_EQUIVALENT_RADIUS,new FlagBaseTriggerHandler(getFunctionWrapper(this.sendFullMoveCommand)));
}
private function addTrigger(param1:Vector3, param2:Number, param3:IFlagBaseTrigerEvents) : void {
var local4:FlagBaseTrigger = new FlagBaseTrigger(param1,param2,param3,battleService.getBattleRunner().getCollisionDetector());
this.triggers.push(local4);
battleService.getBattleRunner().addTrigger(local4);
}
public function dropFlyingFlag(param1:int, param2:int, param3:ClientFlagFlyingData) : void {
var local4:CommonFlag = this.getFlag(param1);
local4.dropFlying(param3,FlagState.DROPPED);
this.tryToEnableFlagPickup(local4);
FlagNotification(object.adapt(FlagNotification)).notifyFlagFacedOff(local4);
}
public function throwFlyingFlag(param1:int, param2:ClientFlagFlyingData) : void {
var local3:CommonFlag = this.getFlag(param1);
this.handleDropIfLocal(local3,BALL_PICKUP_LOCK_DURATION);
FlagNotification(object.adapt(FlagNotification)).notifyFlagThrown(local3);
local3.dropFlying(param2,FlagState.FLYING);
}
private function returnFlag(param1:CommonFlag) : void {
this.dropCommandSent = false;
param1.returnToBase();
if(Boolean(this.localTank) && Boolean(this.localTank.teamType)) {
this.setFlagCarrierForEvaluators(param1,null);
}
FlagNotification(object.adapt(FlagNotification)).guiShowFlagAtBase(param1);
}
public function returnFlagToBase(param1:int, param2:IGameObject) : void {
var local3:CommonFlag = this.getFlag(param1);
this.returnFlag(local3);
FlagNotification(object.adapt(FlagNotification)).notifyFlagReturned(local3,param2);
}
public function dropFlag(param1:int, param2:Vector3d) : void {
var local3:CommonFlag = this.getFlag(param1);
if(local3.carrierId != null) {
this.handleDropIfLocal(local3,FLAG_PICKUP_LOCK_DURATION);
FlagNotification(object.adapt(FlagNotification)).notifyFlagDropped(local3);
local3.dropAt(Vector3.fromVector3d(param2));
}
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.smoky {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.types.Vector3d;
public class SmokyModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:SmokyModelServer;
private var client:ISmokyModelBase = ISmokyModelBase(this);
private var modelId:Long = Long.getLong(505740619,208573179);
private var _localCriticalHitId:Long = Long.getLong(1314377165,-137514211);
private var _localCriticalHit_targetCodec:ICodec;
private var _shootId:Long = Long.getLong(1283643622,1059974789);
private var _shoot_shooterCodec:ICodec;
private var _shootStaticId:Long = Long.getLong(954743485,-2074939053);
private var _shootStatic_shooterCodec:ICodec;
private var _shootStatic_hitPointCodec:ICodec;
private var _shootTargetId:Long = Long.getLong(954743485,-2063362954);
private var _shootTarget_shooterCodec:ICodec;
private var _shootTarget_targetCodec:ICodec;
private var _shootTarget_hitPointCodec:ICodec;
private var _shootTarget_weakeningCoeffCodec:ICodec;
private var _shootTarget_isCriticalCodec:ICodec;
public function SmokyModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new SmokyModelServer(IModel(this));
this._localCriticalHit_targetCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._shoot_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._shootStatic_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._shootStatic_hitPointCodec = this._protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._shootTarget_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._shootTarget_targetCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._shootTarget_hitPointCodec = this._protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._shootTarget_weakeningCoeffCodec = this._protocol.getCodec(new TypeCodecInfo(Float,false));
this._shootTarget_isCriticalCodec = this._protocol.getCodec(new TypeCodecInfo(Boolean,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._localCriticalHitId:
this.client.localCriticalHit(IGameObject(this._localCriticalHit_targetCodec.decode(param2)));
break;
case this._shootId:
this.client.shoot(IGameObject(this._shoot_shooterCodec.decode(param2)));
break;
case this._shootStaticId:
this.client.shootStatic(IGameObject(this._shootStatic_shooterCodec.decode(param2)),Vector3d(this._shootStatic_hitPointCodec.decode(param2)));
break;
case this._shootTargetId:
this.client.shootTarget(IGameObject(this._shootTarget_shooterCodec.decode(param2)),IGameObject(this._shootTarget_targetCodec.decode(param2)),Vector3d(this._shootTarget_hitPointCodec.decode(param2)),Number(this._shootTarget_weakeningCoeffCodec.decode(param2)),Boolean(this._shootTarget_isCriticalCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.battleselect.model.matchmaking.spectator {
public interface IMatchmakingSpectatorEntranceModelBase {
function enterFailedNoSuitableBattles() : void;
}
}
|
package alternativa.tanks.view.battleinfo {
import flash.events.Event;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class BattleInfoViewEvent extends Event {
public static const ENTER_BATTLE:String = "BattleInfoViewEvent.ENTER_BATTLE";
public static const ENTER_SPECTATOR:String = "BattleInfoViewEvent.ENTER_SPECTATOR";
public static const BUY_PRO_ABONEMENT:String = "BattleInfoViewEvent.BUY_PRO_ABONEMENT";
public var team:BattleTeam;
public function BattleInfoViewEvent(param1:String, param2:BattleTeam = null) {
super(param1);
this.team = param2;
}
override public function clone() : Event {
return new BattleInfoViewEvent(type,this.team);
}
}
}
|
package alternativa.tanks.models.tank.reloader {
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.death.TankReloadedEvent;
import alternativa.tanks.battle.events.reload.ReloadScheduledEvent;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.event.LocalTankLoadListener;
import alternativa.tanks.models.tank.support.TankReloaderSupport;
import projects.tanks.client.battlefield.models.user.reloader.ITankReloaderModelBase;
import projects.tanks.client.battlefield.models.user.reloader.TankReloaderModelBase;
[ModelInfo]
public class TankReloaderModel extends TankReloaderModelBase implements ITankReloaderModelBase, LocalTankLoadListener {
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
public function TankReloaderModel() {
super();
}
public function localTankLoaded(param1:Boolean) : void {
if(!param1) {
putData(TankReloaderSupport,new TankReloaderSupport(object));
}
}
[Obfuscation(rename="false")]
public function onDeathScheduled(param1:int) : void {
battleEventDispatcher.dispatchEvent(new ReloadScheduledEvent(param1));
}
[Obfuscation(rename="false")]
public function die(param1:int) : void {
var local2:ITankModel = ITankModel(object.adapt(ITankModel));
local2.die(param1);
}
[Obfuscation(rename="false")]
public function onReload() : void {
battleEventDispatcher.dispatchEvent(new TankReloadedEvent(object.id));
}
}
}
|
package alternativa.tanks.model.gift
{
import alternativa.model.IResourceLoadListener;
import alternativa.tanks.model.gift.icons.ItemGiftBackgrounds;
import alternativa.tanks.model.gift.server.GiftServerItem;
import alternativa.types.Long;
import assets.icons.InputCheckIcon;
import assets.scroller.color.ScrollThumbSkinGreen;
import assets.scroller.color.ScrollTrackGreen;
import controls.Label;
import fl.controls.ScrollBarDirection;
import fl.controls.TileList;
import fl.data.DataProvider;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.GlowFilter;
import flash.geom.Rectangle;
import flash.system.Capabilities;
import flash.utils.getTimer;
import forms.RegisterForm;
import scpacker.resource.ResourceType;
import scpacker.resource.ResourceUtil;
import scpacker.resource.images.ImageResource;
public class GiftInfoList extends Sprite implements IResourceLoadListener
{
private static const MIN_POSSIBLE_SPEED:Number = 70;
private static const MAX_DELTA_FOR_SELECT:Number = 7;
private static const ADDITIONAL_SCROLL_AREA_HEIGHT:Number = 3;
private var list:TileList;
private var dataProvider:DataProvider;
private var previousPositionX:Number;
private var currentPositionX:Number;
private var sumDragWay:Number;
private var lastItemIndex:int;
private var previousTime:int;
private var currentTime:int;
private var scrollSpeed:Number = 0;
private var _width:int;
private var _height:int;
public function GiftInfoList()
{
super();
this.dataProvider = new DataProvider();
this.list = new TileList();
this.list.dataProvider = this.dataProvider;
this.list.rowCount = 2;
this.list.rowHeight = 117;
this.list.columnWidth = 160;
this.list.setStyle("cellRenderer",GiftRollerRenderer);
this.list.direction = ScrollBarDirection.HORIZONTAL;
this.list.focusEnabled = false;
this.list.horizontalScrollBar.focusEnabled = false;
this.list.setStyle("downArrowUpSkin",ScrollArrowDownGreen);
this.list.setStyle("downArrowDownSkin",ScrollArrowDownGreen);
this.list.setStyle("downArrowOverSkin",ScrollArrowDownGreen);
this.list.setStyle("downArrowDisabledSkin",ScrollArrowDownGreen);
this.list.setStyle("upArrowUpSkin",ScrollArrowUpGreen);
this.list.setStyle("upArrowDownSkin",ScrollArrowUpGreen);
this.list.setStyle("upArrowOverSkin",ScrollArrowUpGreen);
this.list.setStyle("upArrowDisabledSkin",ScrollArrowUpGreen);
this.list.setStyle("trackUpSkin",ScrollTrackGreen);
this.list.setStyle("trackDownSkin",ScrollTrackGreen);
this.list.setStyle("trackOverSkin",ScrollTrackGreen);
this.list.setStyle("trackDisabledSkin",ScrollTrackGreen);
this.list.setStyle("thumbUpSkin",ScrollThumbSkinGreen);
this.list.setStyle("thumbDownSkin",ScrollThumbSkinGreen);
this.list.setStyle("thumbOverSkin",ScrollThumbSkinGreen);
this.list.setStyle("thumbDisabledSkin",ScrollThumbSkinGreen);
}
public function initData(items:Array) : void
{
var item:GiftServerItem = null;
var data:Object = null;
var icon:DisplayObject = null;
items.sortOn("rare",Array.NUMERIC);
var i:int = 0;
for each(item in items)
{
data = {};
data.id = item.id;
data.index = i;
data.count = item.count;
data.rare = item.rare;
data.preview = ResourceUtil.getResource(ResourceType.IMAGE,item.id + "_m0_preview");
icon = this.myIcon(data,false);
this.dataProvider.addItem({
"iconNormal":icon,
"iconSelected":icon,
"dat":data,
"accessable":false,
"rang":0,
"type":1,
"typesort":0,
"sort":1
});
i++;
}
addChild(this.list);
addEventListener(Event.ADDED_TO_STAGE,this.addListeners);
addEventListener(Event.REMOVED_FROM_STAGE,this.removeListeners);
}
private function addListeners(e:Event) : void
{
addEventListener(MouseEvent.MOUSE_WHEEL,this.scrollList);
addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
}
private function removeListeners(e:Event) : void
{
removeEventListener(MouseEvent.MOUSE_WHEEL,this.scrollList);
removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
removeEventListener(Event.ENTER_FRAME,this.onEnterFrame);
stage.removeEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
stage.removeEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
}
private function scrollList(e:MouseEvent) : void
{
this.list.horizontalScrollPosition -= e.delta * (!!Boolean(Capabilities.os.search("Linux") != -1) ? 50 : 10);
}
private function onMouseDown(e:MouseEvent) : void
{
this.scrollSpeed = 0;
var rect:Rectangle = this.list.horizontalScrollBar.getBounds(stage);
rect.top -= ADDITIONAL_SCROLL_AREA_HEIGHT;
if(!rect.contains(e.stageX,e.stageY))
{
this.sumDragWay = 0;
this.previousPositionX = this.currentPositionX = e.stageX;
this.currentTime = this.previousTime = getTimer();
this.lastItemIndex = this.list.selectedIndex;
stage.addEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
stage.addEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
}
}
private function onMouseUp(e:MouseEvent) : void
{
stage.removeEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
stage.removeEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
var delta:Number = (getTimer() - this.previousTime) / 1000;
if(delta == 0)
{
delta = 0.1;
}
var deltaX:Number = e.stageX - this.previousPositionX;
this.scrollSpeed = deltaX / delta;
this.previousTime = this.currentTime;
this.currentTime = getTimer();
addEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
private function onEnterFrame(param1:Event) : void
{
this.previousTime = this.currentTime;
this.currentTime = getTimer();
var dt:Number = (this.currentTime - this.previousTime) / 1000;
this.list.horizontalScrollPosition -= this.scrollSpeed * dt;
var horizontalPos:Number = this.list.horizontalScrollPosition;
var maxHorizontalPos:Number = this.list.maxHorizontalScrollPosition;
if(Math.abs(this.scrollSpeed) > MIN_POSSIBLE_SPEED && 0 < horizontalPos && horizontalPos < maxHorizontalPos)
{
this.scrollSpeed *= Math.exp(-1.5 * dt);
}
else
{
this.scrollSpeed = 0;
removeEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
}
private function onMouseMove(e:MouseEvent) : void
{
this.previousPositionX = this.currentPositionX;
this.currentPositionX = e.stageX;
this.previousTime = this.currentTime;
this.currentTime = getTimer();
var deltaX:Number = this.currentPositionX - this.previousPositionX;
this.sumDragWay += Math.abs(deltaX);
if(this.sumDragWay > MAX_DELTA_FOR_SELECT)
{
this.list.horizontalScrollPosition -= deltaX;
}
e.updateAfterEvent();
}
public function resourceLoaded(resource:Object) : void
{
var item:Object = null;
for(var i:int = 0; i < this.dataProvider.length; i++)
{
item = this.dataProvider.getItemAt(i);
if(resource.id.split("_m0_preview")[0] == item.dat.id)
{
this.update(item.dat.index,"preview",resource as ImageResource);
}
}
}
private function itemByIndex(id:Object, searchInSilent:Boolean = false) : int
{
var obj:Object = null;
for(var i:int = 0; i < this.dataProvider.length; i++)
{
obj = this.dataProvider.getItemAt(i);
if(obj.dat.index == i)
{
return i;
}
}
return -1;
}
public function update(index:int, param:String, value:* = null) : void
{
var iNormal:DisplayObject = null;
var iSelected:DisplayObject = null;
var obj:Object = this.dataProvider.getItemAt(index);
var data:Object = obj.dat;
data[param] = value;
iNormal = this.myIcon(data,false);
iSelected = this.myIcon(data,true);
obj.dat = data;
obj.iconNormal = iNormal;
obj.iconSelected = iSelected;
this.dataProvider.replaceItemAt(obj,index);
this.dataProvider.invalidateItemAt(index);
}
public function resourceUnloaded(resourceId:Long) : void
{
}
private function myIcon(param1:Object, param2:Boolean) : DisplayObject
{
var _loc5_:BitmapData = null;
var _loc6_:ImageResource = null;
var _loc8_:uint = 0;
var _loc10_:Bitmap = null;
var _loc11_:Label = null;
var _loc12_:GlowFilter = null;
var _loc3_:Sprite = new Sprite();
var _loc4_:Sprite = new Sprite();
_loc6_ = param1.preview;
var _loc7_:Bitmap = new Bitmap(ItemGiftBackgrounds.getBG(param1.rare));
_loc7_.x = 2;
_loc7_.y = 4;
_loc8_ = ItemGiftBackgrounds.getColor(param1.rare);
_loc4_.addChildAt(_loc7_,0);
var _loc9_:InputCheckIcon = new InputCheckIcon();
_loc6_ = param1.preview;
if(_loc6_ == null)
{
_loc4_.addChild(_loc9_);
_loc9_.x = 130 - _loc9_.width >> 1;
_loc9_.y = 93 - _loc9_.height >> 1;
_loc9_.gotoAndStop(RegisterForm.CALLSIGN_STATE_INVALID);
}
else if(_loc6_.loaded())
{
_loc10_ = new Bitmap(_loc6_.bitmapData as BitmapData);
_loc10_.width *= 0.85;
_loc10_.height *= 0.85;
_loc10_.x = 13;
_loc10_.y = 18;
_loc4_.addChild(_loc10_);
}
else if(_loc6_ != null && !_loc6_.loaded())
{
_loc4_.addChild(_loc9_);
_loc9_.x = 134 - _loc9_.width >> 1;
_loc9_.y = 97 - _loc9_.height >> 1;
_loc9_.gotoAndStop(RegisterForm.CALLSIGN_STATE_PROGRESS);
_loc6_.completeLoadListener = this;
_loc6_.load();
}
if(param1.count > 1)
{
_loc11_ = new Label();
_loc11_.text = "x" + param1.count;
_loc8_ = ItemGiftBackgrounds.getColor(param1.rare);
_loc12_ = new GlowFilter(_loc8_);
_loc12_.strength = 1.4;
_loc11_.filters = [_loc12_];
_loc11_.x = 13;
_loc11_.y = 12;
_loc4_.addChild(_loc11_);
}
_loc5_ = new BitmapData(_loc4_.width + 5,_loc4_.height + 5,true,0);
_loc5_.draw(_loc4_);
_loc3_.addChildAt(new Bitmap(_loc5_),0);
return _loc3_;
}
override public function set width(value:Number) : void
{
this._width = int(value);
this.list.width = this._width;
}
override public function get width() : Number
{
return this._width;
}
override public function set height(value:Number) : void
{
this._height = int(value);
this.list.height = this._height;
}
override public function get height() : Number
{
return this._height;
}
}
}
|
package alternativa.tanks.models.tank {
import alternativa.tanks.battle.BattleRunnerProvider;
import alternativa.tanks.battle.objects.tank.Weapon;
public class RemoteWeaponController extends BattleRunnerProvider implements IWeaponController {
private var weapon:Weapon;
public function RemoteWeaponController(param1:Weapon) {
super();
this.weapon = param1;
}
public function lockWeapon(param1:int, param2:Boolean) : void {
this.weapon.disable(false);
}
public function unlockWeapon(param1:int) : void {
this.weapon.enable();
}
public function activateWeapon() : void {
this.weapon.activate();
}
public function deactivateWeapon() : void {
this.weapon.deactivate();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.