code
stringlengths 57
237k
|
|---|
package projects.tanks.clients.flash.commons.models.serverhalt {
import forms.ServerStopAlert;
import projects.tanks.client.commons.models.clienthalt.IServerHaltModelBase;
import projects.tanks.client.commons.models.clienthalt.ServerHaltModelBase;
import projects.tanks.clients.flash.commons.services.serverhalt.IServerHaltService;
[ModelInfo]
public class ServerHaltModel extends ServerHaltModelBase implements IServerHaltModelBase {
[Inject]
public static var serverHaltService:IServerHaltService;
public function ServerHaltModel() {
super();
}
public function haltServer(param1:int) : void {
serverHaltService.setServerHalt(true);
var local2:ServerStopAlert = new ServerStopAlert(param1);
}
}
}
|
package alternativa.tanks.models.battlefield.decals
{
import alternativa.engine3d.containers.KDContainer;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Decal;
import alternativa.math.Vector3;
import alternativa.physics.collision.ICollisionDetector;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.tanks.physics.CollisionGroup;
import flash.geom.Vector3D;
public class DecalFactory
{
private static const ANGLE_LIMIT:Number = 85 * Math.PI / 180;
private static const rayHit:RayIntersection = new RayIntersection();
private static const direction:Vector3 = new Vector3();
private static const right:Vector3 = new Vector3();
private static const up:Vector3 = new Vector3();
private static const normal:Vector3 = new Vector3();
private static const origins:Vector.<Vector3> = Vector.<Vector3>([new Vector3(),new Vector3(),new Vector3(),new Vector3(),new Vector3()]);
private static const position3D:Vector3D = new Vector3D();
private static const normal3D:Vector3D = new Vector3D();
private var collisionDetector:ICollisionDetector;
public function DecalFactory(param1:ICollisionDetector)
{
super();
this.collisionDetector = param1;
}
public function createDecal(param1:Vector3, param2:Vector3, param3:Number, param4:TextureMaterial, param5:KDContainer, param6:RotationState) : Decal
{
var _loc8_:Vector3 = null;
var _loc9_:Number = NaN;
direction.vDiff(param1,param2);
var _loc7_:Number = direction.vLength() + 200;
direction.vNormalize();
right.vCross2(direction,Vector3.Z_AXIS).vNormalize();
up.vCross2(right,direction);
Vector3(origins[4]).vCopy(param2);
Vector3(origins[0]).vCopy(param2).vAddScaled(50,right);
Vector3(origins[1]).vCopy(param2).vAddScaled(50,up);
Vector3(origins[2]).vCopy(param2).vAddScaled(-50,right);
Vector3(origins[3]).vCopy(param2).vAddScaled(-50,up);
normal.reset(0,0,0);
for each(_loc8_ in origins)
{
if(this.collisionDetector.intersectRayWithStatic(_loc8_,direction,CollisionGroup.STATIC,_loc7_,null,rayHit))
{
normal.vAdd(rayHit.normal);
}
}
normal.vNormalize();
this.copyToVector3D(param1,position3D);
this.copyToVector3D(normal,normal3D);
_loc9_ = this.getRotation(param6);
return param5.createDecal(position3D,normal3D,param3,_loc9_,ANGLE_LIMIT,300,param4);
}
public function copyToVector3D(param1:Vector3, param2:Vector3D) : void
{
param2.x = param1.x;
param2.y = param1.y;
param2.z = param1.z;
}
private function getRotation(param1:RotationState) : Number
{
switch(param1)
{
case RotationState.WITHOUT_ROTATION:
return 0;
default:
return Math.random() * 2 * Math.PI;
}
}
}
}
|
package controls.timer {
public interface CountDownTimerOnTick {
function onTick(param1:CountDownTimer) : void;
}
}
|
package alternativa.tanks.models.weapon.artillery {
import alternativa.tanks.battle.objects.tank.tankskin.turret.ArtilleryTurretSkin;
[ModelInterface]
public interface ArtillerySkin {
function getSkin() : ArtilleryTurretSkin;
}
}
|
package alternativa.tanks.models.battle.jgr {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class JuggernautEvents implements Juggernaut {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function JuggernautEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function bossId() : Long {
var result:Long = null;
var i:int = 0;
var m:Juggernaut = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = Juggernaut(this.impl[i]);
result = m.bossId();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.model.challenge
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChallengesIcons_winCryBitmap extends BitmapAsset
{
public function ChallengesIcons_winCryBitmap()
{
super();
}
}
}
|
package alternativa.tanks.models.controlpoints.sound {
import alternativa.math.Vector3;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.ISound3DEffect;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.media.Sound;
public class KeyPointSoundEffect extends PooledObject implements ISound3DEffect {
private static const NEAR_RADIUS:Number = 1500;
private static const FAR_RADIUS:Number = 5000;
private static const FAR_DELIMITER:Number = 10;
private static const BASE_VOLUME:Number = 1.3;
private var sound3d:Sound3D;
private var position:Vector3 = new Vector3();
private var alive:Boolean;
public function KeyPointSoundEffect(param1:Pool) {
super(param1);
}
public function init(param1:Sound, param2:Vector3) : void {
this.sound3d = Sound3D.create(param1,BASE_VOLUME,NEAR_RADIUS,FAR_RADIUS,FAR_DELIMITER);
this.position.copy(param2);
this.alive = true;
}
public function play(param1:int, param2:GameCamera) : void {
if(!this.sound3d.isPlaying()) {
this.sound3d.play(0,99999);
}
this.sound3d.checkVolume(param2.position,this.position,param2.xAxis);
}
public function destroy() : void {
this.sound3d.stop();
Sound3D.destroy(this.sound3d);
this.sound3d = null;
recycle();
}
public function kill() : void {
this.alive = false;
}
public function set enabled(param1:Boolean) : void {
if(!param1) {
this.sound3d.stop();
}
}
public function readPosition(param1:Vector3) : void {
param1.copy(this.position);
}
public function get numSounds() : int {
return this.alive ? 1 : 0;
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapBigRank06.png")]
public class DefaultRanksBitmaps_bitmapBigRank06 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapBigRank06() {
super();
}
}
}
|
package alternativa.tanks.models.battlefield.inventory
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import alternativa.tanks.models.inventory.IInventory;
import alternativa.tanks.models.tank.ITank;
import alternativa.tanks.models.tank.TankModel;
import alternativa.types.Long;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
import projects.tanks.client.battlefield.gui.models.inventory.item.IInventoryItemModelBase;
import projects.tanks.client.battlefield.gui.models.inventory.item.InventoryItemModelBase;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
public class InventoryItemModel extends InventoryItemModelBase implements IInventoryItemModelBase, IInventoryItemModel
{
private var inventoryPanel:IInventoryPanel;
private var itemByObject:Dictionary;
private var tankInterface:TankModel;
public function InventoryItemModel()
{
this.itemByObject = new Dictionary();
super();
_interfaces.push(IModel,IInventoryItemModelBase,IInventoryItemModel);
}
public function initObject(clientObject:ClientObject, battleId:Long, count:int, itemEffectTime:int, itemId:int, itemRestSec:int) : void
{
var modelService:IModelService = null;
if(this.inventoryPanel == null)
{
modelService = IModelService(Main.osgi.getService(IModelService));
this.inventoryPanel = IInventoryPanel(modelService.getModelsByInterface(IInventoryPanel)[0]);
this.tankInterface = TankModel(Main.osgi.getService(ITank));
}
var item:InventoryItem = new InventoryItem(clientObject,itemId,count,(itemRestSec + itemEffectTime) * 1000);
this.itemByObject[clientObject] = item;
var slotIndex:int = itemId - 1;
this.inventoryPanel.assignItemToSlot(item,slotIndex);
}
public function activated(clientObject:ClientObject) : void
{
var item:InventoryItem = this.itemByObject[clientObject];
if(item == null)
{
return;
}
item.startCooldown(0);
--item.count;
this.inventoryPanel.itemActivated(item);
}
public function updateItemCount(clientObject:ClientObject, count:int) : void
{
var item:InventoryItem = this.itemByObject[clientObject];
if(item == null)
{
return;
}
item.count = count;
InventoryModel(IModelService(Main.osgi.getService(IModelService)).getModelsByInterface(IInventory)[0]).itemUpdated(item);
}
public function requestActivation(item:InventoryItem) : void
{
var v:Vector3D = null;
if(item.canActivate())
{
v = new Vector3D();
this.tankInterface.readLocalTankPosition(v);
this.activate(item.getClientObject(),v);
}
}
private function activate(clientObject:ClientObject, vector:Vector3D) : void
{
Network(Main.osgi.getService(INetworker)).send("battle;activate_item;" + clientObject.id + ";" + vector.x + ";" + vector.y + ";" + vector.z);
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ExchangeGroup_bitmapCrystal extends BitmapAsset
{
public function ExchangeGroup_bitmapCrystal()
{
super();
}
}
}
|
package alternativa.tanks.service.country {
import flash.events.IEventDispatcher;
import projects.tanks.client.panel.model.usercountry.CountryInfo;
import projects.tanks.client.panel.model.usercountry.UserCountryCC;
public interface CountryService extends IEventDispatcher {
function initService(param1:UserCountryCC) : void;
function getRegisteredCountries() : Vector.<CountryInfo>;
function getDefaultCountryCode() : String;
function setDefaultCountryCode(param1:String) : void;
function changeCountry(param1:String) : void;
function chooseCountryForPayment() : void;
}
}
|
package alternativa.tanks.models.user {
import alternativa.types.Long;
import flash.events.IEventDispatcher;
import platform.client.fp10.core.type.IGameObject;
public interface ClanUserService extends IEventDispatcher {
function get userObject() : IGameObject;
function set userObject(param1:IGameObject) : void;
function getObjectById(param1:Long) : IGameObject;
function get hasClanLicense() : Boolean;
function set hasClanLicense(param1:Boolean) : void;
function set licenseGarageObject(param1:IGameObject) : void;
function get licenseGarageObject() : IGameObject;
function get otherClan() : Boolean;
function set otherClan(param1:Boolean) : void;
function get showBuyLicenseButton() : Boolean;
function set showBuyLicenseButton(param1:Boolean) : void;
function containsClanInOutgoing(param1:String) : Boolean;
function getIncomingClanNames(param1:String) : Boolean;
function hideNotInClanPanel() : void;
}
}
|
package alternativa.tanks.bonuses {
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class RemovalAnimation extends PooledObject implements Renderer {
[Inject]
public static var battleService:BattleService;
private static const REMOVAL_ALPHA_SPEED:Number = 0.001;
private var bonusMesh:BonusMesh;
private var canRemove:Boolean;
public function RemovalAnimation(param1:Pool) {
super(param1);
}
public function init(param1:BattleBonus) : void {
this.bonusMesh = param1.getBonusMesh();
this.canRemove = false;
battleService.getBattleScene3D().addRenderer(this,0);
param1.onPickup.addOnce(this.onBonusPickup);
param1.onRemove.addOnce(this.onBonusRemove);
}
private function onBonusPickup() : void {
this.bonusMesh = null;
this.destroy();
}
private function onBonusRemove() : void {
this.canRemove = true;
}
public function render(param1:int, param2:int) : void {
if(this.canRemove) {
this.fadeOut(param2);
}
}
private function fadeOut(param1:int) : void {
var local3:Number = NaN;
var local4:Number = NaN;
var local2:Number = this.bonusMesh.getAlpha();
local2 -= REMOVAL_ALPHA_SPEED * param1;
if(local2 > 0) {
this.bonusMesh.setAlpha(local2);
local3 = this.bonusMesh.getScale();
if(local3 > 0) {
local4 = local3 - 0.002 * param1;
if(local4 < 0) {
local4 = 0;
}
this.bonusMesh.setScale(local4);
}
} else {
this.destroy();
}
}
private function destroy() : void {
battleService.getBattleScene3D().removeRenderer(this,0);
if(this.bonusMesh != null) {
this.bonusMesh.removeFromScene();
this.bonusMesh.recycle();
this.bonusMesh = null;
}
recycle();
}
}
}
|
package forms.friends
{
public interface IRejectAllIncomingButtonEnabled
{
function setEnable(param1:Boolean) : void;
}
}
|
package alternativa.tanks.models.weapon.shaft
{
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.init.Main;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.physics.Body;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.service.IModelService;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.battlefield.Object3DNames;
import alternativa.tanks.models.tank.ITank;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.tank.TankModel;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.IWeaponController;
import alternativa.tanks.models.weapon.WeaponConst;
import alternativa.tanks.models.weapon.WeaponUtils;
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapon.shaft.modes.TargetingController;
import alternativa.tanks.models.weapon.shaft.quickshot.ShaftShotResult;
import alternativa.tanks.models.weapon.shaft.quickshot.ShaftTargetSystem;
import alternativa.tanks.models.weapon.shaft.sfx.ShaftSFXModel;
import alternativa.tanks.models.weapon.shaft.states.ShaftModes;
import alternativa.tanks.models.weapon.shared.shot.ShotData;
import alternativa.tanks.models.weapon.weakening.IWeaponWeakeningModel;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import alternativa.tanks.utils.MathUtils;
import alternativa.tanks.vehicles.tanks.Tank;
import alternativa.tanks.vehicles.tanks.TankSkin;
import com.alternativaplatform.projects.tanks.client.commons.types.Vector3d;
import com.alternativaplatform.projects.tanks.client.models.tank.TankSpawnState;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.gun.IGunModelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.utils.Dictionary;
import flash.utils.getTimer;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
import scpacker.server.models.shaft.ServerShaftTargetData;
import scpacker.tanks.WeaponsManager;
public class ShaftModel implements IGunModelBase, IObjectLoadListener, IWeaponController
{
private static var _barrelOrigin:Vector3 = new Vector3();
private static const _origin:Vector3 = new Vector3();
private static const _direction:Vector3 = new Vector3();
private static const _m:Matrix4 = new Matrix4();
private static const _p:Vector3 = new Vector3();
private static const _closestBarrelOrigin:Vector3 = new Vector3();
private static const thousand:int = 1000;
private static const allGunParams:AllGlobalGunParams = new AllGlobalGunParams();
[Embed(source="1097.png")]
private static const decal:Class;
private static var decalMaterial:TextureMaterial = new TextureMaterial(new decal().bitmapData);
private var _hitPos:Vector3;
private var _hitPosLocal:Vector3;
private var _hitPosGlobal:Vector3;
private var _gunDirGlobal:Vector3;
private var _muzzlePosGlobal:Vector3;
private var _xAxis:Vector3;
private var _hitPos3d:Vector3d;
private var _tankPos3d:Vector3d;
private var weaponUtils:WeaponUtils;
private var tank:Tank;
private var localTankData:TankData;
private var localShotData:ShotData;
private var localWeaponCommonData:WeaponCommonData;
private var modelService:IModelService;
private var battlefieldModel:BattlefieldModel;
private var tankModel:TankModel;
private var weaponWeakeningModel:IWeaponWeakeningModel;
private var collisionDetector:TanksCollisionDetector;
private var weaponCommonModel:IWeaponCommonModel;
private var maxTargetingDistance:Number = 100000;
private var pressed:Boolean = false;
private var image:Bitmap;
private var activate:Boolean = false;
private var activatedTime:Number = 0;
private var indicator:Indicator;
private var targetController:TargetingController;
private var updateController:Boolean = false;
private var lock:Boolean = false;
private var indicatorBitmap:Bitmap;
private var lockCheckIntersection:Boolean;
private var energyAdditive:Number = 1000;
private var energySpeed:Number = -250;
private var energyBaseTime:int;
private var exitTime:int;
private var fired:Boolean;
private var energyMode:ShaftEnergyMode;
public var shaftData:ShaftData;
private var exclusionSet:Dictionary;
private var exclusionSetController:SetControllerForTemporaryItems;
private var multybodyPredicate:MultybodyCollisionPredicate;
private var intersection:RayIntersection;
private var quickShotTargetSystem:ShaftTargetSystem;
private var shotResult:ShaftShotResult;
private var commonModel:IWeaponCommonModel;
private var quickShot:Boolean;
private var tempRayResult:RayIntersection;
public function ShaftModel()
{
this._hitPos = new Vector3();
this._hitPosLocal = new Vector3();
this._hitPosGlobal = new Vector3();
this._gunDirGlobal = new Vector3();
this._muzzlePosGlobal = new Vector3();
this._xAxis = new Vector3();
this._hitPos3d = new Vector3d(0,0,0);
this._tankPos3d = new Vector3d(0,0,0);
this.weaponUtils = WeaponUtils.getInstance();
this.energyMode = ShaftEnergyMode.RECHARGE;
this.shaftData = new ShaftData();
this.multybodyPredicate = new MultybodyCollisionPredicate();
this.intersection = new RayIntersection();
this.quickShotTargetSystem = new ShaftTargetSystem();
this.shotResult = new ShaftShotResult();
this.tempRayResult = new RayIntersection();
super();
}
public static function globalToLocal(param1:Body, param2:Vector3) : void
{
param2.vSubtract(param1.state.pos);
param2.vTransformBy3Tr(param1.baseMatrix);
}
public static function localToGlobal(param1:Body, param2:Vector3) : void
{
param2.vTransformBy3(param1.baseMatrix);
param2.vAdd(param1.state.pos);
}
private static function getShotDirection(param1:Vector3, param2:Vector3, param3:Vector3) : Vector3
{
if(param2 != null)
{
return new Vector3().vDiff(param2,param1).vNormalize();
}
if(param3 == null)
{
param3 = allGunParams.direction;
}
return new Vector3().vDiff(param3,param1).vNormalize();
}
private static function getClosestBarrelOrigin(param1:Vector3, param2:Vector.<Vector3>, param3:Vector3) : void
{
var _loc6_:Number = NaN;
_barrelOrigin.vCopy(param2[0]);
_barrelOrigin.y = 0;
param3.vCopy(_barrelOrigin);
var _loc4_:Number = param1.distanceToSquared(_barrelOrigin);
var _loc5_:int = 1;
while(_loc5_ < param2.length)
{
_barrelOrigin.vCopy(param2[_loc5_]);
_barrelOrigin.y = 0;
_loc6_ = param1.distanceToSquared(_barrelOrigin);
if(_loc6_ < _loc4_)
{
_loc4_ = _loc6_;
param3.vCopy(_barrelOrigin);
}
_loc5_++;
}
}
public function initObject(clientObject:ClientObject, maxEnegry:Number, chargeRate:Number, dischargeRate:Number, elevationAngleUp:Number, elevationAngleDown:Number, verticalTargetingSpeed:Number, horizontalTargetingSpeed:Number, initialFOV:Number, minimumFOV:Number, shrubsHidingRadiusMin:Number, shrubsHidingRadiusMax:Number, impactQuickShot:Number) : void
{
var shaftData:ShaftData = new ShaftData();
shaftData.maxEnergy = maxEnegry;
shaftData.chargeRate = chargeRate;
shaftData.dischargeRate = dischargeRate;
shaftData.elevationAngleUp = elevationAngleUp;
shaftData.elevationAngleDown = elevationAngleDown;
shaftData.verticalTargetingSpeed = verticalTargetingSpeed;
shaftData.horizontalTargetingSpeed = horizontalTargetingSpeed;
shaftData.initialFOV = initialFOV;
shaftData.minimumFOV = minimumFOV;
shaftData.shrubsHidingRadiusMin = shrubsHidingRadiusMin;
shaftData.shrubsHidingRadiusMax = shrubsHidingRadiusMax;
shaftData.impactQuickShot = impactQuickShot * WeaponConst.BASE_IMPACT_FORCE;
clientObject.putParams(ShaftData,shaftData);
this.objectLoaded(null);
}
public function objectLoaded(object:ClientObject) : void
{
if(this.modelService == null)
{
this.modelService = IModelService(Main.osgi.getService(IModelService));
this.battlefieldModel = Main.osgi.getService(IBattleField) as BattlefieldModel;
this.tankModel = Main.osgi.getService(ITank) as TankModel;
this.weaponCommonModel = Main.osgi.getService(IWeaponCommonModel) as IWeaponCommonModel;
this.weaponWeakeningModel = IWeaponWeakeningModel(this.modelService.getModelsByInterface(IWeaponWeakeningModel)[0]);
this.commonModel = Main.osgi.getService(IWeaponCommonModel) as IWeaponCommonModel;
(this.battlefieldModel as BattlefieldModel).blacklist.push(decalMaterial.getTextureResource());
this.exclusionSet = this.battlefieldModel.bfData.viewport.shaftRaycastExcludedObjects;
this.exclusionSetController = new SetControllerForTemporaryItems(this.exclusionSet);
this.collisionDetector = TanksCollisionDetector(this.battlefieldModel.bfData.physicsScene.collisionDetector);
}
}
public function setEnergyMode(mode:ShaftEnergyMode) : void
{
var physTime:int = 0;
var energy:Number = NaN;
if(this.battlefieldModel == null || this.battlefieldModel.bfData == null)
{
return;
}
if(mode != this.energyMode)
{
physTime = this.battlefieldModel.bfData.physTime;
energy = this.getEnergy(physTime);
this.doSetEnergyMode(mode,energy,physTime);
}
}
public function objectUnloaded(object:ClientObject) : void
{
}
private function startTargetMode() : void
{
}
private function stopTargetMode() : void
{
}
public function update(param1:int, param2:int) : Number
{
var _loc3_:int = 0;
var _loc4_:Vector3 = null;
var _loc5_:WeaponCommonData = null;
var _loc6_:Tank = null;
var _loc7_:BitmapData = null;
var _loc8_:GameCamera = null;
if(this.tank == null)
{
this.tank = TankData.localTankData.tank;
}
if(this.activate && TankData.localTankData.spawnState == TankSpawnState.ACTIVE)
{
this.activatedTime += param2;
}
else
{
if(TankData.localTankData.spawnState == TankSpawnState.ACTIVE && this.activatedTime > 0 && this.activatedTime < 300)
{
this.quickShot = true;
}
this.activatedTime = 0;
}
if(this.activatedTime >= 300)
{
_loc3_ = this.getEnergy(param1);
if(!this.lock && _loc3_ == 1000 && param1 >= this.exitTime && (!(this.tank.leftTrack.lastContactsNum == 0 && this.tank.rightTrack.lastContactsNum == 0) || !this.hasIntersection()))
{
this.updateController = true;
this.updateCrossPosition();
Main.stage.addChild(this.image);
this.targetController.camera = this.battlefieldModel.bfData.viewport.camera;
this.targetController.skin = TankData.localTankData.tank.skin;
this.targetController.cameraController.setAnchorObject(TankData.localTankData.tank.skin.turretMesh);
_loc4_ = new Vector3();
_loc5_ = this.commonModel.getCommonData(TankData.localTankData.turret);
TankData.localTankData.tank.getBarrelOrigin(_loc4_,_loc5_.muzzles);
this.targetController.cameraController.setLocalPosition(_loc4_);
this.targetController.cameraController.elevation = 0;
this.targetController.cameraController.elevationDirection = 0;
this.targetController.enter(param1);
_loc6_ = TankData.localTankData.tank;
_loc6_.title.hide();
_loc7_ = _loc6_.title.getTexture();
this.indicatorBitmap = new Bitmap(_loc7_);
_loc8_ = this.battlefieldModel.bfData.viewport.camera;
this.indicatorBitmap.x = Main.stage.stageWidth - this.indicatorBitmap.width >> 1;
this.indicatorBitmap.y = Main.stage.stageHeight / 2 + this.indicatorBitmap.height * 2;
Main.stage.addChild(this.indicatorBitmap);
this.lock = true;
this.fired = false;
this.lockCheckIntersection = true;
this.exitTime = -1;
this.sendStartAimCommand();
}
}
else if(this.quickShot)
{
_loc3_ = this.getEnergy(param1);
if(_loc3_ == 1000)
{
this.onQuickShot();
}
this.quickShot = false;
}
else if(this.fired)
{
this.activatedTime = 0;
if(this.exitTime > 0)
{
if(param1 >= this.exitTime)
{
if(Main.stage.contains(this.image))
{
Main.stage.removeChild(this.image);
Main.stage.removeChild(this.indicatorBitmap);
_loc6_ = TankData.localTankData.tank;
_loc6_.title.show();
this.battlefieldModel.activateFollowCamera();
this.battlefieldModel.resetFollowCamera();
this.targetController.exit();
this.updateController = false;
this.lock = false;
this.lockCheckIntersection = false;
this.fired = false;
}
}
}
}
else if(Main.stage.contains(this.image))
{
this.setEnergyMode(ShaftEnergyMode.RECHARGE);
this.performAimedShot(1000);
this.exitTime = getTimer() + 500;
this.fired = true;
}
if(this.updateController)
{
this.updateCrossPosition();
this.indicatorBitmap.x = Main.stage.stageWidth - this.indicatorBitmap.width >> 1;
this.indicatorBitmap.y = Main.stage.stageHeight / 2 + this.indicatorBitmap.height * 2;
this.targetController.update(param1,param2);
if(!(!(this.tank.leftTrack.lastContactsNum == 0 && this.tank.rightTrack.lastContactsNum == 0) || !this.hasIntersection()))
{
this.forceExit(param1);
}
}
return this.getStatus();
}
private function forceExit(time:int) : void
{
if(Main.stage.contains(this.image))
{
this.activatedTime = 0;
Main.stage.removeChild(this.image);
Main.stage.removeChild(this.indicatorBitmap);
this.tank.title.show();
this.battlefieldModel.activateFollowCamera();
this.battlefieldModel.resetFollowCamera();
this.targetController.exit();
this.updateController = false;
this.lock = false;
this.lockCheckIntersection = false;
this.fired = false;
this.doSetEnergyMode(ShaftEnergyMode.RECHARGE,Math.min(this.getEnergy(time),0),time);
this.targetController.shaftMode = ShaftModes.TARGET_DEACTIVATION;
}
}
private function sendQuickShotCommand(result:ShaftShotResult) : void
{
Network(Main.osgi.getService(INetworker)).send("battle;quick_shot_shaft;" + result.toJSON());
trace("battle;quick_shot_shaft;" + result.toJSON());
}
private function sendStartAimCommand() : void
{
Network(Main.osgi.getService(INetworker)).send("battle;start_fire");
}
private function sendStopAimCommand(physTime:int, staticShot:Vector3, aims:Array) : void
{
var json:Object = new Object();
json.phys_time = physTime;
json.static_shot = staticShot;
json.targets = aims;
json.energy = this.getEnergy(this.battlefieldModel.bfData.physTime);
Network(Main.osgi.getService(INetworker)).send("battle;fire;" + JSON.stringify(json,function(k:*, v:*):*
{
var aim:* = undefined;
var pointPos:* = undefined;
if(v is Aim)
{
aim = v as Aim;
pointPos = aim.targetHitPoint.vClone();
globalToLocal(aim.target,pointPos);
return {"target":{
"id":aim.target.tankData.userName,
"pos":aim.targetHitPoint,
"point_pos":pointPos
}};
}
return v;
}));
trace("battle;fire;" + JSON.stringify(json,function(k:*, v:*):*
{
var aim:* = undefined;
var pointPos:* = undefined;
if(v is Aim)
{
aim = v as Aim;
pointPos = aim.targetHitPoint.vClone();
globalToLocal(aim.target,pointPos);
return {"target":{
"id":aim.target.tankData.userName,
"pos":aim.targetHitPoint,
"point_pos":pointPos
}};
}
return v;
}));
}
private function onQuickShot() : void
{
var i:int = 0;
var target:TankData = null;
var currTank:Tank = null;
var tankData:TankData = TankData.localTankData;
var commonData:WeaponCommonData = this.commonModel.getCommonData(tankData.turret);
var shaftSFX:ShaftSFXModel = WeaponsManager.getShaftSFX(WeaponsManager.getObjectFor(TankData.localTankData.turret.id));
this.weaponUtils.calculateGunParams(tankData.tank.skin.turretMesh,commonData.muzzles[0],allGunParams.muzzlePosition,_barrelOrigin,this._xAxis,allGunParams.direction);
this.quickShotTargetSystem.getTargets(tankData,_barrelOrigin,allGunParams.direction,this._xAxis,this.battlefieldModel.getBattlefieldData().tanks,this.shotResult);
if(this.shotResult.hitPoints.length == 0)
{
trace("shot v nikuda");
}
else if(this.shotResult.targets.length == 0)
{
trace("shot on static");
this.createStaticShotEffect(tankData.user,this.shotResult.hitPoints[0] as Vector3,allGunParams.direction);
this.battlefieldModel.addDecal(this.shotResult.hitPoints[0] as Vector3,allGunParams.muzzlePosition,50,decalMaterial);
}
else
{
for(i = 0; i < this.shotResult.targets.length; i++)
{
target = this.shotResult.targets[i];
trace("quick shot: " + target.userName);
currTank = target.tank;
this.createTankShotEffect(tankData.user,this.shotResult.hitPoints[i],allGunParams.direction);
currTank.addWorldForceScaled(this.shotResult.hitPoints[i],allGunParams.direction,this.shaftData.impactQuickShot);
}
if(this.shotResult.hitPoints.length > this.shotResult.targets.length)
{
trace("shot on static");
this.createStaticShotEffect(tankData.user,this.shotResult.hitPoints[this.shotResult.targets.length] as Vector3,allGunParams.direction);
this.battlefieldModel.addDecal(this.shotResult.hitPoints[this.shotResult.targets.length] as Vector3,allGunParams.muzzlePosition,50,decalMaterial);
}
}
trace(this.shotResult.toJSON());
shaftSFX.createMuzzleFlashEffect(tankData.turret,tankData.tank.skin.turretDescriptor.shaftMuzzle,tankData.tank.skin.turretMesh);
shaftSFX.createShotSoundEffect(tankData.turret,tankData.user,allGunParams.muzzlePosition);
TankData.localTankData.tank.addWorldForceScaled(allGunParams.muzzlePosition,allGunParams.direction,-commonData.kickback);
this.doSetEnergyMode(ShaftEnergyMode.RECHARGE,0,this.battlefieldModel.bfData.physTime);
this.sendQuickShotCommand(this.shotResult);
}
[ServerData]
public function quickFire(param1:ClientObject, param2:Array, param3:Array, param4:Vector3) : void
{
var _loc9_:Vector3 = null;
var _loc10_:int = 0;
var _loc11_:Vector3 = null;
var _loc12_:TankData = null;
var _loc13_:Tank = null;
var _loc5_:TankData = this.tankModel.getTankData(param1);
if(_loc5_ == TankData.localTankData)
{
return;
}
if(param2 == null || param3 == null)
{
return;
}
if(this.commonModel == null)
{
this.commonModel = Main.osgi.getService(IWeaponCommonModel) as IWeaponCommonModel;
}
var _loc6_:WeaponCommonData = this.commonModel.getCommonData(_loc5_.turret);
var _loc7_:ShaftData = _loc5_.turret.getParams(ShaftData) as ShaftData;
this.weaponUtils.calculateGunParamsAux(_loc5_.tank.skin.turretMesh,_loc6_.muzzles[0],allGunParams.muzzlePosition,allGunParams.direction);
var _loc8_:ShaftSFXModel = WeaponsManager.getShaftSFX(WeaponsManager.getObjectFor(_loc5_.turret.id));
_loc8_.createMuzzleFlashEffect(_loc5_.turret,_loc5_.tank.skin.turretDescriptor.shaftMuzzle,_loc5_.tank.skin.turretMesh);
_loc5_.tank.addWorldForceScaled(allGunParams.muzzlePosition,allGunParams.direction,-_loc6_.kickback);
if(param3.length == 0)
{
return;
}
if(param2.length == 0)
{
_loc9_ = new Vector3(param3[0].x,param3[0].y,param3[0].z);
this.createStaticShotEffect(_loc5_.user,_loc9_,allGunParams.direction);
this.battlefieldModel.addDecal(_loc9_,allGunParams.muzzlePosition,50,decalMaterial);
}
else
{
for(_loc10_ = 0; _loc10_ < param2.length; _loc10_++)
{
_loc11_ = new Vector3(param3[_loc10_].x,param3[_loc10_].y,param3[_loc10_].z);
_loc12_ = this.tankModel.getTankData(BattleController.activeTanks[param2[_loc10_].target_id]);
_loc13_ = _loc12_.tank;
this.createTankShotEffect(_loc5_.user,_loc11_,allGunParams.direction);
_loc13_.addWorldForceScaled(_loc11_,allGunParams.direction,_loc7_.impactQuickShot);
}
if(param3.length > param2.length)
{
_loc9_ = new Vector3(param3[param2.length].x,param3[param2.length].y,param3[param2.length].z);
this.createStaticShotEffect(_loc5_.user,_loc9_,allGunParams.direction);
this.battlefieldModel.addDecal(_loc9_,allGunParams.muzzlePosition,50,decalMaterial);
}
}
}
[ServerData]
public function fire(user:ClientObject, staticHit:Vector3, targets:Array) : void
{
var target:ServerShaftTargetData = null;
var targetTankPos:Vector3 = null;
var targetTank:TankData = null;
var firringTank:TankData = this.tankModel.getTankData(user);
if(firringTank == TankData.localTankData)
{
return;
}
if(this.commonModel == null)
{
this.commonModel = Main.osgi.getService(IWeaponCommonModel) as IWeaponCommonModel;
}
var commonData:WeaponCommonData = this.commonModel.getCommonData(firringTank.turret);
this.weaponUtils.calculateGunParamsAux(firringTank.tank.skin.turretMesh,commonData.muzzles[0],allGunParams.muzzlePosition,allGunParams.direction);
var effects:ShaftSFXModel = WeaponsManager.getShaftSFX(WeaponsManager.getObjectFor(firringTank.turret.id));
effects.createMuzzleFlashEffect(firringTank.turret,firringTank.tank.skin.turretDescriptor.shaftMuzzle,firringTank.tank.skin.turretMesh);
for(var i:int = 0; i < targets.length; i++)
{
target = targets[i];
targetTank = this.tankModel.getTankData(BattleController.activeTanks[target.targetId]);
if(targetTank != null)
{
targetTankPos = targetTank.tank.state.pos;
}
localToGlobal(targetTank.tank,target.globalHitPoint);
this.createTankShotEffect(firringTank.user,target.globalHitPoint,allGunParams.direction);
targetTank.tank.addWorldForceScaled(target.globalHitPoint,allGunParams.direction,commonData.impactForce);
}
if(staticHit != null)
{
this.createStaticShotEffect(firringTank.user,staticHit,allGunParams.direction);
this.battlefieldModel.addDecal(staticHit,allGunParams.muzzlePosition,50,decalMaterial);
}
effects.createShotSoundEffect(firringTank.turret,firringTank.user,allGunParams.muzzlePosition);
}
public function performAimedShot(param1:Number) : void
{
var a:Object = null;
var currTank:Tank = null;
var commonData:WeaponCommonData = this.weaponCommonModel.getCommonData(TankData.localTankData.turret);
var shaftSFX:ShaftSFXModel = WeaponsManager.getShaftSFX(WeaponsManager.getObjectFor(TankData.localTankData.turret.id));
var _loc2_:int = this.battlefieldModel.bfData.physTime;
shaftSFX.stopManualSound(TankData.localTankData.user);
this.localTankData.tank.getAllGunParams(allGunParams,commonData.muzzles);
var result:AimedShotResult = this.getAimedShotTargets();
this.targetController.cameraController.readCameraDirection(_direction);
var _loc4_:Number = param1 - this.getEnergy(_loc2_);
for(var i:int = 0; i < result.aims.length; i++)
{
a = result.aims[i];
this.createTankShotEffect(TankData.localTankData.user,a.targetHitPoint,_direction);
currTank = a.target;
currTank.addWorldForceScaled(a.targetHitPoint,_direction,commonData.impactForce);
}
if(result.staticHitPoint != null)
{
this.createStaticShotEffect(TankData.localTankData.user,result.staticHitPoint,_direction);
this.battlefieldModel.addDecal(result.staticHitPoint,allGunParams.muzzlePosition,50,decalMaterial);
}
shaftSFX.createShotSoundEffect(TankData.localTankData.turret,TankData.localTankData.user,allGunParams.muzzlePosition);
TankData.localTankData.tank.addWorldForceScaled(allGunParams.muzzlePosition,allGunParams.direction,-commonData.kickback);
this.sendStopAimCommand(_loc2_,result.staticHitPoint,result.aims);
this.doSetEnergyMode(ShaftEnergyMode.RECHARGE,Math.min(this.getEnergy(_loc2_),0),_loc2_);
this.targetController.shaftMode = ShaftModes.TARGET_DEACTIVATION;
}
private function createTankShotEffect(user:ClientObject, point:Vector3, dir:Vector3) : void
{
var tankData:TankData = this.tankModel.getTankData(user);
if(this.commonModel == null)
{
this.commonModel = Main.osgi.getService(IWeaponCommonModel) as IWeaponCommonModel;
}
var commonData:WeaponCommonData = this.commonModel.getCommonData(tankData.turret);
this.weaponUtils.calculateGunParamsAux(tankData.tank.skin.turretMesh,commonData.muzzles[0],allGunParams.muzzlePosition,allGunParams.direction);
var effects:ShaftSFXModel = WeaponsManager.getShaftSFX(WeaponsManager.getObjectFor(tankData.turret.id));
effects.createHitPointsGraphicEffects(tankData.turret,tankData.user,null,point,allGunParams.muzzlePosition,allGunParams.direction,dir);
}
private function createStaticShotEffect(user:ClientObject, point:Vector3, dir:Vector3) : void
{
var tankData:TankData = this.tankModel.getTankData(user);
if(this.commonModel == null)
{
this.commonModel = Main.osgi.getService(IWeaponCommonModel) as IWeaponCommonModel;
}
var commonData:WeaponCommonData = this.commonModel.getCommonData(tankData.turret);
this.weaponUtils.calculateGunParamsAux(tankData.tank.skin.turretMesh,commonData.muzzles[0],allGunParams.muzzlePosition,allGunParams.direction);
var effects:ShaftSFXModel = WeaponsManager.getShaftSFX(WeaponsManager.getObjectFor(tankData.turret.id));
effects.createHitPointsGraphicEffects(tankData.turret,tankData.user,point,null,allGunParams.muzzlePosition,allGunParams.direction,dir);
}
public function hasIntersection() : Boolean
{
var object:Object3D = null;
var commonData:WeaponCommonData = this.weaponCommonModel.getCommonData(TankData.localTankData.turret);
this.localTankData.tank.getAllGunParams(allGunParams,commonData.muzzles);
var tankPos:Vector3 = TankData.localTankData.tank.state.pos;
_direction.vDiff(allGunParams.barrelOrigin,tankPos);
this.exclusionSetController.addTemporaryItem(this.localTankData.tank.skin.turretMesh);
this.exclusionSetController.addTemporaryItem(this.localTankData.tank.skin.hullMesh);
var rayData:RayIntersectionData = this.battlefieldModel.raycast(tankPos,_direction,this.exclusionSet);
trace(_direction);
trace(allGunParams.barrelOrigin);
trace(commonData.muzzles);
if(rayData != null && rayData.time <= 1)
{
object = rayData.object;
trace("hasIntersection " + object.name);
this.exclusionSetController.deleteAllTemporaryItems();
return object.name == Object3DNames.STATIC;
}
this.exclusionSetController.deleteAllTemporaryItems();
trace("hasIntersection " + false);
return false;
}
private function getAimedShotTargets() : AimedShotResult
{
var data:RayIntersectionData = null;
var aim:Object3D = null;
var hitPoint:Vector3 = null;
var target:Tank = null;
var result:AimedShotResult = new AimedShotResult();
this.targetController.cameraController.readCameraPosition(_origin);
this.targetController.cameraController.readCameraDirection(_direction);
this.addTankSkinToExclusionSet(this.localTankData.tank.skin);
while(true)
{
data = this.battlefieldModel.raycast(_origin,_direction,this.exclusionSet);
if(data == null)
{
break;
}
aim = data.object;
hitPoint = _origin.vClone().vAddScaled(data.time + 0.1,_direction);
if(aim.name == Object3DNames.STATIC)
{
result.setStaticHitPoint(hitPoint);
break;
}
if(aim.name == Object3DNames.TANK_PART)
{
target = this.battlefieldModel.objects2tank[aim];
if(this.isValidHit(target,aim,hitPoint))
{
result.setTarget(target,hitPoint);
}
this.addTankSkinToExclusionSet(target.skin);
}
else
{
this.exclusionSetController.addTemporaryItem(aim);
}
_origin.vCopy(hitPoint);
}
this.exclusionSetController.deleteAllTemporaryItems();
return result;
}
private function isValidHit(param1:Tank, param2:Object3D, param3:Vector3) : Boolean
{
var commonData:WeaponCommonData = null;
var _loc4_:TankSkin = param1.skin;
if(_loc4_.turretMesh == param2)
{
_m.setMatrix(param2.x,param2.y,param2.z,param2.rotationX,param2.rotationY,param2.rotationZ);
_m.transformVectorInverse(param3,_p);
commonData = this.weaponCommonModel.getCommonData(param1.tankData.turret);
getClosestBarrelOrigin(_p,commonData.muzzles,_closestBarrelOrigin);
_m.transformVector(_closestBarrelOrigin,_p);
_p.vSubtract(param3);
if(this.battlefieldModel.bfData.collisionDetector.hasStaticHit(param3,_p,CollisionGroup.STATIC,1))
{
return false;
}
}
return _loc4_.hullMesh.alpha == 1;
}
private function addTankSkinToExclusionSet(param1:TankSkin) : void
{
this.exclusionSetController.addTemporaryItem(param1.hullMesh);
this.exclusionSetController.addTemporaryItem(param1.turretMesh);
}
public function targetModeOn() : void
{
this.tankModel.lockControls(true);
this.tankModel.applyControlState(TankData.localTankData,0,true);
this.tankModel.setControlState(TankData.localTankData,0,true);
var shaftSFX:ShaftSFXModel = WeaponsManager.getShaftSFX(WeaponsManager.getObjectFor(TankData.localTankData.turret.id));
shaftSFX.createManualModeEffects(TankData.localTankData.turret,TankData.localTankData.user,TankData.localTankData.tank.skin.turretMesh);
}
public function getStatus() : Number
{
return this.getEnergy(getTimer()) / this.shaftData.maxEnergy;
}
public function doSetEnergyMode(mode:ShaftEnergyMode, energy:Number, physTime:int) : void
{
this.energyMode = mode;
switch(mode)
{
case ShaftEnergyMode.RECHARGE:
this.energyAdditive = 0;
this.energySpeed = this.shaftData.chargeRate;
this.energyBaseTime = physTime - energy / this.energySpeed * thousand;
break;
case ShaftEnergyMode.DRAIN:
this.energyAdditive = this.shaftData.maxEnergy;
this.energySpeed = -this.shaftData.dischargeRate;
this.energyBaseTime = physTime + (this.shaftData.maxEnergy - energy) / this.energySpeed * thousand;
this.sendBeginEnergyDrain(physTime);
}
}
private function sendBeginEnergyDrain(time:int) : void
{
Network(Main.osgi.getService(INetworker)).send("battle;begin_enegry_drain;" + time);
}
public function getEnergy(energyTime:Number) : Number
{
var enegry:Number = this.energyAdditive + (energyTime - this.energyBaseTime) * this.energySpeed / thousand;
return MathUtils.clamp(enegry,0,this.shaftData.maxEnergy);
}
private function updateCrossPosition() : void
{
this.image.x = Main.stage.stageWidth - this.image.width >> 1;
this.image.y = Main.stage.stageHeight - this.image.height >> 1;
}
public function stopEffects(ownerTankData:TankData) : void
{
var tank:Tank = null;
if(TankData.localTankData == ownerTankData)
{
if(Main.stage.contains(this.image))
{
Main.stage.removeChild(this.image);
Main.stage.removeChild(this.indicatorBitmap);
tank = TankData.localTankData.tank;
tank.title.show();
this.battlefieldModel.activateFollowCamera();
this.battlefieldModel.resetFollowCamera();
this.targetController.exit();
this.setEnergyMode(ShaftEnergyMode.RECHARGE);
this.targetController.deactivationTask.stop();
}
this.updateController = false;
this.lock = false;
this.lockCheckIntersection = false;
this.fired = false;
this.battlefieldModel.onResize(null);
}
}
public function reset() : void
{
this.doSetEnergyMode(ShaftEnergyMode.RECHARGE,this.shaftData.maxEnergy,this.battlefieldModel.bfData.physTime);
if(TankData.localTankData == null)
{
return;
}
var shaftSFX:ShaftSFXModel = WeaponsManager.getShaftSFX(WeaponsManager.getObjectFor(TankData.localTankData.turret.id));
shaftSFX.stopManualSound(TankData.localTankData.user);
this.lockCheckIntersection = false;
}
public function setLocalUser(localUserData:TankData) : void
{
this.objectLoaded(null);
this.localTankData = localUserData;
this.localShotData = WeaponsManager.shotDatas[localUserData.turret.id];
this.localWeaponCommonData = this.weaponCommonModel.getCommonData(localUserData.turret);
trace(this.localShotData.autoAimingAngleUp.value,this.localShotData.numRaysUp.value,this.localShotData.autoAimingAngleDown.value,this.localShotData.numRaysDown.value);
this.quickShotTargetSystem.setParams(this.battlefieldModel.getBattlefieldData().physicsScene.collisionDetector,this.localShotData.autoAimingAngleUp.value,this.localShotData.numRaysUp.value,this.localShotData.autoAimingAngleDown.value,this.localShotData.numRaysDown.value,1,null);
this.shaftData = localUserData.turret.getParams(ShaftData) as ShaftData;
this.image = new Bitmap(Indicator.getIndicator(localUserData.turret));
this.targetController = new TargetingController(this);
this.reset();
}
public function clearLocalUser() : void
{
}
public function activateWeapon(time:int) : void
{
this.activate = true;
}
public function deactivateWeapon(time:int, sendServerCommand:Boolean) : void
{
this.activate = false;
}
public function get targetingController() : TargetingController
{
return this.targetController;
}
}
}
import alternativa.physics.Body;
import alternativa.physics.collision.IRayCollisionPredicate;
import flash.utils.Dictionary;
class MultybodyCollisionPredicate implements IRayCollisionPredicate
{
public var bodies:Dictionary;
function MultybodyCollisionPredicate()
{
this.bodies = new Dictionary();
super();
}
public function considerBody(body:Body) : Boolean
{
return this.bodies[body] == null;
}
}
|
package alternativa.tanks.vehicles.tanks
{
import alternativa.engine3d.core.Camera3D;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.BodyState;
import alternativa.physics.collision.types.RayIntersection;
import flash.display.Graphics;
import flash.geom.Vector3D;
public class SuspensionRay
{
private static var _v:Vector3 = new Vector3();
private static var _worldUp:Vector3 = new Vector3();
private static var _groundUp:Vector3;
private static var _groundForward:Vector3 = new Vector3();
private static var _groundRight:Vector3 = new Vector3();
private static var _relVel:Vector3 = new Vector3();
public static var _force:Vector3 = new Vector3();
private static var _p:Vector3D = new Vector3D();
public var collisionGroup:int;
private var body:Body;
public var relPos:Vector3;
public var relDir:Vector3;
public var worldPos:Vector3;
public var worldDir:Vector3;
public var globalOrigin:Vector3;
private var lastCollided:Boolean = false;
private var lastIntersection:RayIntersection;
private var prevDisplacement:Number = 0;
private var predicate:RayPredicate;
public function SuspensionRay(body:Body, relPos:Vector3, relDir:Vector3)
{
this.relPos = new Vector3();
this.relDir = new Vector3();
this.worldPos = new Vector3();
this.worldDir = new Vector3();
this.globalOrigin = new Vector3();
this.lastIntersection = new RayIntersection();
super();
this.body = body;
this.relPos.vCopy(relPos);
this.relDir.vCopy(relDir);
this.predicate = new RayPredicate(body);
}
public function setRelPos(value:Vector3) : void
{
this.relPos.vCopy(value);
}
public function setRelPosXYZ(x:Number, y:Number, z:Number) : void
{
this.relPos.x = x;
this.relPos.y = y;
this.relPos.z = z;
}
public function calculateIntersection(maxLength:Number) : Boolean
{
this.body.baseMatrix.transformVector(this.relDir,this.worldDir);
this.body.baseMatrix.transformVector(this.relPos,this.worldPos);
var p:Vector3 = this.body.state.pos;
this.worldPos.x += p.x;
this.worldPos.y += p.y;
this.worldPos.z += p.z;
if(this.lastCollided)
{
this.prevDisplacement = maxLength - this.lastIntersection.t;
}
return this.lastCollided = this.body.world.collisionDetector.intersectRay(this.worldPos,this.worldDir,this.collisionGroup,maxLength,this.predicate,this.lastIntersection);
}
public function addForce(dt:Number, throttle:Number, maxSpeed:Number, slipTerm:int, springCoeff:Number, data:SuspensionData, fwdBrake:Boolean) : void
{
var len:Number = NaN;
var state:BodyState = null;
var relSpeed:Number = NaN;
var bState:BodyState = null;
len = NaN;
state = null;
relSpeed = NaN;
bState = null;
var slipSpeed:Number = NaN;
var sideFriction:Number = NaN;
var frictionForce:Number = NaN;
var fwdFriction:Number = NaN;
if(!this.lastCollided)
{
return;
}
_groundUp = this.lastIntersection.normal;
_v.x = this.body.baseMatrix.b;
_v.y = this.body.baseMatrix.f;
_v.z = this.body.baseMatrix.j;
_groundRight.x = _v.y * _groundUp.z - _v.z * _groundUp.y;
_groundRight.y = _v.z * _groundUp.x - _v.x * _groundUp.z;
_groundRight.z = _v.x * _groundUp.y - _v.y * _groundUp.x;
len = _groundRight.x * _groundRight.x + _groundRight.y * _groundRight.y + _groundRight.z * _groundRight.z;
if(len == 0)
{
_groundRight.x = 1;
}
else
{
len = Math.sqrt(len);
_groundRight.x /= len;
_groundRight.y /= len;
_groundRight.z /= len;
}
_groundForward.x = _groundUp.y * _groundRight.z - _groundUp.z * _groundRight.y;
_groundForward.y = _groundUp.z * _groundRight.x - _groundUp.x * _groundRight.z;
_groundForward.z = _groundUp.x * _groundRight.y - _groundUp.y * _groundRight.x;
state = this.body.state;
_v.x = this.lastIntersection.pos.x - state.pos.x;
_v.y = this.lastIntersection.pos.y - state.pos.y;
_v.z = this.lastIntersection.pos.z - state.pos.z;
var rot:Vector3 = state.rotation;
_relVel.x = rot.y * _v.z - rot.z * _v.y + state.velocity.x;
_relVel.y = rot.z * _v.x - rot.x * _v.z + state.velocity.y;
_relVel.z = rot.x * _v.y - rot.y * _v.x + state.velocity.z;
if(this.lastIntersection.primitive.body != null)
{
bState = this.lastIntersection.primitive.body.state;
_v.x = this.lastIntersection.pos.x - bState.pos.x;
_v.y = this.lastIntersection.pos.y - bState.pos.y;
_v.z = this.lastIntersection.pos.z - bState.pos.z;
rot = bState.rotation;
_relVel.x -= rot.y * _v.z - rot.z * _v.y + bState.velocity.x;
_relVel.y -= rot.z * _v.x - rot.x * _v.z + bState.velocity.y;
_relVel.z -= rot.x * _v.y - rot.y * _v.x + bState.velocity.z;
}
relSpeed = Math.sqrt(_relVel.x * _relVel.x + _relVel.y * _relVel.y + _relVel.z * _relVel.z);
var fwdSpeed:Number = _relVel.x * _groundForward.x + _relVel.y * _groundForward.y + _relVel.z * _groundForward.z;
if(throttle > 0 && fwdSpeed < maxSpeed || throttle < 0 && -fwdSpeed < maxSpeed)
{
_v.x = this.worldPos.x + data.forceOffset * this.worldDir.x;
_v.y = this.worldPos.y + data.forceOffset * this.worldDir.y;
_v.z = this.worldPos.z + data.forceOffset * this.worldDir.z;
_force.x = throttle * _groundForward.x;
_force.y = throttle * _groundForward.y;
_force.z = throttle * _groundForward.z;
this.body.addWorldForce(_v,_force);
}
_worldUp.x = this.body.baseMatrix.c;
_worldUp.y = this.body.baseMatrix.g;
_worldUp.z = this.body.baseMatrix.k;
var t:Number = this.lastIntersection.t;
var currDisplacement:Number = data.rayLength - t;
var springForce:Number = springCoeff * currDisplacement * (_worldUp.x * this.lastIntersection.normal.x + _worldUp.y * this.lastIntersection.normal.y + _worldUp.z * this.lastIntersection.normal.z);
var upSpeed:Number = (currDisplacement - this.prevDisplacement) / dt;
springForce += upSpeed * data.dampingCoeff;
if(springForce < 0)
{
springForce = 0;
}
_force.x = -springForce * this.worldDir.x;
_force.y = -springForce * this.worldDir.y;
_force.z = -springForce * this.worldDir.z;
if(relSpeed > 0.001)
{
slipSpeed = _relVel.vDot(_groundRight);
sideFriction = slipTerm == 0 || slipSpeed >= 0 && slipTerm > 0 || slipSpeed <= 0 && slipTerm < 0 ? Number(Number(data.staticFriction)) : Number(Number(2 * data.dynamicFriction));
frictionForce = sideFriction * springForce * slipSpeed / relSpeed;
if(slipSpeed > -data.smallVel && slipSpeed < data.smallVel)
{
frictionForce *= slipSpeed / data.smallVel;
if(slipSpeed < 0)
{
frictionForce = -frictionForce;
}
}
_force.x -= frictionForce * _groundRight.x;
_force.y -= frictionForce * _groundRight.y;
_force.z -= frictionForce * _groundRight.z;
if(fwdBrake)
{
fwdFriction = 0.3 * data.staticFriction;
}
else if(fwdSpeed * throttle <= 0)
{
fwdFriction = 0.5 * data.staticFriction;
}
else
{
fwdFriction = data.dynamicFriction;
}
frictionForce = fwdFriction * springForce * fwdSpeed / relSpeed;
if(fwdSpeed > -data.smallVel && fwdSpeed < data.smallVel)
{
frictionForce *= fwdSpeed / data.smallVel;
if(fwdSpeed < 0)
{
frictionForce = -frictionForce;
}
}
_force.x -= frictionForce * _groundForward.x;
_force.y -= frictionForce * _groundForward.y;
_force.z -= frictionForce * _groundForward.z;
}
_v.x = this.worldPos.x + data.forceOffset * this.worldDir.x;
_v.y = this.worldPos.y + data.forceOffset * this.worldDir.y;
_v.z = this.worldPos.z + data.forceOffset * this.worldDir.z;
this.body.addWorldForce(_v,_force);
}
public function debugDraw(g:Graphics, camera:Camera3D, data:SuspensionData) : void
{
_v.vCopy(this.worldPos).vAddScaled(data.rayLength,this.worldDir);
this.drawLine(g,camera,this.worldPos,_v,16776960,4);
if(this.lastCollided)
{
this.drawLine(g,camera,this.worldPos,this.lastIntersection.pos,16711680,4);
_v.vCopy(this.lastIntersection.pos).vAddScaled(data.rayLength,this.lastIntersection.normal);
this.drawLine(g,camera,this.lastIntersection.pos,_v,65535,1);
}
}
public function getGlobalOrigin() : Vector3
{
return this.worldPos;
}
private function drawLine(g:Graphics, camera:Camera3D, wBegin:Vector3, wEnd:Vector3, color:int, thickness:int = 0, alpha:Number = 1) : void
{
}
}
}
import alternativa.physics.Body;
import alternativa.physics.collision.IRayCollisionPredicate;
class RayPredicate implements IRayCollisionPredicate
{
private var body:Body;
function RayPredicate(body:Body)
{
super();
this.body = body;
}
public function considerBody(body:Body) : Boolean
{
return this.body != body;
}
}
|
package _codec.platform.client.core.general.socialnetwork.models.socialnetworkparameters {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.core.general.socialnetwork.models.socialnetworkparameters.SocialNetworkParametersCC;
public class VectorCodecSocialNetworkParametersCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecSocialNetworkParametersCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(SocialNetworkParametersCC,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<SocialNetworkParametersCC> = new Vector.<SocialNetworkParametersCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = SocialNetworkParametersCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:SocialNetworkParametersCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<SocialNetworkParametersCC> = Vector.<SocialNetworkParametersCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_22 extends BitmapAsset
{
public function BigRangIcon_rang_22()
{
super();
}
}
}
|
package projects.tanks.clients.tankslauncershared.dishonestprogressbar {
import flash.display.BitmapData;
import projects.tanks.clients.tankslauncershared.service.Locale;
public class LoadingLabel {
private static const loadingLabelRuClass:Class = LoadingLabel_loadingLabelRuClass;
private static const loadingLabelEnClass:Class = LoadingLabel_loadingLabelEnClass;
private static const loadingLabelDeClass:Class = LoadingLabel_loadingLabelDeClass;
private static const loadingLabelCnClass:Class = LoadingLabel_loadingLabelCnClass;
private static const loadingLabelBrClass:Class = LoadingLabel_loadingLabelBrClass;
private static const loadingLabelPlClass:Class = LoadingLabel_loadingLabelPlClass;
private static const loadingLabelEsClass:Class = LoadingLabel_loadingLabelEsClass;
public function LoadingLabel() {
super();
}
public static function getLocalizedBitmapData(param1:String) : BitmapData {
switch(param1) {
case Locale.RU:
return new loadingLabelRuClass().bitmapData;
case Locale.DE:
return new loadingLabelDeClass().bitmapData;
case Locale.CN:
return new loadingLabelCnClass().bitmapData;
case Locale.PT_BR:
return new loadingLabelBrClass().bitmapData;
case Locale.PL:
return new loadingLabelPlClass().bitmapData;
case Locale.ES:
return new loadingLabelEsClass().bitmapData;
default:
return new loadingLabelEnClass().bitmapData;
}
}
}
}
|
package projects.tanks.client.clans.clan.permissions {
public class ClanPermissionsCC {
private var _actions:Vector.<ClanAction>;
public function ClanPermissionsCC(param1:Vector.<ClanAction> = null) {
super();
this._actions = param1;
}
public function get actions() : Vector.<ClanAction> {
return this._actions;
}
public function set actions(param1:Vector.<ClanAction>) : void {
this._actions = param1;
}
public function toString() : String {
var local1:String = "ClanPermissionsCC [";
local1 += "actions = " + this.actions + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.gui.chat {
import projects.tanks.client.chat.models.chat.chat.ChatAddressMode;
public class ChatAddressModeUtil {
public static const PUBLIC_ADDRESS_MARKER:String = "; ";
public static const PRIVATE_ADDRESS_MARKER:String = ": ";
public function ChatAddressModeUtil() {
super();
}
public static function getAddressMarker(param1:ChatAddressMode) : String {
switch(param1) {
case ChatAddressMode.PUBLIC_ADDRESSED:
return PUBLIC_ADDRESS_MARKER;
case ChatAddressMode.PRIVATE:
return PRIVATE_ADDRESS_MARKER;
default:
return "";
}
}
public static function parseAddressMode(param1:String) : ChatAddressMode {
switch(param1) {
case PUBLIC_ADDRESS_MARKER:
return ChatAddressMode.PUBLIC_ADDRESSED;
case PRIVATE_ADDRESS_MARKER:
return ChatAddressMode.PRIVATE;
default:
return ChatAddressMode.PUBLIC_TO_ALL;
}
}
public static function isPersonal(param1:ChatAddressMode) : Boolean {
return param1 != ChatAddressMode.PUBLIC_TO_ALL;
}
}
}
|
package alternativa.tanks.model.item.item {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
public class IItemAdapt implements IItem {
private var object:IGameObject;
private var impl:IItem;
public function IItemAdapt(param1:IGameObject, param2:IItem) {
super();
this.object = param1;
this.impl = param2;
}
public function getPosition() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getPosition());
}
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;
}
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;
}
}
}
|
package controls.cellrenderer {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.cellrenderer.CellUnavailable_normalRight.png")]
public class CellUnavailable_normalRight extends BitmapAsset {
public function CellUnavailable_normalRight() {
super();
}
}
}
|
package alternativa.tanks.model.bonus.showing.info {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.LocalizedImageResource;
import platform.client.fp10.core.type.IGameObject;
public class BonusInfoAdapt implements BonusInfo {
private var object:IGameObject;
private var impl:BonusInfo;
public function BonusInfoAdapt(param1:IGameObject, param2:BonusInfo) {
super();
this.object = param1;
this.impl = param2;
}
public function getTopText() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getTopText();
}
finally {
Model.popObject();
}
return result;
}
public function getBottomText() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getBottomText();
}
finally {
Model.popObject();
}
return result;
}
public function getImage() : LocalizedImageResource {
var result:LocalizedImageResource = null;
try {
Model.object = this.object;
result = this.impl.getImage();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.engine3d.containers {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Canvas;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Object3DContainer;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.engine3d.core.VG;
import flash.geom.ColorTransform;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
use namespace alternativa3d;
public class LODContainer extends Object3DContainer {
public function LODContainer() {
super();
}
public function getChildDistance(param1:Object3D) : Number {
if(param1 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1.alternativa3d::_parent != this) {
throw new ArgumentError("The supplied Object3D must be a child of the caller.");
}
return param1.alternativa3d::distance;
}
public function setChildDistance(param1:Object3D, param2:Number) : void {
if(param1 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1.alternativa3d::_parent != this) {
throw new ArgumentError("The supplied Object3D must be a child of the caller.");
}
param1.alternativa3d::distance = param2;
}
public function addLOD(param1:Object3D, param2:Number) : Object3D {
this.addChild(param1);
param1.alternativa3d::distance = param2;
return param1;
}
override public function addChild(param1:Object3D) : Object3D {
if(param1 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1 == this) {
throw new ArgumentError("An object cannot be added as a child of itself.");
}
var local2:Object3DContainer = alternativa3d::_parent;
while(local2 != null) {
if(local2 == param1) {
throw new ArgumentError("An object cannot be added as a child to one of it\'s children (or children\'s children, etc.).");
}
local2 = local2.alternativa3d::_parent;
}
if(param1.alternativa3d::_parent != this) {
param1.alternativa3d::distance = 0;
}
if(param1.alternativa3d::_parent != null) {
param1.alternativa3d::_parent.removeChild(param1);
}
alternativa3d::addToList(param1);
return param1;
}
override public function addChildAt(param1:Object3D, param2:int) : Object3D {
if(param1 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1 == this) {
throw new ArgumentError("An object cannot be added as a child of itself.");
}
if(param2 < 0) {
throw new RangeError("The supplied index is out of bounds.");
}
var local3:Object3DContainer = alternativa3d::_parent;
while(local3 != null) {
if(local3 == param1) {
throw new ArgumentError("An object cannot be added as a child to one of it\'s children (or children\'s children, etc.).");
}
local3 = local3.alternativa3d::_parent;
}
var local4:Object3D = alternativa3d::childrenList;
var local5:int = 0;
while(local5 < param2) {
if(local4 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
local4 = local4.alternativa3d::next;
local5++;
}
if(param1.alternativa3d::_parent != this) {
param1.alternativa3d::distance = 0;
}
if(param1.alternativa3d::_parent != null) {
param1.alternativa3d::_parent.removeChild(param1);
}
alternativa3d::addToList(param1,local4);
return param1;
}
override public function intersectRay(param1:Vector3D, param2:Vector3D, param3:Dictionary = null, param4:Camera3D = null) : RayIntersectionData {
if(param3 != null && Boolean(param3[this])) {
return null;
}
if(!alternativa3d::boundIntersectRay(param1,param2,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ)) {
return null;
}
var local5:Object3D = alternativa3d::childrenList;
local5.alternativa3d::composeMatrix();
local5.alternativa3d::invertMatrix();
var local6:Vector3D = new Vector3D();
var local7:Vector3D = new Vector3D();
local6.x = local5.alternativa3d::ma * param1.x + local5.alternativa3d::mb * param1.y + local5.alternativa3d::mc * param1.z + local5.alternativa3d::md;
local6.y = local5.alternativa3d::me * param1.x + local5.alternativa3d::mf * param1.y + local5.alternativa3d::mg * param1.z + local5.alternativa3d::mh;
local6.z = local5.alternativa3d::mi * param1.x + local5.alternativa3d::mj * param1.y + local5.alternativa3d::mk * param1.z + local5.alternativa3d::ml;
local7.x = local5.alternativa3d::ma * param2.x + local5.alternativa3d::mb * param2.y + local5.alternativa3d::mc * param2.z;
local7.y = local5.alternativa3d::me * param2.x + local5.alternativa3d::mf * param2.y + local5.alternativa3d::mg * param2.z;
local7.z = local5.alternativa3d::mi * param2.x + local5.alternativa3d::mj * param2.y + local5.alternativa3d::mk * param2.z;
return local5.intersectRay(local6,local7,param3,param4);
}
override alternativa3d function checkIntersection(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Dictionary) : Boolean {
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local9:Object3D = alternativa3d::childrenList;
if(param8 != null && !param8[local9]) {
local9.alternativa3d::composeMatrix();
local9.alternativa3d::invertMatrix();
local10 = local9.alternativa3d::ma * param1 + local9.alternativa3d::mb * param2 + local9.alternativa3d::mc * param3 + local9.alternativa3d::md;
local11 = local9.alternativa3d::me * param1 + local9.alternativa3d::mf * param2 + local9.alternativa3d::mg * param3 + local9.alternativa3d::mh;
local12 = local9.alternativa3d::mi * param1 + local9.alternativa3d::mj * param2 + local9.alternativa3d::mk * param3 + local9.alternativa3d::ml;
local13 = local9.alternativa3d::ma * param4 + local9.alternativa3d::mb * param5 + local9.alternativa3d::mc * param6;
local14 = local9.alternativa3d::me * param4 + local9.alternativa3d::mf * param5 + local9.alternativa3d::mg * param6;
local15 = local9.alternativa3d::mi * param4 + local9.alternativa3d::mj * param5 + local9.alternativa3d::mk * param6;
return Boolean(alternativa3d::boundCheckIntersection(local10,local11,local12,local13,local14,local15,param7,local9.boundMinX,local9.boundMinY,local9.boundMinZ,local9.boundMaxX,local9.boundMaxY,local9.boundMaxZ)) && Boolean(local9.alternativa3d::checkIntersection(local10,local11,local12,local13,local14,local15,param7,param8));
}
return false;
}
override alternativa3d function collectPlanes(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Vector3D, param5:Vector3D, param6:Vector.<Face>, param7:Dictionary = null) : void {
if(param7 != null && Boolean(param7[this])) {
return;
}
var local8:Vector3D = alternativa3d::calculateSphere(param1,param2,param3,param4,param5);
if(!alternativa3d::boundIntersectSphere(local8,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ)) {
return;
}
var local9:Object3D = alternativa3d::childrenList;
local9.alternativa3d::composeAndAppend(this);
local9.alternativa3d::collectPlanes(param1,param2,param3,param4,param5,param6,param7);
}
override public function clone() : Object3D {
var local1:LODContainer = new LODContainer();
local1.clonePropertiesFrom(this);
return local1;
}
override alternativa3d function draw(param1:Camera3D, param2:Canvas) : void {
var local4:Canvas = null;
var local5:int = 0;
var local3:Object3D = this.getLODObject(param1);
if(local3 != null && local3.visible) {
local3.alternativa3d::composeAndAppend(this);
if(local3.alternativa3d::cullingInCamera(param1,alternativa3d::culling) >= 0) {
if(param1.debug && (local5 = int(param1.alternativa3d::checkInDebug(this))) > 0) {
local4 = param2.alternativa3d::getChildCanvas(true,false);
if(Boolean(local5 & Debug.BOUNDS)) {
Debug.alternativa3d::drawBounds(param1,local4,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ);
}
}
local4 = param2.alternativa3d::getChildCanvas(false,true,this,alpha,blendMode,colorTransform,filters);
local4.alternativa3d::numDraws = 0;
local3.alternativa3d::draw(param1,local4);
if(local4.alternativa3d::numDraws > 0) {
local4.alternativa3d::remChildren(local4.alternativa3d::numDraws);
} else {
--param2.alternativa3d::numDraws;
}
}
}
}
override alternativa3d function getVG(param1:Camera3D) : VG {
var local2:VG = null;
var local4:ColorTransform = null;
var local5:int = 0;
var local6:Array = null;
var local7:int = 0;
var local8:int = 0;
var local3:Object3D = this.getLODObject(param1);
if(local3 != null && local3.visible) {
local3.alternativa3d::composeAndAppend(this);
if(local3.alternativa3d::cullingInCamera(param1,alternativa3d::culling) >= 0) {
local2 = local3.alternativa3d::getVG(param1);
if(alpha != 1) {
local2.alternativa3d::alpha *= alpha;
}
if(blendMode != "normal") {
if(local2.alternativa3d::blendMode == "normal") {
local2.alternativa3d::blendMode = blendMode;
}
}
if(colorTransform != null) {
if(local2.alternativa3d::colorTransform != null) {
local4 = new ColorTransform(colorTransform.redMultiplier,colorTransform.greenMultiplier,colorTransform.blueMultiplier,colorTransform.alphaMultiplier,colorTransform.redOffset,colorTransform.greenOffset,colorTransform.blueOffset,colorTransform.alphaOffset);
local4.concat(local2.alternativa3d::colorTransform);
local2.alternativa3d::colorTransform = local4;
} else {
local2.alternativa3d::colorTransform = colorTransform;
}
}
if(filters != null) {
if(local2.alternativa3d::filters != null) {
local6 = new Array();
local7 = 0;
local8 = int(local2.alternativa3d::filters.length);
local5 = 0;
while(local5 < local8) {
local6[local7] = local2.alternativa3d::filters[local5];
local7++;
local5++;
}
local8 = int(filters.length);
local5 = 0;
while(local5 < local8) {
local6[local7] = filters[local5];
local7++;
local5++;
}
local2.alternativa3d::filters = local6;
} else {
local2.alternativa3d::filters = filters;
}
}
}
}
return local2;
}
private function getLODObject(param1:Camera3D) : Object3D {
var local6:Object3D = null;
var local8:Number = NaN;
var local2:Number = alternativa3d::md * param1.alternativa3d::viewSizeX / param1.alternativa3d::focalLength;
var local3:Number = alternativa3d::mh * param1.alternativa3d::viewSizeY / param1.alternativa3d::focalLength;
var local4:Number = Math.sqrt(local2 * local2 + local3 * local3 + alternativa3d::ml * alternativa3d::ml);
var local5:Number = 1e+22;
var local7:Object3D = alternativa3d::childrenList;
while(local7 != null) {
local8 = local7.alternativa3d::distance - local4;
if(local8 > 0 && local8 < local5) {
local5 = local8;
local6 = local7;
}
local7 = local7.alternativa3d::next;
}
return local6;
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_def_UP_RIGHT.png")]
public dynamic class button_def_UP_RIGHT extends BitmapData {
public function button_def_UP_RIGHT(param1:int = 7, param2:int = 30) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.model.item.availabledevices {
import alternativa.tanks.gui.device.DevicesLoadedEvent;
import alternativa.tanks.service.device.DeviceService;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.garage.models.item.availabledevices.AvailableDevicesModelBase;
import projects.tanks.client.garage.models.item.availabledevices.IAvailableDevicesModelBase;
[ModelInfo]
public class AvailableDevicesModel extends AvailableDevicesModelBase implements IAvailableDevicesModelBase, AvailableDevices {
[Inject]
public static var deviceService:DeviceService;
public function AvailableDevicesModel() {
super();
}
public function loadDevices() : void {
server.loadAvailableDevices();
}
public function devicesLoaded(param1:Vector.<IGameObject>, param2:IGameObject) : void {
deviceService.setAvailableDevices(object,param1);
deviceService.insertDevice(object,param2);
deviceService.dispatchEvent(new DevicesLoadedEvent());
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.battlefield.fps {
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.EnumCodecInfo;
import projects.tanks.client.battlefield.models.battle.battlefield.fps.FpsStatisticType;
public class VectorCodecFpsStatisticTypeLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecFpsStatisticTypeLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(FpsStatisticType,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.<FpsStatisticType> = new Vector.<FpsStatisticType>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = FpsStatisticType(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:FpsStatisticType = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<FpsStatisticType> = Vector.<FpsStatisticType>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.model.presents {
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.service.settings.SettingEnum;
import alternativa.tanks.service.settings.SettingsServiceEvent;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.panel.model.presents.IPresentsSettingsModelBase;
import projects.tanks.client.panel.model.presents.PresentsSettingsModelBase;
[ModelInfo]
public class PresentSettingsModel extends PresentsSettingsModelBase implements IPresentsSettingsModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var settingsService:ISettingsService;
public function PresentSettingsModel() {
super();
}
public function objectLoaded() : void {
settingsService.receivePresents = getInitParam().receivePresentsEnabled;
settingsService.addEventListener(SettingsServiceEvent.SETTINGS_CHANGED,getFunctionWrapper(this.settingsChanged));
}
public function objectUnloaded() : void {
settingsService.removeEventListener(SettingsServiceEvent.SETTINGS_CHANGED,getFunctionWrapper(this.settingsChanged));
}
private function settingsChanged(param1:SettingsServiceEvent) : void {
if(param1.getSetting() == SettingEnum.RECEIVE_PRESENTS) {
server.setReceivePresents(settingsService.receivePresents);
}
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.rarity {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.garage.models.item.rarity.Rarity;
public class CodecRarity implements ICodec {
public function CodecRarity() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:Rarity = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = Rarity.CUSTOMISE;
break;
case 1:
local2 = Rarity.LEGENDARY;
break;
case 2:
local2 = Rarity.EPIC;
break;
case 3:
local2 = Rarity.RARE;
break;
case 4:
local2 = Rarity.CASUAL;
}
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.garage.present {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class PresentGivenAdapt implements PresentGiven {
private var object:IGameObject;
private var impl:PresentGiven;
public function PresentGivenAdapt(param1:IGameObject, param2:PresentGiven) {
super();
this.object = param1;
this.impl = param2;
}
public function removePresent(param1:Long) : void {
var present:Long = param1;
try {
Model.object = this.object;
this.impl.removePresent(present);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.weapon.thunder {
import alternativa.math.Vector3;
import alternativa.physics.Body;
[ModelInterface]
public interface ThunderCallback {
function onShot(param1:int) : void;
function onShotStatic(param1:int, param2:Vector3) : void;
function onShotTarget(param1:int, param2:Vector3, param3:Body) : void;
}
}
|
package alternativa.tanks.models.tank.explosion
{
import alternativa.console.ConsoleVarFloat;
import alternativa.engine3d.objects.Mesh;
import alternativa.init.Main;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.service.IModelService;
import alternativa.tanks.engine3d.MaterialSequence;
import alternativa.tanks.engine3d.MaterialType;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.services.materialregistry.IMaterialRegistry;
import alternativa.tanks.services.objectpool.IObjectPoolService;
import alternativa.tanks.sfx.AnimatedPlaneEffectOld;
import alternativa.tanks.sfx.AnimatedSpriteEffectNew;
import alternativa.tanks.sfx.MovingObject3DPositionProvider;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.GraphicsUtils;
import alternativa.tanks.utils.objectpool.ObjectPool;
import com.alternativaplatform.projects.tanks.client.models.tank.explosion.ITankExplosionModelBase;
import com.alternativaplatform.projects.tanks.client.models.tank.explosion.TankExplosionModelBase;
import flash.display.BitmapData;
import scpacker.resource.ResourceType;
import scpacker.resource.ResourceUtil;
public class TankExplosionModel extends TankExplosionModelBase implements ITankExplosionModelBase, IObjectLoadListener, ITankExplosionModel
{
private const EXPLOSION_SIZE:Number = 800;
private const SMOKE_SIZE:Number = 400;
private const SHOCKWAVE_SIZE:Number = 1000;
private const BASE_DIAGONAL:Number = 600;
private const MIN_SMOKE_SPEED:Number = 800;
private const SMOKE_SPEED_DELTA:Number = 200;
private const SMOKE_ACCELERATION:Number = -2000;
private const EXPLOSION_FPS:Number = 25;
private const SMOKE_FPS:Number = 15;
private var objectPoolService:IObjectPoolService;
private var materialRegistry:IMaterialRegistry;
private var explosionSize:ConsoleVarFloat;
private var smokeSize:ConsoleVarFloat;
private var scaleModifier:ConsoleVarFloat;
private var shockWaveScaleSpeed:ConsoleVarFloat;
private var battlefieldModel:IBattleField;
private var rayHit:RayIntersection;
private var position:Vector3;
private var eulerAngles:Vector3;
private var velocity:Vector3;
private var matrix:Matrix3;
public function TankExplosionModel()
{
this.objectPoolService = IObjectPoolService(Main.osgi.getService(IObjectPoolService));
this.materialRegistry = IMaterialRegistry(Main.osgi.getService(IMaterialRegistry));
this.explosionSize = new ConsoleVarFloat("tankexpl_size",this.EXPLOSION_SIZE,1,2000);
this.smokeSize = new ConsoleVarFloat("tankexpl_smoke_size",this.SMOKE_SIZE,1,2000);
this.scaleModifier = new ConsoleVarFloat("tankexpl_scale",1,0,10);
this.shockWaveScaleSpeed = new ConsoleVarFloat("tankexpl_scale_speed",1,0,10);
this.rayHit = new RayIntersection();
this.position = new Vector3();
this.eulerAngles = new Vector3();
this.velocity = new Vector3();
this.matrix = new Matrix3();
super();
_interfaces.push(IModel,IObjectLoadListener,ITankExplosionModel);
}
public function initObject(clientObject:ClientObject, explosionTextureId:String, shockWaveTextureId:String, smokeTextureId:String) : void
{
var modelService:IModelService = null;
if(this.battlefieldModel == null)
{
modelService = IModelService(Main.osgi.getService(IModelService));
this.battlefieldModel = Main.osgi.getService(IBattleField) as IBattleField;
}
var explosionSequence:MaterialSequence = this.getMaterialSequence(explosionTextureId,this.EXPLOSION_SIZE);
var shockWaveSequence:MaterialSequence = this.getMaterialSequence(shockWaveTextureId,this.SHOCKWAVE_SIZE);
var smokeSequence:MaterialSequence = this.getMaterialSequence(smokeTextureId,this.SMOKE_SIZE);
var explData:TextureAnimation = GraphicsUtils.getTextureAnimation(null,ResourceUtil.getResource(ResourceType.IMAGE,explosionTextureId).bitmapData,200,200);
explData.fps = 25;
var shockData:TextureAnimation = GraphicsUtils.getTextureAnimation(null,ResourceUtil.getResource(ResourceType.IMAGE,shockWaveTextureId).bitmapData,250,250);
shockData.fps = 25;
var smokeData:TextureAnimation = GraphicsUtils.getTextureAnimation(null,ResourceUtil.getResource(ResourceType.IMAGE,smokeTextureId).bitmapData,200,200);
smokeData.fps = 15;
var explosionSFXData:ExplosionData = new ExplosionData(explosionSequence,shockWaveSequence,smokeSequence);
explosionSFXData.explosionData = explData;
explosionSFXData.shockData = shockData;
explosionSFXData.smokeData = smokeData;
clientObject.putParams(TankExplosionModel,explosionSFXData);
}
public function objectLoaded(object:ClientObject) : void
{
}
public function objectUnloaded(object:ClientObject) : void
{
this.getData(object).release();
}
public function createExplosionEffects(clientObject:ClientObject, tankData:TankData) : void
{
var effectScale:Number = NaN;
var explosionData:ExplosionData = null;
var objectPool:ObjectPool = null;
effectScale = NaN;
var size:Number = NaN;
var minTime:Number = NaN;
var normal:Vector3 = null;
var angle:Number = NaN;
var axis:Vector3 = null;
var animatedPlaneEffect:AnimatedPlaneEffectOld = null;
var speed:Number = NaN;
var smokeEffect:AnimatedSpriteEffectNew = null;
var animationSmoke:TextureAnimation = null;
var positionProvider:MovingObject3DPositionProvider = null;
var smokeSize:Number = NaN;
explosionData = this.getData(clientObject);
objectPool = this.objectPoolService.objectPool;
var hullMesh:Mesh = tankData.tank.skin.hullMesh;
var dx:Number = hullMesh.boundMaxX - hullMesh.boundMinX;
var dy:Number = hullMesh.boundMaxY - hullMesh.boundMinY;
var dz:Number = hullMesh.boundMaxZ - hullMesh.boundMinZ;
var diagonal:Number = Math.sqrt(dx * dx + dy * dy + dz * dz);
effectScale = this.scaleModifier.value * diagonal / this.BASE_DIAGONAL;
var dir:Vector3 = new Vector3(0,0,-1);
this.position.vCopy(tankData.tank.state.pos);
if(this.battlefieldModel.getBattlefieldData().collisionDetector.intersectRayWithStatic(this.position,dir,255,500,null,this.rayHit))
{
this.rayHit.pos.z += 10;
size = this.SHOCKWAVE_SIZE;
minTime = 200;
if(this.rayHit.t > minTime)
{
size *= (500 - this.rayHit.t) / (500 - minTime);
}
normal = this.rayHit.normal;
angle = Math.acos(normal.z);
axis = new Vector3(-normal.y,normal.x,0);
axis.vNormalize();
this.matrix.fromAxisAngle(axis,angle);
this.matrix.getEulerAngles(this.eulerAngles);
animatedPlaneEffect = AnimatedPlaneEffectOld(objectPool.getObject(AnimatedPlaneEffectOld));
animatedPlaneEffect.init(effectScale * size,this.rayHit.pos,this.eulerAngles,this.EXPLOSION_FPS,explosionData.shockWaveSequence.materials,this.shockWaveScaleSpeed.value);
this.battlefieldModel.addGraphicEffect(animatedPlaneEffect);
}
this.position.z += 50;
var explosion:AnimatedSpriteEffectNew = AnimatedSpriteEffectNew(objectPool.getObject(AnimatedSpriteEffectNew));
var animaton:TextureAnimation = explosionData.explosionData;
var pos:StaticObject3DPositionProvider = StaticObject3DPositionProvider(objectPool.getObject(StaticObject3DPositionProvider));
pos.init(this.position,200);
var explosionSize:Number = this.explosionSize.value * effectScale;
var explosionSequence:MaterialSequence = explosionData.explosionSequence;
explosionSequence.mipMapResolution = explosionSize / explosionSequence.frameWidth;
explosion.init(explosionSize,explosionSize,animaton,Math.random() * 2 * Math.PI,pos);
this.battlefieldModel.addGraphicEffect(explosion);
for(var i:int = 0; i < 3; i++)
{
speed = this.MIN_SMOKE_SPEED + Math.random() * this.SMOKE_SPEED_DELTA;
this.velocity.x = speed * (1 - 2 * Math.random());
this.velocity.y = speed * (1 - 2 * Math.random());
this.velocity.z = speed * 0.5 * (1 + Math.random());
smokeEffect = AnimatedSpriteEffectNew(objectPool.getObject(AnimatedSpriteEffectNew));
animationSmoke = explosionData.smokeData;
positionProvider = MovingObject3DPositionProvider(objectPool.getObject(MovingObject3DPositionProvider));
positionProvider.init(this.position,this.velocity,-2000);
smokeSize = this.smokeSize.value * effectScale;
smokeEffect.init(smokeSize,smokeSize,animationSmoke,Math.random() * 2 * Math.PI,positionProvider);
this.battlefieldModel.addGraphicEffect(smokeEffect);
}
}
private function getData(clientObject:ClientObject) : ExplosionData
{
return ExplosionData(clientObject.getParams(TankExplosionModel));
}
private function getMaterialSequence(textureId:String, size:Number) : MaterialSequence
{
var texture:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,textureId).bitmapData;
var frameSize:int = texture.height;
return this.materialRegistry.materialSequenceRegistry.getSequence(MaterialType.EFFECT,texture,frameSize,size / frameSize);
}
}
}
import alternativa.tanks.engine3d.MaterialSequence;
import alternativa.tanks.engine3d.TextureAnimation;
class ExplosionData
{
public var explosionSequence:MaterialSequence;
public var shockWaveSequence:MaterialSequence;
public var smokeSequence:MaterialSequence;
public var explosionData:TextureAnimation;
public var shockData:TextureAnimation;
public var smokeData:TextureAnimation;
function ExplosionData(explosionSequence:MaterialSequence, shockWaveSequence:MaterialSequence, smokeSequence:MaterialSequence)
{
super();
this.explosionSequence = explosionSequence;
this.shockWaveSequence = shockWaveSequence;
this.smokeSequence = smokeSequence;
}
public function release() : void
{
this.explosionSequence.release();
this.shockWaveSequence.release();
this.smokeSequence.release();
}
}
|
package projects.tanks.client.entrance.model.entrance.objectdetach {
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 EntranceObjectDetachModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:EntranceObjectDetachModelServer;
private var client:IEntranceObjectDetachModelBase = IEntranceObjectDetachModelBase(this);
private var modelId:Long = Long.getLong(1377053011,190397042);
private var _objectDetachId:Long = Long.getLong(5859656,-1143601287);
public function EntranceObjectDetachModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new EntranceObjectDetachModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._objectDetachId:
this.client.objectDetach();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_doublebarrelIconClass.png")]
public class DeviceIcons_doublebarrelIconClass extends BitmapAsset {
public function DeviceIcons_doublebarrelIconClass() {
super();
}
}
}
|
package alternativa.physics
{
public namespace altphysics = "http://alternativaplatform.com/en/altphysics";
}
|
package alternativa.engine3d.primitives {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
use namespace alternativa3d;
public class Box extends Mesh {
public function Box(param1:Number = 100, param2:Number = 100, param3:Number = 100, param4:uint = 1, param5:uint = 1, param6:uint = 1, param7:Boolean = false, param8:Boolean = false, param9:Material = null, param10:Material = null, param11:Material = null, param12:Material = null, param13:Material = null, param14:Material = null) {
var local15:int = 0;
var local16:int = 0;
var local17:int = 0;
super();
if(param4 < 1) {
throw new ArgumentError(param4 + " width segments not enough.");
}
if(param5 < 1) {
throw new ArgumentError(param5 + " length segments not enough.");
}
if(param6 < 1) {
throw new ArgumentError(param6 + " height segments not enough.");
}
var local18:int = param4 + 1;
var local19:int = param5 + 1;
var local20:int = param6 + 1;
var local21:Number = param1 * 0.5;
var local22:Number = param2 * 0.5;
var local23:Number = param3 * 0.5;
var local24:Number = 1 / param4;
var local25:Number = 1 / param5;
var local26:Number = 1 / param6;
var local27:Number = param1 / param4;
var local28:Number = param2 / param5;
var local29:Number = param3 / param6;
var local30:Vector.<Vertex> = new Vector.<Vertex>();
var local31:int = 0;
local15 = 0;
while(local15 < local18) {
local16 = 0;
while(local16 < local19) {
var local33:* = local31++;
local30[local33] = this.createVertex(local15 * local27 - local21,local16 * local28 - local22,-local23,(param4 - local15) * local24,(param5 - local16) * local25);
local16++;
}
local15++;
}
local15 = 0;
while(local15 < local18) {
local16 = 0;
while(local16 < local19) {
if(local15 < param4 && local16 < param5) {
this.createFace(local30[(local15 + 1) * local19 + local16 + 1],local30[(local15 + 1) * local19 + local16],local30[local15 * local19 + local16],local30[local15 * local19 + local16 + 1],0,0,-1,local23,param7,param8,param13);
}
local16++;
}
local15++;
}
var local32:uint = uint(local18 * local19);
local15 = 0;
while(local15 < local18) {
local16 = 0;
while(local16 < local19) {
local33 = local31++;
local30[local33] = this.createVertex(local15 * local27 - local21,local16 * local28 - local22,local23,local15 * local24,(param5 - local16) * local25);
local16++;
}
local15++;
}
local15 = 0;
while(local15 < local18) {
local16 = 0;
while(local16 < local19) {
if(local15 < param4 && local16 < param5) {
this.createFace(local30[local32 + local15 * local19 + local16],local30[local32 + (local15 + 1) * local19 + local16],local30[local32 + (local15 + 1) * local19 + local16 + 1],local30[local32 + local15 * local19 + local16 + 1],0,0,1,local23,param7,param8,param14);
}
local16++;
}
local15++;
}
local32 += local18 * local19;
local15 = 0;
while(local15 < local18) {
local17 = 0;
while(local17 < local20) {
local33 = local31++;
local30[local33] = this.createVertex(local15 * local27 - local21,-local22,local17 * local29 - local23,local15 * local24,(param6 - local17) * local26);
local17++;
}
local15++;
}
local15 = 0;
while(local15 < local18) {
local17 = 0;
while(local17 < local20) {
if(local15 < param4 && local17 < param6) {
this.createFace(local30[local32 + local15 * local20 + local17],local30[local32 + (local15 + 1) * local20 + local17],local30[local32 + (local15 + 1) * local20 + local17 + 1],local30[local32 + local15 * local20 + local17 + 1],0,-1,0,local22,param7,param8,param11);
}
local17++;
}
local15++;
}
local32 += local18 * local20;
local15 = 0;
while(local15 < local18) {
local17 = 0;
while(local17 < local20) {
local33 = local31++;
local30[local33] = this.createVertex(local15 * local27 - local21,local22,local17 * local29 - local23,(param4 - local15) * local24,(param6 - local17) * local26);
local17++;
}
local15++;
}
local15 = 0;
while(local15 < local18) {
local17 = 0;
while(local17 < local20) {
if(local15 < param4 && local17 < param6) {
this.createFace(local30[local32 + local15 * local20 + local17],local30[local32 + local15 * local20 + local17 + 1],local30[local32 + (local15 + 1) * local20 + local17 + 1],local30[local32 + (local15 + 1) * local20 + local17],0,1,0,local22,param7,param8,param12);
}
local17++;
}
local15++;
}
local32 += local18 * local20;
local16 = 0;
while(local16 < local19) {
local17 = 0;
while(local17 < local20) {
local33 = local31++;
local30[local33] = this.createVertex(-local21,local16 * local28 - local22,local17 * local29 - local23,(param5 - local16) * local25,(param6 - local17) * local26);
local17++;
}
local16++;
}
local16 = 0;
while(local16 < local19) {
local17 = 0;
while(local17 < local20) {
if(local16 < param5 && local17 < param6) {
this.createFace(local30[local32 + local16 * local20 + local17],local30[local32 + local16 * local20 + local17 + 1],local30[local32 + (local16 + 1) * local20 + local17 + 1],local30[local32 + (local16 + 1) * local20 + local17],-1,0,0,local21,param7,param8,param9);
}
local17++;
}
local16++;
}
local32 += local19 * local20;
local16 = 0;
while(local16 < local19) {
local17 = 0;
while(local17 < local20) {
local33 = local31++;
local30[local33] = this.createVertex(local21,local16 * local28 - local22,local17 * local29 - local23,local16 * local25,(param6 - local17) * local26);
local17++;
}
local16++;
}
local16 = 0;
while(local16 < local19) {
local17 = 0;
while(local17 < local20) {
if(local16 < param5 && local17 < param6) {
this.createFace(local30[local32 + local16 * local20 + local17],local30[local32 + (local16 + 1) * local20 + local17],local30[local32 + (local16 + 1) * local20 + local17 + 1],local30[local32 + local16 * local20 + local17 + 1],1,0,0,local21,param7,param8,param10);
}
local17++;
}
local16++;
}
boundMinX = -local21;
boundMinY = -local22;
boundMinZ = -local23;
boundMaxX = local21;
boundMaxY = local22;
boundMaxZ = local23;
}
private function createVertex(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number) : Vertex {
var local6:Vertex = new Vertex();
local6.x = param1;
local6.y = param2;
local6.z = param3;
local6.u = param4;
local6.v = param5;
local6.alternativa3d::next = alternativa3d::vertexList;
alternativa3d::vertexList = local6;
return local6;
}
private function createFace(param1:Vertex, param2:Vertex, param3:Vertex, param4:Vertex, param5:Number, param6:Number, param7:Number, param8:Number, param9:Boolean, param10:Boolean, param11:Material) : void {
var local12:Vertex = null;
var local13:Face = null;
if(param9) {
param5 = -param5;
param6 = -param6;
param7 = -param7;
param8 = -param8;
local12 = param1;
param1 = param4;
param4 = local12;
local12 = param2;
param2 = param3;
param3 = local12;
}
if(param10) {
local13 = new Face();
local13.material = param11;
local13.alternativa3d::wrapper = new Wrapper();
local13.alternativa3d::wrapper.alternativa3d::vertex = param1;
local13.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = param2;
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param3;
local13.alternativa3d::normalX = param5;
local13.alternativa3d::normalY = param6;
local13.alternativa3d::normalZ = param7;
local13.alternativa3d::offset = param8;
local13.alternativa3d::next = alternativa3d::faceList;
alternativa3d::faceList = local13;
local13 = new Face();
local13.material = param11;
local13.alternativa3d::wrapper = new Wrapper();
local13.alternativa3d::wrapper.alternativa3d::vertex = param1;
local13.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = param3;
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param4;
local13.alternativa3d::normalX = param5;
local13.alternativa3d::normalY = param6;
local13.alternativa3d::normalZ = param7;
local13.alternativa3d::offset = param8;
local13.alternativa3d::next = alternativa3d::faceList;
alternativa3d::faceList = local13;
} else {
local13 = new Face();
local13.material = param11;
local13.alternativa3d::wrapper = new Wrapper();
local13.alternativa3d::wrapper.alternativa3d::vertex = param1;
local13.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = param2;
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param3;
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::next = new Wrapper();
local13.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param4;
local13.alternativa3d::normalX = param5;
local13.alternativa3d::normalY = param6;
local13.alternativa3d::normalZ = param7;
local13.alternativa3d::offset = param8;
local13.alternativa3d::next = alternativa3d::faceList;
alternativa3d::faceList = local13;
}
}
override public function clone() : Object3D {
var local1:Box = new Box();
local1.clonePropertiesFrom(this);
return local1;
}
}
}
|
package projects.tanks.client.battlefield.models.battle.gui.inventory {
public class InventoryCC {
private var _ultimateEnabled:Boolean;
public function InventoryCC(param1:Boolean = false) {
super();
this._ultimateEnabled = param1;
}
public function get ultimateEnabled() : Boolean {
return this._ultimateEnabled;
}
public function set ultimateEnabled(param1:Boolean) : void {
this._ultimateEnabled = param1;
}
public function toString() : String {
var local1:String = "InventoryCC [";
local1 += "ultimateEnabled = " + this.ultimateEnabled + " ";
return local1 + "]";
}
}
}
|
package scpacker.test.spectator
{
import alternativa.console.ConsoleVarFloat;
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.tanks.camera.CameraControllerBase;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.camera.ICameraController;
import flash.display.Stage;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.ui.Keyboard;
public class SpectatorCameraController extends CameraControllerBase implements ICameraController
{
public static var display:Stage;
private static const conSmooth:ConsoleVarFloat = new ConsoleVarFloat("cam_smooth",0.1,0.001,1);
private static const conMousePitchSensitivity:ConsoleVarFloat = new ConsoleVarFloat("m_pitch",-0.006,-100,100);
private static const conMouseYawSensitivity:ConsoleVarFloat = new ConsoleVarFloat("m_yaw",-0.006,-100,100);
private static const conSpeed:ConsoleVarFloat = new ConsoleVarFloat("cam_spd",1300,0,10000);
private static const conAcceleration:ConsoleVarFloat = new ConsoleVarFloat("cam_acc",4,0,1000000);
private static const conYawSpeed:ConsoleVarFloat = new ConsoleVarFloat("yaw_speed",1,-10,10);
private static const conPitchSpeed:ConsoleVarFloat = new ConsoleVarFloat("pitch_speed",1,-10,10);
private var mouseDown:Boolean;
private var mouseDownX:Number;
private var mouseDownY:Number;
private var startCameraRotationX:Number;
private var startCameraRotationZ:Number;
private var position:Vector3;
private var rotation:Vector3;
private var rotationDelta:Vector3;
private var moveMethods:MovementMethods;
private var keyboardHandlers:Vector.<KeyboardHandler>;
private var userInput:UserInput;
public var playerCamera:PlayerCamera;
private var addedEvents:Boolean = false;
public function SpectatorCameraController(camera:GameCamera)
{
super(camera);
display = Main.stage;
this.position = new Vector3();
this.rotation = new Vector3();
this.rotationDelta = new Vector3();
this.userInput = new UserInputImpl();
this.playerCamera = new PlayerCamera(this);
this.keyboardHandlers = Vector.<KeyboardHandler>([new BookmarksHandler(this),this.userInput,this.playerCamera,new SpectatorBonusRegionController()]);
this.setPositionFromCamera();
this.moveMethods = new MovementMethods(Vector.<MovementMethod>([new FlightMovement(conSpeed,conAcceleration),new WalkMovement(conSpeed,conAcceleration)]));
}
private static function calculateAngleDelta(param1:Number, param2:Number) : Number
{
var _loc3_:Number = (param2 - param1) % (2 * Math.PI);
if(_loc3_ > Math.PI)
{
return _loc3_ - 2 * Math.PI;
}
if(_loc3_ < -Math.PI)
{
return 2 * Math.PI + _loc3_;
}
return _loc3_;
}
public function setCameraState(param1:Vector3, param2:Vector3) : void
{
var _loc3_:GameCamera = null;
_loc3_ = null;
this.playerCamera.unfocus();
this.position.copyFrom(param1);
this.rotation.copyFrom(param2);
_loc3_ = getCamera();
this.rotationDelta.x = calculateAngleDelta(_loc3_.rotationX,param2.x);
this.rotationDelta.y = calculateAngleDelta(_loc3_.rotationY,param2.y);
this.rotationDelta.z = calculateAngleDelta(_loc3_.rotationZ,param2.z);
}
public function update(param1:int, param2:int) : void
{
if(getCamera() != null)
{
this.calculatePosition(param2);
this.calculateRotation(param2 / 1000);
this.applyTransformation();
}
}
private function calculatePosition(param1:int) : void
{
var _loc2_:Vector3 = null;
_loc2_ = this.moveMethods.getMethod().getDisplacement(this.userInput,getCamera(),param1 / 1000);
this.position.x += _loc2_.x;
this.position.y += _loc2_.y;
this.position.z += _loc2_.z;
}
private function calculateRotation(param1:Number) : void
{
var _loc2_:GameCamera = null;
_loc2_ = getCamera();
if(this.mouseDown)
{
this.rotation.x = this.startCameraRotationX + (display.mouseY - this.mouseDownY) * conMousePitchSensitivity.value;
this.rotationDelta.x = this.rotation.x - _loc2_.rotationX;
this.rotation.z = this.startCameraRotationZ + (display.mouseX - this.mouseDownX) * conMouseYawSensitivity.value;
this.rotationDelta.z = this.rotation.z - _loc2_.rotationZ;
}
else if(this.userInput.isRotating())
{
this.rotation.x += this.userInput.getPitchDirection() * conPitchSpeed.value * param1;
this.rotationDelta.x = this.rotation.x - _loc2_.rotationX;
this.rotationDelta.z += this.userInput.getYawDirection() * conYawSpeed.value * param1;
}
}
private function applyTransformation() : void
{
this.applyDisplacement();
this.applyRotation();
}
private function applyDisplacement() : void
{
var _loc1_:GameCamera = getCamera();
_loc1_.x += (this.position.x - _loc1_.x) * conSmooth.value;
_loc1_.y += (this.position.y - _loc1_.y) * conSmooth.value;
_loc1_.z += (this.position.z - _loc1_.z) * conSmooth.value;
}
private function applyRotation() : void
{
var _loc1_:GameCamera = null;
_loc1_ = getCamera();
var _loc2_:Number = this.rotationDelta.x * conSmooth.value;
_loc1_.rotationX += _loc2_;
this.rotationDelta.x -= _loc2_;
var _loc3_:Number = this.rotationDelta.y * conSmooth.value;
_loc1_.rotationY += _loc3_;
this.rotationDelta.y -= _loc3_;
var _loc4_:Number = this.rotationDelta.z * conSmooth.value;
_loc1_.rotationZ += _loc4_;
this.rotationDelta.z -= _loc4_;
}
public function activate() : void
{
this.rotationDelta.reset();
this.activateInput();
}
public function setPositionFromCamera() : void
{
var _loc1_:GameCamera = null;
_loc1_ = getCamera();
this.position.x = _loc1_.x;
this.position.y = _loc1_.y;
this.position.z = _loc1_.z;
this.rotation.x = _loc1_.rotationX;
this.rotation.y = _loc1_.rotationY;
this.rotation.z = _loc1_.rotationZ;
}
public function deactivate() : void
{
this.userInput.reset();
this.rotationDelta.reset();
this.deactivateInput();
}
private function onMouseDown(param1:MouseEvent) : void
{
this.mouseDown = true;
this.mouseDownX = param1.stageX;
this.mouseDownY = param1.stageY;
var _loc2_:GameCamera = getCamera();
this.startCameraRotationX = _loc2_.rotationX;
this.startCameraRotationZ = _loc2_.rotationZ;
display.addEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
}
private function onKeyUp(param1:KeyboardEvent) : void
{
var _loc2_:KeyboardHandler = null;
for each(_loc2_ in this.keyboardHandlers)
{
_loc2_.handleKeyUp(param1);
}
}
private function onKeyDown(param1:KeyboardEvent) : void
{
var _loc2_:KeyboardHandler = null;
if(param1.keyCode == Keyboard.SPACE)
{
this.moveMethods.selectNextMethod();
}
if(param1.keyCode == Keyboard.H)
{
Main.contentUILayer.visible = !Main.contentUILayer.visible;
}
for each(_loc2_ in this.keyboardHandlers)
{
_loc2_.handleKeyDown(param1);
}
}
private function releaseMouse() : void
{
if(this.mouseDown)
{
display.removeEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
this.mouseDown = false;
}
}
private function onMouseUp(param1:MouseEvent) : void
{
this.releaseMouse();
}
[Obfuscation(rename="false")]
public function close() : void
{
this.playerCamera.close();
}
public function deactivateInput() : void
{
var k:KeyboardHandler = null;
var _loc1_:Stage = null;
this.releaseMouse();
if(this.addedEvents)
{
_loc1_ = display;
_loc1_.removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
_loc1_.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
_loc1_.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
for each(k in this.keyboardHandlers)
{
k = null;
}
this.keyboardHandlers = null;
this.addedEvents = false;
}
}
public function activateInput() : void
{
var _loc1_:Stage = null;
if(!this.addedEvents)
{
_loc1_ = display;
_loc1_.addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
_loc1_.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
_loc1_.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
this.addedEvents = true;
}
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.facilities.facillity {
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 FacilitySphericalZoneModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:FacilitySphericalZoneModelServer;
private var client:IFacilitySphericalZoneModelBase = IFacilitySphericalZoneModelBase(this);
private var modelId:Long = Long.getLong(573858908,22312341);
public function FacilitySphericalZoneModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new FacilitySphericalZoneModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(FacilitySphericalZoneCC,false)));
}
protected function getInitParam() : FacilitySphericalZoneCC {
return FacilitySphericalZoneCC(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 controls.scroller.blue {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.scroller.blue.ScrollSkinBlue_trackTop.png")]
public class ScrollSkinBlue_trackTop extends BitmapAsset {
public function ScrollSkinBlue_trackTop() {
super();
}
}
}
|
package assets.window.bitmaps {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.window.bitmaps.WindowRight.png")]
public class WindowRight extends BitmapData {
public function WindowRight(param1:int, param2:int, param3:Boolean = true, param4:uint = 0) {
super(param1,param2,param3,param4);
}
}
}
|
package _codec.projects.tanks.client.battleservice {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battleservice.Range;
public class CodecRange implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_max:ICodec;
private var codec_min:ICodec;
public function CodecRange() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_max = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_min = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:Range = new Range();
local2.max = this.codec_max.decode(param1) as int;
local2.min = this.codec_min.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Range = Range(param2);
this.codec_max.encode(param1,local3.max);
this.codec_min.encode(param1,local3.min);
}
}
}
|
package alternativa.tanks.controller.events {
import flash.events.Event;
public class ChooseInitialStateEvent extends Event {
public static const CHOOSE_INITIAL_STATE:String = "CHOOSE_INITIAL_STATE";
public function ChooseInitialStateEvent() {
super(CHOOSE_INITIAL_STATE);
}
}
}
|
package alternativa.tanks.view.mainview {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.mainview.BattleTypesPanel_dmBtnClass.png")]
public class BattleTypesPanel_dmBtnClass extends BitmapAsset {
public function BattleTypesPanel_dmBtnClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.coinpackage {
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 CoinPackageModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:CoinPackageModelServer;
private var client:ICoinPackageModelBase = ICoinPackageModelBase(this);
private var modelId:Long = Long.getLong(713651658,-469479644);
public function CoinPackageModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new CoinPackageModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(CoinPackageCC,false)));
}
protected function getInitParam() : CoinPackageCC {
return CoinPackageCC(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 scpacker.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksI_coldload11 extends BitmapAsset
{
public function GTanksI_coldload11()
{
super();
}
}
}
|
package alternativa.tanks.model.quest.common.gui.window.buttons {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.service.money.IMoneyListener;
import alternativa.tanks.service.money.IMoneyService;
import assets.Diamond;
import controls.Money;
import controls.base.ThreeLineBigButton;
import controls.labels.MouseDisabledLabel;
import flash.display.Sprite;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class DailyQuestChangeButton extends ThreeLineBigButton implements IMoneyListener {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var moneyService:IMoneyService;
private static const NOT_ENOUGH_CRYSTALS_TEXT_COLOR:int = 16731648;
private static const ENOUGH_CRYSTALS_TEXT_COLOR:int = 16777215;
private var priceLabel:MouseDisabledLabel;
private var crystals:int;
public function DailyQuestChangeButton() {
super();
this.priceLabel = new MouseDisabledLabel();
this.priceLabel.size = 11;
super.setText(localeService.getText(TanksLocale.TEXT_DAILY_QUEST_CHANGE));
moneyService.addListener(this);
}
public function showButtonWithCrystals(param1:int) : void {
this.crystals = param1;
var local2:Diamond = new Diamond();
local2.y = 3;
var local3:Sprite = new Sprite();
local3.addChild(this.priceLabel);
local3.addChild(local2);
addChild(local3);
this.priceLabel.text = Money.numToString(param1,false);
this.priceLabel.x = int(_width / 2 - (this.priceLabel.width + local2.width) / 2);
local2.x = this.priceLabel.x + this.priceLabel.textWidth + 7;
this.updatePriceLabelColor();
super.showInTwoRows(captionLabel,local3);
}
public function showButtonWithoutCrystals() : void {
super.showInOneRow(captionLabel);
}
public function crystalsChanged(param1:int) : void {
this.updatePriceLabelColor();
}
private function updatePriceLabelColor() : void {
this.priceLabel.textColor = moneyService.crystal < this.crystals ? uint(NOT_ENOUGH_CRYSTALS_TEXT_COLOR) : uint(ENOUGH_CRYSTALS_TEXT_COLOR);
}
public function removeListeners() : void {
moneyService.removeListener(this);
}
}
}
|
package _codec.projects.tanks.client.commons.models.coloring {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.commons.models.coloring.ColoringCC;
public class CodecColoringCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_animatedColoring:ICodec;
private var codec_coloring:ICodec;
public function CodecColoringCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_animatedColoring = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,true));
this.codec_coloring = param1.getCodec(new TypeCodecInfo(TextureResource,true));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ColoringCC = new ColoringCC();
local2.animatedColoring = this.codec_animatedColoring.decode(param1) as MultiframeTextureResource;
local2.coloring = this.codec_coloring.decode(param1) as TextureResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ColoringCC = ColoringCC(param2);
this.codec_animatedColoring.encode(param1,local3.animatedColoring);
this.codec_coloring.encode(param1,local3.coloring);
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.container {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.container.ContainerGivenItem;
public class VectorCodecContainerGivenItemLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecContainerGivenItemLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ContainerGivenItem,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.<ContainerGivenItem> = new Vector.<ContainerGivenItem>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ContainerGivenItem(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ContainerGivenItem = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ContainerGivenItem> = Vector.<ContainerGivenItem>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.battlefield.mine {
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.battlefield.mine.BattleMineCC;
public class VectorCodecBattleMineCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattleMineCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BattleMineCC,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.<BattleMineCC> = new Vector.<BattleMineCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattleMineCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattleMineCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattleMineCC> = Vector.<BattleMineCC>(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.models.tankparts.weapon.ricochet {
public class RicochetCC {
private var _energyCapacity:Number;
private var _energyPerShot:Number;
private var _energyRechargeSpeed:Number;
private var _maxRicochetCount:int;
private var _shellRadius:Number;
private var _shellSpeed:Number;
private var _shotDistance:Number;
public function RicochetCC(param1:Number = 0, param2:Number = 0, param3:Number = 0, param4:int = 0, param5:Number = 0, param6:Number = 0, param7:Number = 0) {
super();
this._energyCapacity = param1;
this._energyPerShot = param2;
this._energyRechargeSpeed = param3;
this._maxRicochetCount = param4;
this._shellRadius = param5;
this._shellSpeed = param6;
this._shotDistance = param7;
}
public function get energyCapacity() : Number {
return this._energyCapacity;
}
public function set energyCapacity(param1:Number) : void {
this._energyCapacity = param1;
}
public function get energyPerShot() : Number {
return this._energyPerShot;
}
public function set energyPerShot(param1:Number) : void {
this._energyPerShot = param1;
}
public function get energyRechargeSpeed() : Number {
return this._energyRechargeSpeed;
}
public function set energyRechargeSpeed(param1:Number) : void {
this._energyRechargeSpeed = param1;
}
public function get maxRicochetCount() : int {
return this._maxRicochetCount;
}
public function set maxRicochetCount(param1:int) : void {
this._maxRicochetCount = param1;
}
public function get shellRadius() : Number {
return this._shellRadius;
}
public function set shellRadius(param1:Number) : void {
this._shellRadius = param1;
}
public function get shellSpeed() : Number {
return this._shellSpeed;
}
public function set shellSpeed(param1:Number) : void {
this._shellSpeed = param1;
}
public function get shotDistance() : Number {
return this._shotDistance;
}
public function set shotDistance(param1:Number) : void {
this._shotDistance = param1;
}
public function toString() : String {
var local1:String = "RicochetCC [";
local1 += "energyCapacity = " + this.energyCapacity + " ";
local1 += "energyPerShot = " + this.energyPerShot + " ";
local1 += "energyRechargeSpeed = " + this.energyRechargeSpeed + " ";
local1 += "maxRicochetCount = " + this.maxRicochetCount + " ";
local1 += "shellRadius = " + this.shellRadius + " ";
local1 += "shellSpeed = " + this.shellSpeed + " ";
local1 += "shotDistance = " + this.shotDistance + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.weapon.gauss {
import alternativa.math.Vector3;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class GaussWeaponCallbackEvents implements GaussWeaponCallback {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function GaussWeaponCallbackEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function doPrimaryShot(param1:int, param2:Vector3) : void {
var i:int = 0;
var m:GaussWeaponCallback = null;
var shotId:int = param1;
var shotDirection:Vector3 = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = GaussWeaponCallback(this.impl[i]);
m.doPrimaryShot(shotId,shotDirection);
i++;
}
}
finally {
Model.popObject();
}
}
public function doSecondaryShot(param1:IGameObject, param2:Vector3, param3:Vector3) : void {
var i:int = 0;
var m:GaussWeaponCallback = null;
var target:IGameObject = param1;
var targetPosition:Vector3 = param2;
var localHitPosition:Vector3 = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = GaussWeaponCallback(this.impl[i]);
m.doSecondaryShot(target,targetPosition,localHitPosition);
i++;
}
}
finally {
Model.popObject();
}
}
public function doDummyShot() : void {
var i:int = 0;
var m:GaussWeaponCallback = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = GaussWeaponCallback(this.impl[i]);
m.doDummyShot();
i++;
}
}
finally {
Model.popObject();
}
}
public function doStartAiming() : void {
var i:int = 0;
var m:GaussWeaponCallback = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = GaussWeaponCallback(this.impl[i]);
m.doStartAiming();
i++;
}
}
finally {
Model.popObject();
}
}
public function doStopAiming() : void {
var i:int = 0;
var m:GaussWeaponCallback = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = GaussWeaponCallback(this.impl[i]);
m.doStopAiming();
i++;
}
}
finally {
Model.popObject();
}
}
public function doPrimaryHitStatic(param1:int, param2:Vector3) : void {
var i:int = 0;
var m:GaussWeaponCallback = null;
var shotId:int = param1;
var targetPosition:Vector3 = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = GaussWeaponCallback(this.impl[i]);
m.doPrimaryHitStatic(shotId,targetPosition);
i++;
}
}
finally {
Model.popObject();
}
}
public function doPrimaryHitTarget(param1:int, param2:IGameObject, param3:Vector3, param4:Vector3) : void {
var i:int = 0;
var m:GaussWeaponCallback = null;
var shotId:int = param1;
var target:IGameObject = param2;
var targetPosition:Vector3 = param3;
var hitPointWorld:Vector3 = param4;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = GaussWeaponCallback(this.impl[i]);
m.doPrimaryHitTarget(shotId,target,targetPosition,hitPointWorld);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package platform.client.fp10.core.network.command {
public interface IConnectionInitCommand {
}
}
|
package projects.tanks.client.garage.models.item.buyable {
public interface IBuyableModelBase {
}
}
|
package projects.tanks.client.panel.model
{
import scpacker.Base;
public class UserDataModelBase extends Base
{
public function UserDataModelBase()
{
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.bonus.battle.bonusregions {
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.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.bonus.battle.bonusregions.BonusRegionResource;
import projects.tanks.client.battlefield.models.bonus.bonus.BonusesType;
public class CodecBonusRegionResource implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_dropZoneResource:ICodec;
private var codec_regionType:ICodec;
public function CodecBonusRegionResource() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_dropZoneResource = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_regionType = param1.getCodec(new EnumCodecInfo(BonusesType,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BonusRegionResource = new BonusRegionResource();
local2.dropZoneResource = this.codec_dropZoneResource.decode(param1) as TextureResource;
local2.regionType = this.codec_regionType.decode(param1) as BonusesType;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BonusRegionResource = BonusRegionResource(param2);
this.codec_dropZoneResource.encode(param1,local3.dropZoneResource);
this.codec_regionType.encode(param1,local3.regionType);
}
}
}
|
package {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol1174")]
public dynamic class SliderTrack_skin extends MovieClip {
public function SliderTrack_skin() {
super();
}
}
}
|
package scpacker.gui
{
import flash.display.Bitmap;
public interface GTanksLoaderImages
{
function getRandomPict() : Bitmap;
}
}
|
package alternativa.tanks.battle.triggers {
import alternativa.physics.Body;
import alternativa.tanks.battle.*;
public class Triggers {
private const _triggers:Vector.<Trigger> = new Vector.<Trigger>();
private const deferredActions:Vector.<DeferredAction> = new Vector.<DeferredAction>();
private var running:Boolean;
public function Triggers() {
super();
}
public function add(param1:Trigger) : void {
if(this.running) {
this.deferredActions.push(new DeferredTriggerAddition(this,param1));
} else if(this._triggers.indexOf(param1) < 0) {
this._triggers.push(param1);
}
}
public function remove(param1:Trigger) : void {
var local2:int = 0;
var local3:int = 0;
if(this.running) {
this.deferredActions.push(new DeferredTriggerDeletion(this,param1));
} else {
local2 = int(this._triggers.length);
if(local2 > 0) {
local3 = int(this._triggers.indexOf(param1));
if(local3 >= 0) {
this._triggers[local3] = this._triggers[--local2];
this._triggers.length = local2;
}
}
}
}
public function check(param1:Body) : void {
var local2:int = 0;
var local3:int = 0;
var local4:Trigger = null;
if(param1 != null) {
this.running = true;
local2 = int(this._triggers.length);
local3 = 0;
while(local3 < local2) {
local4 = this._triggers[local3];
local4.checkTrigger(param1);
local3++;
}
this.running = false;
this.executeDeferredActions();
}
}
private function executeDeferredActions() : void {
var local1:DeferredAction = null;
while(true) {
local1 = this.deferredActions.pop();
if(local1 == null) {
break;
}
local1.execute();
}
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_bitmapBackgroundPixelTableKit.png")]
public class ItemInfoPanelBitmaps_bitmapBackgroundPixelTableKit extends BitmapAsset {
public function ItemInfoPanelBitmaps_bitmapBackgroundPixelTableKit() {
super();
}
}
}
|
package alternativa.tanks.model.payment.shop.cashpackage {
[ModelInterface]
public interface CashPackage {
function getAmount() : int;
function getBonusAmount() : int;
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.artillery.rotation {
public interface IArtilleryElevatingBarrelModelBase {
function update(param1:BarrelElevationCommand) : void;
}
}
|
package controls {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.VKButton_hoveredBitmapVK.png")]
public class VKButton_hoveredBitmapVK extends BitmapAsset {
public function VKButton_hoveredBitmapVK() {
super();
}
}
}
|
package projects.tanks.client.panel.model.payment {
public interface ICrystalsPaymentModelBase {
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.KillMessageOutputLine_freezeIconClass.png")]
public class KillMessageOutputLine_freezeIconClass extends BitmapAsset {
public function KillMessageOutputLine_freezeIconClass() {
super();
}
}
}
|
package controls {
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.TextEvent;
import flash.system.Capabilities;
import flash.text.TextField;
public class TextFieldUtf8 extends TextField {
private static const NOTHING:int = -1;
private static const INVALID:int = -2;
private var character:int = 0;
private var bits_left:int = 0;
private var utf32_char:int = -1;
public function TextFieldUtf8() {
super();
if(Boolean(Capabilities.os.search("Linux") != -1 && int((Capabilities.version.split(" ")[1] as String).split(",")[0]) < 10) && Capabilities.playerType != "StandAlone") {
addEventListener(TextEvent.TEXT_INPUT,this.textInputHandler,false,1);
addEventListener(KeyboardEvent.KEY_DOWN,this.keyDownHandler,false,1);
}
}
private function utf8Decode(param1:int) : int {
if(this.bits_left == 0) {
if((param1 & 0x80) == 0) {
return param1 & 0x7F;
}
if((param1 & 0xE0) == 192) {
this.character = (param1 & 0x1F) << 6;
this.bits_left = 6;
} else if((param1 & 0xF0) == 224) {
this.character = (param1 & 0x0F) << 12;
this.bits_left = 12;
} else if((param1 & 0xF8) == 240) {
this.character = (param1 & 7) << 18;
this.bits_left = 18;
} else if((param1 & 0xFC) == 248) {
this.character = (param1 & 3) << 24;
this.bits_left = 24;
} else {
if((param1 & 0xFE) != 252) {
return INVALID;
}
this.character = (param1 & 1) << 30;
this.bits_left = 30;
}
return NOTHING;
}
if((param1 & 0xC0) != 128) {
return INVALID;
}
this.bits_left -= 6;
this.character |= (param1 & 0x3F) << this.bits_left;
if(this.bits_left == 0) {
return this.character;
}
if(this.bits_left > 30) {
this.bits_left = 0;
return INVALID;
}
return NOTHING;
}
private function keyDownHandler(param1:KeyboardEvent) : void {
this.utf32_char = this.utf8Decode(param1.charCode);
}
private function textInputHandler(param1:TextEvent) : void {
var local2:String = null;
var local3:String = null;
var local4:int = 0;
if(this.utf32_char == 10 && !this.multiline) {
param1.preventDefault();
param1.stopImmediatePropagation();
return;
}
if(param1.text.length == 1) {
if(this.utf32_char != NOTHING && this.utf32_char != INVALID) {
if(this.selectionBeginIndex == this.selectionEndIndex) {
local2 = this.text.substr(0,this.caretIndex);
local3 = this.text.substr(this.caretIndex);
local4 = this.caretIndex + 1;
} else {
local2 = this.text.substr(0,this.selectionBeginIndex);
local3 = this.text.substr(this.selectionEndIndex);
local4 = this.selectionBeginIndex + 1;
}
param1.text = this.text = local2 + String.fromCharCode(this.utf32_char) + local3;
this.setSelection(local4,local4);
this.dispatchEvent(new Event(Event.CHANGE));
} else {
param1.stopImmediatePropagation();
}
param1.preventDefault();
}
}
}
}
|
package alternativa.tanks.view.battlelist.forms {
import alternativa.tanks.view.battlelist.battleitem.renderer.full.CellRendererFullUp;
import alternativa.tanks.view.battlelist.battleitem.renderer.full.CellRendererFullUpSelected;
import alternativa.tanks.view.battlelist.battleitem.renderer.normal.CellNormalSelected;
import alternativa.tanks.view.battlelist.battleitem.renderer.unavailable.CellUnavailableSelected;
import controls.cellrenderer.CellNormal;
import controls.cellrenderer.CellUnavailable;
import fl.controls.listClasses.CellRenderer;
import fl.controls.listClasses.ListData;
import flash.display.DisplayObject;
public class BattleListRenderer extends CellRenderer {
private var access:Boolean = true;
private var nicon:DisplayObject;
private var sicon:DisplayObject;
private var isFull:Boolean;
public function BattleListRenderer() {
super();
}
override public function set data(param1:Object) : void {
_data = param1;
this.access = param1.accessible;
this.nicon = param1.iconNormal;
this.sicon = param1.iconSelected;
this.isFull = param1.isFull;
this.setupBackgroundStyles();
}
override public function set listData(param1:ListData) : void {
_listData = param1;
label = _listData.label;
if(this.nicon != null && this.sicon != null) {
setStyle("icon",this.nicon);
setStyle("selectedUpIcon",this.sicon);
setStyle("selectedOverIcon",this.sicon);
setStyle("selectedDownIcon",this.sicon);
}
}
override protected function drawBackground() : void {
var local1:String = enabled ? mouseState : "disabled";
if(selected) {
local1 = "selected" + local1.substr(0,1).toUpperCase() + local1.substr(1);
}
local1 += "Skin";
var local2:DisplayObject = background;
background = getDisplayObjectInstance(getStyleValue(local1));
addChildAt(background,0);
if(local2 != null && local2 != background) {
removeChild(local2);
}
}
override protected function drawLayout() : void {
super.drawLayout();
background.width = width - 4;
background.height = height;
}
override protected function drawIcon() : void {
var local1:DisplayObject = icon;
var local2:String = enabled ? mouseState : "disabled";
if(selected) {
local2 = "selected" + local2.substr(0,1).toUpperCase() + local2.substr(1);
}
local2 += "Icon";
var local3:Object = getStyleValue(local2);
if(local3 == null) {
local3 = getStyleValue("icon");
}
if(local3 != null) {
icon = getDisplayObjectInstance(local3);
}
if(icon != null) {
addChildAt(icon,1);
}
if(local1 != null && local1 != icon && local1.parent == this) {
removeChild(local1);
}
}
private function setupBackgroundStyles() : void {
if(this.access) {
if(this.isFull) {
setStyle("upSkin",CellRendererFullUp);
setStyle("overSkin",CellRendererFullUp);
setStyle("downSkin",CellRendererFullUp);
setStyle("selectedUpSkin",CellRendererFullUpSelected);
setStyle("selectedOverSkin",CellRendererFullUpSelected);
setStyle("selectedDownSkin",CellRendererFullUpSelected);
} else {
setStyle("upSkin",CellNormal);
setStyle("overSkin",CellNormal);
setStyle("downSkin",CellNormal);
setStyle("selectedUpSkin",CellNormalSelected);
setStyle("selectedOverSkin",CellNormalSelected);
setStyle("selectedDownSkin",CellNormalSelected);
}
} else {
setStyle("upSkin",CellUnavailable);
setStyle("overSkin",CellUnavailable);
setStyle("downSkin",CellUnavailable);
setStyle("selectedUpSkin",CellUnavailableSelected);
setStyle("selectedOverSkin",CellUnavailableSelected);
setStyle("selectedDownSkin",CellUnavailableSelected);
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.inventory.cooldown {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import projects.tanks.client.battlefield.models.inventory.cooldown.DependedCooldownItem;
public class CodecDependedCooldownItem implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_duration:ICodec;
private var codec_id:ICodec;
public function CodecDependedCooldownItem() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_duration = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_id = param1.getCodec(new TypeCodecInfo(Long,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:DependedCooldownItem = new DependedCooldownItem();
local2.duration = this.codec_duration.decode(param1) as int;
local2.id = this.codec_id.decode(param1) as Long;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:DependedCooldownItem = DependedCooldownItem(param2);
this.codec_duration.encode(param1,local3.duration);
this.codec_id.encode(param1,local3.id);
}
}
}
|
package scpacker.test.spectator
{
import alternativa.console.ConsoleVarFloat;
import alternativa.math.Vector3;
import alternativa.tanks.camera.GameCamera;
public class FlightMovement implements MovementMethod
{
private static const direction:Vector3 = new Vector3();
private static const localDirection:Vector3 = new Vector3();
private var conSpeed:ConsoleVarFloat;
private var conAcceleration:ConsoleVarFloat;
public function FlightMovement(param1:ConsoleVarFloat, param2:ConsoleVarFloat)
{
super();
this.conSpeed = param1;
this.conAcceleration = param2;
}
public function getDisplacement(param1:UserInput, param2:GameCamera, param3:Number) : Vector3
{
localDirection.x = param1.getSideDirection();
localDirection.y = -param1.getVerticalDirection();
localDirection.z = param1.getForwardDirection();
param2.getGlobalVector(localDirection,direction);
if(direction.lengthSqr() > 0)
{
direction.vNormalize();
}
if(param1.isAcceleratied())
{
direction.scale(this.conSpeed.value * this.conAcceleration.value * param3);
}
else
{
direction.scale(this.conSpeed.value * param3);
}
return direction;
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p12 extends BitmapAsset
{
public function RangsIcon_p12()
{
super();
}
}
}
|
package projects.tanks.client.entrance.model.entrance.timezone {
public interface ITimeZoneOffsetModelBase {
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_ultimateBgdClass.png")]
public class HudInventoryIcon_ultimateBgdClass extends BitmapAsset {
public function HudInventoryIcon_ultimateBgdClass() {
super();
}
}
}
|
package projects.tanks.clients.flash.commons.models.layout {
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.commons.models.layout.ILobbyLayoutModelBase;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.client.commons.models.layout.LobbyLayoutModelBase;
import projects.tanks.clients.flash.commons.services.layout.LobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.address.TanksAddressService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
[ModelInfo]
public class LobbyLayoutModel extends LobbyLayoutModelBase implements ILobbyLayoutModelBase, ILobbyLayout, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var tanksAddressService:TanksAddressService;
[Inject]
public static var battleInfoSerivce:IBattleInfoService;
public static const USE_BATTLE_LIST_KEY:String = "USE_BATTLE_LIST";
public function LobbyLayoutModel() {
super();
}
public function showGarage() : void {
server.showGarage();
}
public function showBattleSelect() : void {
storageService.getStorage().data[USE_BATTLE_LIST_KEY] = true;
server.showBattleSelect();
}
public function showMatchmaking() : void {
storageService.getStorage().data[USE_BATTLE_LIST_KEY] = false;
server.showMatchmaking();
battleInfoSerivce.forceResetCurrentSelectionBattleId();
tanksAddressService.resetBattle();
}
public function showBattleLobby() : void {
server.exitFromBattleToBattleLobby();
}
public function showClan() : void {
server.showClan();
}
public function exitFromBattle() : void {
server.exitFromBattleToBattleLobby();
if(!storageService.getStorage().data[USE_BATTLE_LIST_KEY]) {
battleInfoSerivce.resetCurrentSelectionBattleId();
}
}
public function exitFromBattleToState(param1:LayoutState) : void {
server.exitFromBattle(param1);
if(param1 != LayoutState.BATTLE_SELECT) {
battleInfoSerivce.resetCurrentSelectionBattleId();
}
}
public function returnToBattle() : void {
server.returnToBattle();
}
public function objectLoaded() : void {
this.setDefaultRightLayout();
var local1:LobbyLayoutService = LobbyLayoutService(lobbyLayoutService);
if(local1.getServiceGameObject() == null) {
local1.setServiceGameObject(object);
return;
}
throw new Error("Service gameObject already has been loaded");
}
private function setDefaultRightLayout() : void {
var local1:Object = storageService.getStorage().data[USE_BATTLE_LIST_KEY];
var local2:Boolean = local1 != null && Boolean(local1) || Boolean(tanksAddressService.hasBattle());
storageService.getStorage().data[USE_BATTLE_LIST_KEY] = local2;
server.setBattleLobbyLayout(local2);
}
public function objectUnloaded() : void {
var local1:LobbyLayoutService = LobbyLayoutService(lobbyLayoutService);
local1.setServiceGameObject(null);
}
}
}
|
package alternativa.tanks.models.weapon.healing
{
import com.reygazu.anticheat.variables.SecureInt;
import com.reygazu.anticheat.variables.SecureNumber;
public class HealingGunData
{
public var capacity:SecureInt;
public var chargeRate:SecureInt;
public var dischargeRate:SecureInt;
public var tickPeriod:SecureInt;
public var lockAngle:SecureNumber;
public var lockAngleCos:SecureNumber;
public var maxAngle:SecureNumber;
public var maxAngleCos:SecureNumber;
public var maxRadius:SecureNumber;
public function HealingGunData()
{
this.capacity = new SecureInt("capacity isida",0);
this.chargeRate = new SecureInt("chargeRate isida",0);
this.dischargeRate = new SecureInt("dischargeRate isida",0);
this.tickPeriod = new SecureInt("capacity isida",0);
this.lockAngle = new SecureNumber("lockAngle isida",0);
this.lockAngleCos = new SecureNumber("lockAngleCos isida",0);
this.maxAngle = new SecureNumber("maxAngle isida",0);
this.maxAngleCos = new SecureNumber("maxAngleCos isida",0);
this.maxRadius = new SecureNumber("maxRadius isida",0);
super();
}
}
}
|
package _codec {
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 alternativa.types.Short;
public class VectorCodecshortLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecshortLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(Short,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<int> = new Vector.<int>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = int(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:int = 0;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<int> = Vector.<int>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.weapons.stream {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class StreamWeaponCommunicationEvents implements StreamWeaponCommunication {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function StreamWeaponCommunicationEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function fireStarted(param1:int) : void {
var i:int = 0;
var m:StreamWeaponCommunication = null;
var clientTime:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = StreamWeaponCommunication(this.impl[i]);
m.fireStarted(clientTime);
i++;
}
}
finally {
Model.popObject();
}
}
public function fireStopped(param1:int) : void {
var i:int = 0;
var m:StreamWeaponCommunication = null;
var clientTime:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = StreamWeaponCommunication(this.impl[i]);
m.fireStopped(clientTime);
i++;
}
}
finally {
Model.popObject();
}
}
public function targetUpdate(param1:int, param2:Vector3, param3:Tank) : void {
var i:int = 0;
var m:StreamWeaponCommunication = null;
var clientTime:int = param1;
var direction:Vector3 = param2;
var target:Tank = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = StreamWeaponCommunication(this.impl[i]);
m.targetUpdate(clientTime,direction,target);
i++;
}
}
finally {
Model.popObject();
}
}
public function targetsUpdateDummy(param1:int, param2:Vector3) : void {
var i:int = 0;
var m:StreamWeaponCommunication = null;
var clientTime:int = param1;
var direction:Vector3 = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = StreamWeaponCommunication(this.impl[i]);
m.targetsUpdateDummy(clientTime,direction);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.quest {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.panel.model.quest.QuestTypeEnum;
public class CodecQuestTypeEnum implements ICodec {
public function CodecQuestTypeEnum() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:QuestTypeEnum = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = QuestTypeEnum.MAIN;
break;
case 1:
local2 = QuestTypeEnum.DAILY;
break;
case 2:
local2 = QuestTypeEnum.WEEKLY;
break;
case 3:
local2 = QuestTypeEnum.CHALLENGE;
}
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 _codec.projects.tanks.client.battlefield.models.tankparts.weapon.freeze {
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.weapon.freeze.FreezeCC;
public class VectorCodecFreezeCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecFreezeCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(FreezeCC,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.<FreezeCC> = new Vector.<FreezeCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = FreezeCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:FreezeCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<FreezeCC> = Vector.<FreezeCC>(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 controls {
import assets.button.button_OFF_CENTER;
import assets.button.button_OFF_LEFT;
import assets.button.button_OFF_RIGHT;
import assets.button.button_blue_DOWN_CENTER;
import assets.button.button_blue_DOWN_LEFT;
import assets.button.button_blue_DOWN_RIGHT;
import assets.button.button_blue_OVER_CENTER;
import assets.button.button_blue_OVER_LEFT;
import assets.button.button_blue_OVER_RIGHT;
import assets.button.button_blue_UP_CENTER;
import assets.button.button_blue_UP_LEFT;
import assets.button.button_blue_UP_RIGHT;
import assets.button.button_def_DOWN_CENTER;
import assets.button.button_def_DOWN_LEFT;
import assets.button.button_def_DOWN_RIGHT;
import assets.button.button_def_OVER_CENTER;
import assets.button.button_def_OVER_LEFT;
import assets.button.button_def_OVER_RIGHT;
import assets.button.button_def_UP_CENTER;
import assets.button.button_def_UP_LEFT;
import assets.button.button_def_UP_RIGHT;
import assets.button.button_red_DOWN_CENTER;
import assets.button.button_red_DOWN_LEFT;
import assets.button.button_red_DOWN_RIGHT;
import assets.button.button_red_OVER_CENTER;
import assets.button.button_red_OVER_LEFT;
import assets.button.button_red_OVER_RIGHT;
import assets.button.button_red_UP_CENTER;
import assets.button.button_red_UP_LEFT;
import assets.button.button_red_UP_RIGHT;
import base.DiscreteMovieClip;
import flash.display.BitmapData;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.DropShadowFilter;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.text.TextFormatAlign;
import fonts.TanksFontService;
public class ColorButton extends DiscreteMovieClip {
public static const DEFAULT:String = "def";
public static const RED:String = "red";
public static const BLUE:String = "blue";
public var stateUP:ButtonState = new ButtonState();
public var stateOVER:ButtonState = new ButtonState();
public var stateDOWN:ButtonState = new ButtonState();
public var stateOFF:ButtonState = new ButtonState();
protected var _label:Label = new Label();
protected var _hint:Hint;
public var labelColor:uint = 16777215;
private var format:TextFormat = TanksFontService.getTextFormat(12);
private var _enable:Boolean = true;
protected var _width:int;
public function ColorButton() {
super();
this.configUI();
this.enable = true;
tabEnabled = false;
}
public function get label() : String {
return this._label.text;
}
public function set label(param1:String) : void {
this._label.text = param1;
}
public function set hint(param1:String) : void {
if(this._hint != null) {
this._hint.text = param1;
return;
}
this._hint = new Hint();
this._hint.text = param1;
addChild(this._hint);
this._hint.visible = false;
this._hint.y = -this._hint.height;
addEventListener(MouseEvent.MOUSE_OVER,this.showHint);
addEventListener(MouseEvent.MOUSE_OUT,this.hideHint);
}
private function showHint(param1:Event) : void {
this._hint.visible = true;
}
private function hideHint(param1:Event) : void {
this._hint.visible = false;
}
public function set enable(param1:Boolean) : void {
this._enable = param1;
if(this._enable) {
this.addListeners();
} else {
this.removeListeners();
}
}
public function get enable() : Boolean {
return this._enable;
}
override public function set width(param1:Number) : void {
this._width = int(param1);
this.stateDOWN.width = this.stateOFF.width = this.stateOVER.width = this.stateUP.width = this._width;
this._label.width = this._width - 4;
}
public function configUI() : void {
addChild(this.stateOFF);
addChild(this.stateDOWN);
addChild(this.stateOVER);
addChild(this.stateUP);
addChild(this._label);
this.format.align = "center";
this.format.color = this.labelColor;
this._label.embedFonts = TanksFontService.isEmbedFonts();
this._label.align = TextFormatAlign.CENTER;
this._label.autoSize = TextFieldAutoSize.NONE;
this._label.selectable = false;
this._label.x = 2;
this._label.y = 6;
this._label.width = 92;
this._label.height = 22;
this._label.mouseEnabled = false;
this._label.filters = [new DropShadowFilter(1,45,0,0.7,1,1,1)];
}
protected function addListeners() : void {
this.setState(1);
buttonMode = true;
mouseEnabled = true;
mouseChildren = true;
addEventListener(MouseEvent.MOUSE_OVER,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_OUT,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_UP,this.onMouseEvent);
}
protected function removeListeners() : void {
this.setState(0);
buttonMode = false;
mouseEnabled = false;
mouseChildren = false;
removeEventListener(MouseEvent.MOUSE_OVER,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_OUT,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_UP,this.onMouseEvent);
}
protected function onMouseEvent(param1:MouseEvent) : void {
if(this._enable) {
switch(param1.type) {
case MouseEvent.MOUSE_OVER:
this.setState(2);
this._label.y = 6;
break;
case MouseEvent.MOUSE_OUT:
this.setState(1);
this._label.y = 6;
break;
case MouseEvent.MOUSE_DOWN:
this.setState(3);
this._label.y = 7;
break;
case MouseEvent.MOUSE_UP:
this.setState(1);
this._label.y = 6;
}
}
}
protected function setState(param1:int = 0) : void {
switch(param1) {
case 0:
this.stateOFF.alpha = 1;
this.stateUP.alpha = 0;
this.stateOVER.alpha = 0;
this.stateDOWN.alpha = 0;
break;
case 1:
this.stateOFF.alpha = 0;
this.stateUP.alpha = 1;
this.stateOVER.alpha = 0;
this.stateDOWN.alpha = 0;
break;
case 2:
this.stateOFF.alpha = 0;
this.stateUP.alpha = 0;
this.stateOVER.alpha = 1;
this.stateDOWN.alpha = 0;
break;
case 3:
this.stateOFF.alpha = 0;
this.stateUP.alpha = 0;
this.stateOVER.alpha = 0;
this.stateDOWN.alpha = 1;
}
}
public function setStyle(param1:String = "def") : void {
var local3:String = null;
var local2:* = "button_" + param1 + "_";
local3 = "UP";
this.stateUP.bmpLeft = this.getBitmapByName(local2 + local3 + "_LEFT");
this.stateUP.bmpCenter = this.getBitmapByName(local2 + local3 + "_CENTER");
this.stateUP.bmpRight = this.getBitmapByName(local2 + local3 + "_RIGHT");
local3 = "OVER";
this.stateOVER.bmpLeft = this.getBitmapByName(local2 + local3 + "_LEFT");
this.stateOVER.bmpCenter = this.getBitmapByName(local2 + local3 + "_CENTER");
this.stateOVER.bmpRight = this.getBitmapByName(local2 + local3 + "_RIGHT");
local3 = "DOWN";
this.stateDOWN.bmpLeft = this.getBitmapByName(local2 + local3 + "_LEFT");
this.stateDOWN.bmpCenter = this.getBitmapByName(local2 + local3 + "_CENTER");
this.stateDOWN.bmpRight = this.getBitmapByName(local2 + local3 + "_RIGHT");
local3 = "OFF";
local2 = "button_";
this.stateOFF.bmpLeft = this.getBitmapByName(local2 + local3 + "_LEFT");
this.stateOFF.bmpCenter = this.getBitmapByName(local2 + local3 + "_CENTER");
this.stateOFF.bmpRight = this.getBitmapByName(local2 + local3 + "_RIGHT");
this.width = 96;
}
private function getBitmapByName(param1:String) : BitmapData {
var local2:BitmapData = new BitmapData(1,1);
switch(param1) {
case "button_def_UP_LEFT":
local2 = new button_def_UP_LEFT(1,1);
break;
case "button_def_UP_CENTER":
local2 = new button_def_UP_CENTER(1,1);
break;
case "button_def_UP_RIGHT":
local2 = new button_def_UP_RIGHT(1,1);
break;
case "button_def_OVER_LEFT":
local2 = new button_def_OVER_LEFT(1,1);
break;
case "button_def_OVER_CENTER":
local2 = new button_def_OVER_CENTER(1,1);
break;
case "button_def_OVER_RIGHT":
local2 = new button_def_OVER_RIGHT(1,1);
break;
case "button_def_DOWN_LEFT":
local2 = new button_def_DOWN_LEFT(1,1);
break;
case "button_def_DOWN_CENTER":
local2 = new button_def_DOWN_CENTER(1,1);
break;
case "button_def_DOWN_RIGHT":
local2 = new button_def_DOWN_RIGHT(1,1);
break;
case "button_red_UP_LEFT":
local2 = new button_red_UP_LEFT(1,1);
break;
case "button_red_UP_CENTER":
local2 = new button_red_UP_CENTER(1,1);
break;
case "button_red_UP_RIGHT":
local2 = new button_red_UP_RIGHT(1,1);
break;
case "button_red_OVER_LEFT":
local2 = new button_red_OVER_LEFT(1,1);
break;
case "button_red_OVER_CENTER":
local2 = new button_red_OVER_CENTER(1,1);
break;
case "button_red_OVER_RIGHT":
local2 = new button_red_OVER_RIGHT(1,1);
break;
case "button_red_DOWN_LEFT":
local2 = new button_red_DOWN_LEFT(1,1);
break;
case "button_red_DOWN_CENTER":
local2 = new button_red_DOWN_CENTER(1,1);
break;
case "button_red_DOWN_RIGHT":
local2 = new button_red_DOWN_RIGHT(1,1);
break;
case "button_blue_UP_LEFT":
local2 = new button_blue_UP_LEFT(1,1);
break;
case "button_blue_UP_CENTER":
local2 = new button_blue_UP_CENTER(1,1);
break;
case "button_blue_UP_RIGHT":
local2 = new button_blue_UP_RIGHT(1,1);
break;
case "button_blue_OVER_LEFT":
local2 = new button_blue_OVER_LEFT(1,1);
break;
case "button_blue_OVER_CENTER":
local2 = new button_blue_OVER_CENTER(1,1);
break;
case "button_blue_OVER_RIGHT":
local2 = new button_blue_OVER_RIGHT(1,1);
break;
case "button_blue_DOWN_LEFT":
local2 = new button_blue_DOWN_LEFT(1,1);
break;
case "button_blue_DOWN_CENTER":
local2 = new button_blue_DOWN_CENTER(1,1);
break;
case "button_blue_DOWN_RIGHT":
local2 = new button_blue_DOWN_RIGHT(1,1);
break;
case "button_OFF_LEFT":
local2 = new button_OFF_LEFT(1,1);
break;
case "button_OFF_CENTER":
local2 = new button_OFF_CENTER(1,1);
break;
case "button_OFF_RIGHT":
local2 = new button_OFF_RIGHT(1,1);
}
return local2;
}
}
}
|
package scpacker.gui.en
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksIEN_coldload5 extends BitmapAsset
{
public function GTanksIEN_coldload5()
{
super();
}
}
}
|
package alternativa.tanks.model.battle {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class BattleEntranceAdapt implements BattleEntrance {
private var object:IGameObject;
private var impl:BattleEntrance;
public function BattleEntranceAdapt(param1:IGameObject, param2:BattleEntrance) {
super();
this.object = param1;
this.impl = param2;
}
public function fight(param1:BattleTeam = null) : void {
var team:BattleTeam = param1;
try {
Model.object = this.object;
this.impl.fight(team);
}
finally {
Model.popObject();
}
}
public function enterAsSpectator() : void {
try {
Model.object = this.object;
this.impl.enterAsSpectator();
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.battlefield.models.teamlight {
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 TeamLightModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:TeamLightModelServer;
private var client:ITeamLightModelBase = ITeamLightModelBase(this);
private var modelId:Long = Long.getLong(40022888,448727509);
public function TeamLightModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new TeamLightModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(TeamLightCC,false)));
}
protected function getInitParam() : TeamLightCC {
return TeamLightCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.gui.shop.forms {
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.model.payment.modes.asyncurl.AsyncUrlPayMode;
import platform.client.fp10.core.type.IGameObject;
public class GoToUrlForm extends PayModeForm {
public function GoToUrlForm(param1:IGameObject) {
super(param1);
}
override public function activate() : void {
AsyncUrlPayMode(payMode.adapt(AsyncUrlPayMode)).requestAsyncUrl();
logProceedAction();
}
override public function shouldBeOmitted() : Boolean {
return true;
}
}
}
|
package platform.client.core.general.socialnetwork.osgi {
import _codec.map.String__String;
import _codec.platform.client.core.general.socialnetwork.models.socialnetworkparameters.CodecSocialNetworkParametersCC;
import _codec.platform.client.core.general.socialnetwork.models.socialnetworkparameters.VectorCodecSocialNetworkParametersCCLevel1;
import _codec.platform.client.core.general.socialnetwork.types.CodecGender;
import _codec.platform.client.core.general.socialnetwork.types.CodecLoginParameters;
import _codec.platform.client.core.general.socialnetwork.types.VectorCodecGenderLevel1;
import _codec.platform.client.core.general.socialnetwork.types.VectorCodecLoginParametersLevel1;
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.MapCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.core.general.socialnetwork.models.socialnetworkparameters.SocialNetworkParametersCC;
import platform.client.core.general.socialnetwork.types.Gender;
import platform.client.core.general.socialnetwork.types.LoginParameters;
public class Activator implements IBundleActivator {
public static var osgi:OSGi;
public function Activator() {
super();
}
public function start(param1:OSGi) : void {
var local3:ICodec = null;
osgi = param1;
var local2:IProtocol = IProtocol(osgi.getService(IProtocol));
local3 = new CodecSocialNetworkParametersCC();
local2.registerCodec(new TypeCodecInfo(SocialNetworkParametersCC,false),local3);
local2.registerCodec(new TypeCodecInfo(SocialNetworkParametersCC,true),new OptionalCodecDecorator(local3));
local3 = new CodecGender();
local2.registerCodec(new EnumCodecInfo(Gender,false),local3);
local2.registerCodec(new EnumCodecInfo(Gender,true),new OptionalCodecDecorator(local3));
local3 = new CodecLoginParameters();
local2.registerCodec(new TypeCodecInfo(LoginParameters,false),local3);
local2.registerCodec(new TypeCodecInfo(LoginParameters,true),new OptionalCodecDecorator(local3));
local3 = new String__String(false,false);
local2.registerCodec(new MapCodecInfo(new TypeCodecInfo(String,false),new TypeCodecInfo(String,false),false),local3);
local2.registerCodec(new MapCodecInfo(new TypeCodecInfo(String,false),new TypeCodecInfo(String,false),true),new OptionalCodecDecorator(local3));
local3 = new VectorCodecSocialNetworkParametersCCLevel1(false);
local2.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(SocialNetworkParametersCC,false),false,1),local3);
local2.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(SocialNetworkParametersCC,false),true,1),new OptionalCodecDecorator(local3));
local3 = new VectorCodecSocialNetworkParametersCCLevel1(true);
local2.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(SocialNetworkParametersCC,true),false,1),local3);
local2.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(SocialNetworkParametersCC,true),true,1),new OptionalCodecDecorator(local3));
local3 = new VectorCodecGenderLevel1(false);
local2.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(Gender,false),false,1),local3);
local2.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(Gender,false),true,1),new OptionalCodecDecorator(local3));
local3 = new VectorCodecGenderLevel1(true);
local2.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(Gender,true),false,1),local3);
local2.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(Gender,true),true,1),new OptionalCodecDecorator(local3));
local3 = new VectorCodecLoginParametersLevel1(false);
local2.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(LoginParameters,false),false,1),local3);
local2.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(LoginParameters,false),true,1),new OptionalCodecDecorator(local3));
local3 = new VectorCodecLoginParametersLevel1(true);
local2.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(LoginParameters,true),false,1),local3);
local2.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(LoginParameters,true),true,1),new OptionalCodecDecorator(local3));
}
public function stop(param1:OSGi) : void {
}
}
}
|
package controls.base {
public class MainPanelClanButtonBase extends MainPanelButtonBase {
private var iconClass:Class = MainPanelClanButtonBase_iconClass;
public function MainPanelClanButtonBase() {
super(this.iconClass);
}
}
}
|
package alternativa.engine3d.loaders.collada {
use namespace collada;
public class DaeSource extends DaeElement {
private const FLOAT_ARRAY:String = "float_array";
private const INT_ARRAY:String = "int_array";
private const NAME_ARRAY:String = "Name_array";
public var numbers:Vector.<Number>;
public var ints:Vector.<int>;
public var names:Vector.<String>;
public var stride:int;
public function DaeSource(param1:XML, param2:DaeDocument) {
super(param1,param2);
this.constructArrays();
}
private function constructArrays() : void {
var local4:XML = null;
var local5:DaeArray = null;
var local1:XMLList = data.children();
var local2:int = 0;
var local3:int = int(local1.length());
while(local2 < local3) {
local4 = local1[local2];
switch(local4.localName()) {
case this.FLOAT_ARRAY:
case this.INT_ARRAY:
case this.NAME_ARRAY:
local5 = new DaeArray(local4,document);
if(local5.id != null) {
document.arrays[local5.id] = local5;
}
break;
}
local2++;
}
}
private function get accessor() : XML {
return data.technique_common.accessor[0];
}
override protected function parseImplementation() : Boolean {
var local2:XML = null;
var local3:DaeArray = null;
var local4:String = null;
var local5:int = 0;
var local6:XML = null;
var local7:XML = null;
var local8:int = 0;
var local9:int = 0;
var local1:XML = this.accessor;
if(local1 != null) {
local2 = local1.@source[0];
local3 = local2 == null ? null : document.findArray(local2);
if(local3 != null) {
local4 = local1.@count[0];
if(local4 != null) {
local5 = parseInt(local4.toString(),10);
local6 = local1.@offset[0];
local7 = local1.@stride[0];
local8 = local6 == null ? 0 : int(parseInt(local6.toString(),10));
local9 = local7 == null ? 1 : int(parseInt(local7.toString(),10));
local3.parse();
if(local3.array.length < local8 + local5 * local9) {
document.logger.logNotEnoughDataError(local1);
return false;
}
this.stride = this.parseArray(local8,local5,local9,local3.array,local3.type);
return true;
}
} else {
document.logger.logNotFoundError(local2);
}
}
return false;
}
private function numValidParams(param1:XMLList) : int {
var local2:int = 0;
var local3:int = 0;
var local4:int = int(param1.length());
while(local3 < local4) {
if(param1[local3].@name[0] != null) {
local2++;
}
local3++;
}
return local2;
}
private function parseArray(param1:int, param2:int, param3:int, param4:Array, param5:String) : int {
var local10:XML = null;
var local11:int = 0;
var local12:String = null;
var local6:XMLList = this.accessor.param;
var local7:int = Math.max(this.numValidParams(local6),param3);
switch(param5) {
case this.FLOAT_ARRAY:
this.numbers = new Vector.<Number>(int(local7 * param2));
break;
case this.INT_ARRAY:
this.ints = new Vector.<int>(int(local7 * param2));
break;
case this.NAME_ARRAY:
this.names = new Vector.<String>(int(local7 * param2));
}
var local8:int = 0;
var local9:int = 0;
while(local9 < local7) {
local10 = local6[local9];
if(local10 == null || Boolean(local10.hasOwnProperty("@name"))) {
switch(param5) {
case this.FLOAT_ARRAY:
local11 = 0;
while(local11 < param2) {
local12 = param4[int(param1 + param3 * local11 + local9)];
if(local12.indexOf(",") != -1) {
local12 = local12.replace(/,/,".");
}
this.numbers[int(local7 * local11 + local8)] = parseFloat(local12);
local11++;
}
break;
case this.INT_ARRAY:
local11 = 0;
while(local11 < param2) {
this.ints[int(local7 * local11 + local8)] = parseInt(param4[int(param1 + param3 * local11 + local9)],10);
local11++;
}
break;
case this.NAME_ARRAY:
local11 = 0;
while(local11 < param2) {
this.names[int(local7 * local11 + local8)] = param4[int(param1 + param3 * local11 + local9)];
local11++;
}
}
local8++;
}
local9++;
}
return local7;
}
}
}
|
package alternativa.tanks.gui.tables {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.model.item.kit.GarageKit;
import alternativa.tanks.service.item.ItemService;
import assets.Diamond;
import controls.Money;
import controls.base.LabelBase;
import flash.display.BitmapData;
import flash.display.Shape;
import flash.display.Sprite;
import flash.geom.Matrix;
import flash.text.TextFormatAlign;
import forms.ColorConstants;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.types.ItemCategoryEnum;
import projects.tanks.client.garage.models.item.kit.KitItem;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class KitInfoTable extends Sprite {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var itemService:ItemService;
private static const upgradeSelectionLeftClass:Class = KitInfoTable_upgradeSelectionLeftClass;
private static const upgradeSelectionCenterClass:Class = KitInfoTable_upgradeSelectionCenterClass;
private const LEFT_TOP_MARGIN:int = 12;
private const SUMMARY_TOP_MARGIN:int = 13;
private const CRYSTAL_TOP_MARGIN:int = 4;
private const ITEM_HEIGHT:int = 17;
private var selection:Shape = new Shape();
private var _width:int;
private var topPartHeight:int;
private var bottomPartHeight:int;
private var kitObject:IGameObject;
private var kit:GarageKit;
public function KitInfoTable(param1:int) {
super();
this._width = param1;
this.topPartHeight = 0;
}
public function show(param1:IGameObject) : void {
this.kitObject = param1;
this.kit = GarageKit(param1.adapt(GarageKit));
var local2:int = int(this.kit.getItems().length);
this.topPartHeight = this.LEFT_TOP_MARGIN + (local2 + 1) * this.ITEM_HEIGHT;
this.clearTable();
this.addHeader();
this.addRows();
this.addSum();
this.addSummary();
}
public function clearTable() : void {
while(this.numChildren > 0) {
this.removeChildAt(0);
}
}
private function addHeader() : void {
var local1:LabelBase = new LabelBase();
local1.color = ColorConstants.GREEN_LABEL;
local1.align = TextFormatAlign.LEFT;
local1.text = localeService.getText(TanksLocale.TEXT_ITEMS_IN_KIT);
local1.x = this.LEFT_TOP_MARGIN;
local1.y = this.LEFT_TOP_MARGIN;
addChild(local1);
var local2:LabelBase = new LabelBase();
local2.color = ColorConstants.GREEN_LABEL;
local2.align = TextFormatAlign.RIGHT;
local2.text = localeService.getText(TanksLocale.TEXT_GARAGE_PRICE);
local2.x = this._width - local2.width - local1.x;
local2.y = local1.y;
addChild(local2);
}
private function addRows() : void {
var local2:KitItem = null;
var local3:KitItemInfoRow = null;
this.kit.getItems().sort(this.compareItems);
var local1:int = this.LEFT_TOP_MARGIN + this.ITEM_HEIGHT;
for each(local2 in this.kit.getItems()) {
local3 = new KitItemInfoRow(local1,this._width,local2,this.LEFT_TOP_MARGIN,this.CRYSTAL_TOP_MARGIN);
addChild(local3);
local1 += this.ITEM_HEIGHT;
}
}
private function addSum() : void {
var local1:LabelBase = new LabelBase();
local1.color = ColorConstants.GREEN_LABEL;
local1.align = TextFormatAlign.LEFT;
local1.text = localeService.getText(TanksLocale.TEXT_TOTAL_PRICE_KIT);
local1.x = this.LEFT_TOP_MARGIN;
local1.y = this.topPartHeight + this.ITEM_HEIGHT - 6;
addChild(local1);
var local2:Diamond = new Diamond();
local2.x = this._width - local1.x - local2.width;
addChild(local2);
local2.y = local1.y + this.CRYSTAL_TOP_MARGIN;
var local3:LabelBase = new LabelBase();
local3.color = ColorConstants.GREEN_LABEL;
local3.align = TextFormatAlign.RIGHT;
local3.text = Money.numToString(this.kit.getPriceWithoutDiscount(),false);
local3.x = local2.x - local3.width - 1;
local3.y = local1.y;
addChild(local3);
}
private function addSummary() : void {
addChild(this.selection);
this.selection.y = this.SUMMARY_TOP_MARGIN + this.ITEM_HEIGHT + this.topPartHeight;
this.resizeSelection();
var local1:int = int(itemService.getDiscount(this.kitObject));
var local2:int = int(itemService.getPrice(this.kitObject));
var local3:String = localeService.getText(TanksLocale.TEXT_DISCOUNTED_AT_KIT);
local3 = local3.replace("{0}",local1 + "%");
this.addSummaryRow(local3,local2);
this.bottomPartHeight = 2 * this.ITEM_HEIGHT;
}
private function addSummaryRow(param1:String, param2:int) : void {
var local3:LabelBase = new LabelBase();
local3.align = TextFormatAlign.LEFT;
local3.text = param1;
local3.x = this.LEFT_TOP_MARGIN;
local3.y = this.SUMMARY_TOP_MARGIN + this.ITEM_HEIGHT + this.topPartHeight;
addChild(local3);
var local4:Diamond = new Diamond();
local4.x = this._width - local3.x - local4.width;
addChild(local4);
local4.y = local3.y + this.CRYSTAL_TOP_MARGIN;
var local5:LabelBase = new LabelBase();
local5.align = TextFormatAlign.RIGHT;
local5.text = Money.numToString(param2,false);
local5.x = local4.x - local5.width - 1;
local5.y = local3.y;
addChild(local5);
}
private function resizeSelection() : void {
var local1:int = this._width - 18;
var local2:BitmapData = new upgradeSelectionLeftClass().bitmapData;
this.selection.x = 9;
this.selection.graphics.clear();
this.selection.graphics.beginBitmapFill(local2);
this.selection.graphics.drawRect(0,0,local2.width,local2.height);
var local3:BitmapData = new upgradeSelectionCenterClass().bitmapData;
this.selection.graphics.beginBitmapFill(local3);
this.selection.graphics.drawRect(local2.width,0,local1 - local2.width * 2,local3.height);
var local4:Matrix = new Matrix(-1,0,0,1,local1,0);
this.selection.graphics.beginBitmapFill(local2,local4);
this.selection.graphics.drawRect(local1 - local2.width,0,local2.width,local2.height);
this.selection.graphics.endFill();
}
private function compareItems(param1:KitItem, param2:KitItem) : Number {
var local3:int = this.getTypeIndex(param1);
var local4:int = this.getTypeIndex(param2);
if(local3 > local4) {
return 1;
}
if(local3 < local4) {
return -1;
}
var local5:int = itemService.getPrice(param1.item) * param1.count;
var local6:int = itemService.getPrice(param2.item) * param2.count;
if(local5 < local6) {
return 1;
}
if(local5 > local6) {
return -1;
}
return 0;
}
private function getTypeIndex(param1:KitItem) : int {
switch(itemService.getCategory(param1.item)) {
case ItemCategoryEnum.WEAPON:
return 0;
case ItemCategoryEnum.ARMOR:
return 1;
case ItemCategoryEnum.INVENTORY:
return 3;
case ItemCategoryEnum.PLUGIN:
return 4;
case ItemCategoryEnum.PAINT:
return 5;
default:
return 6;
}
}
public function getTopPartTableHeight() : int {
return this.topPartHeight;
}
public function getFullTableHeight() : int {
return this.SUMMARY_TOP_MARGIN + this.topPartHeight + this.bottomPartHeight;
}
public function getBottomPartTableHeight() : int {
return this.bottomPartHeight;
}
}
}
|
package alternativa.tanks.gui.panel.buttons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.panel.buttons.MainPanelGrayWideButton_buttonNormal.png")]
public class MainPanelGrayWideButton_buttonNormal extends BitmapAsset {
public function MainPanelGrayWideButton_buttonNormal() {
super();
}
}
}
|
package alternativa.tanks.view.mainview.button {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.service.battlelist.MatchmakingEvent;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.events.MouseEvent;
import projects.tanks.client.battleselect.model.matchmaking.queue.MatchmakingMode;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class MatchmakingButton extends MainViewButton {
[Inject]
public static var localeService:ILocaleService;
private var mode:MatchmakingMode;
public function MatchmakingButton(param1:String, param2:String, param3:Bitmap, param4:MatchmakingMode, param5:int) {
var local6:Bitmap = Boolean(param3) ? param3 : new Bitmap(new BitmapData(166,106,true,2298478591));
super(localeService.getText(param1),localeService.getText(param2),local6,param5);
this.mode = param4;
button.setText(localeService.getText(TanksLocale.TEXT_PLAY_BUTTON));
}
override protected function onClick(param1:MouseEvent) : void {
dispatchEvent(new MatchmakingEvent(MatchmakingEvent.REGISTRATION,this.mode));
}
override protected function onSpectatorClick(param1:MouseEvent) : void {
dispatchEvent(new MatchmakingEvent(MatchmakingEvent.ENTER_AS_SPECTATOR,this.mode));
}
}
}
|
package alternativa.engine3d.core {
import alternativa.engine3d.alternativa3d;
use namespace alternativa3d;
public class Light3D extends Object3D {
public var color:uint;
public var intensity:Number = 1;
alternativa3d var localWeight:Number;
alternativa3d var localRed:Number;
alternativa3d var localGreen:Number;
alternativa3d var localBlue:Number;
alternativa3d var cma:Number;
alternativa3d var cmb:Number;
alternativa3d var cmc:Number;
alternativa3d var cmd:Number;
alternativa3d var cme:Number;
alternativa3d var cmf:Number;
alternativa3d var cmg:Number;
alternativa3d var cmh:Number;
alternativa3d var cmi:Number;
alternativa3d var cmj:Number;
alternativa3d var cmk:Number;
alternativa3d var cml:Number;
alternativa3d var oma:Number;
alternativa3d var omb:Number;
alternativa3d var omc:Number;
alternativa3d var omd:Number;
alternativa3d var ome:Number;
alternativa3d var omf:Number;
alternativa3d var omg:Number;
alternativa3d var omh:Number;
alternativa3d var omi:Number;
alternativa3d var omj:Number;
alternativa3d var omk:Number;
alternativa3d var oml:Number;
alternativa3d var nextLight:Light3D;
public function Light3D() {
super();
}
override public function clone() : Object3D {
var local1:Light3D = new Light3D();
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
super.clonePropertiesFrom(param1);
var local2:Light3D = param1 as Light3D;
this.color = local2.color;
this.intensity = local2.intensity;
}
alternativa3d function calculateCameraMatrix(param1:Camera3D) : void {
alternativa3d::composeMatrix();
var local2:Object3D = this;
while(local2.alternativa3d::_parent != null) {
local2 = local2.alternativa3d::_parent;
local2.alternativa3d::composeMatrix();
alternativa3d::appendMatrix(local2);
}
alternativa3d::appendMatrix(param1);
this.alternativa3d::cma = alternativa3d::ma;
this.alternativa3d::cmb = alternativa3d::mb;
this.alternativa3d::cmc = alternativa3d::mc;
this.alternativa3d::cmd = alternativa3d::md;
this.alternativa3d::cme = alternativa3d::me;
this.alternativa3d::cmf = alternativa3d::mf;
this.alternativa3d::cmg = alternativa3d::mg;
this.alternativa3d::cmh = alternativa3d::mh;
this.alternativa3d::cmi = alternativa3d::mi;
this.alternativa3d::cmj = alternativa3d::mj;
this.alternativa3d::cmk = alternativa3d::mk;
this.alternativa3d::cml = alternativa3d::ml;
}
alternativa3d function calculateObjectMatrix(param1:Object3D) : void {
this.alternativa3d::oma = param1.alternativa3d::ima * this.alternativa3d::cma + param1.alternativa3d::imb * this.alternativa3d::cme + param1.alternativa3d::imc * this.alternativa3d::cmi;
this.alternativa3d::omb = param1.alternativa3d::ima * this.alternativa3d::cmb + param1.alternativa3d::imb * this.alternativa3d::cmf + param1.alternativa3d::imc * this.alternativa3d::cmj;
this.alternativa3d::omc = param1.alternativa3d::ima * this.alternativa3d::cmc + param1.alternativa3d::imb * this.alternativa3d::cmg + param1.alternativa3d::imc * this.alternativa3d::cmk;
this.alternativa3d::omd = param1.alternativa3d::ima * this.alternativa3d::cmd + param1.alternativa3d::imb * this.alternativa3d::cmh + param1.alternativa3d::imc * this.alternativa3d::cml + param1.alternativa3d::imd;
this.alternativa3d::ome = param1.alternativa3d::ime * this.alternativa3d::cma + param1.alternativa3d::imf * this.alternativa3d::cme + param1.alternativa3d::img * this.alternativa3d::cmi;
this.alternativa3d::omf = param1.alternativa3d::ime * this.alternativa3d::cmb + param1.alternativa3d::imf * this.alternativa3d::cmf + param1.alternativa3d::img * this.alternativa3d::cmj;
this.alternativa3d::omg = param1.alternativa3d::ime * this.alternativa3d::cmc + param1.alternativa3d::imf * this.alternativa3d::cmg + param1.alternativa3d::img * this.alternativa3d::cmk;
this.alternativa3d::omh = param1.alternativa3d::ime * this.alternativa3d::cmd + param1.alternativa3d::imf * this.alternativa3d::cmh + param1.alternativa3d::img * this.alternativa3d::cml + param1.alternativa3d::imh;
this.alternativa3d::omi = param1.alternativa3d::imi * this.alternativa3d::cma + param1.alternativa3d::imj * this.alternativa3d::cme + param1.alternativa3d::imk * this.alternativa3d::cmi;
this.alternativa3d::omj = param1.alternativa3d::imi * this.alternativa3d::cmb + param1.alternativa3d::imj * this.alternativa3d::cmf + param1.alternativa3d::imk * this.alternativa3d::cmj;
this.alternativa3d::omk = param1.alternativa3d::imi * this.alternativa3d::cmc + param1.alternativa3d::imj * this.alternativa3d::cmg + param1.alternativa3d::imk * this.alternativa3d::cmk;
this.alternativa3d::oml = param1.alternativa3d::imi * this.alternativa3d::cmd + param1.alternativa3d::imj * this.alternativa3d::cmh + param1.alternativa3d::imk * this.alternativa3d::cml + param1.alternativa3d::iml;
}
override alternativa3d function setParent(param1:Object3DContainer) : void {
var local2:Object3DContainer = null;
var local3:Light3D = null;
var local4:Light3D = null;
if(param1 == null) {
local2 = alternativa3d::_parent;
while(local2.alternativa3d::_parent != null) {
local2 = local2.alternativa3d::_parent;
}
local4 = local2.alternativa3d::lightList;
while(local4 != null) {
if(local4 == this) {
if(local3 != null) {
local3.alternativa3d::nextLight = this.alternativa3d::nextLight;
} else {
local2.alternativa3d::lightList = this.alternativa3d::nextLight;
}
this.alternativa3d::nextLight = null;
break;
}
local3 = local4;
local4 = local4.alternativa3d::nextLight;
}
} else {
local2 = param1;
while(local2.alternativa3d::_parent != null) {
local2 = local2.alternativa3d::_parent;
}
this.alternativa3d::nextLight = local2.alternativa3d::lightList;
local2.alternativa3d::lightList = this;
}
alternativa3d::_parent = param1;
}
alternativa3d function drawDebug(param1:Camera3D) : void {
}
override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void {
param1.boundMinX = -1e+22;
param1.boundMinY = -1e+22;
param1.boundMinZ = -1e+22;
param1.boundMaxX = 1e+22;
param1.boundMaxY = 1e+22;
param1.boundMaxZ = 1e+22;
}
override alternativa3d function cullingInCamera(param1:Camera3D, param2:int) : int {
return -1;
}
alternativa3d function checkFrustumCulling(param1:Camera3D) : Boolean {
var local2:Vertex = alternativa3d::boundVertexList;
local2.x = boundMinX;
local2.y = boundMinY;
local2.z = boundMinZ;
local2 = local2.alternativa3d::next;
local2.x = boundMaxX;
local2.y = boundMinY;
local2.z = boundMinZ;
local2 = local2.alternativa3d::next;
local2.x = boundMinX;
local2.y = boundMaxY;
local2.z = boundMinZ;
local2 = local2.alternativa3d::next;
local2.x = boundMaxX;
local2.y = boundMaxY;
local2.z = boundMinZ;
local2 = local2.alternativa3d::next;
local2.x = boundMinX;
local2.y = boundMinY;
local2.z = boundMaxZ;
local2 = local2.alternativa3d::next;
local2.x = boundMaxX;
local2.y = boundMinY;
local2.z = boundMaxZ;
local2 = local2.alternativa3d::next;
local2.x = boundMinX;
local2.y = boundMaxY;
local2.z = boundMaxZ;
local2 = local2.alternativa3d::next;
local2.x = boundMaxX;
local2.y = boundMaxY;
local2.z = boundMaxZ;
local2 = alternativa3d::boundVertexList;
while(local2 != null) {
local2.alternativa3d::cameraX = alternativa3d::ma * local2.x + alternativa3d::mb * local2.y + alternativa3d::mc * local2.z + alternativa3d::md;
local2.alternativa3d::cameraY = alternativa3d::me * local2.x + alternativa3d::mf * local2.y + alternativa3d::mg * local2.z + alternativa3d::mh;
local2.alternativa3d::cameraZ = alternativa3d::mi * local2.x + alternativa3d::mj * local2.y + alternativa3d::mk * local2.z + alternativa3d::ml;
local2 = local2.alternativa3d::next;
}
local2 = alternativa3d::boundVertexList;
while(local2 != null) {
if(local2.alternativa3d::cameraZ > param1.nearClipping) {
break;
}
local2 = local2.alternativa3d::next;
}
if(local2 == null) {
return false;
}
local2 = alternativa3d::boundVertexList;
while(local2 != null) {
if(local2.alternativa3d::cameraZ < param1.farClipping) {
break;
}
local2 = local2.alternativa3d::next;
}
if(local2 == null) {
return false;
}
local2 = alternativa3d::boundVertexList;
while(local2 != null) {
if(-local2.alternativa3d::cameraX < local2.alternativa3d::cameraZ) {
break;
}
local2 = local2.alternativa3d::next;
}
if(local2 == null) {
return false;
}
local2 = alternativa3d::boundVertexList;
while(local2 != null) {
if(local2.alternativa3d::cameraX < local2.alternativa3d::cameraZ) {
break;
}
local2 = local2.alternativa3d::next;
}
if(local2 == null) {
return false;
}
local2 = alternativa3d::boundVertexList;
while(local2 != null) {
if(-local2.alternativa3d::cameraY < local2.alternativa3d::cameraZ) {
break;
}
local2 = local2.alternativa3d::next;
}
if(local2 == null) {
return false;
}
local2 = alternativa3d::boundVertexList;
while(local2 != null) {
if(local2.alternativa3d::cameraY < local2.alternativa3d::cameraZ) {
break;
}
local2 = local2.alternativa3d::next;
}
if(local2 == null) {
return false;
}
return true;
}
alternativa3d function checkBoundsIntersection(param1:Object3D) : Boolean {
var local2:Number = NaN;
var local3:Number = NaN;
var local4:Number = (boundMaxX - boundMinX) * 0.5;
var local5:Number = (boundMaxY - boundMinY) * 0.5;
var local6:Number = (boundMaxZ - boundMinZ) * 0.5;
var local7:Number = this.alternativa3d::oma * local4;
var local8:Number = this.alternativa3d::ome * local4;
var local9:Number = this.alternativa3d::omi * local4;
var local10:Number = this.alternativa3d::omb * local5;
var local11:Number = this.alternativa3d::omf * local5;
var local12:Number = this.alternativa3d::omj * local5;
var local13:Number = this.alternativa3d::omc * local6;
var local14:Number = this.alternativa3d::omg * local6;
var local15:Number = this.alternativa3d::omk * local6;
var local16:Number = (param1.boundMaxX - param1.boundMinX) * 0.5;
var local17:Number = (param1.boundMaxY - param1.boundMinY) * 0.5;
var local18:Number = (param1.boundMaxZ - param1.boundMinZ) * 0.5;
var local19:Number = this.alternativa3d::oma * (boundMinX + local4) + this.alternativa3d::omb * (boundMinY + local5) + this.alternativa3d::omc * (boundMinZ + local6) + this.alternativa3d::omd - param1.boundMinX - local16;
var local20:Number = this.alternativa3d::ome * (boundMinX + local4) + this.alternativa3d::omf * (boundMinY + local5) + this.alternativa3d::omg * (boundMinZ + local6) + this.alternativa3d::omh - param1.boundMinY - local17;
var local21:Number = this.alternativa3d::omi * (boundMinX + local4) + this.alternativa3d::omj * (boundMinY + local5) + this.alternativa3d::omk * (boundMinZ + local6) + this.alternativa3d::oml - param1.boundMinZ - local18;
local2 = 0;
local3 = local7 >= 0 ? local7 : -local7;
local2 += local3;
local3 = local10 >= 0 ? local10 : -local10;
local2 += local3;
local3 = local13 >= 0 ? local13 : -local13;
local2 += local3;
local2 += local16;
local3 = local19 >= 0 ? local19 : -local19;
local2 -= local3;
if(local2 <= 0) {
return false;
}
local2 = 0;
local3 = local8 >= 0 ? local8 : -local8;
local2 += local3;
local3 = local11 >= 0 ? local11 : -local11;
local2 += local3;
local3 = local14 >= 0 ? local14 : -local14;
local2 += local3;
local2 += local17;
local3 = local20 >= 0 ? local20 : -local20;
local2 -= local3;
if(local2 <= 0) {
return false;
}
local2 = 0;
local3 = local9 >= 0 ? local9 : -local9;
local2 += local3;
local3 = local12 >= 0 ? local12 : -local12;
local2 += local3;
local3 = local15 >= 0 ? local15 : -local15;
local2 += local3;
local2 += local17;
local3 = local21 >= 0 ? local21 : -local21;
local2 -= local3;
if(local2 <= 0) {
return false;
}
local2 = 0;
local3 = this.alternativa3d::oma * local7 + this.alternativa3d::ome * local8 + this.alternativa3d::omi * local9;
local3 = local3 >= 0 ? local3 : -local3;
local2 += local3;
local3 = this.alternativa3d::oma * local10 + this.alternativa3d::ome * local11 + this.alternativa3d::omi * local12;
local3 = local3 >= 0 ? local3 : -local3;
local2 += local3;
local3 = this.alternativa3d::oma * local13 + this.alternativa3d::ome * local14 + this.alternativa3d::omi * local15;
local3 = local3 >= 0 ? local3 : -local3;
local2 += local3;
local3 = this.alternativa3d::oma >= 0 ? this.alternativa3d::oma * local16 : -this.alternativa3d::oma * local16;
local2 += local3;
local3 = this.alternativa3d::ome >= 0 ? this.alternativa3d::ome * local17 : -this.alternativa3d::ome * local17;
local2 += local3;
local3 = this.alternativa3d::omi >= 0 ? this.alternativa3d::omi * local18 : -this.alternativa3d::omi * local18;
local2 += local3;
local3 = this.alternativa3d::oma * local19 + this.alternativa3d::ome * local20 + this.alternativa3d::omi * local21;
local3 = local3 >= 0 ? local3 : -local3;
local2 -= local3;
if(local2 <= 0) {
return false;
}
local2 = 0;
local3 = this.alternativa3d::omb * local7 + this.alternativa3d::omf * local8 + this.alternativa3d::omj * local9;
local3 = local3 >= 0 ? local3 : -local3;
local2 += local3;
local3 = this.alternativa3d::omb * local10 + this.alternativa3d::omf * local11 + this.alternativa3d::omj * local12;
local3 = local3 >= 0 ? local3 : -local3;
local2 += local3;
local3 = this.alternativa3d::omb * local13 + this.alternativa3d::omf * local14 + this.alternativa3d::omj * local15;
local3 = local3 >= 0 ? local3 : -local3;
local2 += local3;
local3 = this.alternativa3d::omb >= 0 ? this.alternativa3d::omb * local16 : -this.alternativa3d::omb * local16;
local2 += local3;
local3 = this.alternativa3d::omf >= 0 ? this.alternativa3d::omf * local17 : -this.alternativa3d::omf * local17;
local2 += local3;
local3 = this.alternativa3d::omj >= 0 ? this.alternativa3d::omj * local18 : -this.alternativa3d::omj * local18;
local2 += local3;
local3 = this.alternativa3d::omb * local19 + this.alternativa3d::omf * local20 + this.alternativa3d::omj * local21;
local3 = local3 >= 0 ? local3 : -local3;
local2 -= local3;
if(local2 <= 0) {
return false;
}
local2 = 0;
local3 = this.alternativa3d::omc * local7 + this.alternativa3d::omg * local8 + this.alternativa3d::omk * local9;
local3 = local3 >= 0 ? local3 : -local3;
local2 += local3;
local3 = this.alternativa3d::omc * local10 + this.alternativa3d::omg * local11 + this.alternativa3d::omk * local12;
local3 = local3 >= 0 ? local3 : -local3;
local2 += local3;
local3 = this.alternativa3d::omc * local13 + this.alternativa3d::omg * local14 + this.alternativa3d::omk * local15;
local3 = local3 >= 0 ? local3 : -local3;
local2 += local3;
local3 = this.alternativa3d::omc >= 0 ? this.alternativa3d::omc * local16 : -this.alternativa3d::omc * local16;
local2 += local3;
local3 = this.alternativa3d::omg >= 0 ? this.alternativa3d::omg * local17 : -this.alternativa3d::omg * local17;
local2 += local3;
local3 = this.alternativa3d::omk >= 0 ? this.alternativa3d::omk * local18 : -this.alternativa3d::omk * local18;
local2 += local3;
local3 = this.alternativa3d::omc * local19 + this.alternativa3d::omg * local20 + this.alternativa3d::omk * local21;
local3 = local3 >= 0 ? local3 : -local3;
local2 -= local3;
if(local2 <= 0) {
return false;
}
return true;
}
}
}
|
package projects.tanks.client.panel.model.shop.kitpackage {
public interface IKitPackageModelBase {
}
}
|
package scpacker.networking.connecting
{
import alternativa.init.Main;
import flash.events.Event;
import flash.net.URLLoader;
import flash.net.URLLoaderDataFormat;
import flash.net.URLRequest;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
import specter.utils.Logger;
public class ServerConnectionServiceImpl implements ServerConnectionService
{
private var loader:URLLoader;
private var networker:Network;
private var connectionListener:Function;
public function ServerConnectionServiceImpl()
{
super();
}
public function connect(urlConfig:String, connectionListener:Function) : void
{
this.networker = new Network();
this.connectionListener = connectionListener;
this.networker.connectionListener = connectionListener;
Logger.log("Created listener for connection");
this.loader = new URLLoader();
this.loader.dataFormat = URLLoaderDataFormat.TEXT;
this.loader.addEventListener(Event.COMPLETE,this.onComplete);
this.loader.load(new URLRequest(urlConfig));
}
private function onComplete(e:Event) : void
{
this.loader.removeEventListener(Event.COMPLETE,this.onComplete);
var json:Object = JSON.parse(this.loader.data);
var ip:String = json.ip;
var port:int = json.port;
this.networker.connect(ip,port);
Logger.log("Connected to: " + ip + ":" + port);
Main.osgi.registerService(INetworker,this.networker);
}
}
}
|
package alternativa.tanks.gui.friends {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.FriendsWindowStateSmallButton_inboxClass.png")]
public class FriendsWindowStateSmallButton_inboxClass extends BitmapAsset {
public function FriendsWindowStateSmallButton_inboxClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.effects.description {
public class EffectCategory {
public static const INVENTORY:EffectCategory = new EffectCategory(0,"INVENTORY");
public static const BONUS:EffectCategory = new EffectCategory(1,"BONUS");
public static const OVERDRIVE:EffectCategory = new EffectCategory(2,"OVERDRIVE");
public static const OTHER:EffectCategory = new EffectCategory(3,"OTHER");
private var _value:int;
private var _name:String;
public function EffectCategory(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<EffectCategory> {
var local1:Vector.<EffectCategory> = new Vector.<EffectCategory>();
local1.push(INVENTORY);
local1.push(BONUS);
local1.push(OVERDRIVE);
local1.push(OTHER);
return local1;
}
public function toString() : String {
return "EffectCategory [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.gui.friends.battleinvite {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.types.Long;
import assets.cellrenderer.battlelist.SportBattleItemIcon;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import flash.events.MouseEvent;
import flash.text.TextLineMetrics;
import forms.ColorConstants;
import forms.userlabel.UserLabel;
import projects.tanks.client.tanksservices.types.battle.BattleInfoData;
import projects.tanks.clients.flash.commons.services.notification.Notification;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogwindowdispatcher.IDialogWindowsDispatcherService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.battleinvite.IBattleInviteService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
public class BattleInviteNotification extends Notification {
[Inject]
public static var battleInviteService:IBattleInviteService;
[Inject]
public static var battleAlertService:IAlertService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var dialogWindowsDispatcherService:IDialogWindowsDispatcherService;
private static const DEFAULT_BUTTON_WIDTH:int = 96;
private static const SHOW_ALERT_ABOUT_INACCESSIBLE_IN_STANDALONE:String = "SHOW_ALERT_ABOUT_INACCESSIBLE_IN_STANDALONE";
private var _userLabel:UserLabel;
private var battleData:BattleInfoData;
private var _baseMessageLabel:LabelBase;
private var _mapAndServerNumberMessageLabel:LabelBase;
private var _rejectButton:DefaultButtonBase;
private var _acceptButton:DefaultButtonBase;
private var _mapAndServerNumberString:String;
private var _noSuppliesIcon:SportBattleItemIcon;
public function BattleInviteNotification(param1:Long, param2:String, param3:String, param4:BattleInfoData) {
this.battleData = param4;
this._mapAndServerNumberString = param3;
super(param1,param2);
}
override protected function init() : void {
super.init();
this._userLabel = new UserLabel(userId);
addChild(this._userLabel);
this._baseMessageLabel = new LabelBase();
this._baseMessageLabel.color = ColorConstants.GREEN_LABEL;
this._baseMessageLabel.mouseEnabled = false;
addChild(this._baseMessageLabel);
this._baseMessageLabel.htmlText = message;
this._mapAndServerNumberMessageLabel = new LabelBase();
this._mapAndServerNumberMessageLabel.color = ColorConstants.GREEN_LABEL;
this._mapAndServerNumberMessageLabel.mouseEnabled = false;
addChild(this._mapAndServerNumberMessageLabel);
this._mapAndServerNumberMessageLabel.htmlText = this._mapAndServerNumberString;
if(this.battleData.proBattle) {
this._noSuppliesIcon = new SportBattleItemIcon();
this._noSuppliesIcon.gotoAndStop(1);
addChild(this._noSuppliesIcon);
}
this._acceptButton = new DefaultButtonBase();
this._acceptButton.width = DEFAULT_BUTTON_WIDTH;
this._acceptButton.label = localeService.getText(TanksLocale.TEXT_GO_TO_BATTLE_LABEL);
addChild(this._acceptButton);
this._rejectButton = new DefaultButtonBase();
this._rejectButton.width = DEFAULT_BUTTON_WIDTH;
this._rejectButton.label = localeService.getText(TanksLocale.TEXT_DECLINE_LABEL);
addChild(this._rejectButton);
}
override protected function setEvents() : void {
super.setEvents();
this._acceptButton.addEventListener(MouseEvent.CLICK,this.onAcceptClick);
this._rejectButton.addEventListener(MouseEvent.CLICK,this.onRejectClick);
}
override protected function removeEvents() : void {
super.removeEvents();
this._acceptButton.removeEventListener(MouseEvent.CLICK,this.onAcceptClick);
this._rejectButton.removeEventListener(MouseEvent.CLICK,this.onRejectClick);
}
private function onAcceptClick(param1:MouseEvent = null) : void {
dialogWindowsDispatcherService.forciblyClose();
battleInviteService.accept(userId,this.battleData);
hide();
}
private function onRejectClick(param1:MouseEvent) : void {
this.closeNotification();
}
override protected function closeNotification() : void {
battleInviteService.reject(userId);
hide();
}
override protected function resize() : void {
this._userLabel.x = GAP + 7;
this._userLabel.y = GAP + 5;
this._baseMessageLabel.x = GAP + 9;
this._baseMessageLabel.y = this._userLabel.y + this._userLabel.height - 1;
this._mapAndServerNumberMessageLabel.x = GAP + 9;
var local1:TextLineMetrics = this._baseMessageLabel.getLineMetrics(0);
if(this.battleData.proBattle) {
this._noSuppliesIcon.x = GAP + 12;
this._noSuppliesIcon.y = this._baseMessageLabel.y + local1.height + 3;
this._mapAndServerNumberMessageLabel.x = this._noSuppliesIcon.x + this._noSuppliesIcon.width + 2;
}
this._mapAndServerNumberMessageLabel.y = this._baseMessageLabel.y + local1.height;
_innerHeight = this._baseMessageLabel.y + this._baseMessageLabel.height - 3;
var local2:int = this._baseMessageLabel.x + this._baseMessageLabel.width + GAP * 2;
if(local2 > _width) {
_width = local2;
}
var local3:int = _innerHeight + 16;
this._acceptButton.x = GAP;
this._acceptButton.y = local3;
this._rejectButton.x = _width - this._rejectButton.width - GAP;
this._rejectButton.y = local3;
_height = this._acceptButton.y + this._acceptButton.height + GAP + 1;
super.resize();
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory.cooldown {
import alternativa.tanks.models.battle.gui.inventory.IInventoryItem;
import alternativa.tanks.models.battle.gui.inventory.IInventoryPanel;
import flash.utils.Dictionary;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.battlefield.models.inventory.cooldown.DependedCooldownItem;
import projects.tanks.client.battlefield.models.inventory.cooldown.IInventoryCooldownModelBase;
import projects.tanks.client.battlefield.models.inventory.cooldown.InventoryCooldownModelBase;
[ModelInfo]
public class InventoryCooldownModel extends InventoryCooldownModelBase implements IInventoryCooldownModelBase, ObjectLoadPostListener, ObjectUnloadListener {
[Inject]
public static var inventoryPanel:IInventoryPanel;
private var slotIndexByObjectId:Dictionary = new Dictionary();
public function InventoryCooldownModel() {
super();
}
[Obfuscation(rename="false")]
public function activateCooldown(param1:int) : void {
inventoryPanel.activateCooldown(this.slotIndexByObjectId[object.id],param1);
}
[Obfuscation(rename="false")]
public function activateDependentCooldown(param1:Vector.<DependedCooldownItem>) : void {
var local4:DependedCooldownItem = null;
var local2:int = int(param1.length);
var local3:int = 0;
while(local3 < local2) {
local4 = param1[local3];
inventoryPanel.activateDependedCooldown(this.slotIndexByObjectId[local4.id],local4.duration);
local3++;
}
}
[Obfuscation(rename="false")]
public function objectLoadedPost() : void {
var local1:IInventoryItem = IInventoryItem(object.adapt(IInventoryItem));
this.slotIndexByObjectId[object.id] = int(local1.getSlotIndex());
}
[Obfuscation(rename="false")]
public function objectUnloaded() : void {
delete this.slotIndexByObjectId[object.id];
}
[Obfuscation(rename="false")]
public function setCooldownDuration(param1:int) : void {
inventoryPanel.setCooldownDuration(this.slotIndexByObjectId[object.id],param1);
}
public function ready() : void {
inventoryPanel.ready(this.slotIndexByObjectId[object.id]);
}
}
}
|
package forms
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
import controls.Label;
import controls.statassets.BlackRoundRect;
import flash.display.Sprite;
import flash.events.TimerEvent;
import flash.text.TextFormatAlign;
import flash.utils.Timer;
public class ServerStopAlert extends Sprite
{
protected const PADDING:int = 15;
protected var bg:BlackRoundRect;
protected var timeLimitLabel:Label;
protected var countDown:int = 0;
protected var countDownTimer:Timer;
public var str:String;
public function ServerStopAlert(time:int)
{
this.bg = new BlackRoundRect();
this.timeLimitLabel = new Label();
super();
this.countDown = time;
this.init();
}
protected function init() : void
{
var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
this.timeLimitLabel.align = TextFormatAlign.CENTER;
this.str = localeService.getText(TextConst.SERVER_STOP_ALERT_TEXT);
this.timeLimitLabel.text = this.getText(this.str,"88");
addChild(this.bg);
addChild(this.timeLimitLabel);
this.timeLimitLabel.x = this.PADDING;
this.timeLimitLabel.y = this.PADDING;
this.bg.width = this.timeLimitLabel.width + this.PADDING * 2;
this.bg.height = this.timeLimitLabel.height + this.PADDING * 2;
this.showCountDown();
}
protected function showCountDown() : void
{
this.countDownTimer = new Timer(1000);
this.countDownTimer.addEventListener(TimerEvent.TIMER,this.showCountDownTick);
this.countDownTimer.start();
this.showCountDownTick();
}
protected function showCountDownTick(e:TimerEvent = null) : void
{
var str1:String = null;
var min:int = int(this.countDown / 60);
var sec:int = this.countDown - min * 60;
str1 = sec > 9 ? String(sec) : "0" + String(sec);
this.timeLimitLabel.text = this.timeLimitLabel.text = this.getText(this.str,str1);
--this.countDown;
if(this.countDown < 0)
{
this.countDownTimer.removeEventListener(TimerEvent.TIMER,this.showCountDownTick);
this.countDownTimer.stop();
}
}
protected function getText(id:String, ... vars) : String
{
var text:String = id;
for(var i:int = 0; i < vars.length; i++)
{
text = text.replace("%" + (i + 1),vars[i]);
}
return text;
}
}
}
|
package alternativa.tanks.gui.notinclan.buttons {
import alternativa.tanks.gui.IClanNotificationListener;
import alternativa.tanks.models.service.ClanUserNotificationsManager;
import controls.base.ThreeLineBigButton;
import flash.display.Bitmap;
import flash.display.BitmapData;
public class ClanUserListsButton extends ThreeLineBigButton implements IClanNotificationListener {
public static var attentionIconClass:Class = ClanUserListsButton_attentionIconClass;
private static var attentionIconBitmapData:BitmapData = Bitmap(new attentionIconClass()).bitmapData;
private var _attentionIcon:Bitmap = new Bitmap(attentionIconBitmapData);
public function ClanUserListsButton() {
super();
addChild(this._attentionIcon);
this._attentionIcon.y = -6;
ClanUserNotificationsManager.addIncomingIndicatorListener(this);
}
override public function set width(param1:Number) : void {
super.width = param1;
this._attentionIcon.x = width - this._attentionIcon.width / 2;
}
public function updateNotifications() : void {
this._attentionIcon.visible = ClanUserNotificationsManager.getIncomingNotificationsCount() > 0;
}
public function destroy() : void {
ClanUserNotificationsManager.removeIncomingIndicatorListener(this);
}
}
}
|
package forms.friends.list.renderer
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class FriendsAcceptedListRenderer_socialFriendClass extends BitmapAsset
{
public function FriendsAcceptedListRenderer_socialFriendClass()
{
super();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.