code
stringlengths 57
237k
|
|---|
package alternativa.tanks.model.item.container.gui.opening {
import controls.buttons.h50px.GreyBigButton;
public class OpenBoxButton extends GreyBigButton {
public var count:int;
public var mode:int;
public function OpenBoxButton(param1:String, param2:int, param3:int) {
super();
this.label = param1;
this.count = param2;
this.mode = param3;
this.width = 130;
}
}
}
|
package projects.tanks.client.battlefield.models.drone.demoman {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.client.battlefield.types.Vector3d;
public class DroneExplosionModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:DroneExplosionModelServer;
private var client:IDroneExplosionModelBase = IDroneExplosionModelBase(this);
private var modelId:Long = Long.getLong(327725701,-804290777);
private var _addExplosionEffectId:Long = Long.getLong(1094361499,58760275);
private var _addExplosionEffect_positionCodec:ICodec;
private var _addExplosionEffect_radiusCodec:ICodec;
public function DroneExplosionModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new DroneExplosionModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(DroneExplosionCC,false)));
this._addExplosionEffect_positionCodec = this._protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._addExplosionEffect_radiusCodec = this._protocol.getCodec(new TypeCodecInfo(Float,false));
}
protected function getInitParam() : DroneExplosionCC {
return DroneExplosionCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._addExplosionEffectId:
this.client.addExplosionEffect(Vector3d(this._addExplosionEffect_positionCodec.decode(param2)),Number(this._addExplosionEffect_radiusCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.payment.category {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class PayFullDescriptionAdapt implements PayFullDescription {
private var object:IGameObject;
private var impl:PayFullDescription;
public function PayFullDescriptionAdapt(param1:IGameObject, param2:PayFullDescription) {
super();
this.object = param1;
this.impl = param2;
}
public function getFullDescription() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getFullDescription();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIcon_p10 extends BitmapAsset
{
public function RangIcon_p10()
{
super();
}
}
}
|
package alternativa.osgi.service.console
{
public interface IConsoleService
{
function showConsole() : void;
function hideConsole() : void;
function clearConsole() : void;
function writeToConsole(param1:String, ... rest) : void;
function writeToConsoleChannel(param1:String, param2:String, ... rest) : void;
function get console() : Object;
}
}
|
package alternativa.tanks.models.controlpoints.hud.marker {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.controlpoints.hud.marker.MarkerBitmaps_redMarkerClass.png")]
public class MarkerBitmaps_redMarkerClass extends BitmapAsset {
public function MarkerBitmaps_redMarkerClass() {
super();
}
}
}
|
package com.lorentz.SVG.display
{
import com.lorentz.SVG.data.MarkerPlace;
import com.lorentz.SVG.display.base.ISVGPreserveAspectRatio;
import com.lorentz.SVG.display.base.ISVGViewBox;
import com.lorentz.SVG.display.base.SVGContainer;
import com.lorentz.SVG.display.base.SVGElement;
import com.lorentz.SVG.parser.SVGParserCommon;
import com.lorentz.SVG.utils.SVGUtil;
import com.lorentz.SVG.utils.SVGViewPortUtils;
import flash.geom.Point;
import flash.geom.Rectangle;
public class SVGMarker extends SVGContainer implements ISVGViewBox, ISVGPreserveAspectRatio {
private var _invalidPlacement:Boolean = true;
private var _markerPlace:MarkerPlace;
public function SVGMarker(){
super("marker");
}
public function get svgRefX():String {
return getAttribute("refX") as String;
}
public function set svgRefX(value:String):void {
setAttribute("refX", value);
invalidatePlacement();
}
public function get svgRefY():String {
return getAttribute("refY") as String;
}
public function set svgRefY(value:String):void {
setAttribute("refY", value);
invalidatePlacement();
}
public function get svgMarkerWidth():String {
return getAttribute("markerWidth") as String;
}
public function set svgMarkerWidth(value:String):void {
setAttribute("markerWidth", value);
invalidatePlacement();
}
public function get svgMarkerHeight():String {
return getAttribute("markerHeight") as String;
}
public function set svgMarkerHeight(value:String):void {
setAttribute("markerHeight", value);
invalidatePlacement();
}
public function get svgOrient():String {
return getAttribute("orient") as String;
}
public function set svgOrient(value:String):void {
setAttribute("orient", value);
invalidatePlacement();
}
public function get svgViewBox():Rectangle {
return getAttribute("viewBox") as Rectangle;
}
public function set svgViewBox(value:Rectangle):void {
setAttribute("viewBox", value);
invalidatePlacement();
}
public function get svgPreserveAspectRatio():String {
return getAttribute("preserveAspectRatio") as String;
}
public function set svgPreserveAspectRatio(value:String):void {
setAttribute("preserveAspectRatio", value);
invalidatePlacement();
}
protected function invalidatePlacement():void {
if(!_invalidPlacement)
{
_invalidPlacement = true;
invalidate();
}
}
override protected function getElementToInheritStyles():SVGElement {
if(!parentElement)
return null;
return parentElement.parentElement;
}
public function get markerPlace():MarkerPlace {
return _markerPlace;
}
public function set markerPlace(value:MarkerPlace):void {
_markerPlace = value;
invalidatePlacement();
}
override public function validate():void {
super.validate();
if(_invalidPlacement){
_invalidPlacement = false;
//viewport
scrollRect = null;
content.scaleX = 1;
content.scaleY = 1;
content.x = 0;
content.y = 0;
var markerWidth:Number = 3;
if(svgMarkerWidth)
markerWidth = getViewPortUserUnit(svgMarkerWidth, SVGUtil.WIDTH);
var markerHeight:Number = 3;
if(svgMarkerHeight)
markerHeight = getViewPortUserUnit(svgMarkerHeight, SVGUtil.HEIGHT);
if(svgViewBox != null){
if(svgPreserveAspectRatio != "none"){
var viewPortBox:Rectangle = new Rectangle(0, 0, markerWidth, markerHeight);
var preserveAspectRatio:Object = SVGParserCommon.parsePreserveAspectRatio(svgPreserveAspectRatio || "");
var viewPortContentMetrics:Object = SVGViewPortUtils.getContentMetrics(viewPortBox, svgViewBox, preserveAspectRatio.align, preserveAspectRatio.meetOrSlice);
if(preserveAspectRatio.meetOrSlice == "slice"){
scrollRect = viewPortBox;
}
content.scaleX = viewPortContentMetrics.contentScaleX;
content.scaleY = viewPortContentMetrics.contentScaleY;
content.x = viewPortContentMetrics.contentX;
content.y = viewPortContentMetrics.contentY;
} else {
content.x = x;
content.y = y;
content.scaleX = markerWidth / content.width;
content.scaleY = markerHeight / content.height;
}
}
//Position and so on
var refX:Number = 0;
if(svgRefX)
refX = getViewPortUserUnit(svgRefX, SVGUtil.WIDTH);
var refY:Number = 0;
if(svgRefY)
refY = getViewPortUserUnit(svgRefY, SVGUtil.HEIGHT);
rotation = !svgOrient || svgOrient == "auto" ? markerPlace.angle : Number(svgOrient);
scaleX = markerPlace.strokeWidth;
scaleY = markerPlace.strokeWidth;
var referenceGlobal:Point = content.localToGlobal(new Point(refX, refY));
var referencePointOnParentObject:Point = parent.globalToLocal(referenceGlobal);
x = markerPlace.position.x - referencePointOnParentObject.x - x;
y = markerPlace.position.y - referencePointOnParentObject.y - y;
}
}
override public function clone():Object {
var c:SVGMarker = super.clone() as SVGMarker;
c.svgRefX = svgRefX;
c.svgRefY = svgRefY;
c.svgMarkerWidth = svgMarkerWidth;
c.svgMarkerHeight = svgMarkerHeight;
c.svgOrient = svgOrient;
return c;
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo {
import alternativa.math.Vector3;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.ClientTankState;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.WeaponUtils;
import alternativa.tanks.models.weapon.laser.LaserPointer;
import alternativa.tanks.models.weapon.rocketlauncher.RocketLauncherObject;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.IRocketLauncherWeapon;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.RocketLauncherWeaponState;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.aim.RocketLauncherAim;
import alternativa.tanks.models.weapons.charging.WeaponChargingCommunication;
import alternativa.tanks.models.weapons.targeting.TargetingResult;
import alternativa.tanks.models.weapons.targeting.TargetingSystem;
import flash.utils.getTimer;
import projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher.RocketLauncherCC;
public class SalvoShotState implements RocketLauncherWeaponState {
private static const gunParamsForSalvo:AllGlobalGunParams = new AllGlobalGunParams();
private var salvoStartTime:int;
private var nextSalvoShotTime:int;
private var numberOfRemainingShots:int;
private var weapon:IRocketLauncherWeapon;
private var weaponPlatform:WeaponPlatform;
private var target:RocketTargetPoint;
private var targetingSystem:TargetingSystem;
private var rocketLauncherParams:RocketLauncherCC;
private var aim:RocketLauncherAim;
private var laser:LaserPointer;
private var chargingCommunication:WeaponChargingCommunication;
private var shotDirectionVerticalProjection:Number;
private var endGracePeriodTime:int;
public function SalvoShotState(param1:IRocketLauncherWeapon, param2:WeaponPlatform, param3:RocketLauncherObject, param4:RocketLauncherCC) {
super();
this.weapon = param1;
this.weaponPlatform = param2;
this.targetingSystem = param1.getTargetingSystem();
this.target = param1.getTarget();
this.rocketLauncherParams = param4;
this.laser = param3.laser();
this.chargingCommunication = param3.charging();
this.aim = new RocketLauncherAim(this.target,param1,param1.getEffects());
}
public function start(param1:int) : void {
if(this.weapon.canShoot(param1)) {
this.resetAiming();
this.numberOfRemainingShots = this.rocketLauncherParams.salvoSize;
}
}
public function getStatus() : Number {
var local1:int = this.salvoStartTime;
if(this.target.isLost()) {
local1 += this.rocketLauncherParams.salvoAimingGracePeriod - (this.endGracePeriodTime - getTimer());
}
return Math.max((local1 - getTimer()) / this.rocketLauncherParams.salvoAimingTime,0);
}
public function update(param1:int) : void {
if(this.weapon.isBuffed()) {
this.completeSalvo(param1);
return;
}
if(!this.salvoStarted(param1) || this.target.isLost()) {
this.actualizeTarget(param1);
return;
}
if(this.numberOfRemainingShots > 0 && param1 >= this.nextSalvoShotTime) {
this.doSalvoShot(param1);
}
}
private function actualizeTarget(param1:int) : void {
this.resetAimingIfTargetNotAlive();
WeaponUtils.calculateMainGunParams(this.weaponPlatform.getTurret3D(),this.weaponPlatform.getLaserLocalPosition(),gunParamsForSalvo);
if(!BattleUtils.isTurretAboveGround(this.weaponPlatform.getBody(),gunParamsForSalvo) || BattleUtils.barrelCollidesWithStatic(gunParamsForSalvo)) {
this.laser.hideLaser();
this.resetAiming();
return;
}
var local2:TargetingResult = this.targetingSystem.target(gunParamsForSalvo);
if(local2.hasTankHit()) {
this.updateTarget(local2,param1);
} else {
this.loseTarget(local2,param1);
}
}
private function resetAimingIfTargetNotAlive() : void {
if(!this.target.isAlive()) {
this.resetAiming();
}
}
private function updateTarget(param1:TargetingResult, param2:int) : void {
var local3:RayHit = param1.getSingleHit();
var local4:Tank = local3.shape.body.tank;
if(!this.target.hasTarget()) {
this.setTarget(local4,param2);
}
if(!this.target.isSameTank(local4)) {
this.loseTarget(param1,param2);
return;
}
if(this.target.isLost()) {
this.salvoStartTime += this.rocketLauncherParams.salvoAimingGracePeriod - (this.endGracePeriodTime - param2);
this.nextSalvoShotTime = this.salvoStartTime;
}
var local5:Vector3 = this.getTargetLocalPoint(local3,local4);
this.laser.aimAtTank(local4,local5);
this.target.setLocalPoint(local5);
this.updateShotDirection(param1);
}
private function setTarget(param1:Tank, param2:int) : void {
if(param1.state == ClientTankState.ACTIVE && !param1.isSameTeam(this.weaponPlatform.teamType)) {
this.target.setTank(param1);
this.aim.show();
this.salvoStartTime = param2 + this.rocketLauncherParams.salvoAimingTime;
this.nextSalvoShotTime = this.salvoStartTime;
this.chargingCommunication.startCharging(param2);
} else {
this.resetAiming();
}
}
private function getTargetLocalPoint(param1:RayHit, param2:Tank) : Vector3 {
var local3:Vector3 = BattleUtils.tmpVector;
local3.copy(param1.position);
BattleUtils.globalToLocal(param2.getBody(),local3);
return local3;
}
private function updateShotDirection(param1:TargetingResult) : void {
var local2:Vector3 = BattleUtils.tmpVector;
local2.cross2(gunParamsForSalvo.elevationAxis,gunParamsForSalvo.direction).normalize();
this.shotDirectionVerticalProjection = local2.dot(param1.getDirection());
}
private function loseTarget(param1:TargetingResult, param2:int) : void {
this.laser.updateDirection(param1.getDirection());
if(this.target.hasTarget() && !this.target.isLost()) {
this.target.markAsLost();
this.endGracePeriodTime = param2 + this.rocketLauncherParams.salvoAimingGracePeriod;
}
if(!this.target.hasTarget() || param2 > this.endGracePeriodTime) {
this.resetAiming();
}
}
private function doSalvoShot(param1:int) : void {
if(this.numberOfRemainingShots == this.rocketLauncherParams.salvoSize) {
this.finishAiming(param1);
}
this.laser.hideLaser();
--this.numberOfRemainingShots;
this.nextSalvoShotTime = param1 + this.rocketLauncherParams.timeBetweenShotsOfSalvo;
this.weapon.salvoShoot(param1,this.shotDirectionVerticalProjection);
if(this.numberOfRemainingShots <= 0) {
this.completeSalvo(param1);
}
}
private function finishAiming(param1:int) : void {
this.chargingCommunication.finishCharging(param1);
this.weapon.getEffects().playAimingCompleteSoundEffect();
}
public function stop(param1:int) : void {
if(!this.salvoStarted(param1)) {
this.completeSalvo(param1);
}
}
public function salvoStarted(param1:int) : Boolean {
return param1 >= this.salvoStartTime;
}
private function completeSalvo(param1:int) : void {
this.resetAiming();
this.laser.hideLaser();
this.numberOfRemainingShots = 0;
this.weapon.onEndingOfSalvo(param1);
}
public function getReloadTime() : int {
return this.rocketLauncherParams.salvoReloadTime;
}
[Obfuscation(rename="false")]
public function close() : void {
this.resetAiming();
this.laser.hideLaser();
this.weapon = null;
this.target = null;
this.targetingSystem = null;
this.rocketLauncherParams = null;
this.aim = null;
this.laser = null;
}
private function resetAiming() : void {
this.target.resetTarget();
this.aim.hide();
this.salvoStartTime = int.MAX_VALUE;
this.nextSalvoShotTime = int.MAX_VALUE;
}
public function weaponStunned(param1:int) : void {
this.completeSalvo(param1);
}
}
}
|
package alternativa.tanks.models.weapon.artillery {
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.WeaponMount;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.weapon.artillery.sfx.ArtilleryEffects;
import alternativa.tanks.models.weapon.artillery.sfx.ArtillerySfxData;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapons.common.CommonLocalWeapon;
import flash.utils.getTimer;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapons.artillery.ArtilleryCC;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class ArtilleryWeapon extends CommonLocalWeapon {
private const BUFFED_SHOT_POWER:* = 1;
private var reloadTimeMs:int;
private var reloadingEndTime:int;
private var weaponObject:ArtilleryObject;
private var user:IGameObject;
private var shotId:int;
private var params:ArtilleryCC;
private var startChargingTime:Number;
private var needReleaseTrigger:Boolean;
private var weaponMount:WeaponMount;
private var effects:ArtilleryEffects;
private var extraReloadingTimeMs:int;
private var sfxData:ArtillerySfxData;
private var buffed:Boolean;
private var stunned:Boolean;
private var stunStatus:Number;
public function ArtilleryWeapon(param1:IGameObject, param2:ArtilleryObject, param3:ArtilleryCC, param4:ArtillerySfxData, param5:ArtilleryEffects) {
super(param2.isLocal());
this.user = param1;
this.weaponObject = param2;
this.params = param3;
this.reloadTimeMs = param2.getReloadTimeMS();
this.extraReloadingTimeMs = this.reloadTimeMs;
this.effects = param5;
this.sfxData = param4;
this.reset();
}
override public function init(param1:WeaponPlatform) : void {
var local2:ITankModel = ITankModel(this.user.adapt(ITankModel));
this.weaponMount = local2.getWeaponMount();
super.init(param1);
}
override public function getStatus() : Number {
if(this.stunned) {
return this.stunStatus;
}
if(this.buffed) {
return 1 - Math.max(0,(this.reloadingEndTime - getTimer()) / this.reloadTimeMs);
}
if(this.isCharging()) {
return 1 - Math.min(1,(getTimer() - this.startChargingTime) * 0.001 / this.params.chargingTime);
}
return 1 - Math.max(0,(this.reloadingEndTime - getTimer()) / (this.reloadTimeMs + this.extraReloadingTimeMs));
}
override public function runLogic(param1:int, param2:int) : void {
if(this.needReleaseTrigger) {
this.needReleaseTrigger = false;
if(this.canShoot(this.startChargingTime)) {
this.shoot(getPhysicsTime() - this.startChargingTime);
}
super.releaseTrigger();
}
super.runLogic(param1,param2);
if(this.canShoot(param1)) {
if(this.buffed) {
this.shoot(getPhysicsTime() - this.startChargingTime);
} else if(!this.canShoot(this.startChargingTime)) {
this.startCharging();
}
}
}
public function startCharging() : void {
this.startChargingTime = getPhysicsTime();
this.weaponObject.charging().startCharging(this.startChargingTime);
if(this.isLocalWeapon()) {
this.effects.createChargingSoundEffect(getWeaponPlatform().getTurret3D());
}
}
override public function releaseTrigger() : void {
this.needReleaseTrigger = true;
}
public function shoot(param1:int) : void {
var local2:int = getPhysicsTime();
this.weaponObject.charging().finishCharging(local2);
this.extraReloadingTimeMs = this.getNotSpentChargingDuration(param1);
if(this.buffed) {
this.reloadingEndTime = local2 + this.reloadTimeMs;
} else {
this.reloadingEndTime = local2 + this.reloadTimeMs + this.extraReloadingTimeMs;
}
var local3:WeaponPlatform = getWeaponPlatform();
local3.getAllGunParams(gunParams);
var local4:WeaponCommonData = this.weaponObject.commonData();
local3.getBody().addWorldForceScaled(gunParams.muzzlePosition,gunParams.direction,-local4.getRecoilForce());
local3.addDust();
if(!BattleUtils.isTurretAboveGround(local3.getBody(),gunParams)) {
this.weaponObject.shellCommunication().tryToDummyShoot(local2,0);
return;
}
this.weaponObject.shellCommunication().tryToShoot(local2,0,++this.shotId,gunParams.direction);
var local5:ArtilleryShell = ArtilleryShell(battleService.getObjectPool().getObject(ArtilleryShell));
local5.init(this.sfxData,this.weaponObject,this.params,this.getSpeed(this.getDiscretePowerByDuration(param1)));
local5.addToGame(gunParams,gunParams.direction,local3.getBody(),this is RemoteArtilleryWeapon,this.shotId);
this.effects.createShotEffect(local3,gunParams,this.getPower(param1),this.weaponMount.getBarrelInterpolatedElevation() * 180 / Math.PI,this.reloadTimeMs + this.extraReloadingTimeMs);
}
private function getNotSpentChargingDuration(param1:int) : int {
return param1 > this.params.chargingTime * 1000 ? 0 : int(this.params.chargingTime * 1000 - param1);
}
private function getSpeed(param1:Number) : Number {
var local2:Number = this.params.minShellSpeed;
var local3:Number = this.params.maxShellSpeed;
return local2 + (local3 - local2) * param1;
}
public function getPower(param1:int) : Number {
return this.getPowerByDuration(param1 - this.startChargingTime);
}
public function getDiscretePower(param1:int) : Number {
return this.getDiscretePowerByDuration(param1 - this.startChargingTime);
}
private function getPowerByDuration(param1:int) : Number {
return this.buffed ? this.BUFFED_SHOT_POWER : this.getChargedPower(param1);
}
private function getDiscretePowerByDuration(param1:int) : Number {
return int(this.getPowerByDuration(param1) * this.params.speedsCount) / this.params.speedsCount;
}
private function getChargedPower(param1:int) : Number {
return Math.min(1,param1 * 0.001 / this.params.chargingTime);
}
public function isCharging() : Boolean {
return !this.stunned && this.startChargingTime >= this.reloadingEndTime;
}
public function isStunned() : Boolean {
return this.stunned;
}
public function isBuffed() : Boolean {
return this.buffed;
}
private function canShoot(param1:int) : Boolean {
return isShooting() && param1 >= this.reloadingEndTime;
}
override public function reset() : void {
super.reset();
this.effects.reset();
this.reloadingEndTime = 0;
this.startChargingTime = -1;
}
override public function getResistanceProperty() : ItemProperty {
return ItemProperty.ARTILLERY_RESISTANCE;
}
private function isLocalWeapon() : Boolean {
return this.weaponObject.isLocal();
}
public function getInitialAngle() : Number {
return this.params.initialTurretAngle;
}
public function setBuffedMode(param1:Boolean) : void {
this.buffed = param1;
this.reloadTimeMs = this.weaponObject.getReloadTimeMS();
this.extraReloadingTimeMs = this.reloadTimeMs;
if(this.buffed) {
this.effects.killChargingSound();
this.effects.stopReloadSound();
}
}
override public function fullyRecharge() : void {
this.reloadingEndTime = 0;
this.startChargingTime = -1;
this.stunStatus = 1;
}
override public function weaponReloadTimeChanged(param1:int, param2:int) : void {
this.reloadingEndTime += param2 - param1 - this.extraReloadingTimeMs;
}
override public function stun() : void {
this.stunStatus = this.isCharging() ? 1 : this.getStatus();
this.stunned = true;
this.effects.killChargingSound();
this.effects.stopReloadSound();
}
override public function calm(param1:int) : void {
var local2:Number = (1 - this.stunStatus) * (this.reloadTimeMs + this.extraReloadingTimeMs);
if(this.isCharging()) {
this.reloadingEndTime += getTimer();
} else {
this.reloadingEndTime += param1;
}
this.startChargingTime = 0;
this.stunned = false;
if(this.stunStatus < 1 && this.isLocalWeapon()) {
this.effects.createReloadSoundEffect(getWeaponPlatform().getTurret3D(),local2);
}
}
}
}
|
package alternativa.tanks.sfx
{
import alternativa.engine3d.core.Object3D;
import alternativa.tanks.camera.GameCamera;
public interface Object3DPositionProvider
{
function initPosition(param1:Object3D) : void;
function updateObjectPosition(param1:Object3D, param2:GameCamera, param3:int) : void;
function destroy() : void;
}
}
|
package controls.base {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.base.TankInput_leftWrondClass.png")]
public class TankInput_leftWrondClass extends BitmapAsset {
public function TankInput_leftWrondClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.sms.types {
public class SMSNumber {
private var _cost:Number;
private var _crystals:int;
private var _currency:String;
private var _number:String;
private var _smsText:String;
public function SMSNumber(param1:Number = 0, param2:int = 0, param3:String = null, param4:String = null, param5:String = null) {
super();
this._cost = param1;
this._crystals = param2;
this._currency = param3;
this._number = param4;
this._smsText = param5;
}
public function get cost() : Number {
return this._cost;
}
public function set cost(param1:Number) : void {
this._cost = param1;
}
public function get crystals() : int {
return this._crystals;
}
public function set crystals(param1:int) : void {
this._crystals = param1;
}
public function get currency() : String {
return this._currency;
}
public function set currency(param1:String) : void {
this._currency = param1;
}
public function get number() : String {
return this._number;
}
public function set number(param1:String) : void {
this._number = param1;
}
public function get smsText() : String {
return this._smsText;
}
public function set smsText(param1:String) : void {
this._smsText = param1;
}
public function toString() : String {
var local1:String = "SMSNumber [";
local1 += "cost = " + this.cost + " ";
local1 += "crystals = " + this.crystals + " ";
local1 += "currency = " + this.currency + " ";
local1 += "number = " + this.number + " ";
local1 += "smsText = " + this.smsText + " ";
return local1 + "]";
}
}
}
|
package {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol1144")]
public dynamic class ScrollArrowDown_upSkin extends MovieClip {
public function ScrollArrowDown_upSkin() {
super();
}
}
}
|
package alternativa.osgi.catalogs {
public class ServiceInfo {
public var service:Object;
public var params:Vector.<ServiceParam>;
public function ServiceInfo(param1:Object, param2:Vector.<ServiceParam>) {
super();
this.service = param1;
this.params = param2;
}
}
}
|
package alternativa.physics.collision
{
import alternativa.physics.collision.types.BoundBox;
public class CollisionKdTree2D
{
private static const nodeBoundBoxThreshold:BoundBox = new BoundBox();
private static const splitCoordsX:Vector.<Number> = new Vector.<Number>();
private static const splitCoordsY:Vector.<Number> = new Vector.<Number>();
private static const splitCoordsZ:Vector.<Number> = new Vector.<Number>();
private static const _nodeBB:Vector.<Number> = new Vector.<Number>(6);
private static const _bb:Vector.<Number> = new Vector.<Number>(6);
public var threshold:Number = 0.1;
public var minPrimitivesPerNode:int = 1;
public var parentTree:CollisionKdTree;
public var parentNode:CollisionKdNode;
public var rootNode:CollisionKdNode;
private var splitAxis:int;
private var splitCost:Number;
private var splitCoord:Number;
public function CollisionKdTree2D(parentTree:CollisionKdTree, parentNode:CollisionKdNode)
{
super();
this.parentTree = parentTree;
this.parentNode = parentNode;
}
public function createTree() : void
{
this.rootNode = new CollisionKdNode();
this.rootNode.boundBox = this.parentNode.boundBox.clone();
this.rootNode.indices = new Vector.<int>();
var numObjects:int = this.parentNode.splitIndices.length;
for(var i:int = 0; i < numObjects; this.rootNode.indices[i] = this.parentNode.splitIndices[i],i++)
{
}
this.splitNode(this.rootNode);
splitCoordsX.length = splitCoordsY.length = splitCoordsZ.length = 0;
}
private function splitNode(node:CollisionKdNode) : void
{
var objects:Vector.<int> = null;
var i:int = 0;
var j:int = 0;
var nodeBoundBox:BoundBox = null;
var numSplitCoordsX:int = 0;
var numSplitCoordsY:int = 0;
var numSplitCoordsZ:int = 0;
var bb:BoundBox = null;
var min:Number = NaN;
var max:Number = NaN;
if(node.indices.length <= this.minPrimitivesPerNode)
{
return;
}
objects = node.indices;
nodeBoundBox = node.boundBox;
nodeBoundBoxThreshold.minX = nodeBoundBox.minX + this.threshold;
nodeBoundBoxThreshold.minY = nodeBoundBox.minY + this.threshold;
nodeBoundBoxThreshold.minZ = nodeBoundBox.minZ + this.threshold;
nodeBoundBoxThreshold.maxX = nodeBoundBox.maxX - this.threshold;
nodeBoundBoxThreshold.maxY = nodeBoundBox.maxY - this.threshold;
nodeBoundBoxThreshold.maxZ = nodeBoundBox.maxZ - this.threshold;
var doubleThreshold:Number = this.threshold * 2;
var staticBoundBoxes:Vector.<BoundBox> = this.parentTree.staticBoundBoxes;
var numObjects:int = objects.length;
for(i = 0; i < numObjects; i++)
{
bb = staticBoundBoxes[objects[i]];
if(this.parentNode.axis != 0)
{
if(bb.minX > nodeBoundBoxThreshold.minX)
{
var _loc19_:* = numSplitCoordsX++;
splitCoordsX[_loc19_] = bb.minX;
}
if(bb.maxX < nodeBoundBoxThreshold.maxX)
{
_loc19_ = numSplitCoordsX++;
splitCoordsX[_loc19_] = bb.maxX;
}
}
if(this.parentNode.axis != 1)
{
if(bb.minY > nodeBoundBoxThreshold.minY)
{
_loc19_ = numSplitCoordsY++;
splitCoordsY[_loc19_] = bb.minY;
}
if(bb.maxY < nodeBoundBoxThreshold.maxY)
{
_loc19_ = numSplitCoordsY++;
splitCoordsY[_loc19_] = bb.maxY;
}
}
if(this.parentNode.axis != 2)
{
if(bb.minZ > nodeBoundBoxThreshold.minZ)
{
_loc19_ = numSplitCoordsZ++;
splitCoordsZ[_loc19_] = bb.minZ;
}
if(bb.maxZ < nodeBoundBoxThreshold.maxZ)
{
_loc19_ = numSplitCoordsZ++;
splitCoordsZ[_loc19_] = bb.maxZ;
}
}
}
this.splitAxis = -1;
this.splitCost = 1e+308;
_nodeBB[0] = nodeBoundBox.minX;
_nodeBB[1] = nodeBoundBox.minY;
_nodeBB[2] = nodeBoundBox.minZ;
_nodeBB[3] = nodeBoundBox.maxX;
_nodeBB[4] = nodeBoundBox.maxY;
_nodeBB[5] = nodeBoundBox.maxZ;
if(this.parentNode.axis != 0)
{
this.checkNodeAxis(node,0,numSplitCoordsX,splitCoordsX,_nodeBB);
}
if(this.parentNode.axis != 1)
{
this.checkNodeAxis(node,1,numSplitCoordsY,splitCoordsY,_nodeBB);
}
if(this.parentNode.axis != 2)
{
this.checkNodeAxis(node,2,numSplitCoordsZ,splitCoordsZ,_nodeBB);
}
if(this.splitAxis < 0)
{
return;
}
var axisX:Boolean = this.splitAxis == 0;
var axisY:Boolean = this.splitAxis == 1;
node.axis = this.splitAxis;
node.coord = this.splitCoord;
node.negativeNode = new CollisionKdNode();
node.negativeNode.parent = node;
node.negativeNode.boundBox = nodeBoundBox.clone();
node.positiveNode = new CollisionKdNode();
node.positiveNode.parent = node;
node.positiveNode.boundBox = nodeBoundBox.clone();
if(axisX)
{
node.negativeNode.boundBox.maxX = node.positiveNode.boundBox.minX = this.splitCoord;
}
else if(axisY)
{
node.negativeNode.boundBox.maxY = node.positiveNode.boundBox.minY = this.splitCoord;
}
else
{
node.negativeNode.boundBox.maxZ = node.positiveNode.boundBox.minZ = this.splitCoord;
}
var coordMin:Number = this.splitCoord - this.threshold;
var coordMax:Number = this.splitCoord + this.threshold;
for(i = 0; i < numObjects; i++)
{
bb = staticBoundBoxes[objects[i]];
min = !!axisX ? Number(Number(bb.minX)) : (!!axisY ? Number(Number(bb.minY)) : Number(Number(bb.minZ)));
max = !!axisX ? Number(Number(bb.maxX)) : (!!axisY ? Number(Number(bb.maxY)) : Number(Number(bb.maxZ)));
if(max <= coordMax)
{
if(min < coordMin)
{
if(node.negativeNode.indices == null)
{
node.negativeNode.indices = new Vector.<int>();
}
node.negativeNode.indices.push(objects[i]);
objects[i] = -1;
}
}
else if(min >= coordMin)
{
if(max > coordMax)
{
if(node.positiveNode.indices == null)
{
node.positiveNode.indices = new Vector.<int>();
}
node.positiveNode.indices.push(objects[i]);
objects[i] = -1;
}
}
}
for(i = 0,j = 0; i < numObjects; i++)
{
if(objects[i] >= 0)
{
_loc19_ = j++;
objects[_loc19_] = objects[i];
}
}
if(j > 0)
{
objects.length = j;
}
else
{
node.indices = null;
}
if(node.negativeNode.indices != null)
{
this.splitNode(node.negativeNode);
}
if(node.positiveNode.indices != null)
{
this.splitNode(node.positiveNode);
}
}
private function checkNodeAxis(node:CollisionKdNode, axis:int, numSplitCoords:int, splitCoords:Vector.<Number>, bb:Vector.<Number>) : void
{
var currSplitCoord:Number = NaN;
var minCoord:Number = NaN;
var maxCoord:Number = NaN;
var areaNegative:Number = NaN;
var areaPositive:Number = NaN;
var numNegative:int = 0;
var numPositive:int = 0;
var conflict:Boolean = false;
var numObjects:int = 0;
var j:int = 0;
var cost:Number = NaN;
var boundBox:BoundBox = null;
var axis1:int = (axis + 1) % 3;
var axis2:int = (axis + 2) % 3;
var area:Number = (bb[axis1 + 3] - bb[axis1]) * (bb[axis2 + 3] - bb[axis2]);
var staticBoundBoxes:Vector.<BoundBox> = this.parentTree.staticBoundBoxes;
for(var i:int = 0; i < numSplitCoords; i++)
{
currSplitCoord = splitCoords[i];
if(!isNaN(currSplitCoord))
{
minCoord = currSplitCoord - this.threshold;
maxCoord = currSplitCoord + this.threshold;
areaNegative = area * (currSplitCoord - bb[axis]);
areaPositive = area * (bb[int(axis + 3)] - currSplitCoord);
numNegative = 0;
numPositive = 0;
conflict = false;
numObjects = node.indices.length;
for(j = 0; j < numObjects; j++)
{
boundBox = staticBoundBoxes[node.indices[j]];
_bb[0] = boundBox.minX;
_bb[1] = boundBox.minY;
_bb[2] = boundBox.minZ;
_bb[3] = boundBox.maxX;
_bb[4] = boundBox.maxY;
_bb[5] = boundBox.maxZ;
if(_bb[axis + 3] <= maxCoord)
{
if(_bb[axis] < minCoord)
{
numNegative++;
}
}
else
{
if(_bb[axis] < minCoord)
{
conflict = true;
break;
}
numPositive++;
}
}
cost = areaNegative * numNegative + areaPositive * numPositive;
if(!conflict && cost < this.splitCost)
{
this.splitAxis = axis;
this.splitCost = cost;
this.splitCoord = currSplitCoord;
}
for(j = i + 1; j < numSplitCoords; j++)
{
if(splitCoords[j] >= currSplitCoord - this.threshold && splitCoords[j] <= currSplitCoord + this.threshold)
{
splitCoords[j] = NaN;
}
}
}
}
}
}
}
|
package _codec.projects.tanks.client.chat.types {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.chat.models.chat.chat.ChatAddressMode;
import projects.tanks.client.chat.types.BattleChatLink;
import projects.tanks.client.chat.types.ChatMessage;
import projects.tanks.client.chat.types.MessageType;
import projects.tanks.client.chat.types.UserStatus;
public class CodecChatMessage implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_addressMode:ICodec;
private var codec_battleLinks:ICodec;
private var codec_channel:ICodec;
private var codec_links:ICodec;
private var codec_messageType:ICodec;
private var codec_sourceUser:ICodec;
private var codec_targetUser:ICodec;
private var codec_text:ICodec;
private var codec_timePassedInSec:ICodec;
public function CodecChatMessage() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_addressMode = param1.getCodec(new EnumCodecInfo(ChatAddressMode,false));
this.codec_battleLinks = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleChatLink,false),false,1));
this.codec_channel = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_links = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(String,false),true,1));
this.codec_messageType = param1.getCodec(new EnumCodecInfo(MessageType,false));
this.codec_sourceUser = param1.getCodec(new TypeCodecInfo(UserStatus,true));
this.codec_targetUser = param1.getCodec(new TypeCodecInfo(UserStatus,true));
this.codec_text = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_timePassedInSec = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ChatMessage = new ChatMessage();
local2.addressMode = this.codec_addressMode.decode(param1) as ChatAddressMode;
local2.battleLinks = this.codec_battleLinks.decode(param1) as Vector.<BattleChatLink>;
local2.channel = this.codec_channel.decode(param1) as String;
local2.links = this.codec_links.decode(param1) as Vector.<String>;
local2.messageType = this.codec_messageType.decode(param1) as MessageType;
local2.sourceUser = this.codec_sourceUser.decode(param1) as UserStatus;
local2.targetUser = this.codec_targetUser.decode(param1) as UserStatus;
local2.text = this.codec_text.decode(param1) as String;
local2.timePassedInSec = this.codec_timePassedInSec.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:ChatMessage = ChatMessage(param2);
this.codec_addressMode.encode(param1,local3.addressMode);
this.codec_battleLinks.encode(param1,local3.battleLinks);
this.codec_channel.encode(param1,local3.channel);
this.codec_links.encode(param1,local3.links);
this.codec_messageType.encode(param1,local3.messageType);
this.codec_sourceUser.encode(param1,local3.sourceUser);
this.codec_targetUser.encode(param1,local3.targetUser);
this.codec_text.encode(param1,local3.text);
this.codec_timePassedInSec.encode(param1,local3.timePassedInSec);
}
}
}
|
package alternativa.tanks.view.battlelist.modefilter {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battlelist.modefilter.BattleModeIcons_rugbyIconClass.png")]
public class BattleModeIcons_rugbyIconClass extends BitmapAsset {
public function BattleModeIcons_rugbyIconClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.panel {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.payment.panel.PaymentButtonCC;
public class VectorCodecPaymentButtonCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecPaymentButtonCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(PaymentButtonCC,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.<PaymentButtonCC> = new Vector.<PaymentButtonCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = PaymentButtonCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:PaymentButtonCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<PaymentButtonCC> = Vector.<PaymentButtonCC>(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.logic.updaters
{
public interface HullTransformUpdater
{
function reset() : void;
function update(param1:Number) : void;
}
}
|
package _codec.projects.tanks.client.panel.model.rulesupdate.showing {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.rulesupdate.showing.RulesUpdateShowingCC;
public class CodecRulesUpdateShowingCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_bottomText:ICodec;
private var codec_showAcceptRulesAlert:ICodec;
private var codec_topText:ICodec;
public function CodecRulesUpdateShowingCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_bottomText = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_showAcceptRulesAlert = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_topText = param1.getCodec(new TypeCodecInfo(String,true));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:RulesUpdateShowingCC = new RulesUpdateShowingCC();
local2.bottomText = this.codec_bottomText.decode(param1) as String;
local2.showAcceptRulesAlert = this.codec_showAcceptRulesAlert.decode(param1) as Boolean;
local2.topText = this.codec_topText.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:RulesUpdateShowingCC = RulesUpdateShowingCC(param2);
this.codec_bottomText.encode(param1,local3.bottomText);
this.codec_showAcceptRulesAlert.encode(param1,local3.showAcceptRulesAlert);
this.codec_topText.encode(param1,local3.topText);
}
}
}
|
package alternativa.osgi.service.console.variables {
public class ConsoleVarFloat extends ConsoleVar {
public var value:Number;
private var minValue:Number;
private var maxValue:Number;
public function ConsoleVarFloat(param1:String, param2:Number, param3:Number, param4:Number, param5:Function = null) {
super(param1,param5);
this.value = param2;
this.minValue = param3;
this.maxValue = param4;
}
override public function acceptInput(param1:String) : String {
var local2:Number = Number(param1);
if(isNaN(local2)) {
return "Incorrect number";
}
if(local2 < this.minValue || local2 > this.maxValue) {
return "Value is out of bounds [" + this.minValue + ", " + this.maxValue + "]";
}
this.value = local2;
if(inputListener != null) {
inputListener(this.value);
}
return null;
}
override public function toString() : String {
return this.value.toString();
}
}
}
|
package alternativa.tanks.models.battle.gui.ultimate {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon;
import alternativa.tanks.models.battle.gui.inventory.IInventoryPanel;
import alternativa.tanks.models.battle.gui.inventory.InventoryIcons;
import alternativa.tanks.models.battle.gui.inventory.InventoryModel;
import alternativa.tanks.models.battle.gui.inventory.InventoryPanelSlot;
import alternativa.tanks.models.battle.gui.inventory.InventorySoundService;
import alternativa.tanks.models.battle.gui.inventory.UltimateIcon;
import alternativa.tanks.models.battle.gui.inventory.cooldown.CooldownIndicator;
import alternativa.tanks.models.battle.gui.inventory.cooldown.InventoryCooldownItem;
import alternativa.tanks.models.battle.gui.inventory.readytouse.LightPillarEffect;
import alternativa.tanks.models.battle.gui.inventory.splash.SplashColor;
import alternativa.tanks.models.battle.gui.inventory.splash.SplashController;
import alternativa.tanks.models.inventory.InventoryItemType;
import alternativa.tanks.services.battlegui.BattleGUIService;
import alternativa.tanks.services.battlegui.BattleGUIServiceEvent;
import alternativa.tanks.services.battlegui.InventoryChangePositionEvent;
import alternativa.tanks.services.battleinput.BattleInputLockEvent;
import alternativa.tanks.services.battleinput.BattleInputService;
import alternativa.utils.removeDisplayObject;
import controls.Label;
import flash.display.Bitmap;
import flash.display.Sprite;
import flash.events.Event;
import flash.text.TextFieldAutoSize;
import flash.utils.clearInterval;
import flash.utils.clearTimeout;
import flash.utils.getTimer;
import flash.utils.setTimeout;
import forms.ColorConstants;
public class UltimateIndicator {
[Inject]
public static var battleInputService:BattleInputService;
[Inject]
public static var inventoryPanel:IInventoryPanel;
[Inject]
public static var display:IDisplay;
[Inject]
public static var battleGuiService:BattleGUIService;
[Inject]
public static var inventorySoundService:InventorySoundService;
private static const KEY_ICON_OFFSET_X:int = -6;
private static const KEY_ICON_OFFSET_Y:int = -20;
private static const ICON_SIZE:int = 78;
private var cooldownItem:InventoryCooldownItem;
private var splashController:SplashController;
private var cooldownIndicator:CooldownIndicator = new CooldownIndicator(HudInventoryIcon.getIcon(HudInventoryIcon.OVERDRIVE_COOLDOWN_OVERLAY));
private var inventoryIcon:InventoryIcons;
private var baseContainer:Sprite = new Sprite();
private var percentLabel:Label = new Label();
private var keyLabel:Label = new Label();
private var lockIcon:Bitmap;
private var disabled:Boolean = true;
private var charged:Boolean;
private var lightPillarEffect:LightPillarEffect = new LightPillarEffect();
private var resizeTimer:uint;
private var flashTimer:uint;
public function UltimateIndicator(param1:int) {
super();
this.lightPillarEffect.scaleX = 2;
this.baseContainer.addChild(this.lightPillarEffect);
var local2:Sprite = new Sprite();
this.baseContainer.addChild(local2);
var local3:Bitmap = new Bitmap(HudInventoryIcon.getIcon(HudInventoryIcon.OVERDRIVE_BG));
local2.addChild(local3);
var local4:CooldownIndicator = new CooldownIndicator(HudInventoryIcon.getBgdIcon(InventoryItemType.ULTIMATE));
this.inventoryIcon = new UltimateIcon(param1);
local2.addChild(this.inventoryIcon);
local2.addChild(this.cooldownIndicator);
this.keyLabel.text = "Shift";
this.keyLabel.x = ICON_SIZE - this.keyLabel.width + KEY_ICON_OFFSET_X;
this.keyLabel.y = ICON_SIZE + KEY_ICON_OFFSET_Y;
this.keyLabel.visible = false;
local2.addChild(this.keyLabel);
this.percentLabel.y = -19;
this.percentLabel.color = InventoryPanelSlot.QUANTITY_COLOR_WHITE;
this.percentLabel.autoSize = TextFieldAutoSize.CENTER;
this.percentLabel.filters = [InventoryPanelSlot.GLOW_FILTER];
local2.addChild(this.percentLabel);
this.setPercentText(0);
this.lockIcon = new Bitmap(HudInventoryIcon.getIcon(HudInventoryIcon.OVERDRIVE_COOLDOWN_OVERLAY));
this.lockIcon.visible = true;
local2.addChild(this.lockIcon);
local2.addChild(local4);
this.splashController = new SplashController(local2);
this.cooldownItem = new InventoryCooldownItem(InventoryItemType.ULTIMATE,local4,this.cooldownIndicator,this.splashController,this.inventoryIcon,this.finishEffectAndCooldown,this.startCooldownCallback,false);
this.onResize();
local2.visible = true;
battleGuiService.getGuiContainer().addChild(this.baseContainer);
display.stage.addEventListener(Event.RESIZE,this.onResize,false,int.MIN_VALUE);
display.stage.addEventListener(Event.ENTER_FRAME,this.onEnterFrame);
battleInputService.addEventListener(BattleInputLockEvent.INPUT_LOCKED,this.onInputLocked);
battleInputService.addEventListener(BattleInputLockEvent.INPUT_UNLOCKED,this.onInputUnlocked);
battleGuiService.addEventListener(InventoryChangePositionEvent.ON_CHANGE_POSITION,this.onResize);
}
private function startCooldownCallback() : void {
}
public function markDisabled(param1:Boolean) : void {
this.disabled = param1;
this.updateState();
}
private function onInputLocked(param1:BattleInputLockEvent) : void {
this.markDisabled(true);
}
private function onInputUnlocked(param1:BattleInputLockEvent) : void {
this.markDisabled(false);
}
private function updateState() : void {
this.disableVisual(this.disabled || !this.charged);
}
private function disableVisual(param1:Boolean) : void {
this.keyLabel.visible = !param1;
this.lockIcon.visible = param1;
this.percentLabel.color = param1 ? InventoryPanelSlot.QUANTITY_COLOR_GRAY : InventoryPanelSlot.QUANTITY_COLOR_WHITE;
}
public function updateCharge(param1:int) : void {
this.charged = param1 >= 100;
this.setPercentText(param1);
this.cooldownIndicator.setProgress(param1 / 100,1);
this.updateState();
}
private function setPercentText(param1:int) : void {
this.percentLabel.text = param1.toString() + " %";
this.percentLabel.x = ICON_SIZE - this.percentLabel.width >> 1;
}
public function onCharged() : void {
this.keyLabel.visible = true;
this.inventoryIcon.state = InventoryIcons.NEUTRAL_STATE;
this.flashIcon();
inventorySoundService.playReadySound(InventoryItemType.ULTIMATE);
this.lightPillarEffect.init(ColorConstants.WHITE);
this.lightPillarEffect.y = -this.lightPillarEffect.height + ICON_SIZE - 2;
this.lightPillarEffect.start();
this.flashTimer = setTimeout(this.flashIcon,350);
}
private function flashIcon() : void {
this.clearFlashTimer();
this.splashController.startFlash(SplashColor.WHITE);
}
private function onResize(param1:Event = null) : void {
if(this.resizeTimer == 0) {
this.resizeTimer = setTimeout(this.doResize,0);
battleGuiService.dispatchEvent(new BattleGUIServiceEvent(BattleGUIServiceEvent.ON_CHANGE_POSITION_DEFAULT_LAYOUT));
}
}
private function doResize() : void {
this.baseContainer.x = 10;
this.baseContainer.y = display.stage.stageHeight - InventoryModel.PANEL_OFFSET_Y - 40;
this.clearResizeTimer();
}
public function destroy() : void {
battleGuiService.removeEventListener(InventoryChangePositionEvent.ON_CHANGE_POSITION,this.onResize);
battleInputService.removeEventListener(BattleInputLockEvent.INPUT_LOCKED,this.onInputLocked);
battleInputService.removeEventListener(BattleInputLockEvent.INPUT_UNLOCKED,this.onInputUnlocked);
removeDisplayObject(this.baseContainer);
display.stage.removeEventListener(Event.RESIZE,this.onResize);
display.stage.removeEventListener(Event.ENTER_FRAME,this.onEnterFrame);
this.percentLabel = null;
this.baseContainer = null;
this.lockIcon = null;
this.clearFlashTimer();
this.clearResizeTimer();
}
public function activate() : void {
this.keyLabel.visible = false;
this.cooldownItem.activateCooldown(1);
}
private function finishEffectAndCooldown() : void {
this.inventoryIcon.state = InventoryIcons.COOLDOWN_STATE;
}
private function onEnterFrame(param1:Event) : void {
var local2:int = getTimer();
this.splashController.update(local2);
this.cooldownItem.update(local2);
this.lightPillarEffect.update(local2);
}
private function clearFlashTimer() : void {
if(this.flashTimer != 0) {
clearInterval(this.flashTimer);
this.flashTimer = 0;
}
}
private function clearResizeTimer() : void {
if(this.resizeTimer != 0) {
clearTimeout(this.resizeTimer);
this.resizeTimer = 0;
}
}
public function effectActivatedOrMerged(param1:int) : void {
this.cooldownItem.changeEffectTime(param1,false);
}
public function effectDeactivated() : void {
this.cooldownItem.stopEffect();
}
}
}
|
package projects.tanks.client.battleselect.model.battle.param {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.BattleCreateParameters;
public class BattleParamInfoCC {
private var _map:IGameObject;
private var _params:BattleCreateParameters;
public function BattleParamInfoCC(param1:IGameObject = null, param2:BattleCreateParameters = null) {
super();
this._map = param1;
this._params = param2;
}
public function get map() : IGameObject {
return this._map;
}
public function set map(param1:IGameObject) : void {
this._map = param1;
}
public function get params() : BattleCreateParameters {
return this._params;
}
public function set params(param1:BattleCreateParameters) : void {
this._params = param1;
}
public function toString() : String {
var local1:String = "BattleParamInfoCC [";
local1 += "map = " + this.map + " ";
local1 += "params = " + this.params + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.kits.serverlayoutkit {
import alternativa.tanks.gui.shop.shopitems.item.base.ButtonItemSkin;
import projects.tanks.client.panel.model.shop.clientlayoutkit.KitBundleViewCC;
public class KitBundleSkin extends ButtonItemSkin {
public function KitBundleSkin(param1:KitBundleViewCC) {
super();
normalState = param1.button.data;
overState = param1.buttonOver.data;
}
}
}
|
package alternativa.engine3d.loaders.collada {
use namespace collada;
public class DaeInput extends DaeElement {
public function DaeInput(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
public function get semantic() : String {
var local1:XML = data.@semantic[0];
return local1 == null ? null : local1.toString();
}
public function get source() : XML {
return data.@source[0];
}
public function get offset() : int {
var local1:XML = data.@offset[0];
return local1 == null ? 0 : int(parseInt(local1.toString(),10));
}
public function get setNum() : int {
var local1:XML = data.@set[0];
return local1 == null ? 0 : int(parseInt(local1.toString(),10));
}
public function prepareSource(param1:int) : DaeSource {
var local2:DaeSource = document.findSource(this.source);
if(local2 != null) {
local2.parse();
if(local2.numbers != null && local2.stride >= param1) {
return local2;
}
} else {
document.logger.logNotFoundError(data.@source[0]);
}
return null;
}
}
}
|
package alternativa.engine3d.animation {
import alternativa.engine3d.alternativa3d;
import flash.events.EventDispatcher;
use namespace alternativa3d;
public class AnimationNotify extends EventDispatcher {
public var name:String;
alternativa3d var _time:Number = 0;
alternativa3d var next:AnimationNotify;
alternativa3d var updateTime:Number;
alternativa3d var processNext:AnimationNotify;
public function AnimationNotify(param1:String) {
super();
this.name = param1;
}
public function get time() : Number {
return this.alternativa3d::_time;
}
}
}
|
package alternativa.engine3d.core {
import alternativa.gfx.agal.FragmentShader;
import alternativa.gfx.agal.SamplerDim;
import alternativa.gfx.agal.SamplerFilter;
import alternativa.gfx.agal.SamplerMipMap;
import alternativa.gfx.agal.SamplerRepeat;
public class DepthRendererBlurFragmentShader extends FragmentShader {
public function DepthRendererBlurFragmentShader() {
super();
mov(ft1,v0);
tex(ft0,ft1,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
sub(ft1.y,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
sub(ft1.x,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
add(ft1.y,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
add(ft1.y,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
add(ft1.y,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
add(ft1.x,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
add(ft1.x,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
add(ft1.x,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
sub(ft1.y,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
sub(ft1.y,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
sub(ft1.y,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
sub(ft1.x,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
add(ft1.y,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
add(ft1.y,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
sub(ft1.x,ft1,fc[0]);
min(ft2,ft1,fc[1]);
tex(ft2,ft2,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
add(ft0.w,ft0,ft2);
mul(ft0.w,ft0,fc[0]);
mov(oc,ft0);
}
}
}
|
package alternativa.tanks.model.shop
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import controls.TankWindowInner;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
public class ShowWindowHeader extends Sprite
{
public static var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
[Embed(source="881.png")]
private static var crystalsImageClass:Class;
private static const crystalsImage:BitmapData = new crystalsImageClass().bitmapData;
public static const WINDOW_MARGIN:int = 11;
private var headerIcon:Bitmap;
private var header:LabelBase;
private var headerInner:TankWindowInner;
private var doubleCrystallsHeader:LabelBase;
public function ShowWindowHeader()
{
this.doubleCrystallsHeader = new LabelBase();
super();
this.headerInner = new TankWindowInner(0,0,TankWindowInner.TRANSPARENT);
addChild(this.headerInner);
this.headerIcon = new Bitmap(crystalsImage);
addChild(this.headerIcon);
this.headerIcon.x = WINDOW_MARGIN;
this.headerIcon.y = 5;
this.header = new LabelBase();
addChild(this.header);
this.header.multiline = true;
this.header.wordWrap = true;
this.header.x = this.headerIcon.x + this.headerIcon.width + WINDOW_MARGIN;
this.header.htmlText = "Здесь вы можете купить различные предметы, которые помогут вам разнообразить игру и могут быть полезными в битвах. Вы соглашаетесь с тем, что купленные предметы будут зачислены на ваш аккаунт после завершения оплаты. Купленные предметы, которые были зачислены на ваш аккаунт, не подлежат возврату.";
if(ShopWindow.haveDoubleCrystalls)
{
this.doubleCrystallsHeader.multiline = true;
this.doubleCrystallsHeader.wordWrap = true;
this.doubleCrystallsHeader.x = this.headerIcon.x + this.headerIcon.width + WINDOW_MARGIN;
this.doubleCrystallsHeader.htmlText = "<font color=\"#ffbe23\" size=\"+5\">У вас есть бонусная карта \"Двойной кристалл\"!\nСколько бы кристаллов вы ни купили, ещё столько же получите от нас в подарок!</font>";
this.doubleCrystallsHeader.bold = true;
this.doubleCrystallsHeader.color = 16760355;
addChild(this.doubleCrystallsHeader);
}
}
public function resize(width:int) : void
{
this.headerInner.width = width;
this.headerInner.height = this.headerIcon.height + (!!ShopWindow.haveDoubleCrystalls ? 55 : 35);
this.header.width = width - this.header.x - WINDOW_MARGIN;
this.header.y = this.headerIcon.y + (this.headerIcon.height - this.header.textHeight >> 1);
this.doubleCrystallsHeader.width = width - this.header.x - WINDOW_MARGIN;
this.doubleCrystallsHeader.y = this.header.y + this.header.height;
}
override public function get height() : Number
{
return this.headerInner.height;
}
}
}
|
package alternativa.tanks.model.payment.category {
import alternativa.tanks.gui.payment.forms.PayModeForm;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class PayModeViewAdapt implements PayModeView {
private var object:IGameObject;
private var impl:PayModeView;
public function PayModeViewAdapt(param1:IGameObject, param2:PayModeView) {
super();
this.object = param1;
this.impl = param2;
}
public function getView() : PayModeForm {
var result:PayModeForm = null;
try {
Model.object = this.object;
result = this.impl.getView();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package controls.base {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.base.TankInput_leftClass.png")]
public class TankInput_leftClass extends BitmapAsset {
public function TankInput_leftClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.meteors {
import platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity.LightEffectItem;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class MeteorStormCC {
private var _bigSplashRadius:Number;
private var _craterDecal:TextureResource;
private var _currentMeteors:Vector.<MeteorDescriptor>;
private var _impactSoundTimelabel:int;
private var _meteorArrivingSound:SoundResource;
private var _meteorDistantSound:SoundResource;
private var _meteorFlyDistance:Number;
private var _meteorModel:Tanks3DSResource;
private var _meteorSpeed:Number;
private var _nuclearBangFlame:TextureResource;
private var _nuclearBangLight:TextureResource;
private var _nuclearBangSmoke:TextureResource;
private var _nuclearBangSound:SoundResource;
private var _nuclearBangWave:TextureResource;
private var _preferredFallAngle:Number;
private var _smallSplashRadius:Number;
private var _splashDamageImpact:Number;
private var _splashDamageMinPercent:Number;
private var _tailFlame:TextureResource;
private var _tailLight:Vector.<LightEffectItem>;
private var _tailSmoke:TextureResource;
public function MeteorStormCC(param1:Number = 0, param2:TextureResource = null, param3:Vector.<MeteorDescriptor> = null, param4:int = 0, param5:SoundResource = null, param6:SoundResource = null, param7:Number = 0, param8:Tanks3DSResource = null, param9:Number = 0, param10:TextureResource = null, param11:TextureResource = null, param12:TextureResource = null, param13:SoundResource = null, param14:TextureResource = null, param15:Number = 0, param16:Number = 0, param17:Number = 0, param18:Number = 0, param19:TextureResource = null, param20:Vector.<LightEffectItem> = null, param21:TextureResource = null) {
super();
this._bigSplashRadius = param1;
this._craterDecal = param2;
this._currentMeteors = param3;
this._impactSoundTimelabel = param4;
this._meteorArrivingSound = param5;
this._meteorDistantSound = param6;
this._meteorFlyDistance = param7;
this._meteorModel = param8;
this._meteorSpeed = param9;
this._nuclearBangFlame = param10;
this._nuclearBangLight = param11;
this._nuclearBangSmoke = param12;
this._nuclearBangSound = param13;
this._nuclearBangWave = param14;
this._preferredFallAngle = param15;
this._smallSplashRadius = param16;
this._splashDamageImpact = param17;
this._splashDamageMinPercent = param18;
this._tailFlame = param19;
this._tailLight = param20;
this._tailSmoke = param21;
}
public function get bigSplashRadius() : Number {
return this._bigSplashRadius;
}
public function set bigSplashRadius(param1:Number) : void {
this._bigSplashRadius = param1;
}
public function get craterDecal() : TextureResource {
return this._craterDecal;
}
public function set craterDecal(param1:TextureResource) : void {
this._craterDecal = param1;
}
public function get currentMeteors() : Vector.<MeteorDescriptor> {
return this._currentMeteors;
}
public function set currentMeteors(param1:Vector.<MeteorDescriptor>) : void {
this._currentMeteors = param1;
}
public function get impactSoundTimelabel() : int {
return this._impactSoundTimelabel;
}
public function set impactSoundTimelabel(param1:int) : void {
this._impactSoundTimelabel = param1;
}
public function get meteorArrivingSound() : SoundResource {
return this._meteorArrivingSound;
}
public function set meteorArrivingSound(param1:SoundResource) : void {
this._meteorArrivingSound = param1;
}
public function get meteorDistantSound() : SoundResource {
return this._meteorDistantSound;
}
public function set meteorDistantSound(param1:SoundResource) : void {
this._meteorDistantSound = param1;
}
public function get meteorFlyDistance() : Number {
return this._meteorFlyDistance;
}
public function set meteorFlyDistance(param1:Number) : void {
this._meteorFlyDistance = param1;
}
public function get meteorModel() : Tanks3DSResource {
return this._meteorModel;
}
public function set meteorModel(param1:Tanks3DSResource) : void {
this._meteorModel = param1;
}
public function get meteorSpeed() : Number {
return this._meteorSpeed;
}
public function set meteorSpeed(param1:Number) : void {
this._meteorSpeed = param1;
}
public function get nuclearBangFlame() : TextureResource {
return this._nuclearBangFlame;
}
public function set nuclearBangFlame(param1:TextureResource) : void {
this._nuclearBangFlame = param1;
}
public function get nuclearBangLight() : TextureResource {
return this._nuclearBangLight;
}
public function set nuclearBangLight(param1:TextureResource) : void {
this._nuclearBangLight = param1;
}
public function get nuclearBangSmoke() : TextureResource {
return this._nuclearBangSmoke;
}
public function set nuclearBangSmoke(param1:TextureResource) : void {
this._nuclearBangSmoke = param1;
}
public function get nuclearBangSound() : SoundResource {
return this._nuclearBangSound;
}
public function set nuclearBangSound(param1:SoundResource) : void {
this._nuclearBangSound = param1;
}
public function get nuclearBangWave() : TextureResource {
return this._nuclearBangWave;
}
public function set nuclearBangWave(param1:TextureResource) : void {
this._nuclearBangWave = param1;
}
public function get preferredFallAngle() : Number {
return this._preferredFallAngle;
}
public function set preferredFallAngle(param1:Number) : void {
this._preferredFallAngle = param1;
}
public function get smallSplashRadius() : Number {
return this._smallSplashRadius;
}
public function set smallSplashRadius(param1:Number) : void {
this._smallSplashRadius = param1;
}
public function get splashDamageImpact() : Number {
return this._splashDamageImpact;
}
public function set splashDamageImpact(param1:Number) : void {
this._splashDamageImpact = param1;
}
public function get splashDamageMinPercent() : Number {
return this._splashDamageMinPercent;
}
public function set splashDamageMinPercent(param1:Number) : void {
this._splashDamageMinPercent = param1;
}
public function get tailFlame() : TextureResource {
return this._tailFlame;
}
public function set tailFlame(param1:TextureResource) : void {
this._tailFlame = param1;
}
public function get tailLight() : Vector.<LightEffectItem> {
return this._tailLight;
}
public function set tailLight(param1:Vector.<LightEffectItem>) : void {
this._tailLight = param1;
}
public function get tailSmoke() : TextureResource {
return this._tailSmoke;
}
public function set tailSmoke(param1:TextureResource) : void {
this._tailSmoke = param1;
}
public function toString() : String {
var local1:String = "MeteorStormCC [";
local1 += "bigSplashRadius = " + this.bigSplashRadius + " ";
local1 += "craterDecal = " + this.craterDecal + " ";
local1 += "currentMeteors = " + this.currentMeteors + " ";
local1 += "impactSoundTimelabel = " + this.impactSoundTimelabel + " ";
local1 += "meteorArrivingSound = " + this.meteorArrivingSound + " ";
local1 += "meteorDistantSound = " + this.meteorDistantSound + " ";
local1 += "meteorFlyDistance = " + this.meteorFlyDistance + " ";
local1 += "meteorModel = " + this.meteorModel + " ";
local1 += "meteorSpeed = " + this.meteorSpeed + " ";
local1 += "nuclearBangFlame = " + this.nuclearBangFlame + " ";
local1 += "nuclearBangLight = " + this.nuclearBangLight + " ";
local1 += "nuclearBangSmoke = " + this.nuclearBangSmoke + " ";
local1 += "nuclearBangSound = " + this.nuclearBangSound + " ";
local1 += "nuclearBangWave = " + this.nuclearBangWave + " ";
local1 += "preferredFallAngle = " + this.preferredFallAngle + " ";
local1 += "smallSplashRadius = " + this.smallSplashRadius + " ";
local1 += "splashDamageImpact = " + this.splashDamageImpact + " ";
local1 += "splashDamageMinPercent = " + this.splashDamageMinPercent + " ";
local1 += "tailFlame = " + this.tailFlame + " ";
local1 += "tailLight = " + this.tailLight + " ";
local1 += "tailSmoke = " + this.tailSmoke + " ";
return local1 + "]";
}
}
}
|
package _codec.platform.client.core.general.socialnetwork.models.socialnetworkparameters {
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.core.general.socialnetwork.models.socialnetworkparameters.SocialNetworkParametersCC;
public class CodecSocialNetworkParametersCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_hasOwnPaymentSystem:ICodec;
private var codec_hasSocialFunction:ICodec;
public function CodecSocialNetworkParametersCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_hasOwnPaymentSystem = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_hasSocialFunction = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:SocialNetworkParametersCC = new SocialNetworkParametersCC();
local2.hasOwnPaymentSystem = this.codec_hasOwnPaymentSystem.decode(param1) as Boolean;
local2.hasSocialFunction = this.codec_hasSocialFunction.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:SocialNetworkParametersCC = SocialNetworkParametersCC(param2);
this.codec_hasOwnPaymentSystem.encode(param1,local3.hasOwnPaymentSystem);
this.codec_hasSocialFunction.encode(param1,local3.hasSocialFunction);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.payment {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class PayModeProceedAdapt implements PayModeProceed {
private var object:IGameObject;
private var impl:PayModeProceed;
public function PayModeProceedAdapt(param1:IGameObject, param2:PayModeProceed) {
super();
this.object = param1;
this.impl = param2;
}
public function proceedPayment() : void {
try {
Model.object = this.object;
this.impl.proceedPayment();
}
finally {
Model.popObject();
}
}
}
}
|
package platform.client.core.general.socialnetwork.models.telegram {
public interface ITelegramSocialLoginModelBase {
}
}
|
package projects.tanks.client.garage.skins {
import platform.client.fp10.core.type.IGameObject;
public class AvailableSkinsCC {
private var _skins:Vector.<IGameObject>;
public function AvailableSkinsCC(param1:Vector.<IGameObject> = null) {
super();
this._skins = param1;
}
public function get skins() : Vector.<IGameObject> {
return this._skins;
}
public function set skins(param1:Vector.<IGameObject>) : void {
this._skins = param1;
}
public function toString() : String {
var local1:String = "AvailableSkinsCC [";
local1 += "skins = " + this.skins + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.controllers.battleinfo {
import alternativa.types.Long;
import flash.events.EventDispatcher;
import platform.client.fp10.core.type.IGameObject;
public class EmptyBattleInfoController extends EventDispatcher implements IBattleInfoController {
public function EmptyBattleInfoController() {
super();
}
public function addFormToStage() : void {
}
public function removeFormFromStage() : void {
}
public function hideForm() : void {
}
public function removeUser(param1:Long) : void {
}
public function updateUserScore(param1:Long, param2:int) : void {
}
public function updateUserSuspiciousState(param1:Long, param2:Boolean) : void {
}
public function roundStart(param1:int) : void {
}
public function roundFinish() : void {
}
public function battleStop() : void {
}
public function getSelectedBattle() : IGameObject {
return null;
}
public function updateBattleName() : void {
}
}
}
|
package alternativa {
import alternativa.launcher.ServerConfigLoader;
import alternativa.launcher.ServerConfigLoaderListener;
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.osgi.service.launcherparams.LauncherParams;
import alternativa.osgi.service.serverlog.ServerLoggingService;
import alternativa.osgi.service.serverlog.ServerLoggingServiceImpl;
import alternativa.startup.CacheURLLoader;
import alternativa.startup.ConnectionParameters;
import alternativa.startup.IClientConfigurator;
import alternativa.startup.LibraryInfo;
import alternativa.startup.StartupSettings;
import alternativa.types.DummyListener;
import alternativa.types.LogOutput;
import flash.display.DisplayObjectContainer;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLLoader;
import flash.net.URLLoaderDataFormat;
import flash.net.URLRequest;
import flash.net.URLRequestMethod;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import flash.utils.ByteArray;
public class Launcher implements ServerConfigLoaderListener {
private var container:DisplayObjectContainer;
private var listener:ILauncherListener;
private var osgi:OSGi;
private var debugMode:Boolean;
private var logOutput:LogOutput;
private var libraryInfos:Vector.<LibraryInfo> = new Vector.<LibraryInfo>();
private var loadingLibrary:LibraryInfo;
private var logStrings:Vector.<String> = new Vector.<String>();
private var connectionParams:ConnectionParameters;
private var params:LauncherParams;
private var configLoader:ServerConfigLoader;
public function Launcher(param1:DisplayObjectContainer, param2:LauncherParams, param3:ILauncherListener = null) {
super();
if(param1 == null) {
throw new ArgumentError("Parameter container is null");
}
if(param2 == null) {
throw new ArgumentError("Parameter params is null");
}
this.osgi = OSGi.getInstance();
this.osgi.registerService(Launcher,this);
this.osgi.registerService(ServerLoggingService,new ServerLoggingServiceImpl(param2));
this.debugMode = param2.isDebug;
this.container = param1;
this.listener = param3 || new DummyListener(this.logOutput);
this.params = param2;
if(this.debugMode) {
this.logOutput = new LogOutput();
param1.addChild(this.logOutput);
}
this.log("Debug mode: " + this.debugMode);
}
public static function findClass(param1:String) : Class {
return Class(ApplicationDomain.currentDomain.getDefinition(param1));
}
public function start() : void {
this.configLoader = new ServerConfigLoader(this.params,this);
this.configLoader.loadServerConfiguration();
}
public function onServerConfigLoadingStart() : void {
this.listener.onConfigLoadingStart();
}
public function onServerUnavailable() : void {
this.listener.onServerUnavailable();
}
public function onServerOverloaded() : void {
this.listener.onServerOverloaded();
}
public function onServerConfigParsed(param1:ConnectionParameters) : void {
this.connectionParams = param1;
this.listener.onLibrariesLoadingStart();
this.loadLibrariesManifest();
}
private function getLibsUrl() : String {
var local1:String = this.connectionParams.resourcesRootURL;
var local2:int = int(local1.indexOf("resources/"));
var local3:String = local2 == -1 ? local1 : local1.substr(0,local2);
return local3 + "libs/";
}
private function loadLibrariesManifest() : void {
var local1:String = this.getLibsUrl() + "manifest.json?rand=" + Math.random();
var local2:URLRequest = new URLRequest(local1);
local2.method = URLRequestMethod.GET;
var local3:URLLoader = new URLLoader();
local3.addEventListener(Event.COMPLETE,this.onLibrariesManifestLoaded);
local3.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadingManifestError);
local3.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadingManifestError);
local3.load(local2);
}
private function onLibrariesManifestLoaded(param1:Event) : void {
var key:String = null;
var event:Event = param1;
var result:Object = JSON.parse(unescape(event.target.data));
var rootPath:String = this.getLibsUrl();
this.libraryInfos = new Vector.<LibraryInfo>();
for(key in result) {
this.libraryInfos.push(new LibraryInfo(key,rootPath + result[key]));
}
this.listener.onLibrariesLoadingStart();
this.loadLibrary("entrance.swf",function():void {
listener.onLibrariesLoadingComplete(params,function():void {
connectToServer();
initLibrary("EntranceActivator");
listener.onLibrariesInitialized();
if(debugMode) {
logOutput.parent.removeChild(logOutput);
}
});
});
}
private function onLoadingManifestError(param1:ErrorEvent) : void {
this.listener.onLibraryLoadingError("Loading manifest error: url = " + this.getLibsUrl() + "manifest.json, error=#" + param1.errorID);
}
public function loadLibrary(param1:String, param2:Function) : void {
var local3:* = undefined;
var local4:URLRequest = null;
var local5:CacheURLLoader = null;
for each(local3 in this.libraryInfos) {
if(local3.name == param1) {
this.loadingLibrary = local3;
break;
}
}
local3.loadingCallback = param2;
this.log("Loading library " + local3.name + " from " + local3.url);
local4 = new URLRequest(local3.url);
local5 = new CacheURLLoader();
local5.dataFormat = URLLoaderDataFormat.BINARY;
local5.addEventListener(Event.COMPLETE,this.byteArrayLoadComplete);
local5.addEventListener(IOErrorEvent.IO_ERROR,this.onLibraryLoadingError);
local5.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLibraryLoadingError);
local5.load(local4);
}
private function byteArrayLoadComplete(param1:Event) : void {
var local2:ByteArray = URLLoader(param1.target).data as ByteArray;
var local3:ByteArray = new ByteArray();
local3.writeBytes(local2,local2.position,local2.bytesAvailable);
var local4:Loader = new Loader();
this.loadingLibrary.loader = local4;
var local5:LoaderInfo = local4.contentLoaderInfo;
local5.addEventListener(Event.COMPLETE,this.onLibraryLoadingComplete);
local5.addEventListener(IOErrorEvent.IO_ERROR,this.onLibraryLoadingError);
local5.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLibraryLoadingError);
var local6:LoaderContext = new LoaderContext(false,ApplicationDomain.currentDomain);
if(StartupSettings.isDesktop) {
local6.allowCodeImport = true;
}
local4.loadBytes(local3,local6);
}
public function onServerConfigLoadingError(param1:String) : void {
this.log(param1);
this.listener.onConfigLoadingError(param1);
}
public function onServerConfigLoadingProgress(param1:uint, param2:uint) : void {
this.listener.onConfigLoadingProgress(param1,param2);
}
public function onServerConfigLoadingComplete() : void {
this.listener.onConfigLoadingComplete();
}
public function initLibrary(param1:String) : void {
var local2:Class = findClass(param1);
IBundleActivator(new local2()).start(OSGi.getInstance());
}
private function connectToServer() : void {
var local1:Class = findClass("alternativa.ClientConfigurator");
IClientConfigurator(new local1()).start(this.container,this.params,this.connectionParams,this.logStrings);
this.connectionParams = null;
}
private function onLibraryLoadingComplete(param1:Event) : void {
var local2:LoaderInfo = LoaderInfo(param1.target);
local2.removeEventListener(Event.COMPLETE,this.onLibraryLoadingComplete);
local2.removeEventListener(IOErrorEvent.IO_ERROR,this.onLibraryLoadingError);
local2.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLibraryLoadingError);
var local3:LibraryInfo = this.loadingLibrary;
this.loadingLibrary = null;
local3.loadingCallback();
local3.loadingCallback = null;
}
private function onLibraryLoadingError(param1:IOErrorEvent) : void {
this.log(param1.text);
this.listener.onLibraryLoadingError(param1.text);
}
public function log(param1:String) : void {
this.logStrings.push(param1);
if(this.debugMode) {
this.logOutput.addLine(param1);
}
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.facilities.facillity {
public interface ICommonFacilityModelBase {
function markAsDispelled() : void;
}
}
|
package alternativa.tanks.gui.panel.buttons {
import alternativa.tanks.gui.friends.button.friends.NewRequestIndicator;
import flash.display.Bitmap;
import flash.display.BitmapData;
public class FriendsButton extends MainPanelSmallButton {
private static const SHOW_FRIENDS_BITMAP:Class = FriendsButton_SHOW_FRIENDS_BITMAP;
private static const SHOW_FRIENDS_BITMAP_DATA:BitmapData = Bitmap(new SHOW_FRIENDS_BITMAP()).bitmapData;
public function FriendsButton() {
super(SHOW_FRIENDS_BITMAP_DATA,1,1);
var local1:NewRequestIndicator = new NewRequestIndicator();
addChild(local1);
local1.x = 10;
local1.y = -4;
}
}
}
|
package alternativa.tanks.utils {
public class PhysicsErrorEvent {
public function PhysicsErrorEvent() {
super();
}
}
}
|
package alternativa.tanks.gui.alerts {
import alternativa.tanks.service.upgradingitems.ItemInfo;
import projects.tanks.client.commons.types.ItemGarageProperty;
import projects.tanks.client.panel.model.garage.GarageItemInfo;
public class UpgradedItemsAlert extends ItemsAlert {
public function UpgradedItemsAlert(param1:Vector.<ItemInfo>, param2:String, param3:String) {
super(param2,param3,this.addItems,param1);
}
private function addItems(param1:Vector.<ItemInfo>) : void {
var local4:ItemInfo = null;
var local5:Vector.<ItemGarageProperty> = null;
var local6:GarageItemInfo = null;
var local7:int = 0;
var local2:int = int(param1.length);
var local3:int = 0;
while(local3 < local2) {
local4 = param1[local3];
local5 = local4.resistances;
local6 = local4.info;
local7 = 0;
partsList.addItem(local6.item,local6.name,local6.category,local6.position,0,local7,false,true,0,local6.preview,0,null,local6.modificationIndex,null,local5,true);
local3++;
}
}
}
}
|
package projects.tanks.client.battlefield.models.user.turnover {
public interface ITankTurnOverModelBase {
}
}
|
package alternativa.tanks.models.weapon.railgun {
import alternativa.engine3d.materials.Material;
import alternativa.math.Vector3;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class ShotTrailEffect extends PooledObject implements GraphicEffect {
private var container:Scene3DContainer;
private var trail:ShotTrail;
private var startPoint:Vector3 = new Vector3();
private var direction:Vector3 = new Vector3();
private var beginScale:Number;
private var endScale:Number;
private var moveDistance:Number;
private var lifeTime:int;
private var time:int;
public function ShotTrailEffect(param1:Pool) {
super(param1);
this.trail = new ShotTrail();
}
public function init(param1:Vector3, param2:Vector3, param3:Material, param4:Number, param5:Number, param6:Number, param7:Number, param8:int) : void {
this.startPoint.copy(param1);
this.direction.diff(param2,param1);
var local9:Number = this.direction.length();
this.direction.scale(1 / local9);
this.beginScale = param5;
this.endScale = param6;
this.moveDistance = param7;
this.lifeTime = param8;
this.trail.init(param4,local9,param3,param7);
this.time = 0;
}
public function play(param1:int, param2:GameCamera) : Boolean {
var local4:Number = NaN;
if(this.time > this.lifeTime) {
return false;
}
SFXUtils.alignObjectPlaneToView(this.trail,this.startPoint,this.direction,param2.position);
var local3:Number = this.time / this.lifeTime;
local4 = Math.sqrt(local3);
this.trail.scaleX = this.beginScale + (this.endScale - this.beginScale) * local4;
this.trail.alpha = 1 - local3;
this.trail.update(local4);
this.time += param1;
return true;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.trail);
}
public function destroy() : void {
this.trail.clear();
this.container.removeChild(this.trail);
this.container = null;
recycle();
}
public function kill() : void {
this.time = this.lifeTime + 1;
}
}
}
|
package controls.buttons {
import controls.buttons.h30px.H30ButtonSkin;
import flash.display.Bitmap;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
public class IconButton extends FixedHeightButton {
protected var icon:Bitmap;
public function IconButton(param1:String, param2:Class) {
super(new CategoryButtonSkin());
enabled = true;
labelSize = H30ButtonSkin.DEFAULT_LABEL_SIZE;
labelHeight = H30ButtonSkin.DEFAULT_LABEL_HEIGHT;
labelPositionY = H30ButtonSkin.DEFAULT_LABEL_Y;
_label.align = TextFormatAlign.LEFT;
_label.autoSize = TextFieldAutoSize.LEFT;
_label.text = param1;
this.icon = new param2();
_innerLayer.addChild(this.icon);
this.alignIcon();
}
override public function set width(param1:Number) : void {
if(_label.visible) {
if(Boolean(this.icon) && this.icon.visible) {
_label.x = 21 + (param1 - 21 - _label.width >> 1);
} else {
_label.x = param1 - _label.width >> 1;
}
}
super.width = param1;
}
protected function alignIcon() : void {
this.icon.x = 30 - this.icon.bitmapData.width >> 1;
this.icon.y = 30 - this.icon.bitmapData.height >> 1;
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank14.png")]
public class PremiumRankBitmaps_bitmapSmallRank14 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank14() {
super();
}
}
}
|
package projects.tanks.client.partners.impl.china.chinamobilesdk.auth {
public interface IChinaMobileSDKEntranceModelBase {
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.base {
public class GreyShopItemSkin extends ButtonItemSkin {
private static const normalStateClass:Class = GreyShopItemSkin_normalStateClass;
private static const overStateClass:Class = GreyShopItemSkin_overStateClass;
public function GreyShopItemSkin() {
super();
normalState = new normalStateClass().bitmapData;
overState = new overStateClass().bitmapData;
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.terminal {
import platform.client.fp10.core.resource.types.ImageResource;
public class TerminalInstance {
private var _image:ImageResource;
private var _url:String;
public function TerminalInstance(param1:ImageResource = null, param2:String = null) {
super();
this._image = param1;
this._url = param2;
}
public function get image() : ImageResource {
return this._image;
}
public function set image(param1:ImageResource) : void {
this._image = param1;
}
public function get url() : String {
return this._url;
}
public function set url(param1:String) : void {
this._url = param1;
}
public function toString() : String {
var local1:String = "TerminalInstance [";
local1 += "image = " + this.image + " ";
local1 += "url = " + this.url + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.controls {
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import projects.tanks.clients.fp10.Prelauncher.Locale;
public class LocalizedControl extends Sprite {
public function LocalizedControl() {
super();
addEventListener(Event.ADDED_TO_STAGE,this.addedToStage);
}
private function addedToStage(e:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.addedToStage);
addEventListener(Event.REMOVED_FROM_STAGE,this.removedFromStage);
addEventListener(Event.RESIZE,this.onResize);
this.onResize(null);
}
private function removedFromStage(e:Event) : void {
removeEventListener(Event.REMOVED_FROM_STAGE,this.removedFromStage);
removeEventListener(Event.RESIZE,this.onResize);
}
protected function onResize(e:Event) : void {
}
public function switchLocale(locale:Locale) : void {
}
protected function addChildToCenter(child:DisplayObject) : void {
addChild(child);
child.x = -child.width >> 1;
child.y = -child.height >> 1;
}
}
}
|
package alternativa.tanks.models.ctf
{
public class CTFFlagState
{
public static const AT_BASE:CTFFlagState = new CTFFlagState(0,"AT_BASE");
public static const DROPPED:CTFFlagState = new CTFFlagState(1,"DROPPED");
public static const CARRIED:CTFFlagState = new CTFFlagState(2,"CARRIED");
private var _value:int;
private var _stringValue:String;
public function CTFFlagState(value:int, stringValue:String)
{
super();
this._value = value;
this._stringValue = stringValue;
}
public function get value() : int
{
return this._value;
}
public function toString() : String
{
return "CTFFlagState [" + this._stringValue + "]";
}
}
}
|
package alternativa.gfx.agal
{
import flash.utils.ByteArray;
public class Register
{
protected var parent:Register;
protected var swizzle:int = 228;
protected var destMask:int = 15;
protected var index:int;
protected var emitCode:int;
protected var relOffset:int;
protected var relType:int;
protected var relSel:uint;
public function Register()
{
super();
}
public static function get(param1:int = 228, param2:int = 15, param3:Register = null) : Register
{
var _loc4_:Register = new Register();
_loc4_.parent = param3;
if(param3 != null)
{
_loc4_.index = param3.index;
_loc4_.emitCode = param3.emitCode;
}
_loc4_.swizzle = param1;
_loc4_.destMask = param2;
return _loc4_;
}
protected static function getSwizzle(param1:int = 0, param2:int = 1, param3:int = 2, param4:int = 3) : int
{
return param1 | param2 << 2 | param3 << 4 | param4 << 6;
}
protected static function getDestMask(param1:Boolean, param2:Boolean, param3:Boolean, param4:Boolean) : int
{
var _loc5_:int = 0;
if(param1)
{
_loc5_ |= 1;
}
if(param2)
{
_loc5_ |= 2;
}
if(param3)
{
_loc5_ |= 4;
}
if(param4)
{
_loc5_ |= 8;
}
return _loc5_;
}
public function writeDest(param1:ByteArray) : void
{
param1.writeShort(this.parent != null ? int(int(this.parent.index)) : int(int(this.index)));
param1.writeByte(this.destMask);
param1.writeByte(this.parent != null ? int(int(this.parent.emitCode)) : int(int(this.emitCode)));
}
public function writeSource(param1:ByteArray) : void
{
param1.writeShort(this.parent != null ? int(int(this.parent.index)) : int(int(this.index)));
param1.writeByte(this.parent != null ? int(int(this.parent.relOffset)) : int(int(this.relOffset)));
param1.writeByte(this.swizzle);
param1.writeByte(this.parent != null ? int(int(this.parent.emitCode)) : int(int(this.emitCode)));
param1.writeByte(this.parent != null ? int(int(this.parent.relType)) : int(int(this.relType)));
param1.writeShort(this.parent != null ? int(int(this.parent.relSel)) : int(int(this.relSel)));
}
protected function relate(param1:Register, param2:uint) : void
{
this.relType = param1.emitCode;
this.index = param1.index;
if((param1.destMask & param1.destMask - 1) != 0)
{
throw new Error("Register must has simple swizzle: .x, .y, .z, .w");
}
this.relSel = Math.log(param1.destMask) / Math.LN2;
this.relSel |= 1 << 15;
this.relOffset = param2;
}
}
}
|
package alternativa.tanks.models.battlefield.mine
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.osgi.service.log.LogLevel;
import alternativa.physics.collision.primitives.CollisionSphere;
import alternativa.service.Logger;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.weapon.shaft.ShaftModel;
import alternativa.tanks.models.weapon.shaft.states.ShaftModes;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.sfx.Blinker;
import flash.geom.ColorTransform;
import flash.utils.getTimer;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
public class ProximityMine
{
private static const FLASH_GROW:int = 1;
private static const FLASH_FADE:int = 2;
private static const FLASH_DONE:int = 3;
private static const INITIAL_BLINK_INTERVAL:int = 320;
private static const MIN_BLINK_INTERVAL:int = 22;
private static const BLINK_INTERVAL_DECREMENT:int = 12;
private static const ALPHA_MIN:Number = 0.2;
private static const BLINK_SPEED_COEFF:Number = 10;
private static var _vector:Vector3 = new Vector3();
private static var pool:ProximityMine;
public var id:String;
public var ownerId:String;
public var hitCommandSent:Boolean;
public var collisionPrimitive:CollisionSphere;
public var position:Vector3;
public var normal:Vector3;
public var next:ProximityMine;
public var prev:ProximityMine;
private var teamType:BattleTeamType;
private var mesh:Mesh;
private var armed:Boolean;
private var mineModelData:MineModelData;
private var flashBaseTime:int;
private var flashState:int;
private var colorTransform:ColorTransform;
private var blinker:Blinker;
public function ProximityMine(referenceMesh:Mesh)
{
this.collisionPrimitive = new CollisionSphere(1,CollisionGroup.WEAPON);
this.position = new Vector3();
this.normal = new Vector3();
this.colorTransform = new ColorTransform();
this.blinker = new Blinker(INITIAL_BLINK_INTERVAL,MIN_BLINK_INTERVAL,BLINK_INTERVAL_DECREMENT,ALPHA_MIN,1,BLINK_SPEED_COEFF);
super();
this.mesh = Mesh(referenceMesh.clone());
}
public static function create(id:String, ownerId:String, proximityRadius:Number, referenceMesh:Mesh, material:Material, teamType:BattleTeamType, mineModelData:MineModelData) : ProximityMine
{
var mine:ProximityMine = null;
if(pool == null)
{
mine = new ProximityMine(referenceMesh);
}
else
{
mine = pool;
pool = pool.next;
mine.next = null;
}
mine.init(id,ownerId,proximityRadius,material,teamType,mineModelData);
return mine;
}
public function dispose() : void
{
this.id = null;
this.ownerId = null;
this.mesh.alternativa3d::removeFromParent();
this.mineModelData = null;
this.prev = null;
this.next = pool == null ? null : pool;
pool = this;
}
public function arm() : void
{
this.armed = true;
this.flashBaseTime = getTimer();
this.flashState = FLASH_GROW;
this.mesh.colorTransform = this.colorTransform;
this.mesh.alpha = 1;
}
public function setPosition(pos:Vector3, normal:Vector3) : void
{
this.position.vCopy(pos);
this.normal.vCopy(normal);
this.mesh.x = pos.x;
this.mesh.y = pos.y;
this.mesh.z = pos.z;
_vector.vCross2(Vector3.Z_AXIS,normal).vNormalize();
var angle:Number = Math.acos(normal.vDot(Vector3.Z_AXIS));
var matrix:Matrix3 = new Matrix3();
matrix.fromAxisAngle(_vector,angle);
matrix.getEulerAngles(_vector);
this.mesh.rotationX = _vector.x;
this.mesh.rotationY = _vector.y;
this.mesh.rotationZ = _vector.z;
this.collisionPrimitive.transform.setPosition(pos);
this.collisionPrimitive.calculateAABB();
}
public function addToContainer(container:Scene3DContainer) : void
{
container.addChild(this.mesh);
}
public function canExplode(tankData:TankData) : Boolean
{
if(tankData == null || tankData.user == null)
{
return true;
}
return (this.teamType == BattleTeamType.NONE || this.teamType != tankData.teamType) && this.armed && this.ownerId != tankData.user.id && tankData.enabled;
}
public function update(now:int, deltaMillis:int, localUserData:TankData) : void
{
if(!this.armed)
{
this.mesh.alpha = this.blinker.updateValue(now,deltaMillis);
}
else if(this.flashState != FLASH_DONE)
{
this.updateFlash(now);
}
else if(localUserData == null || localUserData.health == 0)
{
this.mesh.visible = false;
}
else if(this.canExplode(localUserData))
{
this.updateVisibility(localUserData);
}
else
{
this.mesh.visible = true;
}
}
public function toString() : String
{
return "[ProximityMine id=" + this.id + ", ownerId=" + this.ownerId + ", armed=" + this.armed + "]";
}
private function init(id:String, ownerId:String, proximityRadius:Number, material:Material, teamType:BattleTeamType, mineModelData:MineModelData) : void
{
if(teamType == null)
{
Logger.log(LogLevel.LOG_ERROR,"ProximityMine: teamType is null");
}
this.id = id;
this.ownerId = ownerId;
this.setProximityRadius(proximityRadius);
this.teamType = teamType;
this.mineModelData = mineModelData;
this.mesh.colorTransform = null;
this.mesh.alpha = 1;
this.mesh.visible = true;
this.mesh.setMaterialToAllFaces(material);
this.armed = false;
this.hitCommandSent = false;
this.flashState = FLASH_DONE;
this.flashBaseTime = getTimer();
this.blinker.init(this.flashBaseTime);
}
private function setProximityRadius(value:Number) : void
{
this.collisionPrimitive.r = value;
this.collisionPrimitive.calculateAABB();
}
private function updateVisibility(localUserData:TankData) : void
{
var shaftModel:ShaftModel = null;
var dir:Vector3 = null;
var dAngleX:Number = NaN;
var dAngleZ:Number = NaN;
var dAngle:Number = NaN;
this.mesh.visible = true;
_vector.vDiff(localUserData.tank.state.pos,this.position);
var d:Number = 0;
if(localUserData.turret && localUserData.turret.id.indexOf("shaft") != -1 && localUserData.controlsLocked)
{
shaftModel = BattleController.getWeaponController(localUserData.turret) as ShaftModel;
dir = this.position.vClone();
dir.vDiff(dir,shaftModel.targetingController.camera.pos);
dAngleX = (Math.atan2(dir.z,Math.sqrt(dir.x * dir.x + dir.y * dir.y)) - Math.PI / 2 - shaftModel.targetingController.camera.rotationX) * 57.3;
dAngleZ = (-Math.atan2(dir.x,dir.y) - shaftModel.targetingController.camera.rotationZ) * 57.3;
dAngle = Math.sqrt(dAngleX * dAngleX + dAngleZ * dAngleZ);
if(shaftModel.targetingController.shaftMode == ShaftModes.TARGETING && Math.abs(dAngle) <= 15)
{
d = dAngle * (this.mineModelData.nearRadius + this.mineModelData.farRadius) / 20;
}
else
{
d = _vector.vLength();
}
}
else
{
d = _vector.vLength();
}
if(d > this.mineModelData.farRadius)
{
this.mesh.visible = false;
}
else if(d < this.mineModelData.nearRadius)
{
this.mesh.alpha = 1;
}
else
{
this.mesh.alpha = (this.mineModelData.farRadius - d) / (this.mineModelData.farRadius - this.mineModelData.nearRadius);
}
}
private function updateFlash(now:int) : void
{
switch(this.flashState)
{
case FLASH_GROW:
if(now < this.flashBaseTime + this.mineModelData.armedFlashDuration)
{
this.setColorOffset(this.mineModelData.flashChannelOffset * (now - this.flashBaseTime) / this.mineModelData.armedFlashDuration);
}
else
{
this.setColorOffset(this.mineModelData.flashChannelOffset);
this.flashBaseTime += this.mineModelData.armedFlashDuration + this.mineModelData.armedFlashFadeDuration;
this.flashState = FLASH_FADE;
}
break;
case FLASH_FADE:
if(now < this.flashBaseTime)
{
this.setColorOffset(this.mineModelData.flashChannelOffset * (this.flashBaseTime - now) / this.mineModelData.armedFlashFadeDuration);
}
else
{
this.setColorOffset(0);
this.flashState = FLASH_DONE;
this.mesh.colorTransform = null;
}
}
}
private function setColorOffset(colorOffset:uint) : void
{
this.colorTransform.redOffset = colorOffset;
this.colorTransform.greenOffset = colorOffset;
this.colorTransform.blueOffset = colorOffset;
this.mesh.colorTransform = this.colorTransform;
}
}
}
|
package projects.tanks.client.battleservice.model.performance {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
public class PerformanceModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function PerformanceModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.view.forms {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.service.IPasswordParamsService;
import alternativa.tanks.view.bubbles.Bubble;
import alternativa.tanks.view.bubbles.EntranceBubbleFactory;
import alternativa.tanks.view.events.SendChangeUidAndPasswordEvent;
import alternativa.tanks.view.events.SendChangeUidEvent;
import alternativa.tanks.view.forms.commons.ChangeUidInputField;
import alternativa.tanks.view.forms.primivites.Alert;
import alternativa.tanks.view.forms.primivites.ValidationIcon;
import base.DiscreteSprite;
import controls.TankWindowInner;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.base.TankInputBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.text.TextFormatAlign;
import forms.TankWindowWithHeader;
import forms.events.LoginFormEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class ChangeUidForm extends DiscreteSprite {
[Inject]
public static var display:IDisplay;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var passwordParamsService:IPasswordParamsService;
private static var changeUidBitmapDataClass:Class = ChangeUidForm_changeUidBitmapDataClass;
private static var changeUidBitmapData:BitmapData = Bitmap(new changeUidBitmapDataClass()).bitmapData;
private static const WINDOW_WIDTH:int = 400;
private static const WINDOW_MARGIN:int = 11;
private static const GAP:int = 5;
private static const INPUTS_LEFT_MARGIN:int = 125;
private var _window:TankWindowWithHeader;
private var _windowInner:TankWindowInner;
private var _uidInputField:ChangeUidInputField;
private var _newPasswordInputField:TankInputBase;
private var _repeatPasswordInputField:TankInputBase;
private var _newPasswordCheckIcon:ValidationIcon;
private var _repeatPasswordCheckIcon:ValidationIcon;
private var _passwordIsTooEasyBubble:Bubble;
private var _passwordsDoNotMatchBubble:Bubble;
private var _saveUidButton:DefaultButtonBase;
private var _enablePasswordInput:Boolean;
public function ChangeUidForm(param1:Boolean) {
super();
this._enablePasswordInput = param1;
this.init();
}
public function init() : void {
this.addWindow();
this.addImageAndLabel();
this.addUidInputField();
if(this._enablePasswordInput) {
this.addPasswordInputFields();
}
this.addSaveUidButtonAndSetWindowHeight();
addChild(this._uidInputField);
this.addEventListeners();
this.onResize();
}
private function addWindow() : void {
this._window = new TankWindowWithHeader(localeService.getText(TanksLocale.TEXT_HEADER_CHANGE_UID));
this._window.width = WINDOW_WIDTH;
addChild(this._window);
}
private function addImageAndLabel() : void {
this._windowInner = new TankWindowInner(0,0,TankWindowInner.GREEN);
this._windowInner.x = WINDOW_MARGIN;
this._windowInner.y = WINDOW_MARGIN;
this._windowInner.width = WINDOW_WIDTH - WINDOW_MARGIN * 2;
this._window.addChild(this._windowInner);
var local1:Bitmap = new Bitmap(changeUidBitmapData);
local1.x = this._windowInner.width - local1.width >> 1;
this._windowInner.addChild(local1);
var local2:LabelBase = new LabelBase();
local2.align = TextFormatAlign.CENTER;
local2.wordWrap = true;
local2.multiline = true;
local2.text = localeService.getText(TanksLocale.TEXT_CHANGE_UID_FORM_EXPLANATION_TEXT);
local2.size = 12;
local2.x = WINDOW_MARGIN;
local2.y = local1.y + local1.height + GAP;
local2.width = WINDOW_WIDTH - WINDOW_MARGIN * 4;
this._windowInner.addChild(local2);
this._windowInner.height = local2.y + local2.height + GAP;
}
private function addUidInputField() : void {
this._uidInputField = new ChangeUidInputField();
this._uidInputField.setLabelText(localeService.getText(TanksLocale.TEXT_CHANGE_UID_FORM_NEW_UID_TEXT));
addChild(this._uidInputField);
this._uidInputField.width = this._window.width - INPUTS_LEFT_MARGIN - 2 * WINDOW_MARGIN;
this._uidInputField.x = WINDOW_MARGIN + INPUTS_LEFT_MARGIN;
this._uidInputField.y = this._windowInner.y + this._windowInner.height + GAP;
}
private function addPasswordInputFields() : void {
this._newPasswordInputField = new TankInputBase();
this._newPasswordInputField.label = localeService.getText(TanksLocale.TEXT_CHANGE_UID_FORM_NEW_PASSWORD_TEXT);
this._newPasswordInputField.hidden = true;
this._newPasswordInputField.maxChars = passwordParamsService.maxPasswordLength;
this._repeatPasswordInputField = new TankInputBase();
this._repeatPasswordInputField.label = localeService.getText(TanksLocale.TEXT_CHANGE_UID_FORM_REPEAT_PASSWORD_TEXT);
this._repeatPasswordInputField.hidden = true;
this._repeatPasswordInputField.maxChars = passwordParamsService.maxPasswordLength;
this._newPasswordCheckIcon = new ValidationIcon();
this._repeatPasswordCheckIcon = new ValidationIcon();
this._passwordIsTooEasyBubble = EntranceBubbleFactory.passwordIsTooEasyBubble();
this._passwordsDoNotMatchBubble = EntranceBubbleFactory.passwordsDoNotMatchBubble();
addChild(this._repeatPasswordInputField);
addChild(this._repeatPasswordCheckIcon);
addChild(this._newPasswordInputField);
addChild(this._newPasswordCheckIcon);
this._newPasswordInputField.width = this._window.width - INPUTS_LEFT_MARGIN - 2 * WINDOW_MARGIN;
this._newPasswordInputField.x = WINDOW_MARGIN + INPUTS_LEFT_MARGIN;
this._newPasswordInputField.y = this._uidInputField.y + this._uidInputField.height + GAP;
this._repeatPasswordInputField.width = this._window.width - INPUTS_LEFT_MARGIN - 2 * WINDOW_MARGIN;
this._repeatPasswordInputField.x = this._newPasswordInputField.x;
this._repeatPasswordInputField.y = this._newPasswordInputField.y + this._repeatPasswordInputField.height + GAP;
this._newPasswordCheckIcon.x = this._newPasswordInputField.x + this._newPasswordInputField.textField.width - 20;
this._newPasswordCheckIcon.y = this._newPasswordInputField.y + 7;
this._repeatPasswordCheckIcon.x = this._repeatPasswordInputField.x + this._repeatPasswordInputField.textField.width - 20;
this._repeatPasswordCheckIcon.y = this._repeatPasswordInputField.y + 7;
}
private function addSaveUidButtonAndSetWindowHeight() : void {
this._saveUidButton = new DefaultButtonBase();
this._saveUidButton.enable = false;
this._saveUidButton.label = localeService.getText(TanksLocale.TEXT_SETTINGS_BUTTON_SAVE_TEXT);
addChildAt(this._saveUidButton,1);
this._saveUidButton.x = this._uidInputField.x + this._uidInputField.width - this._saveUidButton.width;
if(this._enablePasswordInput) {
this._saveUidButton.y = this._repeatPasswordInputField.y + this._repeatPasswordInputField.height + GAP;
} else {
this._saveUidButton.y = this._uidInputField.y + this._uidInputField.height + GAP;
}
this._window.height = this._saveUidButton.y + this._saveUidButton.height + WINDOW_MARGIN;
}
private function onResize(param1:Event = null) : void {
this.x = int((display.stage.stageWidth - this._window.width) / 2);
this.y = int((display.stage.stageHeight - this._window.height) / 2);
}
private function addEventListeners() : void {
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
display.stage.addEventListener(Event.RESIZE,this.onResize);
this._uidInputField.addEventListener(Event.CHANGE,this.onChangeUidInputField);
this._saveUidButton.addEventListener(MouseEvent.CLICK,this.onSaveUidButtonClick);
if(this._enablePasswordInput) {
this._newPasswordInputField.addEventListener(LoginFormEvent.TEXT_CHANGED,this.onPasswordChanged);
this._repeatPasswordInputField.addEventListener(LoginFormEvent.TEXT_CHANGED,this.onPasswordChanged);
}
}
private function removeEventListeners() : void {
removeEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
display.stage.removeEventListener(Event.RESIZE,this.onResize);
this._uidInputField.removeEventListener(Event.CHANGE,this.onChangeUidInputField);
this._saveUidButton.removeEventListener(MouseEvent.CLICK,this.onSaveUidButtonClick);
if(this._enablePasswordInput) {
this._newPasswordInputField.removeEventListener(LoginFormEvent.TEXT_CHANGED,this.onPasswordChanged);
this._repeatPasswordInputField.removeEventListener(LoginFormEvent.TEXT_CHANGED,this.onPasswordChanged);
}
}
private function onRemoveFromStage(param1:Event) : void {
this.removeEventListeners();
}
private function onChangeUidInputField(param1:Event) : void {
this.updateEnableSaveUidButton();
}
private function updateEnableSaveUidButton() : void {
var local1:Boolean = false;
if(this._enablePasswordInput) {
this._newPasswordInputField._label.visible = this._repeatPasswordInputField._label.visible = !this._uidInputField.isOpenFreeUidsForm();
if(this._newPasswordInputField.textField.text == "" && this._repeatPasswordInputField.textField.text == "") {
local1 = true;
} else {
local1 = this._newPasswordInputField.textField.text == this._repeatPasswordInputField.textField.text && !passwordParamsService.isPasswordForbidden(this._newPasswordInputField.textField.text);
}
this._saveUidButton.enable = this._uidInputField.isUidValid() && local1;
} else {
this._saveUidButton.enable = this._uidInputField.isUidValid();
}
}
private function onPasswordChanged(param1:LoginFormEvent) : void {
this._passwordIsTooEasyBubble.hide();
this._newPasswordInputField.validValue = true;
this._newPasswordCheckIcon.markAsValid();
if(Boolean(passwordParamsService.isPasswordForbidden(this._newPasswordInputField.textField.text)) && this._newPasswordInputField.textField.text.length != 0) {
this._newPasswordCheckIcon.markAsInvalid();
this._newPasswordInputField.validValue = false;
this._newPasswordCheckIcon.addChild(this._passwordIsTooEasyBubble);
}
if(this._newPasswordInputField.textField.text.length == 0) {
this._newPasswordCheckIcon.turnOff();
}
this._repeatPasswordInputField.validValue = true;
this._repeatPasswordCheckIcon.markAsValid();
this._passwordsDoNotMatchBubble.hide();
if(this._newPasswordInputField.textField.text != this._repeatPasswordInputField.textField.text && this._repeatPasswordInputField.textField.text.length != 0) {
this._repeatPasswordCheckIcon.markAsInvalid();
this._repeatPasswordInputField.validValue = false;
if(!this._passwordIsTooEasyBubble.parent) {
this._repeatPasswordCheckIcon.addChild(this._passwordsDoNotMatchBubble);
}
}
if(this._repeatPasswordInputField.textField.text.length == 0) {
this._repeatPasswordCheckIcon.turnOff();
}
this.updateEnableSaveUidButton();
}
private function onSaveUidButtonClick(param1:MouseEvent) : void {
this._saveUidButton.enable = false;
if(this._enablePasswordInput) {
dispatchEvent(new SendChangeUidAndPasswordEvent(this._uidInputField.callsign,this._newPasswordInputField.value));
} else {
dispatchEvent(new SendChangeUidEvent(this._uidInputField.callsign));
}
}
public function showAlertPasswordIsIncorrect() : void {
this.clearPasswordInputs();
parent.addChild(new Alert(Alert.ERROR_PASSWORD_CHANGE));
}
private function clearPasswordInputs() : void {
this._newPasswordInputField.clear();
this._repeatPasswordInputField.clear();
this._newPasswordCheckIcon.turnOff();
this._repeatPasswordCheckIcon.turnOff();
this.updateEnableSaveUidButton();
}
}
}
|
package projects.tanks.client.garage.models.item.category {
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 ItemCategoryModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ItemCategoryModelServer;
private var client:IItemCategoryModelBase = IItemCategoryModelBase(this);
private var modelId:Long = Long.getLong(492245786,-1837686060);
public function ItemCategoryModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ItemCategoryModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ItemCategoryCC,false)));
}
protected function getInitParam() : ItemCategoryCC {
return ItemCategoryCC(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.camera.controllers.spectator {
import alternativa.tanks.camera.CameraBookmark;
import alternativa.tanks.camera.CameraBookmarks;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
import flash.utils.Dictionary;
public class BookmarksHandler implements KeyboardHandler {
private static const bookmarkKeys:Dictionary = createKeyMap();
private const bookmarks:CameraBookmarks = new CameraBookmarks(10);
private var listener:BookmarkListener;
public function BookmarksHandler() {
super();
}
private static function createKeyMap() : Dictionary {
var local1:Dictionary = new Dictionary();
local1[Keyboard.NUMBER_0] = 0;
local1[Keyboard.NUMBER_1] = 1;
local1[Keyboard.NUMBER_2] = 2;
local1[Keyboard.NUMBER_3] = 3;
local1[Keyboard.NUMBER_4] = 4;
local1[Keyboard.NUMBER_5] = 5;
local1[Keyboard.NUMBER_6] = 6;
local1[Keyboard.NUMBER_7] = 7;
local1[Keyboard.NUMBER_8] = 8;
local1[Keyboard.NUMBER_9] = 9;
return local1;
}
public function setListener(param1:BookmarkListener) : void {
this.listener = param1;
}
public function handleKeyDown(param1:KeyboardEvent) : void {
var local2:* = bookmarkKeys[param1.keyCode];
if(local2 != null) {
if(param1.ctrlKey) {
this.saveCurrentPositionCameraToBookmark(local2);
} else {
this.goToBookmark(local2);
}
}
}
public function handleKeyUp(param1:KeyboardEvent) : void {
}
private function saveCurrentPositionCameraToBookmark(param1:int) : void {
this.bookmarks.saveCurrentPositionCameraToBookmark(param1);
}
private function goToBookmark(param1:int) : void {
var local2:CameraBookmark = this.bookmarks.getBookmark(param1);
if(local2 != null && this.listener != null) {
this.listener.onBookmarkSelected(local2);
}
}
}
}
|
package alternativa.tanks.model.garage.temperature {
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.garage.models.garage.temperature.ITemperatureModelBase;
import projects.tanks.client.garage.models.garage.temperature.TemperatureModelBase;
[ModelInfo]
public class TemperatureModel extends TemperatureModelBase implements ITemperatureModelBase, ObjectLoadListener {
[Inject]
public static var config:TemperatureConfig;
public function TemperatureModel() {
super();
}
public function objectLoaded() : void {
TemperatureConfigImpl(config).temperatureAutoDecrement = getInitParam().temperatureAutoDecrement;
}
}
}
|
package projects.tanks.client.garage.models.item.buyable {
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 BuyableModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BuyableModelServer;
private var client:IBuyableModelBase = IBuyableModelBase(this);
private var modelId:Long = Long.getLong(644770553,-155779331);
public function BuyableModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BuyableModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(BuyableCC,false)));
}
protected function getInitParam() : BuyableCC {
return BuyableCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.friend {
import alternativa.types.Long;
import flash.events.Event;
public class FriendActionServiceUidEvent extends Event {
public static const ADD:String = "FriendActionServiceUidEvent.ADD";
public static const REQUEST_ACCEPTED:String = "FriendActionServiceUidEvent.REQUEST_ACCEPTED";
public var uid:String;
public var userId:Long;
public function FriendActionServiceUidEvent(param1:String, param2:String = null, param3:Long = null, param4:Boolean = false, param5:Boolean = false) {
this.uid = param2;
this.userId = param3;
super(param1,param4,param5);
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.discount.proabonement {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.discount.proabonement.ProAbonementRankDiscountCC;
public class CodecProAbonementRankDiscountCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_percentDiscountPerRank:ICodec;
public function CodecProAbonementRankDiscountCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_percentDiscountPerRank = param1.getCodec(new TypeCodecInfo(Number,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ProAbonementRankDiscountCC = new ProAbonementRankDiscountCC();
local2.percentDiscountPerRank = this.codec_percentDiscountPerRank.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ProAbonementRankDiscountCC = ProAbonementRankDiscountCC(param2);
this.codec_percentDiscountPerRank.encode(param1,local3.percentDiscountPerRank);
}
}
}
|
package projects.tanks.client.tanksservices.model.logging {
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 UserActionsLoggerModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:UserActionsLoggerModelServer;
private var client:IUserActionsLoggerModelBase = IUserActionsLoggerModelBase(this);
private var modelId:Long = Long.getLong(430855235,-1931735028);
public function UserActionsLoggerModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new UserActionsLoggerModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(UserActionsLoggerCC,false)));
}
protected function getInitParam() : UserActionsLoggerCC {
return UserActionsLoggerCC(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.model.antiaddiction
{
public interface IAntiAddictionAlert
{
function setIdNumberAndRealName(param1:String, param2:String) : void;
}
}
|
package projects.tanks.clients.flash.resources.resource {
import alternativa.startup.CacheURLLoader;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLLoaderDataFormat;
import flash.net.URLRequest;
import flash.utils.ByteArray;
import platform.client.fp10.core.resource.IResourceLoadingListener;
import platform.client.fp10.core.resource.Resource;
import platform.client.fp10.core.resource.ResourceFlags;
import platform.client.fp10.core.resource.ResourceInfo;
import platform.client.fp10.core.resource.ResourceStatus;
public class RawDataResource extends Resource {
public static const TYPE:int = 400;
private static const FILE_NAME:String = "data.bin";
private var loader:CacheURLLoader;
private var _data:ByteArray;
private var _dataParsed:Vector.<Number> = new Vector.<Number>();
public function RawDataResource(param1:ResourceInfo) {
super(param1);
}
override public function get description() : String {
return "ByteArray";
}
override public function toString() : String {
return "[RawDataResource id=" + id + "]";
}
override public function load(param1:String, param2:IResourceLoadingListener) : void {
super.load(param1,param2);
this.doLoad();
}
override protected function doReload() : void {
if(isLoading) {
clearFlags(ResourceFlags.IS_LOADING);
this.loader.close();
}
this.doLoad();
}
private function doLoad() : void {
this.loader = new CacheURLLoader();
this.loader.dataFormat = URLLoaderDataFormat.BINARY;
this.loader.addEventListener(Event.OPEN,this.onLoadingOpen);
this.loader.addEventListener(Event.COMPLETE,this.onLoadComplete);
this.loader.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadIOError);
this.loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadError);
this.loader.addEventListener(ProgressEvent.PROGRESS,this.onLoadProgress);
this.loader.load(new URLRequest(baseUrl + FILE_NAME));
startTimeoutTracking();
status = ResourceStatus.REQUESTED;
}
private function onLoadingOpen(param1:Event) : void {
setFlags(ResourceFlags.IS_LOADING);
updateLastActivityTime();
listener.onResourceLoadingStart(this);
}
private function onLoadComplete(param1:Event) : void {
clearFlags(ResourceFlags.IS_LOADING);
this.loader.removeEventListener(Event.OPEN,this.onLoadingOpen);
this.loader.removeEventListener(Event.COMPLETE,this.onLoadComplete);
this.loader.removeEventListener(IOErrorEvent.IO_ERROR,this.onLoadIOError);
this.loader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadError);
this.loader.removeEventListener(ProgressEvent.PROGRESS,this.onLoadProgress);
this._data = this.loader.data as ByteArray;
var local2:ParserWav = new ParserWav();
this._dataParsed = local2.parse(this._data,20,false);
completeLoading();
}
private function onLoadIOError(param1:IOErrorEvent) : void {
listener.onResourceLoadingFatalError(this,param1.toString());
}
private function onLoadError(param1:SecurityErrorEvent) : void {
listener.onResourceLoadingFatalError(this,param1.toString());
}
private function onLoadProgress(param1:ProgressEvent) : void {
updateLastActivityTime();
}
public function get data() : ByteArray {
return this._data;
}
public function get dataParsed() : Vector.<Number> {
return this._dataParsed;
}
}
}
|
package scpacker.gui.en
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksIEN_coldload7 extends BitmapAsset
{
public function GTanksIEN_coldload7()
{
super();
}
}
}
|
package projects.tanks.client.garage.models.item.resistance {
public interface IResistanceModuleModelBase {
}
}
|
package projects.tanks.client.panel.model.antiaddictionalert {
public interface IAntiAddictionAlertModelBase {
function realNameAndIDNumberSetError(param1:String) : void;
function realNameAndIDNumberSetSuccesfully(param1:String) : void;
function showAntiAddictionAlert(param1:int, param2:Boolean) : void;
}
}
|
package projects.tanks.client.panel.model.payment.modes.description {
public interface IBottomDescriptionModelBase {
}
}
|
package alternativa.tanks.models.tank {
import alternativa.tanks.battle.BattleRunnerProvider;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.TankControlLockBits;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.utils.BitMask;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class LocalWeaponController extends BattleRunnerProvider implements IWeaponController {
[Inject]
public static var battleService:BattleService;
private var weapon:Weapon;
private var lockMask:BitMask = new BitMask();
public function LocalWeaponController(param1:Weapon) {
super();
this.weapon = param1;
this.lockMask.setBits(TankControlLockBits.DEAD);
}
public function activateWeapon() : void {
this.weapon.activate();
}
public function deactivateWeapon() : void {
this.weapon.deactivate();
}
public function lockWeapon(param1:int, param2:Boolean) : void {
var local3:Boolean = this.lockMask.isEmpty();
this.lockMask.setBits(param1);
if(local3) {
this.weapon.disable(param2);
}
}
public function unlockWeapon(param1:int) : void {
var local2:Boolean = this.lockMask.isEmpty();
this.lockMask.clearBits(param1);
if(!local2 && this.lockMask.isEmpty()) {
this.weapon.enable();
}
}
public function getResistanceProperty() : ItemProperty {
return this.weapon.getResistanceProperty();
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.serverslist {
import flash.events.Event;
public class ServersListEvent extends Event {
public static const ERROR:String = "ServersListEvent.ERROR";
public static const LOADED:String = "ServersListEvent.LOADED";
public var serversList:Vector.<ServerNode>;
public function ServersListEvent(type:String, serversList:Vector.<ServerNode> = null, bubbles:Boolean = false, cancelable:Boolean = false) {
super(type,bubbles,cancelable);
this.serversList = serversList;
}
}
}
|
package projects.tanks.client.battleservice {
public class BattleRoundParameters {
private var _reArmorEnabled:Boolean;
public function BattleRoundParameters(param1:Boolean = false) {
super();
this._reArmorEnabled = param1;
}
public function get reArmorEnabled() : Boolean {
return this._reArmorEnabled;
}
public function set reArmorEnabled(param1:Boolean) : void {
this._reArmorEnabled = param1;
}
public function toString() : String {
var local1:String = "BattleRoundParameters [";
local1 += "reArmorEnabled = " + this.reArmorEnabled + " ";
return local1 + "]";
}
}
}
|
package _codec.projects.tanks.client.panel.model.bonus.showing.info {
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.LocalizedImageResource;
import projects.tanks.client.panel.model.bonus.showing.info.BonusInfoCC;
public class CodecBonusInfoCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_bottomText:ICodec;
private var codec_image:ICodec;
private var codec_topText:ICodec;
public function CodecBonusInfoCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_bottomText = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_image = param1.getCodec(new TypeCodecInfo(LocalizedImageResource,true));
this.codec_topText = param1.getCodec(new TypeCodecInfo(String,true));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BonusInfoCC = new BonusInfoCC();
local2.bottomText = this.codec_bottomText.decode(param1) as String;
local2.image = this.codec_image.decode(param1) as LocalizedImageResource;
local2.topText = this.codec_topText.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BonusInfoCC = BonusInfoCC(param2);
this.codec_bottomText.encode(param1,local3.bottomText);
this.codec_image.encode(param1,local3.image);
this.codec_topText.encode(param1,local3.topText);
}
}
}
|
package alternativa.tanks.gui.buycrystals {
import alternativa.osgi.service.locale.ILocaleService;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.labels.MouseDisabledLabel;
import flash.display.Bitmap;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.DropShadowFilter;
import forms.base.BaseFormWithInner;
import projects.tanks.client.commons.types.ShopCategoryEnum;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
public class BuyCrystalsAlert extends DialogWindow {
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var paymentDisplayService:PaymentDisplayService;
private static const bitmapClass:Class = BuyCrystalsAlert_bitmapClass;
public static const image:Bitmap = new Bitmap(new bitmapClass().bitmapData);
private static const plusBitmapClass:Class = BuyCrystalsAlert_plusBitmapClass;
public static const plus:Bitmap = new Bitmap(new plusBitmapClass().bitmapData);
private static const VERTICAL_MARGIN:int = 8;
private var baseFormWithInner:BaseFormWithInner;
private var buyButton:DefaultButtonBase;
private var closeButton:DefaultButtonBase;
private var buyCaption:Sprite;
private var label:LabelBase;
private var crystals:int;
public function BuyCrystalsAlert(param1:int) {
super();
this.crystals = param1;
this.baseFormWithInner = new BaseFormWithInner(416,270,30);
addChild(this.baseFormWithInner);
this.baseFormWithInner.window.setHeaderId(TanksLocale.TEXT_HEADER_ATTENTION);
this.buyButton = new DefaultButtonBase();
this.buyButton.width = 150;
this.buyCaption = new Sprite();
this.label = new MouseDisabledLabel();
this.label.text = localeService.getText(TanksLocale.TEXT_GARAGE_BUY_TEXT);
this.label.y = 5;
plus.y = (this.buyButton.height - plus.height) * 0.5;
this.label.x = plus.width;
this.buyCaption.addChild(plus);
this.buyCaption.addChild(this.label);
this.buyButton.x = this.baseFormWithInner.inner.x;
this.buyButton.y = this.baseFormWithInner.inner.y + this.baseFormWithInner.inner.height + VERTICAL_MARGIN;
this.buyCaption.x = int(this.buyButton.x + (this.buyButton.width - this.buyCaption.width) * 0.5);
this.buyCaption.y = this.buyButton.y;
this.baseFormWithInner.window.addChild(this.buyButton);
this.buyCaption.mouseEnabled = false;
this.buyCaption.filters = [new DropShadowFilter(1,45,0,0.7,1,1,1)];
this.baseFormWithInner.window.addChild(this.buyCaption);
this.closeButton = new DefaultButtonBase();
this.closeButton.width = 95;
this.closeButton.label = localeService.getText(TanksLocale.TEXT_GARAGE_CLOSE_TEXT);
this.closeButton.y = this.buyButton.y;
this.closeButton.x = this.baseFormWithInner.inner.x + this.baseFormWithInner.inner.width - this.closeButton.width;
var local2:Bitmap = new Bitmap(localeService.getImage(TanksLocale.IMAGE_GARAGE_ADD_MORE_CRYSTALS));
local2.x = int((this.baseFormWithInner.inner.width - local2.width) / 2);
local2.y = 14;
this.baseFormWithInner.inner.addChild(local2);
image.x = (this.baseFormWithInner.inner.width - image.width) * 0.5 + 3;
image.y = local2.y + local2.height + 3;
this.baseFormWithInner.inner.addChild(image);
this.baseFormWithInner.window.addChild(this.closeButton);
this.buyButton.addEventListener(MouseEvent.CLICK,this.onBuy);
this.closeButton.addEventListener(MouseEvent.CLICK,this.onCancel);
dialogService.addDialog(this);
}
public function onBuy(param1:Event = null) : void {
this.hide();
display.stage.focus = null;
paymentDisplayService.openPaymentAt(ShopCategoryEnum.CRYSTALS);
}
public function onCancel(param1:Event = null) : void {
this.hide();
}
private function hide() : void {
this.buyButton.removeEventListener(MouseEvent.CLICK,this.onBuy);
this.closeButton.removeEventListener(MouseEvent.CLICK,this.onCancel);
dialogService.removeDialog(this);
}
override protected function cancelKeyPressed() : void {
this.onCancel();
}
override protected function confirmationKeyPressed() : void {
this.onBuy();
}
}
}
|
package alternativa.tanks.battle.hidablegraphicobjects {
import alternativa.math.Vector3;
import alternativa.tanks.battle.scene3d.Renderer;
public class HidableGraphicObjects implements Renderer {
private static const _objectPosition:Vector3 = new Vector3();
private var hideRadiusSquared:Number;
private const center:Vector3 = new Vector3();
private const objects:Vector.<HidableGraphicObject> = new Vector.<HidableGraphicObject>();
private var numObjects:int;
public function HidableGraphicObjects() {
super();
}
public function add(param1:HidableGraphicObject) : void {
if(this.objects.indexOf(param1) < 0) {
var local2:* = this.numObjects++;
this.objects[local2] = param1;
}
}
public function remove(param1:HidableGraphicObject) : void {
var local2:int = int(this.objects.indexOf(param1));
if(local2 >= 0) {
param1.setAlphaMultiplier(1);
--this.numObjects;
this.objects[local2] = this.objects[this.numObjects];
this.objects[this.numObjects] = null;
}
}
public function setCenterAndRadius(param1:Vector3, param2:Number) : void {
this.center.copy(param1);
this.hideRadiusSquared = param2 * param2;
}
public function restore() : void {
var local2:HidableGraphicObject = null;
var local1:int = 0;
while(local1 < this.numObjects) {
local2 = this.objects[local1];
local2.setAlphaMultiplier(1);
local1++;
}
}
public function render(param1:int, param2:int) : void {
var local4:HidableGraphicObject = null;
var local3:int = 0;
while(local3 < this.numObjects) {
local4 = this.objects[local3];
local4.readPosition(_objectPosition);
local4.setAlphaMultiplier(this.getAlphaMultiplier(_objectPosition));
local3++;
}
}
private function getAlphaMultiplier(param1:Vector3) : Number {
var local2:Number = param1.x - this.center.x;
var local3:Number = param1.y - this.center.y;
var local4:Number = param1.z - this.center.z;
var local5:Number = local2 * local2 + local3 * local3 + local4 * local4;
if(local5 < this.hideRadiusSquared) {
return Math.sqrt(local5 / this.hideRadiusSquared);
}
return 1;
}
public function clear() : void {
this.objects.length = 0;
this.numObjects = 0;
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.score.ctf {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.field.score.ctf.CTFScoreIndicator_flagBlueLostClass.png")]
public class CTFScoreIndicator_flagBlueLostClass extends BitmapAsset {
public function CTFScoreIndicator_flagBlueLostClass() {
super();
}
}
}
|
package alternativa.tanks.models.sfx.shoot.pumpkingun
{
import alternativa.object.ClientObject;
public interface IPumpkingunSFXModel
{
function getSfxData(param1:ClientObject) : PumpkingunSFXData;
}
}
|
package alternativa.engine3d.animation {
import alternativa.engine3d.alternativa3d;
import flash.events.EventDispatcher;
use namespace alternativa3d;
public class AnimationNotify extends EventDispatcher {
public var name:String;
alternativa3d var _time:Number = 0;
alternativa3d var next:AnimationNotify;
alternativa3d var updateTime:Number;
alternativa3d var processNext:AnimationNotify;
public function AnimationNotify(param1:String) {
super();
this.name = param1;
}
public function get time() : Number {
return this.alternativa3d::_time;
}
}
}
|
package projects.tanks.client.garage.models.item.itemforpartners {
public class ItemEnabledForPartnerCC {
private var _availableForNonPartnerUsers:Boolean;
private var _partnerId:String;
public function ItemEnabledForPartnerCC(param1:Boolean = false, param2:String = null) {
super();
this._availableForNonPartnerUsers = param1;
this._partnerId = param2;
}
public function get availableForNonPartnerUsers() : Boolean {
return this._availableForNonPartnerUsers;
}
public function set availableForNonPartnerUsers(param1:Boolean) : void {
this._availableForNonPartnerUsers = param1;
}
public function get partnerId() : String {
return this._partnerId;
}
public function set partnerId(param1:String) : void {
this._partnerId = param1;
}
public function toString() : String {
var local1:String = "ItemEnabledForPartnerCC [";
local1 += "availableForNonPartnerUsers = " + this.availableForNonPartnerUsers + " ";
local1 += "partnerId = " + this.partnerId + " ";
return local1 + "]";
}
}
}
|
package controls.lifeindicator {
import flash.display.BitmapData;
import flash.display.Shape;
import flash.geom.Matrix;
public class HorizontalBar extends Shape {
private static var drawMatrix:Matrix = new Matrix();
private var left:BitmapData;
private var middle:BitmapData;
private var right:BitmapData;
private var _width:int = 0;
public function HorizontalBar(param1:BitmapData, param2:BitmapData, param3:BitmapData) {
super();
this.left = param1;
this.middle = param2;
this.right = param3;
}
public function setWidth(param1:int) : void {
if(param1 == this._width) {
return;
}
this._width = param1;
this.draw(this._width);
}
private function draw(param1:int) : void {
graphics.clear();
if(param1 <= 0) {
return;
}
var local2:int = this.left.width;
var local3:int = this.left.height;
var local4:int = param1 >> 1;
var local5:int = 2 * local2;
if(param1 <= local5) {
graphics.beginBitmapFill(this.left);
local4 = param1 >> 1;
graphics.drawRect(0,0,local4,local3);
drawMatrix.tx = local4;
graphics.beginBitmapFill(this.right,drawMatrix);
graphics.drawRect(local4,0,param1 - local4,local3);
graphics.endFill();
} else {
graphics.beginBitmapFill(this.left);
graphics.drawRect(0,0,local2,local3);
drawMatrix.tx = local2;
local4 = param1 - local5;
graphics.beginBitmapFill(this.middle,drawMatrix);
graphics.drawRect(local2,0,local4,local3);
drawMatrix.tx = local2 + local4;
graphics.beginBitmapFill(this.right,drawMatrix);
graphics.drawRect(drawMatrix.tx,0,local2,local3);
graphics.endFill();
}
}
}
}
|
package projects.tanks.client.panel.model.quest.daily.type.bonus {
public interface IBonusCatchDailyQuestModelBase {
}
}
|
package controls.chat
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChatPermissionsLevel_tester extends BitmapAsset
{
public function ChatPermissionsLevel_tester()
{
super();
}
}
}
|
package alternativa.tanks.model.challenge.battlepass.notifier {
import flash.events.EventDispatcher;
public class BattlePassPurchaseServiceImpl extends EventDispatcher implements BattlePassPurchaseService {
private var _purchased:Boolean = false;
public function BattlePassPurchaseServiceImpl() {
super();
}
public function isPurchased() : Boolean {
return this._purchased;
}
public function setState(param1:Boolean) : void {
this._purchased = param1;
if(this._purchased) {
dispatchEvent(new BattlePassPurchaseEvent());
}
}
}
}
|
package {
import flash.display.BitmapData;
[Embed(source="/_assets/goldButtonLeft_over.png")]
public dynamic class goldButtonLeft_over extends BitmapData {
public function goldButtonLeft_over(param1:int = 6, param2:int = 29) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.model.item.rename {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.textinputs.PlaceholderInputText;
import alternativa.tanks.model.useremailandpassword.PasswordService;
import controls.TankWindowInner;
import controls.ValidationIcon;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObject;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import forms.TankWindowWithHeader;
import platform.client.models.commons.types.ValidationStatus;
import projects.tanks.clients.flash.commons.services.validate.IValidateService;
import projects.tanks.clients.flash.commons.services.validate.ValidateService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.model.uidcheck.UidCheckService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
public class RenameForm extends DialogWindow {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var uidCheckService:UidCheckService;
[Inject]
public static var passwordService:PasswordService;
[Inject]
public static var validateService:IValidateService;
private static const CHECK_ICON_OFFSET:int = 6;
private static const CHECK_DELAY:int = 500;
private static const PASSWORD_MAX_LENGTH:int = 20;
private static var enterEmailReminderBitmapDataClass:Class = RenameForm_enterEmailReminderBitmapDataClass;
private static var enterEmailReminderBitmapData:BitmapData = Bitmap(new enterEmailReminderBitmapDataClass()).bitmapData;
protected static const WINDOW_WIDTH:int = 335;
protected static const WINDOW_MARGIN:int = 11;
protected static const GAP:int = 5;
protected var window:TankWindowWithHeader;
private var newNickname:PlaceholderInputText;
private var nickanameCheckIcon:ValidationIcon;
private var nicknameCheckTimeOut:uint;
private var nickname:String;
private var nicknameIsValid:Boolean;
private var currentPassword:PlaceholderInputText;
private var passwordCheckIcon:ValidationIcon;
private var passwordCheckTimeOut:uint;
private var password:String;
private var passwordIsValid:Boolean;
private var saveButton:DefaultButtonBase;
private var closeButton:DefaultButtonBase;
private var imageInnerWindow:TankWindowInner;
private var instructionLabel:TankWindowInner;
private var needPassword:Boolean;
public function RenameForm(param1:Boolean) {
super();
this.needPassword = param1;
this.addMainInnerWindow();
this.addInfoImage();
this.addInstructionLabel();
this.addNicknameField();
if(param1) {
this.addPasswordField();
}
this.addSaveButton();
this.addCloseButton();
this.window.height = this.saveButton.y + this.saveButton.height + WINDOW_MARGIN;
}
public function show() : void {
dialogService.addDialog(this);
}
public function close() : void {
dialogService.removeDialog(this);
}
public function isNeedPassword() : Boolean {
return this.needPassword;
}
public function getPassword() : String {
return this.currentPassword.value;
}
private function calculateYPosition(param1:DisplayObject) : int {
return param1.y + param1.height + GAP;
}
private function addMainInnerWindow() : void {
this.window = new TankWindowWithHeader(localeService.getText(TanksLocale.TEXT_HEADER_CHANGE_UID));
this.window.width = WINDOW_WIDTH;
addChild(this.window);
}
private function addInfoImage() : void {
var local1:Bitmap = new Bitmap(enterEmailReminderBitmapData);
local1.x = WINDOW_MARGIN;
this.imageInnerWindow = new TankWindowInner(0,0,TankWindowInner.GREEN);
this.imageInnerWindow.x = WINDOW_MARGIN;
this.imageInnerWindow.y = WINDOW_MARGIN;
this.imageInnerWindow.width = WINDOW_WIDTH - WINDOW_MARGIN * 2;
this.imageInnerWindow.height = local1.height;
this.imageInnerWindow.addChild(local1);
this.window.addChild(this.imageInnerWindow);
}
private function addInstructionLabel() : void {
this.instructionLabel = new TankWindowInner(0,0,TankWindowInner.GREEN);
this.instructionLabel.x = WINDOW_MARGIN;
this.instructionLabel.width = WINDOW_WIDTH - WINDOW_MARGIN * 2;
var local1:LabelBase = new LabelBase();
local1.wordWrap = true;
local1.multiline = true;
local1.htmlText = localeService.getText(TanksLocale.TEXT_RENAME_FORM_INSTRUCTION);
local1.size = 12;
local1.x = WINDOW_MARGIN;
local1.y = WINDOW_MARGIN;
local1.width = WINDOW_WIDTH - WINDOW_MARGIN * 4;
this.instructionLabel.addChild(local1);
this.instructionLabel.height = local1.height + WINDOW_MARGIN * 2;
this.instructionLabel.y = this.calculateYPosition(this.imageInnerWindow);
this.window.addChild(this.instructionLabel);
}
private function addNicknameField() : void {
this.newNickname = this.createPlaceholder(localeService.getText(TanksLocale.TEXT_RENAME_FORM_NEW_UID_INPUT),this.calculateYPosition(this.instructionLabel));
this.newNickname.validValue = true;
this.newNickname.maxChars = uidCheckService.getMaxLength();
this.newNickname.addEventListener(Event.CHANGE,this.onNicknameInputChanged);
this.nickanameCheckIcon = this.createCheckIcon(this.newNickname);
this.window.addChild(this.newNickname);
this.newNickname.addChild(this.nickanameCheckIcon);
}
private function addPasswordField() : void {
this.currentPassword = this.createPlaceholder(localeService.getText(TanksLocale.TEXT_RENAME_FORM_CURRENT_PASSWORD_INPUT),this.calculateYPosition(this.newNickname));
this.currentPassword.hidden = true;
this.currentPassword.maxChars = PASSWORD_MAX_LENGTH;
this.currentPassword.addEventListener(Event.CHANGE,this.onPasswordInputChanged);
this.passwordCheckIcon = this.createCheckIcon(this.currentPassword);
this.window.addChild(this.currentPassword);
this.currentPassword.addChild(this.passwordCheckIcon);
}
private function onNicknameInputChanged(param1:Event) : void {
this.saveButton.enable = false;
var local2:String = this.newNickname.value;
if(!validateService.isValidIdentificationStringForRegistration(local2)) {
this.newNickname.value = local2.replace(ValidateService.NOT_ALLOWED_PATTERN_FOR_REGISTRATION,"");
}
this.nickanameCheckIcon.startProgress();
clearTimeout(this.nicknameCheckTimeOut);
this.nicknameCheckTimeOut = setTimeout(this.checkUid,CHECK_DELAY);
}
private function checkUid() : void {
if(this.needPassword && this.newNickname.value == this.currentPassword.value) {
this.nickanameCheckIcon.markAsInvalid();
this.newNickname.validValue = false;
return;
}
if(this.newNickname.value.length == 0) {
this.nickanameCheckIcon.turnOff();
this.newNickname.validValue = true;
} else {
this.nickname = this.newNickname.value;
uidCheckService.validate(this.nickname,this.callbackUidValidate);
}
}
private function onPasswordInputChanged(param1:Event) : void {
this.saveButton.enable = false;
this.passwordCheckIcon.startProgress();
clearTimeout(this.passwordCheckTimeOut);
this.passwordCheckTimeOut = setTimeout(this.checkPassword,CHECK_DELAY);
}
private function checkPassword() : void {
if(this.needPassword && this.currentPassword.value == this.newNickname.value) {
this.currentPassword.validValue = false;
this.passwordCheckIcon.markAsInvalid();
return;
}
if(this.currentPassword.value.length == 0) {
this.passwordCheckIcon.turnOff();
this.currentPassword.validValue = true;
} else {
this.password = this.currentPassword.value;
passwordService.checkPassword(this.password,this.callbackPasswordCheck);
}
}
private function createPlaceholder(param1:String, param2:int) : PlaceholderInputText {
var local3:PlaceholderInputText = new PlaceholderInputText(param1);
local3.x = WINDOW_MARGIN;
local3.y = param2;
local3.width = WINDOW_WIDTH - WINDOW_MARGIN * 2;
return local3;
}
private function createCheckIcon(param1:PlaceholderInputText) : ValidationIcon {
var local2:ValidationIcon = new ValidationIcon();
local2.turnOff();
local2.y = int((param1.height - local2.height) / 2) + 2;
local2.x = param1.width - local2.width - CHECK_ICON_OFFSET;
return local2;
}
private function addSaveButton() : void {
this.saveButton = new DefaultButtonBase();
this.saveButton.label = localeService.getText(TanksLocale.TEXT_SAVE_BUTTON_LABEL);
this.saveButton.x = WINDOW_WIDTH - 2 * this.saveButton.width - 2 * WINDOW_MARGIN;
this.saveButton.y = this.calculateYPosition(this.needPassword ? this.currentPassword : this.newNickname);
this.saveButton.enable = false;
this.saveButton.addEventListener(MouseEvent.CLICK,this.onSaveButtonClick);
this.window.addChild(this.saveButton);
}
private function addCloseButton() : void {
this.closeButton = new DefaultButtonBase();
this.closeButton.label = localeService.getText(TanksLocale.TEXT_CLOSE_LABEL);
this.closeButton.x = WINDOW_WIDTH - WINDOW_MARGIN - this.closeButton.width;
this.closeButton.y = this.saveButton.y;
this.closeButton.addEventListener(MouseEvent.CLICK,this.onCloseButtonClick);
this.window.addChild(this.closeButton);
}
private function callbackUidValidate(param1:ValidationStatus) : void {
this.nicknameIsValid = param1 == ValidationStatus.CORRECT;
this.newNickname.validValue = this.nicknameIsValid;
if(this.nicknameIsValid) {
this.nickanameCheckIcon.markAsValid();
} else {
this.nickanameCheckIcon.markAsInvalid();
}
this.checkRenameState();
}
private function callbackPasswordCheck(param1:Boolean) : void {
this.passwordIsValid = param1;
if(this.passwordIsValid) {
this.passwordCheckIcon.markAsValid();
} else {
this.passwordCheckIcon.markAsInvalid();
}
this.currentPassword.validValue = this.passwordIsValid;
this.checkRenameState();
}
private function uidIsValid() : void {
this.nickanameCheckIcon.markAsValid();
this.newNickname.validValue = true;
this.checkRenameState();
}
private function uidIsNotValid() : void {
this.nickanameCheckIcon.markAsInvalid();
this.newNickname.validValue = false;
}
private function checkRenameState() : void {
if(this.nicknameIsValid && (this.passwordIsValid || !this.needPassword)) {
this.saveButton.enable = true;
}
}
private function onSaveButtonClick(param1:MouseEvent) : void {
dispatchEvent(new RenameEvent(this.nickname));
}
private function onCloseButtonClick(param1:MouseEvent = null) : void {
dialogService.removeDialog(this);
}
public function dispose() : void {
this.saveButton.removeEventListener(MouseEvent.CLICK,this.onSaveButtonClick);
this.closeButton.removeEventListener(MouseEvent.CLICK,this.onCloseButtonClick);
this.newNickname.removeEventListener(Event.CHANGE,this.onNicknameInputChanged);
if(this.needPassword) {
this.currentPassword.removeEventListener(Event.CHANGE,this.onPasswordInputChanged);
}
}
override protected function cancelKeyPressed() : void {
this.onCloseButtonClick();
}
}
}
|
package alternativa.tanks.service.money {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.buycrystals.BuyCrystalsAlert;
import alternativa.tanks.service.panel.IPanelView;
import alternativa.tanks.service.payment.IPaymentService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
public class MoneyService implements IMoneyService {
[Inject]
public static var panelView:IPanelView;
[Inject]
public static var paymentService:IPaymentService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var localeService:ILocaleService;
private var mask:int = 0;
private var listeners:Vector.<IMoneyListener>;
private var _crystals:int = 0;
private var _lastServerCrystals:int = 0;
private var _crystalsExpenses:int = 0;
public function MoneyService() {
super();
this.listeners = new Vector.<IMoneyListener>();
}
private static function showBuyCrystalsForm(param1:int) : void {
new BuyCrystalsAlert(param1);
}
public function addListener(param1:IMoneyListener) : void {
if(this.listeners.indexOf(param1) == -1) {
this.listeners.push(param1);
}
}
public function removeListener(param1:IMoneyListener) : void {
var local2:Number = Number(this.listeners.indexOf(param1));
if(local2 >= 0) {
this.listeners.splice(local2,1);
}
}
public function get crystal() : int {
var local1:int = this._crystals ^ this.mask;
this.setCrystals(local1);
return local1;
}
public function init(param1:int) : void {
this._lastServerCrystals = param1;
this.updateCrystals(param1);
}
public function checkEnough(param1:int) : Boolean {
if(this.crystal < param1) {
if(paymentService.isEnabled()) {
showBuyCrystalsForm(param1 - this._crystals);
} else {
alertService.showOkAlert(localeService.getText(TanksLocale.TEXT_NOT_ENOUGH_MONEY_FOR_BUY_ITEM));
}
return false;
}
return true;
}
public function spend(param1:int) : void {
this.updateCrystals(this.crystal - param1);
this._crystalsExpenses += param1;
}
public function setServerCrystals(param1:int) : void {
this.changeCrystals(param1 - this._lastServerCrystals);
this._lastServerCrystals = param1;
}
public function changeCrystals(param1:int) : void {
if(param1 < 0) {
this._crystalsExpenses += param1;
if(this._crystalsExpenses < 0) {
param1 = this._crystalsExpenses;
this._crystalsExpenses = 0;
} else {
param1 = 0;
}
}
this.updateCrystals(this.crystal + param1);
}
protected function updateCrystals(param1:int) : void {
var local3:IMoneyListener = null;
panelView.getPanel().playerInfo.crystals = param1;
this.setCrystals(param1);
var local2:int = 0;
while(local2 < this.listeners.length) {
local3 = this.listeners[local2];
local3.crystalsChanged(param1);
local2++;
}
}
protected function setCrystals(param1:int) : void {
this.mask = Math.random() * 4294967295 ^ 0x153B8A92;
this._crystals = param1 ^ this.mask;
}
}
}
|
package alternativa.physics.collision
{
import alternativa.physics.Contact;
public interface ICollider
{
function getContact(param1:CollisionPrimitive, param2:CollisionPrimitive, param3:Contact) : Boolean;
function haveCollision(param1:CollisionPrimitive, param2:CollisionPrimitive) : Boolean;
function destroy() : void;
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank08.png")]
public class PremiumRankBitmaps_bitmapBigRank08 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank08() {
super();
}
}
}
|
package alternativa.init
{
import alternativa.osgi.bundle.IBundleActivator;
import flash.text.Font;
public class TanksFonts implements IBundleActivator
{
[Embed(source = 'MyriadProArabic.ttf', fontName = 'MyriadPro', mimeType = 'application/x-font', embedAsCFF = 'false')]
private static const Arabic:Class;
[Embed(source = 'MyriadProB_MyriadPro.ttf', fontName = 'MyriadPro', mimeType = 'application/x-font', embedAsCFF = 'false')]
private static const MyriadProB:Class;
public function TanksFonts()
{
super();
}
public static function init() : void
{
Font.registerFont(MyriadProB);
Font.registerFont(Arabic);
}
public function start(osgi:OSGi) : void
{
Font.registerFont(MyriadProB);
Font.registerFont(Arabic);
}
public function stop(osgi:OSGi) : void
{
}
}
}
|
package projects.tanks.client.garage.models.item.upgradeable.discount {
public interface IDiscountForUpgradeModelBase {
}
}
|
package alternativa.tanks.models.effects.activeafetrdeath {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IActiveAfterDeathEvents implements IActiveAfterDeath {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IActiveAfterDeathEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function isEnabled() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:IActiveAfterDeath = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IActiveAfterDeath(this.impl[i]);
result = Boolean(m.isEnabled());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_2 extends BitmapAsset
{
public function BigRangIcon_rang_2()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.profile.rename {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class AndroidRenameModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _renameId:Long = Long.getLong(1075257537,512199455);
private var _rename_uidCodec:ICodec;
private var model:IModel;
public function AndroidRenameModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._rename_uidCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function rename(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._rename_uidCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._renameId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package projects.tanks.client.battleselect.model.battle {
import projects.tanks.client.battleservice.model.types.BattleSuspicionLevel;
public class BattleInfoCC {
private var _roundStarted:Boolean;
private var _suspicionLevel:BattleSuspicionLevel;
private var _timeLeftInSec:int;
public function BattleInfoCC(param1:Boolean = false, param2:BattleSuspicionLevel = null, param3:int = 0) {
super();
this._roundStarted = param1;
this._suspicionLevel = param2;
this._timeLeftInSec = param3;
}
public function get roundStarted() : Boolean {
return this._roundStarted;
}
public function set roundStarted(param1:Boolean) : void {
this._roundStarted = param1;
}
public function get suspicionLevel() : BattleSuspicionLevel {
return this._suspicionLevel;
}
public function set suspicionLevel(param1:BattleSuspicionLevel) : void {
this._suspicionLevel = param1;
}
public function get timeLeftInSec() : int {
return this._timeLeftInSec;
}
public function set timeLeftInSec(param1:int) : void {
this._timeLeftInSec = param1;
}
public function toString() : String {
var local1:String = "BattleInfoCC [";
local1 += "roundStarted = " + this.roundStarted + " ";
local1 += "suspicionLevel = " + this.suspicionLevel + " ";
local1 += "timeLeftInSec = " + this.timeLeftInSec + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.radio {
[ModelInterface]
public interface RocketExplosion {
}
}
|
package alternativa.tanks.help
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
public class CreateMapHelper extends BubbleHelper
{
public function CreateMapHelper()
{
super();
var localeService:ILocaleService = ILocaleService(Main.osgi.getService(ILocaleService));
text = localeService.getText(TextConst.HELP_BATTLE_SELECT_CREATE_MAP_HELPER_TEXT);
arrowLehgth = int(localeService.getText(TextConst.HELP_BATTLE_SELECT_CREATE_MAP_HELPER_ARROW_LENGTH));
arrowAlign = HelperAlign.BOTTOM_RIGHT;
_showLimit = 3;
}
}
}
|
package com.lorentz.SVG.display
{
import com.lorentz.SVG.display.base.ISVGViewPort;
import com.lorentz.SVG.display.base.SVGElement;
import com.lorentz.SVG.utils.Base64AsyncDecoder;
import flash.display.Bitmap;
import flash.display.Loader;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.geom.Rectangle;
import flash.net.URLRequest;
import flash.utils.ByteArray;
public class SVGImage extends SVGElement implements ISVGViewPort
{
private var _svgHrefChanged:Boolean = false;
private var _svgHref:String;
private var listeners:Vector.<Function>;
protected var _loader:Loader;
protected var _base64AsyncDecoder:Base64AsyncDecoder;
public function SVGImage()
{
this.listeners = new Vector.<Function>();
super("image");
}
public function get svgPreserveAspectRatio() : String
{
return getAttribute("preserveAspectRatio") as String;
}
public function set svgPreserveAspectRatio(value:String) : void
{
setAttribute("preserveAspectRatio",value);
}
public function get svgX() : String
{
return getAttribute("x") as String;
}
public function set svgX(value:String) : void
{
setAttribute("x",value);
}
public function get svgY() : String
{
return getAttribute("y") as String;
}
public function set svgY(value:String) : void
{
setAttribute("y",value);
}
public function get svgWidth() : String
{
return getAttribute("width") as String;
}
public function set svgWidth(value:String) : void
{
setAttribute("width",value);
}
public function get svgHeight() : String
{
return getAttribute("height") as String;
}
public function set svgHeight(value:String) : void
{
setAttribute("height",value);
}
public function get svgOverflow() : String
{
return getAttribute("overflow") as String;
}
public function set svgOverflow(value:String) : void
{
setAttribute("overflow",value);
}
public function get svgHref() : String
{
return this._svgHref;
}
public function set svgHref(value:String) : void
{
if(this._svgHref != value)
{
this._svgHref = value;
this._svgHrefChanged = true;
invalidateProperties();
}
}
public function loadURL(url:String) : void
{
if(this._loader != null)
{
content.removeChild(this._loader);
this._loader = null;
}
if(url != null)
{
this._loader = new Loader();
this._loader.contentLoaderInfo.addEventListener(Event.COMPLETE,this.loadComplete);
this._loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.loadError);
this._loader.load(new URLRequest(url));
content.addChild(this._loader);
}
}
public function addListener(f:Function) : Function
{
this.listeners.push(f);
return f;
}
public function removeListener(f:Function) : void
{
var ind:int = this.listeners.indexOf(f);
if(ind != -1)
{
this.listeners.removeAt(ind);
}
trace(ind);
}
public function loadBase64(content:String) : void
{
var base64String:String = content.replace(/^data:[a-z\/]*;base64,/,"");
this._base64AsyncDecoder = new Base64AsyncDecoder(base64String);
this._base64AsyncDecoder.addEventListener(Base64AsyncDecoder.COMPLETE,this.base64AsyncDecoder_completeHandler);
this._base64AsyncDecoder.addEventListener(Base64AsyncDecoder.ERROR,this.base64AsyncDecoder_errorHandler);
this._base64AsyncDecoder.decode();
}
private function base64AsyncDecoder_completeHandler(e:Event) : void
{
this.loadBytes(this._base64AsyncDecoder.bytes);
this._base64AsyncDecoder = null;
}
private function base64AsyncDecoder_errorHandler(e:Event) : void
{
trace(this._base64AsyncDecoder.errorMessage);
this._base64AsyncDecoder = null;
}
public function loadBytes(byteArray:ByteArray) : void
{
if(this._loader != null)
{
content.removeChild(this._loader);
this._loader = null;
}
if(byteArray != null)
{
this._loader = new Loader();
this._loader.contentLoaderInfo.addEventListener(Event.COMPLETE,this.loadComplete);
this._loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.loadError);
this._loader.loadBytes(byteArray);
content.addChild(this._loader);
}
}
override protected function commitProperties() : void
{
super.commitProperties();
if(this._svgHrefChanged)
{
this._svgHrefChanged = false;
if(this.svgHref != null && this.svgHref != "")
{
if(this.svgHref.match(/^data:[a-z\/]*;base64,/))
{
this.loadBase64(this.svgHref);
beginASyncValidation("loadImage");
}
else
{
this.loadURL(document.resolveURL(this.svgHref));
beginASyncValidation("loadImage");
}
}
}
}
private function loadComplete(event:Event) : void
{
var f:Function = null;
if(this._loader.content is Bitmap)
{
(this._loader.content as Bitmap).smoothing = true;
}
for each(f in this.listeners)
{
f.call();
}
endASyncValidation("loadImage");
}
private function loadError(e:IOErrorEvent) : void
{
trace("Failed to load image" + e.text);
endASyncValidation("loadImage");
}
override protected function getContentBox() : Rectangle
{
if(this._loader == null || this._loader.content == null)
{
return null;
}
return new Rectangle(0,0,this._loader.content.width,this._loader.content.height);
}
override public function clone() : Object
{
var c:SVGImage = super.clone() as SVGImage;
c.svgHref = this.svgHref;
return c;
}
}
}
|
package alternativa.osgi
{
public interface IBundleListener
{
function bundleStart() : void;
function bundleStop() : void;
}
}
|
package projects.tanks.clients.flash.resources.tanks {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Object3DContainer;
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.objects.BSP;
import alternativa.engine3d.objects.Mesh;
import flash.geom.Vector3D;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class Tanks3DUtils {
public function Tanks3DUtils() {
super();
}
public static function createTank3DPart(param1:Tanks3DSResource, param2:Boolean) : Tank3DPart {
var local9:Object3D = null;
var local10:Mesh = null;
var local11:BSP = null;
var local12:Object3D = null;
var local13:int = 0;
var local14:Object3D = null;
var local15:Object3D = null;
var local3:Tank3DPart = new Tank3DPart();
var local4:Object3DContainer = new Object3DContainer();
var local5:Vector.<Object3D> = param1.objects;
var local6:Vector.<Object3D> = param1.parents;
var local7:Object3D = local5[0];
var local8:int = 0;
while(local8 < local5.length) {
local9 = local5[local8];
if(local9 is Mesh && !Tank3D.EXCLUDED.test(local9.name)) {
local10 = Mesh(local9);
if(local10.sorting != Sorting.DYNAMIC_BSP) {
local10.sorting = Sorting.DYNAMIC_BSP;
local10.calculateFacesNormals(true);
local10.optimizeForDynamicBSP();
}
local11 = new BSP();
local11.createTree(Mesh(local10));
local4.addChild(local11);
local12 = local6[local8];
if(local12 == null) {
local11.x = local10.x - local7.x;
local11.y = local10.y - local7.y;
local11.z = local10.z - local7.z;
} else {
local13 = int(local5.indexOf(local12));
local14 = local4.getChildAt(local13);
local11.x = local10.x + local14.x;
local11.y = local10.y + local14.y;
local11.z = local10.z + local14.z;
}
}
local8++;
}
local3.view = local4;
local3.lightmap = param1.textures["lightmap.jpg"];
local3.details = param1.textures["details.png"];
if(param2) {
local15 = local5[1];
local3.turretMountPoint = new Vector3D(local15.x,local15.y,local15.z);
}
return local3;
}
}
}
|
package alternativa.tanks.view.forms.freeuids {
import assets.combo.ComboListOverState;
import controls.base.LabelBase;
import flash.display.Sprite;
public class FreeUidsFormRender extends Sprite {
public static const HEIGHT:int = 20;
public static const BGD_POS_X:int = 3;
private var _uid:String;
private var _index:int;
private var _width:int;
private var _backGround:ComboListOverState;
public function FreeUidsFormRender(param1:int, param2:int, param3:String) {
super();
this._width = param1;
this._index = param2;
this._uid = param3;
this.init();
}
private function init() : void {
graphics.clear();
graphics.beginFill(16711680,0);
graphics.drawRect(0,0,this._width,HEIGHT);
graphics.endFill();
this._backGround = new ComboListOverState();
this._backGround.width = this._width - BGD_POS_X * 2;
this._backGround.height = HEIGHT;
this._backGround.x = BGD_POS_X;
addChild(this._backGround);
var local1:LabelBase = new LabelBase();
addChild(local1);
local1.text = this._uid;
local1.x = FreeUidsForm.LABEL_POS_X;
this.setSelected(false);
}
public function setSelected(param1:Boolean) : void {
this._backGround.visible = param1;
}
public function get index() : int {
return this._index;
}
public function get uid() : String {
return this._uid;
}
}
}
|
package alternativa.physics {
import alternativa.math.Quaternion;
import alternativa.math.Vector3;
public class BodyState {
public var velocity:Vector3 = new Vector3();
public var orientation:Quaternion = new Quaternion();
public var angularVelocity:Vector3 = new Vector3();
public var position:Vector3 = new Vector3();
public function BodyState() {
super();
}
public function copy(param1:BodyState) : void {
this.position.copy(param1.position);
this.orientation.copy(param1.orientation);
this.velocity.copy(param1.velocity);
this.angularVelocity.copy(param1.angularVelocity);
}
public function isValid() : Boolean {
return this.velocity.isFiniteVector() && this.angularVelocity.isFiniteVector() && this.position.isFiniteVector() && this.orientation.isFiniteQuaternion();
}
public function toString() : String {
return "BodyState{velocity=" + String(this.velocity) + ",position=" + String(this.position) + "}";
}
}
}
|
package alternativa.tanks.models.weapons.discrete {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
[ModelInterface]
public interface DiscreteWeapon {
function tryToShoot(param1:int, param2:Vector3, param3:Vector.<Tank>) : void;
function tryToDummyShoot(param1:int, param2:Vector3) : void;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.