code
stringlengths 57
237k
|
|---|
package alternativa.tanks.models.weapon.turret {
[ModelInterface]
public interface TurretStateSender {
function sendTurretState() : void;
}
}
|
package alternativa.tanks.battle.objects.tank.controllers {
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.BattleView;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.weapon.shaft.ReticleDisplay;
public class ShaftReticleDisplayController {
[Inject]
public static var battleService:BattleService;
private var camera:GameCamera;
private var reticleDisplay:ReticleDisplay;
public function ShaftReticleDisplayController(param1:ReticleDisplay) {
super();
this.reticleDisplay = param1;
this.camera = battleService.getBattleScene3D().getCamera();
}
public function update(param1:Vector3) : void {
var local11:BattleView = null;
var local2:Number = Number(this.camera.focalLength);
var local3:Number = Number(this.camera.viewSizeX);
var local4:Number = Number(this.camera.viewSizeY);
var local5:Number = Math.atan((local4 + this.reticleDisplay.height / 2) / local2);
var local6:Number = Math.atan((local3 + this.reticleDisplay.width / 2) / local2);
var local7:Matrix3 = BattleUtils.tmpMatrix3;
local7.setRotationMatrixForObject3D(this.camera);
var local8:Vector3 = BattleUtils.tmpVector;
local7.transformVectorInverse(param1,local8);
var local9:Number = Math.atan2(local8.x,local8.z);
var local10:Number = Math.atan2(local8.y,local8.z);
this.reticleDisplay.visible = Math.abs(local10) <= local5 && Math.abs(local9) <= local6;
if(this.reticleDisplay.visible) {
local11 = battleService.getBattleView();
this.reticleDisplay.x = local11.getX() + Math.tan(local9) * local2 + local3 - this.reticleDisplay.width / 2;
this.reticleDisplay.y = local11.getY() + Math.tan(local10) * local2 + local4 - this.reticleDisplay.height / 2;
}
}
}
}
|
package alternativa.tanks.model.item.upgradable {
import alternativa.tanks.model.item.properties.ItemPropertyValue;
import alternativa.tanks.model.item.upgradable.calculators.PropertyCalculator;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParams;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParamsService;
import projects.tanks.client.commons.types.ItemGarageProperty;
import projects.tanks.client.garage.models.item.upgradeable.types.GaragePropertyParams;
public class UpgradableItemPropertyValue implements ItemPropertyValue {
[Inject]
public static var propertyParamsService:ItemPropertyParamsService;
private var valueCalculator:PropertyCalculator;
private var params:GaragePropertyParams;
private var isUpgradableProperty:Boolean;
public function UpgradableItemPropertyValue(param1:int, param2:GaragePropertyParams) {
super();
this.params = param2;
var local3:ItemPropertyParams = propertyParamsService.getParams(param2.property);
this.valueCalculator = local3.getAggregationMode().createValueCalculator(param1,param2);
this.isUpgradableProperty = this.getValue(0) != this.getValue(param1);
}
public function isUpgradable() : Boolean {
return this.isUpgradableProperty;
}
public function getValue(param1:int = 0) : String {
return this.valueCalculator.getValue(param1);
}
public function getProperty() : ItemGarageProperty {
return this.params.property;
}
public function isVisibleInInfo() : Boolean {
return this.params.visibleInInfo;
}
public function getDelta(param1:int) : String {
return this.valueCalculator.getDelta(param1);
}
}
}
|
package alternativa.tanks.models.tank.damageindicator {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.sfx.damageindicator.DamageIndicatorEffect;
import forms.ColorConstants;
import projects.tanks.client.battlefield.models.user.damageindicator.DamageIndicatorModelBase;
import projects.tanks.client.battlefield.models.user.damageindicator.DamageIndicatorType;
import projects.tanks.client.battlefield.models.user.damageindicator.IDamageIndicatorModelBase;
import projects.tanks.client.battlefield.models.user.damageindicator.TargetTankDamage;
[ModelInfo]
public class DamageIndicatorModel extends DamageIndicatorModelBase implements IDamageIndicatorModelBase {
public function DamageIndicatorModel() {
super();
}
[Obfuscation(rename="false")]
public function showDamageForShooter(param1:Vector.<TargetTankDamage>) : void {
var local2:TargetTankDamage = null;
var local3:Tank = null;
var local4:Vector3 = null;
var local5:Object3D = null;
for each(local2 in param1) {
if(local2.target != null) {
local3 = ITankModel(local2.target.adapt(ITankModel)).getTank();
local4 = BattleUtils.tmpVector;
if(local3.isLastHitPointSet) {
local4.copy(local3.lastHitPoint);
BattleUtils.localToGlobal(local3.getBody(),local4);
} else {
local5 = local3.getTurret3D();
local4.reset(local5.x,local5.y,local5.z);
}
DamageIndicatorEffect.start(local4,this.getEffectColor(local2),local2.damageAmount);
}
}
}
private function getEffectColor(param1:TargetTankDamage) : uint {
switch(param1.damageIndicatorType) {
case DamageIndicatorType.FATAL:
return ColorConstants.USER_TITLE_RED;
case DamageIndicatorType.CRITICAL:
return ColorConstants.USER_TITLE_YELLOW;
case DamageIndicatorType.HEAL:
return ColorConstants.GREEN_TEXT;
default:
return ColorConstants.WHITE;
}
}
}
}
|
package alternativa.tanks.model.payment.shop.onetimepurchase {
import projects.tanks.client.panel.model.shop.onetimepurchase.event.EventOneTimePurchaseModelBase;
import projects.tanks.client.panel.model.shop.onetimepurchase.event.IEventOneTimePurchaseModelBase;
[ModelInfo]
public class EventOneTimePurchaseModel extends EventOneTimePurchaseModelBase implements IEventOneTimePurchaseModelBase, ShopItemOneTimePurchase {
public function EventOneTimePurchaseModel() {
super();
}
public function isOneTimePurchase() : Boolean {
return getInitParam().oneTimePurchase;
}
public function isTriedToBuy() : Boolean {
return getInitParam().triedToBuy;
}
}
}
|
package alternativa.physics.collision
{
import alternativa.physics.Body;
public interface IBodyCollisionPredicate
{
function considerBodies(param1:Body, param2:Body) : Boolean;
}
}
|
package alternativa.osgi.service.command.impl {
import alternativa.osgi.service.command.FormattedOutput;
public class Command {
public var cmd:String;
public var handler:Function;
public var argsType:Array;
public var scope:String;
private var _help:String;
public function Command(param1:String, param2:String, param3:String, param4:Array, param5:Function) {
super();
this._help = param3;
this.scope = param1;
this.argsType = param4;
this.handler = param5;
this.cmd = param2;
}
public function excute(param1:Array, param2:FormattedOutput) : void {
var local3:Array = new Array();
local3[0] = param2;
var local4:int = 0;
while(local4 < param1.length) {
local3[local4 + 1] = param1[local4];
local4++;
}
this.handler.apply(null,local3);
}
public function help() : String {
return this.argsType + " " + this._help;
}
}
}
|
package alternativa.tanks.model.challenge {
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.panel.model.shop.challenges.toclient.ChallengeShopItemsModelBase;
import projects.tanks.client.panel.model.shop.challenges.toclient.IChallengeShopItemsModelBase;
import projects.tanks.clients.flash.commons.models.challenge.shopitems.ChallengeShopItems;
[ModelInfo]
public class ChallengeShopItemsModel extends ChallengeShopItemsModelBase implements IChallengeShopItemsModelBase, ObjectLoadListener {
[Inject]
public static var challengeShopItems:ChallengeShopItems;
public function ChallengeShopItemsModel() {
super();
}
public function objectLoaded() : void {
challengeShopItems.battlePass = getInitParam().shopBattlePass;
challengeShopItems.starsBundle = getInitParam().starsBundle;
}
public function itemsLoaded() : void {
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapSmallRank25.png")]
public class DefaultRanksBitmaps_bitmapSmallRank25 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapSmallRank25() {
super();
}
}
}
|
package alternativa.tanks.model.videoadvertisement {
import projects.tanks.client.panel.model.videoads.videoadsbattleresult.IVideoAdsBattleResultModelBase;
import projects.tanks.client.panel.model.videoads.videoadsbattleresult.VideoAdsBattleResultModelBase;
[ModelInfo]
public class VideoAdsBattleResultModel extends VideoAdsBattleResultModelBase implements IVideoAdsBattleResultModelBase {
public function VideoAdsBattleResultModel() {
super();
}
public function availableIncreasedRewards(param1:int) : void {
}
public function availableSimpleRewards(param1:int) : void {
}
public function notAvailableRewards() : void {
}
}
}
|
package projects.tanks.client.battlefield.models.user.suicide {
public class SuicideCC {
private var _suicideDelayMS:int;
public function SuicideCC(param1:int = 0) {
super();
this._suicideDelayMS = param1;
}
public function get suicideDelayMS() : int {
return this._suicideDelayMS;
}
public function set suicideDelayMS(param1:int) : void {
this._suicideDelayMS = param1;
}
public function toString() : String {
var local1:String = "SuicideCC [";
local1 += "suicideDelayMS = " + this.suicideDelayMS + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.battlefield.types {
public class Vector3d {
private var _x:Number;
private var _y:Number;
private var _z:Number;
public function Vector3d(param1:Number = 0, param2:Number = 0, param3:Number = 0) {
super();
this._x = param1;
this._y = param2;
this._z = param3;
}
public function get x() : Number {
return this._x;
}
public function set x(param1:Number) : void {
this._x = param1;
}
public function get y() : Number {
return this._y;
}
public function set y(param1:Number) : void {
this._y = param1;
}
public function get z() : Number {
return this._z;
}
public function set z(param1:Number) : void {
this._z = param1;
}
public function toString() : String {
var local1:String = "Vector3d [";
local1 += "x = " + this.x + " ";
local1 += "y = " + this.y + " ";
local1 += "z = " + this.z + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.view {
import alternativa.tanks.controller.events.CallsignCheckResultEvent;
import alternativa.tanks.controller.events.CheckCallsignEvent;
import alternativa.tanks.controller.events.PartnersEvent;
import alternativa.tanks.controller.events.RegistrationBackgroundLoadedEvent;
import alternativa.tanks.controller.events.partners.FinishPartnerRegisterEvent;
import alternativa.tanks.view.forms.PartnersRegistrationForm;
import org.robotlegs.core.IInjector;
import org.robotlegs.mvcs.Mediator;
public class PartnersRegistrationFormMediator extends Mediator {
[Inject]
public var view:PartnersRegistrationForm;
[Inject]
public var injector:IInjector;
public function PartnersRegistrationFormMediator() {
super();
}
override public function onRegister() : void {
this.injector.injectInto(this.view);
addViewListener(CheckCallsignEvent.CHECK_CALLSIGN,dispatch,CheckCallsignEvent);
addViewListener(FinishPartnerRegisterEvent.FINISH_REGISTRATION,dispatch,FinishPartnerRegisterEvent);
addViewListener(PartnersEvent.START_LOGIN,dispatch,PartnersEvent);
addContextListener(RegistrationBackgroundLoadedEvent.LOADED,this.onBackgroundLoaded);
addContextListener(CallsignCheckResultEvent.CALLSIGN_IS_BUSY,this.onCallsignBusy);
addContextListener(CallsignCheckResultEvent.CALLSIGN_IS_FREE,this.onCallsignFree);
addContextListener(CallsignCheckResultEvent.CALLSIGN_IS_INCORRECT,this.onCallsignIncorrect);
}
private function onBackgroundLoaded(param1:RegistrationBackgroundLoadedEvent) : void {
this.view.setBackground(param1.backgroundImage);
}
private function onCallsignFree(param1:CallsignCheckResultEvent) : void {
this.view.alertAboutFreeUid();
}
private function onCallsignBusy(param1:CallsignCheckResultEvent) : void {
this.view.alertAboutBusyUid(param1.freeUids);
}
private function onCallsignIncorrect(param1:CallsignCheckResultEvent) : void {
this.view.alertAboutIncorrectUid();
}
}
}
|
package flashx.textLayout.formats
{
public final class TextAlign
{
public static const START:String = "start";
public static const END:String = "end";
public static const LEFT:String = "left";
public static const RIGHT:String = "right";
public static const CENTER:String = "center";
public static const JUSTIFY:String = "justify";
public function TextAlign()
{
super();
}
}
}
|
package alternativa.tanks.gui.shop.components.window {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.shop.components.window.ShopWindowHeader_crystalsImageClass.png")]
public class ShopWindowHeader_crystalsImageClass extends BitmapAsset {
public function ShopWindowHeader_crystalsImageClass() {
super();
}
}
}
|
package alternativa.tanks.models.battle.gui {
import alternativa.tanks.models.battle.gui.gui.statistics.field.Widget;
import alternativa.tanks.models.battle.gui.gui.statistics.messages.UserAction;
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.types.DamageType;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class BattlefieldGUIEvents implements BattlefieldGUI {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function BattlefieldGUIEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function logUserAction(param1:Long, param2:UserAction, param3:Long) : void {
var i:int = 0;
var m:BattlefieldGUI = null;
var userId:Long = param1;
var action:UserAction = param2;
var targetUserId:Long = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattlefieldGUI(this.impl[i]);
m.logUserAction(userId,action,targetUserId);
i++;
}
}
finally {
Model.popObject();
}
}
public function setIndicatorState(param1:BattleTeam, param2:int) : void {
var i:int = 0;
var m:BattlefieldGUI = null;
var team:BattleTeam = param1;
var newState:int = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattlefieldGUI(this.impl[i]);
m.setIndicatorState(team,newState);
i++;
}
}
finally {
Model.popObject();
}
}
public function setBothIndicatorsState(param1:int, param2:int) : void {
var i:int = 0;
var m:BattlefieldGUI = null;
var redState:int = param1;
var blueState:int = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattlefieldGUI(this.impl[i]);
m.setBothIndicatorsState(redState,blueState);
i++;
}
}
finally {
Model.popObject();
}
}
public function showBattleMessage(param1:uint, param2:String) : void {
var i:int = 0;
var m:BattlefieldGUI = null;
var color:uint = param1;
var text:String = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattlefieldGUI(this.impl[i]);
m.showBattleMessage(color,text);
i++;
}
}
finally {
Model.popObject();
}
}
public function showPointBattleLogMessage(param1:String, param2:UserAction) : void {
var i:int = 0;
var m:BattlefieldGUI = null;
var pointName:String = param1;
var action:UserAction = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattlefieldGUI(this.impl[i]);
m.showPointBattleLogMessage(pointName,action);
i++;
}
}
finally {
Model.popObject();
}
}
public function showUserBattleLogMessage(param1:Long, param2:UserAction) : void {
var i:int = 0;
var m:BattlefieldGUI = null;
var userId:Long = param1;
var action:UserAction = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattlefieldGUI(this.impl[i]);
m.showUserBattleLogMessage(userId,action);
i++;
}
}
finally {
Model.popObject();
}
}
public function showBattleLogMessage(param1:UserAction) : void {
var i:int = 0;
var m:BattlefieldGUI = null;
var action:UserAction = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattlefieldGUI(this.impl[i]);
m.showBattleLogMessage(action);
i++;
}
}
finally {
Model.popObject();
}
}
public function addWidget(param1:Widget) : void {
var i:int = 0;
var m:BattlefieldGUI = null;
var widget:Widget = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattlefieldGUI(this.impl[i]);
m.addWidget(widget);
i++;
}
}
finally {
Model.popObject();
}
}
public function logKillAction(param1:Long, param2:Long, param3:DamageType) : void {
var i:int = 0;
var m:BattlefieldGUI = null;
var killerId:Long = param1;
var targetUserId:Long = param2;
var damageType:DamageType = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattlefieldGUI(this.impl[i]);
m.logKillAction(killerId,targetUserId,damageType);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.panel.model.shop.garageitem.licenseclan {
public interface ILicenseClanShopItemModelBase {
}
}
|
package platform.client.models.commons.periodtime {
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 TimePeriodModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function TimePeriodModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity.LightingEffectEntity;
public class VectorCodecLightingEffectEntityLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecLightingEffectEntityLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(LightingEffectEntity,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = int(LengthCodecHelper.decodeLength(param1));
var local3:Vector.<LightingEffectEntity> = new Vector.<LightingEffectEntity>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = LightingEffectEntity(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:LightingEffectEntity = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<LightingEffectEntity> = Vector.<LightingEffectEntity>(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.camera
{
import alternativa.math.Vector3;
public interface ICameraStateModifier
{
function update(param1:int, param2:int, param3:Vector3, param4:Vector3) : Boolean;
function onAddedToController(param1:IFollowCameraController) : void;
function destroy() : void;
}
}
|
package _codec.projects.tanks.client.tanksservices.model.formatbattle {
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.tanksservices.model.formatbattle.EquipmentConstraintsCC;
public class VectorCodecEquipmentConstraintsCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecEquipmentConstraintsCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(EquipmentConstraintsCC,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.<EquipmentConstraintsCC> = new Vector.<EquipmentConstraintsCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = EquipmentConstraintsCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:EquipmentConstraintsCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<EquipmentConstraintsCC> = Vector.<EquipmentConstraintsCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.uidcheck {
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.tanksservices.model.uidcheck.UidCheckCC;
public class CodecUidCheckCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_length:ICodec;
public function CodecUidCheckCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_length = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:UidCheckCC = new UidCheckCC();
local2.length = this.codec_length.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:UidCheckCC = UidCheckCC(param2);
this.codec_length.encode(param1,local3.length);
}
}
}
|
package assets.window.elemets {
import flash.display.Sprite;
[Embed(source="/_assets/assets.swf", symbol="symbol386")]
public class WindowBottomLeftCorner extends Sprite {
public function WindowBottomLeftCorner() {
super();
}
}
}
|
package controls {
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class Rank {
private static var _ranks:Array;
[Inject]
public static var localeService:ILocaleService;
public function Rank() {
super();
}
public static function name(param1:int) : String {
return ranks[param1 - 1];
}
public static function get ranks() : Array {
var local1:String = null;
if(_ranks == null) {
local1 = localeService.getText(TanksLocale.TEXT_RANK_NAMES);
_ranks = local1.split(",");
}
return _ranks;
}
}
}
|
package _codec.projects.tanks.client.commons.models.layout {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.commons.models.layout.LayoutState;
public class CodecLayoutState implements ICodec {
public function CodecLayoutState() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:LayoutState = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = LayoutState.MATCHMAKING;
break;
case 1:
local2 = LayoutState.BATTLE_SELECT;
break;
case 2:
local2 = LayoutState.GARAGE;
break;
case 3:
local2 = LayoutState.BATTLE;
break;
case 4:
local2 = LayoutState.RELOAD_SPACE;
break;
case 5:
local2 = LayoutState.CLAN;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package alternativa.tanks.models.weapon.shared {
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.physics.PhysicsMaterial;
import alternativa.physics.collision.primitives.CollisionBox;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
public class MarginalCollider {
[Inject]
public static var battleService:BattleService;
private static const BOX_HALFSIZE:Number = 6.5;
private static const midPoint:Vector3 = new Vector3();
private static const halfSize:Vector3 = new Vector3();
private static const direction:Vector3 = new Vector3();
private static const axis:Vector3 = new Vector3();
private static const COS_ONE_DEGREE:Number = Math.cos(Math.PI / 180);
private static const collisionBox:CollisionBox = new CollisionBox(new Vector3(1,1,1),CollisionGroup.STATIC,PhysicsMaterial.DEFAULT_MATERIAL);
public function MarginalCollider() {
super();
}
public static function segmentWithStaticIntersection(param1:Vector3, param2:Vector3) : Boolean {
setupCollisionBox(param1,param2);
var local3:TanksCollisionDetector = battleService.getBattleRunner().getCollisionDetector();
return local3.testStaticCollision(collisionBox);
}
private static function setupCollisionBox(param1:Vector3, param2:Vector3) : void {
halfSize.diff(param1,param2);
halfSize.y = halfSize.length() / 2;
halfSize.x = BOX_HALFSIZE;
halfSize.z = BOX_HALFSIZE;
collisionBox.hs.copy(halfSize);
midPoint.sum(param1,param2);
midPoint.scale(0.5);
var local3:Matrix4 = collisionBox.transform;
local3.toIdentity();
local3.setPosition(midPoint);
direction.diff(param2,param1);
direction.normalize();
var local4:Number = direction.dot(Vector3.Y_AXIS);
if(Math.abs(direction.y) < COS_ONE_DEGREE) {
axis.cross2(Vector3.Y_AXIS,direction);
axis.normalize();
local3.fromAxisAngle(axis,Math.acos(local4));
}
collisionBox.calculateAABB();
}
}
}
|
package alternativa.tanks.models.effects.common {
import alternativa.tanks.bonuses.Bonus;
import alternativa.types.Long;
[ModelInterface]
public interface IBonusCommonModel {
function getBonus(param1:Long) : Bonus;
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p24 extends BitmapAsset
{
public function RangsIcon_p24()
{
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.coinpackage {
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.shop.coinpackage.CoinPackageCC;
public class VectorCodecCoinPackageCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecCoinPackageCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(CoinPackageCC,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.<CoinPackageCC> = new Vector.<CoinPackageCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = CoinPackageCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:CoinPackageCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<CoinPackageCC> = Vector.<CoinPackageCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.model.payment.modes.errors {
[ModelInterface]
public interface ErrorDescription {
function showError(param1:int) : void;
function showUnknownError() : void;
}
}
|
package projects.tanks.client.battlefield.models.bonus.bonuslight {
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 BonusLightModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BonusLightModelServer;
private var client:IBonusLightModelBase = IBonusLightModelBase(this);
private var modelId:Long = Long.getLong(1742678945,1383804656);
public function BonusLightModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BonusLightModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(BonusLightCC,false)));
}
protected function getInitParam() : BonusLightCC {
return BonusLightCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package com.lorentz.SVG.data.path
{
import com.lorentz.SVG.utils.ICloneable;
public class SVGPathCommand implements ICloneable
{
public function SVGPathCommand()
{
}
public function get type():String {
return "";
}
public function clone():Object {
return null;
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class EntranceAlertWindow_DISCOUNT_PICTURE_RU extends BitmapAsset
{
public function EntranceAlertWindow_DISCOUNT_PICTURE_RU()
{
super();
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_bitmapRicochetResistance_x2.png")]
public class ResistancesIcons_bitmapRicochetResistance_x2 extends BitmapAsset {
public function ResistancesIcons_bitmapRicochetResistance_x2() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.gauss.sfx {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.weapon.BasicGlobalGunParams;
import alternativa.tanks.sfx.AnimatedLightEffect;
import alternativa.tanks.sfx.AnimatedSpriteEffect;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.sfx.LightAnimation;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.media.Sound;
public class GaussPowerShotEffect extends PooledObject implements GraphicEffect {
[Inject]
public static var battleService:BattleService;
private const EXPLOSION_OFFSET_TO_CAMERA:Number = 110;
private const EXPLOSION_SPRITE_SIZE:Number = 1500;
private const FAR_SHOT_MIN_DISTANCE:Number = 10000;
private var sfxData:GaussSFXData;
private var weaponPlatform:WeaponPlatform;
private var target:Body;
private var shotCounter:int;
protected var hitPoint:Vector3;
public function GaussPowerShotEffect(param1:Pool) {
super(param1);
}
public function init(param1:GaussSFXData, param2:WeaponPlatform, param3:Body, param4:Vector3) : void {
this.sfxData = param1;
this.weaponPlatform = param2;
this.target = param3;
this.hitPoint = param4;
var local5:BasicGlobalGunParams = new BasicGlobalGunParams();
param2.getBasicGunParams(local5);
this.createPowerMuzzleEffect(local5);
this.createShotSound(local5.muzzlePosition);
this.createLightningEffect(local5.muzzlePosition,param4);
this.createPowerExplosionEffect();
this.createExplosionSound(param4);
}
private function createPowerMuzzleEffect(param1:BasicGlobalGunParams) : void {
var local2:* = new Vector3().copy(this.hitPoint).subtract(param1.muzzlePosition).normalize().scale(50).add(param1.muzzlePosition);
this.createElectroEffect(param1.muzzlePosition,200 + Math.random() * 50,0);
this.createElectroEffect(local2,300 + Math.random() * 50,0);
}
private function createShotSound(param1:Vector3) : void {
var local2:* = battleService.getBattleScene3D().getCamera().position.distanceTo(param1);
var local3:Sound = local2 < this.FAR_SHOT_MIN_DISTANCE ? this.sfxData.secondaryShotSound : this.sfxData.powerShotFarSounds[this.shotCounter % this.sfxData.powerShotFarSounds.length];
battleService.addSound3DEffect(Sound3DEffect.create(param1,Sound3D.create(local3)));
++this.shotCounter;
}
private function createLightningEffect(param1:Vector3, param2:Vector3) : void {
var local3:GaussLightningEffect = GaussLightningEffect(this.getObjectPool().getObject(GaussLightningEffect));
local3.init(param1,param2,this.sfxData.trailTextureMaterial,this.sfxData.lightningTextureMaterial);
battleService.addGraphicEffect(local3);
}
private function createPowerExplosionEffect() : void {
this.createExplosionEffect(this.hitPoint);
this.addLightAnimation(this.hitPoint,this.sfxData.secondaryExplosionLightAnimation);
this.createElectroEffect(this.hitPoint,600 + Math.random() * 200,20 / 60);
this.createElectroEffect(this.hitPoint,600 + Math.random() * 200,26 / 60);
this.createElectroEffect(this.hitPoint,600 + Math.random() * 200,30 / 60);
}
private function createElectroEffect(param1:Vector3, param2:Number, param3:Number) : void {
var local4:GaussElectroEffect = GaussElectroEffect(battleService.getObjectPool().getObject(GaussElectroEffect));
local4.init(param1,param2,this.sfxData.electroTextureMaterial,param3);
battleService.addGraphicEffect(local4);
}
private function addLightAnimation(param1:Vector3, param2:LightAnimation) : void {
var local3:StaticObject3DPositionProvider = StaticObject3DPositionProvider(battleService.getObjectPool().getObject(StaticObject3DPositionProvider));
local3.init(param1,this.EXPLOSION_OFFSET_TO_CAMERA);
var local4:AnimatedLightEffect = AnimatedLightEffect(battleService.getObjectPool().getObject(AnimatedLightEffect));
local4.init(local3,param2);
battleService.addGraphicEffect(local4);
}
private function createExplosionEffect(param1:Vector3) : void {
var local2:StaticObject3DPositionProvider = StaticObject3DPositionProvider(battleService.getObjectPool().getObject(StaticObject3DPositionProvider));
local2.init(param1,this.EXPLOSION_OFFSET_TO_CAMERA);
var local3:AnimatedSpriteEffect = AnimatedSpriteEffect(this.getObjectPool().getObject(AnimatedSpriteEffect));
var local4:* = Math.random() * Math.PI - Math.PI / 2;
local3.init(this.EXPLOSION_SPRITE_SIZE,this.EXPLOSION_SPRITE_SIZE,this.sfxData.explosionElectroTextureAnimation,local4,local2);
battleService.addGraphicEffect(local3);
}
private function getObjectPool() : ObjectPool {
return battleService.getObjectPool();
}
private function createExplosionSound(param1:Vector3) : void {
battleService.addSound3DEffect(Sound3DEffect.create(param1,Sound3D.create(this.sfxData.secondaryHitSound)));
}
public function addedToScene(param1:Scene3DContainer) : void {
}
public function play(param1:int, param2:GameCamera) : Boolean {
return false;
}
public function destroy() : void {
}
public function kill() : void {
}
}
}
|
package platform.client.fp10.core.protocol.codec {
import alternativa.osgi.service.logging.LogService;
import alternativa.osgi.service.logging.Logger;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Byte;
import flash.utils.Dictionary;
import platform.client.fp10.core.network.command.ControlCommand;
import platform.client.fp10.core.network.command.SpaceOpenedCommand;
import platform.client.fp10.core.network.command.control.client.HashRequestCommandCodec;
import platform.client.fp10.core.network.command.control.client.LogCommandCodec;
import platform.client.fp10.core.network.command.control.server.HashResponseCommandCodec;
import platform.client.fp10.core.network.command.control.server.OpenSpaceCommandCodec;
public class ControlRootCodec implements ICodec {
[Inject]
public static var logService:LogService;
private static var logger:Logger;
private var byteCodec:ICodec;
private var serverCommandCodecs:Dictionary = new Dictionary();
private var clientCommandCodecs:Dictionary = new Dictionary();
public function ControlRootCodec() {
super();
}
private static function getLogger() : Logger {
return logger || (logger = logService.getLogger("codec"));
}
public function init(param1:IProtocol) : void {
this.byteCodec = param1.getCodec(new TypeCodecInfo(Byte,false));
param1.registerCodec(new TypeCodecInfo(SpaceOpenedCommand,false),new SpaceOpenedCommandCodec());
this.serverCommandCodecs[ControlCommand.SV_HASH_RESPONSE] = new HashResponseCommandCodec(param1);
this.serverCommandCodecs[ControlCommand.SV_OPEN_SPACE] = new OpenSpaceCommandCodec(param1);
this.clientCommandCodecs[ControlCommand.CL_HASH_REQUEST] = new HashRequestCommandCodec(param1);
this.clientCommandCodecs[ControlCommand.CL_LOG] = new LogCommandCodec(param1);
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local3:ControlCommand = ControlCommand(param2);
this.byteCodec.encode(param1,local3.id);
var local4:ICodec = this.clientCommandCodecs[local3.id];
if(local4 != null) {
local4.encode(param1,param2);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = int(this.byteCodec.decode(param1));
var local3:ICodec = this.serverCommandCodecs[local2];
if(local3 == null) {
getLogger().error("ControlRootCodec::doDecode() No codec found for command id=" + local2);
return null;
}
return local3.decode(param1);
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_twitchIcon.png")]
public class MakeUp_twitchIcon extends BitmapAsset {
public function MakeUp_twitchIcon() {
super();
}
}
}
|
package alternativa.tanks.gui.device {
import alternativa.tanks.gui.crystalbutton.UpgradeSaleIcon;
import alternativa.tanks.gui.shop.shopitems.item.base.ShopButton;
import flash.display.Bitmap;
import flash.display.BitmapData;
public class DeviceButton extends ShopButton {
protected var _discountIcon:Bitmap = UpgradeSaleIcon.createInstance();
protected var deviceImage:Bitmap;
private var slot:int;
public function DeviceButton(param1:int) {
super(new DeviceButtonSkin());
this.slot = param1;
this.setUnclickable();
}
private function addSaleIcon() : void {
addChildAt(this._discountIcon,3);
this._discountIcon.x = 3;
this._discountIcon.y = height - this._discountIcon.height - 3;
this._discountIcon.visible = false;
}
public function setUnclickable() : void {
this.setDevicesLockedIcon();
buttonMode = false;
super.removeEvents();
}
public function setClickable() : void {
super.init();
}
public function setDeviceImage(param1:BitmapData) : void {
if(this.deviceImage != null) {
removeChild(this.deviceImage);
}
this.deviceImage = new Bitmap(param1);
this.deviceImage.x = width - this.deviceImage.width >> 1;
this.deviceImage.y = height - this.deviceImage.height >> 1;
addChildAt(this.deviceImage,2);
}
public function setDevicesAvailableIcon() : void {
this.setDeviceImage(this.getDefaultIcon(this.slot));
}
public function setDevicesLockedIcon() : void {
this.setDeviceImage(DevicesIcons.lockedIcon);
}
public function setSale(param1:Boolean) : void {
this._discountIcon.visible = param1;
}
private function getDefaultIcon(param1:int) : BitmapData {
switch(param1) {
case 0:
return DevicesIcons.iconDefaultSkinBitmap;
case 1:
return DevicesIcons.iconDefaultDeviceBitmap;
case 2:
return DevicesIcons.iconDefaultShotColorBitmap;
default:
throw new Error("Invalid slot index " + param1);
}
}
}
}
|
package scpacker.gui.en
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksIEN_coldload15 extends BitmapAsset
{
public function GTanksIEN_coldload15()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.sfx {
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
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.LightingSFXEntity;
public class ShotgunSFXCC {
private var _explosionMarkTextures:Vector.<TextureResource>;
private var _lightingSFXEntity:LightingSFXEntity;
private var _magazineReloadSound:SoundResource;
private var _pelletTrailTexture:TextureResource;
private var _reloadSound:SoundResource;
private var _shotAcrossTexture:MultiframeTextureResource;
private var _shotAlongTexture:MultiframeTextureResource;
private var _shotSound:SoundResource;
private var _smokeTexture:MultiframeTextureResource;
private var _sparkleTexture:TextureResource;
public function ShotgunSFXCC(param1:Vector.<TextureResource> = null, param2:LightingSFXEntity = null, param3:SoundResource = null, param4:TextureResource = null, param5:SoundResource = null, param6:MultiframeTextureResource = null, param7:MultiframeTextureResource = null, param8:SoundResource = null, param9:MultiframeTextureResource = null, param10:TextureResource = null) {
super();
this._explosionMarkTextures = param1;
this._lightingSFXEntity = param2;
this._magazineReloadSound = param3;
this._pelletTrailTexture = param4;
this._reloadSound = param5;
this._shotAcrossTexture = param6;
this._shotAlongTexture = param7;
this._shotSound = param8;
this._smokeTexture = param9;
this._sparkleTexture = param10;
}
public function get explosionMarkTextures() : Vector.<TextureResource> {
return this._explosionMarkTextures;
}
public function set explosionMarkTextures(param1:Vector.<TextureResource>) : void {
this._explosionMarkTextures = param1;
}
public function get lightingSFXEntity() : LightingSFXEntity {
return this._lightingSFXEntity;
}
public function set lightingSFXEntity(param1:LightingSFXEntity) : void {
this._lightingSFXEntity = param1;
}
public function get magazineReloadSound() : SoundResource {
return this._magazineReloadSound;
}
public function set magazineReloadSound(param1:SoundResource) : void {
this._magazineReloadSound = param1;
}
public function get pelletTrailTexture() : TextureResource {
return this._pelletTrailTexture;
}
public function set pelletTrailTexture(param1:TextureResource) : void {
this._pelletTrailTexture = param1;
}
public function get reloadSound() : SoundResource {
return this._reloadSound;
}
public function set reloadSound(param1:SoundResource) : void {
this._reloadSound = param1;
}
public function get shotAcrossTexture() : MultiframeTextureResource {
return this._shotAcrossTexture;
}
public function set shotAcrossTexture(param1:MultiframeTextureResource) : void {
this._shotAcrossTexture = param1;
}
public function get shotAlongTexture() : MultiframeTextureResource {
return this._shotAlongTexture;
}
public function set shotAlongTexture(param1:MultiframeTextureResource) : void {
this._shotAlongTexture = param1;
}
public function get shotSound() : SoundResource {
return this._shotSound;
}
public function set shotSound(param1:SoundResource) : void {
this._shotSound = param1;
}
public function get smokeTexture() : MultiframeTextureResource {
return this._smokeTexture;
}
public function set smokeTexture(param1:MultiframeTextureResource) : void {
this._smokeTexture = param1;
}
public function get sparkleTexture() : TextureResource {
return this._sparkleTexture;
}
public function set sparkleTexture(param1:TextureResource) : void {
this._sparkleTexture = param1;
}
public function toString() : String {
var local1:String = "ShotgunSFXCC [";
local1 += "explosionMarkTextures = " + this.explosionMarkTextures + " ";
local1 += "lightingSFXEntity = " + this.lightingSFXEntity + " ";
local1 += "magazineReloadSound = " + this.magazineReloadSound + " ";
local1 += "pelletTrailTexture = " + this.pelletTrailTexture + " ";
local1 += "reloadSound = " + this.reloadSound + " ";
local1 += "shotAcrossTexture = " + this.shotAcrossTexture + " ";
local1 += "shotAlongTexture = " + this.shotAlongTexture + " ";
local1 += "shotSound = " + this.shotSound + " ";
local1 += "smokeTexture = " + this.smokeTexture + " ";
local1 += "sparkleTexture = " + this.sparkleTexture + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.weapons.charging {
import projects.tanks.client.battlefield.models.tankparts.weapons.common.charging.IWeaponChargingCommunicationModelBase;
import projects.tanks.client.battlefield.models.tankparts.weapons.common.charging.WeaponChargingCommunicationModelBase;
[ModelInfo]
public class WeaponChargingCommunicationModel extends WeaponChargingCommunicationModelBase implements IWeaponChargingCommunicationModelBase, WeaponChargingCommunication {
public function WeaponChargingCommunicationModel() {
super();
}
public function startCharging(param1:int) : void {
server.startCharging(param1);
}
public function finishCharging(param1:int) : void {
server.finishCharging(param1);
}
[Obfuscation(rename="false")]
public function handleChargingStart() : void {
this.listeners().handleChargingStart();
}
[Obfuscation(rename="false")]
public function handleChargingFinish(param1:int) : void {
this.listeners().handleChargingFinish(param1);
}
private function listeners() : WeaponChargingListener {
return WeaponChargingListener(object.event(WeaponChargingListener));
}
}
}
|
package org.osflash.signals {
import flash.errors.IllegalOperationError;
import flash.utils.Dictionary;
import flash.utils.getQualifiedClassName;
[DefaultProperty("valueClasses")]
public class Signal implements ISignalOwner, IDispatcher {
protected var _valueClasses:Array;
protected var listeners:Array;
protected var onceListeners:Dictionary;
protected var listenersNeedCloning:Boolean = false;
public function Signal(... valueClasses) {
super();
this.listeners = [];
this.onceListeners = new Dictionary();
if(valueClasses.length == 1 && valueClasses[0] is Array) {
valueClasses = valueClasses[0];
}
this.valueClasses = valueClasses;
}
public function get valueClasses() : Array {
return this._valueClasses;
}
public function set valueClasses(value:Array) : void {
this._valueClasses = Boolean(value) ? value.slice() : [];
for(var i:int = int(this._valueClasses.length); Boolean(i--); ) {
if(!(this._valueClasses[i] is Class)) {
throw new ArgumentError("Invalid valueClasses argument: item at index " + i + " should be a Class but was:<" + this._valueClasses[i] + ">." + getQualifiedClassName(this._valueClasses[i]));
}
}
}
public function get numListeners() : uint {
return this.listeners.length;
}
public function add(listener:Function) : Function {
this.registerListener(listener);
return listener;
}
public function addOnce(listener:Function) : Function {
this.registerListener(listener,true);
return listener;
}
public function remove(listener:Function) : Function {
var index:int = int(this.listeners.indexOf(listener));
if(index == -1) {
return listener;
}
if(this.listenersNeedCloning) {
this.listeners = this.listeners.slice();
this.listenersNeedCloning = false;
}
this.listeners.splice(index,1);
delete this.onceListeners[listener];
return listener;
}
public function removeAll() : void {
for(var i:uint = this.listeners.length; Boolean(i--); ) {
this.remove(this.listeners[i] as Function);
}
}
public function dispatch(... valueObjects) : void {
var valueObject:Object = null;
var valueClass:Class = null;
var listener:Function = null;
var numValueClasses:int = int(this._valueClasses.length);
if(valueObjects.length < numValueClasses) {
throw new ArgumentError("Incorrect number of arguments. Expected at least " + numValueClasses + " but received " + valueObjects.length + ".");
}
for(var i:int = 0; i < numValueClasses; i++) {
valueObject = valueObjects[i];
if(!(valueObject === null || valueObject is (valueClass = this._valueClasses[i]))) {
throw new ArgumentError("Value object <" + valueObject + "> is not an instance of <" + valueClass + ">.");
}
}
if(!this.listeners.length) {
return;
}
this.listenersNeedCloning = true;
switch(valueObjects.length) {
case 0:
for each(listener in this.listeners) {
if(Boolean(this.onceListeners[listener])) {
this.remove(listener);
}
listener();
}
break;
case 1:
for each(listener in this.listeners) {
if(Boolean(this.onceListeners[listener])) {
this.remove(listener);
}
listener(valueObjects[0]);
}
break;
default:
for each(listener in this.listeners) {
if(Boolean(this.onceListeners[listener])) {
this.remove(listener);
}
listener.apply(null,valueObjects);
}
}
this.listenersNeedCloning = false;
}
protected function registerListener(listener:Function, once:Boolean = false) : void {
var argumentString:String = null;
if(listener.length < this._valueClasses.length) {
argumentString = listener.length == 1 ? "argument" : "arguments";
throw new ArgumentError("Listener has " + listener.length + " " + argumentString + " but it needs at least " + this._valueClasses.length + " to match the given value classes.");
}
if(!this.listeners.length) {
this.listeners[0] = listener;
if(once) {
this.onceListeners[listener] = true;
}
return;
}
if(this.listeners.indexOf(listener) >= 0) {
if(Boolean(this.onceListeners[listener]) && !once) {
throw new IllegalOperationError("You cannot addOnce() then add() the same listener without removing the relationship first.");
}
if(!this.onceListeners[listener] && once) {
throw new IllegalOperationError("You cannot add() then addOnce() the same listener without removing the relationship first.");
}
return;
}
if(this.listenersNeedCloning) {
this.listeners = this.listeners.slice();
this.listenersNeedCloning = false;
}
this.listeners[this.listeners.length] = listener;
if(once) {
this.onceListeners[listener] = true;
}
}
}
}
|
package alternativa.engine3d.loaders.collada {
use namespace collada;
public class DaeImage extends DaeElement {
public function DaeImage(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
public function get init_from() : String {
var local2:XML = null;
var local1:XML = data.init_from[0];
if(local1 != null) {
if(document.versionMajor > 4) {
local2 = local1.ref[0];
return local2 == null ? null : local2.text().toString();
}
return local1.text().toString();
}
return null;
}
}
}
|
package alternativa.tanks.model.payment
{
public interface IPaymentListener
{
function setInitData(param1:Array, param2:Array, param3:String, param4:int, param5:String) : void;
function setOperators(param1:String, param2:Array) : void;
function setNumbers(param1:int, param2:Array) : void;
}
}
|
package controls.dropdownlist {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.dropdownlist.AccountsBackground_bitmapBG.jpg")]
public class AccountsBackground_bitmapBG extends BitmapAsset {
public function AccountsBackground_bitmapBG() {
super();
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class AntiAddictionWindow_Watches5Hours extends BitmapAsset
{
public function AntiAddictionWindow_Watches5Hours()
{
super();
}
}
}
|
package com.alternativaplatform.projects.tanks.client.commons.types
{
public class TankSpecification
{
public var speed:Number;
public var turnSpeed:Number;
public var turretRotationSpeed:Number;
public function TankSpecification()
{
super();
}
}
}
|
package alternativa.osgi.service.logging.impl {
import alternativa.osgi.service.logging.LogLevel;
import alternativa.osgi.service.logging.LogTarget;
import alternativa.osgi.service.logging.Logger;
public class LoggerImpl implements Logger {
private var logTarget:LogTarget;
private var object:Object;
public function LoggerImpl(param1:Object, param2:LogTarget) {
super();
this.object = param1;
this.logTarget = param2;
}
public function trace(param1:String, param2:Array = null) : void {
this.logTarget.log(this.object,LogLevel.TRACE,param1,param2);
}
public function debug(param1:String, param2:Array = null) : void {
this.logTarget.log(this.object,LogLevel.DEBUG,param1,param2);
}
public function info(param1:String, param2:Array = null) : void {
this.logTarget.log(this.object,LogLevel.INFO,param1,param2);
}
public function warning(param1:String, param2:Array = null) : void {
this.logTarget.log(this.object,LogLevel.WARNING,param1,param2);
}
public function error(param1:String, param2:Array = null) : void {
this.logTarget.log(this.object,LogLevel.ERROR,param1,param2);
}
}
}
|
package mx.core
{
import flash.display.BitmapData;
import flash.display.DisplayObjectContainer;
import flash.events.Event;
import flash.geom.Point;
import flash.system.ApplicationDomain;
use namespace mx_internal;
public class BitmapAsset extends FlexBitmap implements IFlexAsset, IFlexDisplayObject, ILayoutDirectionElement
{
mx_internal static const VERSION:String = "4.6.0.23201";
private static var FlexVersionClass:Class;
private static var MatrixUtilClass:Class;
private var layoutFeaturesClass:Class;
private var layoutFeatures:IAssetLayoutFeatures;
private var _height:Number;
private var _layoutDirection:String = "ltr";
public function BitmapAsset(bitmapData:BitmapData = null, pixelSnapping:String = "auto", smoothing:Boolean = false)
{
var appDomain:ApplicationDomain = null;
super(bitmapData,pixelSnapping,smoothing);
if(FlexVersionClass == null)
{
appDomain = ApplicationDomain.currentDomain;
if(appDomain.hasDefinition("mx.core::FlexVersion"))
{
FlexVersionClass = Class(appDomain.getDefinition("mx.core::FlexVersion"));
}
}
if(FlexVersionClass && FlexVersionClass["compatibilityVersion"] >= FlexVersionClass["VERSION_4_0"])
{
this.addEventListener(Event.ADDED,this.addedHandler);
}
}
override public function get x() : Number
{
return this.layoutFeatures == null ? Number(super.x) : Number(this.layoutFeatures.layoutX);
}
override public function set x(value:Number) : void
{
if(this.x == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.x = value;
}
else
{
this.layoutFeatures.layoutX = value;
this.validateTransformMatrix();
}
}
override public function get y() : Number
{
return this.layoutFeatures == null ? Number(super.y) : Number(this.layoutFeatures.layoutY);
}
override public function set y(value:Number) : void
{
if(this.y == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.y = value;
}
else
{
this.layoutFeatures.layoutY = value;
this.validateTransformMatrix();
}
}
override public function get z() : Number
{
return this.layoutFeatures == null ? Number(super.z) : Number(this.layoutFeatures.layoutZ);
}
override public function set z(value:Number) : void
{
if(this.z == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.z = value;
}
else
{
this.layoutFeatures.layoutZ = value;
this.validateTransformMatrix();
}
}
override public function get width() : Number
{
var p:Point = null;
if(this.layoutFeatures == null)
{
return super.width;
}
if(MatrixUtilClass != null)
{
p = MatrixUtilClass["transformSize"](this.layoutFeatures.layoutWidth,this._height,transform.matrix);
}
return Boolean(p) ? Number(p.x) : Number(super.width);
}
override public function set width(value:Number) : void
{
if(this.width == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.width = value;
}
else
{
this.layoutFeatures.layoutWidth = value;
this.layoutFeatures.layoutScaleX = this.measuredWidth != 0 ? Number(value / this.measuredWidth) : Number(0);
this.validateTransformMatrix();
}
}
override public function get height() : Number
{
var p:Point = null;
if(this.layoutFeatures == null)
{
return super.height;
}
if(MatrixUtilClass != null)
{
p = MatrixUtilClass["transformSize"](this.layoutFeatures.layoutWidth,this._height,transform.matrix);
}
return Boolean(p) ? Number(p.y) : Number(super.height);
}
override public function set height(value:Number) : void
{
if(this.height == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.height = value;
}
else
{
this._height = value;
this.layoutFeatures.layoutScaleY = this.measuredHeight != 0 ? Number(value / this.measuredHeight) : Number(0);
this.validateTransformMatrix();
}
}
override public function get rotationX() : Number
{
return this.layoutFeatures == null ? Number(super.rotationX) : Number(this.layoutFeatures.layoutRotationX);
}
override public function set rotationX(value:Number) : void
{
if(this.rotationX == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.rotationX = value;
}
else
{
this.layoutFeatures.layoutRotationX = value;
this.validateTransformMatrix();
}
}
override public function get rotationY() : Number
{
return this.layoutFeatures == null ? Number(super.rotationY) : Number(this.layoutFeatures.layoutRotationY);
}
override public function set rotationY(value:Number) : void
{
if(this.rotationY == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.rotationY = value;
}
else
{
this.layoutFeatures.layoutRotationY = value;
this.validateTransformMatrix();
}
}
override public function get rotationZ() : Number
{
return this.layoutFeatures == null ? Number(super.rotationZ) : Number(this.layoutFeatures.layoutRotationZ);
}
override public function set rotationZ(value:Number) : void
{
if(this.rotationZ == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.rotationZ = value;
}
else
{
this.layoutFeatures.layoutRotationZ = value;
this.validateTransformMatrix();
}
}
override public function get rotation() : Number
{
return this.layoutFeatures == null ? Number(super.rotation) : Number(this.layoutFeatures.layoutRotationZ);
}
override public function set rotation(value:Number) : void
{
if(this.rotation == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.rotation = value;
}
else
{
this.layoutFeatures.layoutRotationZ = value;
this.validateTransformMatrix();
}
}
override public function get scaleX() : Number
{
return this.layoutFeatures == null ? Number(super.scaleX) : Number(this.layoutFeatures.layoutScaleX);
}
override public function set scaleX(value:Number) : void
{
if(this.scaleX == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.scaleX = value;
}
else
{
this.layoutFeatures.layoutScaleX = value;
this.layoutFeatures.layoutWidth = Math.abs(value) * this.measuredWidth;
this.validateTransformMatrix();
}
}
override public function get scaleY() : Number
{
return this.layoutFeatures == null ? Number(super.scaleY) : Number(this.layoutFeatures.layoutScaleY);
}
override public function set scaleY(value:Number) : void
{
if(this.scaleY == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.scaleY = value;
}
else
{
this.layoutFeatures.layoutScaleY = value;
this._height = Math.abs(value) * this.measuredHeight;
this.validateTransformMatrix();
}
}
override public function get scaleZ() : Number
{
return this.layoutFeatures == null ? Number(super.scaleZ) : Number(this.layoutFeatures.layoutScaleZ);
}
override public function set scaleZ(value:Number) : void
{
if(this.scaleZ == value)
{
return;
}
if(this.layoutFeatures == null)
{
super.scaleZ = value;
}
else
{
this.layoutFeatures.layoutScaleZ = value;
this.validateTransformMatrix();
}
}
[Inspectable(category="General",enumeration="ltr,rtl")]
public function get layoutDirection() : String
{
return this._layoutDirection;
}
public function set layoutDirection(value:String) : void
{
if(value == this._layoutDirection)
{
return;
}
this._layoutDirection = value;
this.invalidateLayoutDirection();
}
public function get measuredHeight() : Number
{
if(bitmapData)
{
return bitmapData.height;
}
return 0;
}
public function get measuredWidth() : Number
{
if(bitmapData)
{
return bitmapData.width;
}
return 0;
}
public function invalidateLayoutDirection() : void
{
var mirror:Boolean = false;
var p:DisplayObjectContainer = parent;
while(p)
{
if(p is ILayoutDirectionElement)
{
mirror = this._layoutDirection != null && ILayoutDirectionElement(p).layoutDirection != null && this._layoutDirection != ILayoutDirectionElement(p).layoutDirection;
if(mirror && this.layoutFeatures == null)
{
this.initAdvancedLayoutFeatures();
if(this.layoutFeatures != null)
{
this.layoutFeatures.mirror = mirror;
this.validateTransformMatrix();
}
}
else if(!mirror && this.layoutFeatures)
{
this.layoutFeatures.mirror = mirror;
this.validateTransformMatrix();
this.layoutFeatures = null;
}
break;
}
p = p.parent;
}
}
public function move(x:Number, y:Number) : void
{
this.x = x;
this.y = y;
}
public function setActualSize(newWidth:Number, newHeight:Number) : void
{
this.width = newWidth;
this.height = newHeight;
}
private function addedHandler(event:Event) : void
{
this.invalidateLayoutDirection();
}
private function initAdvancedLayoutFeatures() : void
{
var appDomain:ApplicationDomain = null;
var features:IAssetLayoutFeatures = null;
if(this.layoutFeaturesClass == null)
{
appDomain = ApplicationDomain.currentDomain;
if(appDomain.hasDefinition("mx.core::AdvancedLayoutFeatures"))
{
this.layoutFeaturesClass = Class(appDomain.getDefinition("mx.core::AdvancedLayoutFeatures"));
}
if(MatrixUtilClass == null)
{
if(appDomain.hasDefinition("mx.utils::MatrixUtil"))
{
MatrixUtilClass = Class(appDomain.getDefinition("mx.utils::MatrixUtil"));
}
}
}
if(this.layoutFeaturesClass != null)
{
features = new this.layoutFeaturesClass();
features.layoutScaleX = this.scaleX;
features.layoutScaleY = this.scaleY;
features.layoutScaleZ = this.scaleZ;
features.layoutRotationX = this.rotationX;
features.layoutRotationY = this.rotationY;
features.layoutRotationZ = this.rotation;
features.layoutX = this.x;
features.layoutY = this.y;
features.layoutZ = this.z;
features.layoutWidth = this.width;
this._height = this.height;
this.layoutFeatures = features;
}
}
private function validateTransformMatrix() : void
{
if(this.layoutFeatures != null)
{
if(this.layoutFeatures.is3D)
{
super.transform.matrix3D = this.layoutFeatures.computedMatrix3D;
}
else
{
super.transform.matrix = this.layoutFeatures.computedMatrix;
}
}
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.armor.rankup {
import platform.client.fp10.core.resource.types.SoundResource;
public class TankRankUpEffectCC {
private var _rankUpSound:SoundResource;
public function TankRankUpEffectCC(param1:SoundResource = null) {
super();
this._rankUpSound = param1;
}
public function get rankUpSound() : SoundResource {
return this._rankUpSound;
}
public function set rankUpSound(param1:SoundResource) : void {
this._rankUpSound = param1;
}
public function toString() : String {
var local1:String = "TankRankUpEffectCC [";
local1 += "rankUpSound = " + this.rankUpSound + " ";
return local1 + "]";
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.user.bossstate {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import projects.tanks.client.battlefield.models.user.bossstate.BossRelationRole;
import projects.tanks.client.battlefield.models.user.bossstate.BossStateCC;
public class CodecBossStateCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_enabled:ICodec;
private var codec_hullId:ICodec;
private var codec_local:ICodec;
private var codec_role:ICodec;
private var codec_weaponId:ICodec;
public function CodecBossStateCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_enabled = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_hullId = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_local = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_role = param1.getCodec(new EnumCodecInfo(BossRelationRole,false));
this.codec_weaponId = param1.getCodec(new TypeCodecInfo(Long,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BossStateCC = new BossStateCC();
local2.enabled = this.codec_enabled.decode(param1) as Boolean;
local2.hullId = this.codec_hullId.decode(param1) as Long;
local2.local = this.codec_local.decode(param1) as Boolean;
local2.role = this.codec_role.decode(param1) as BossRelationRole;
local2.weaponId = this.codec_weaponId.decode(param1) as Long;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BossStateCC = BossStateCC(param2);
this.codec_enabled.encode(param1,local3.enabled);
this.codec_hullId.encode(param1,local3.hullId);
this.codec_local.encode(param1,local3.local);
this.codec_role.encode(param1,local3.role);
this.codec_weaponId.encode(param1,local3.weaponId);
}
}
}
|
package projects.tanks.client.garage.models.item.grouped {
public interface IGroupedItemModelBase {
}
}
|
package projects.tanks.client.panel.model.payment.modes.alipay {
import projects.tanks.client.panel.model.payment.types.PaymentRequestUrl;
public interface IAlipayPaymentModelBase {
function receiveUrl(param1:PaymentRequestUrl) : void;
}
}
|
package forms.friends.list
{
import alternativa.types.Long;
import fl.controls.List;
import flash.display.Sprite;
import flash.utils.Dictionary;
import forms.friends.list.dataprovider.FriendsDataProvider;
import utils.ScrollStyleUtils;
public class FriendsList extends Sprite
{
protected var _dataProvider:FriendsDataProvider;
protected var _list:List;
protected var _width:Number;
protected var _height:Number;
protected var _viewed:Dictionary;
private var de:Long;
public function FriendsList()
{
this._dataProvider = new FriendsDataProvider();
this._list = new List();
this._viewed = new Dictionary();
this.de = new Long(0,10000);
super();
}
protected function init(param1:Object) : void
{
this._list.rowHeight = 20;
this._list.setStyle("cellRenderer",param1);
this._list.focusEnabled = true;
this._list.selectable = false;
ScrollStyleUtils.setGreenStyle(this._list);
this._list.dataProvider = this._dataProvider;
addChild(this._list);
ScrollStyleUtils.setGreenStyle(this._list);
}
protected function isViewed(param1:Object) : Boolean
{
return param1 in this._viewed;
}
protected function setAsViewed(param1:Object) : void
{
this._viewed[param1] = true;
}
protected function fillFriendsList(friends_json:String) : void
{
var obj:Object = null;
var i:int = 0;
for each(obj in JSON.parse(friends_json).friends)
{
if(obj == null)
{
return;
}
this._dataProvider.addUser(obj.id,obj.battleId,i,obj.rank,obj.online);
i++;
}
if(obj == null)
{
return;
}
this._dataProvider.setOnlineUser(new Long(0,obj.id),obj.online);
this._dataProvider.refresh();
}
protected function fillIncomingList(friends_json:String) : void
{
var obj:Object = null;
var i:int = 0;
for each(obj in JSON.parse(friends_json).incoming)
{
if(obj == null)
{
return;
}
this._dataProvider.addUser(obj.id,"",i,obj.rank,true);
i++;
}
if(obj == null)
{
return;
}
this._dataProvider.setOnlineUser(new Long(0,obj.id),true);
this._dataProvider.refresh();
}
protected function fillOutcomingList(friends_json:String) : void
{
var obj:Object = null;
var i:int = 0;
for each(obj in JSON.parse(friends_json).outcoming)
{
if(obj == null)
{
return;
}
this._dataProvider.addUser(obj.id,"",i,obj.rank,true);
i++;
}
if(obj == null)
{
return;
}
this._dataProvider.setOnlineUser(new Long(0,obj.id),true);
this._dataProvider.refresh();
}
public function addFriend(uid:String, id:int, rank:int, isOnline:Boolean) : void
{
this._dataProvider.addUser(uid,"",id,rank,isOnline);
this._dataProvider.setOnlineUser(new Long(0,id),isOnline);
this._dataProvider.refresh();
}
protected function filterByProperty(param1:String, param2:String) : void
{
this._dataProvider.setFilter(param1,param2);
this.resize(this._width,this._height);
}
public function resize(param1:Number, param2:Number) : void
{
this._width = param1;
this._height = param2;
var _loc3_:Boolean = this._list.verticalScrollBar.visible;
this._list.width = !!_loc3_ ? Number(Number(Number(this._width + 6))) : Number(Number(Number(this._width)));
this._list.height = this._height;
}
}
}
|
package alternativa.model.general.dispatcher
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.osgi.service.alert.IAlertService;
import alternativa.osgi.service.log.ILogService;
import alternativa.osgi.service.log.LogLevel;
import alternativa.protocol.codec.ICodec;
import alternativa.protocol.codec.NullMap;
import alternativa.protocol.codec.primitive.LongCodec;
import alternativa.protocol.factory.ICodecFactory;
import alternativa.register.ClientClass;
import alternativa.register.ObjectRegister;
import alternativa.register.SpaceInfo;
import alternativa.service.IClassService;
import alternativa.service.IModelService;
import alternativa.service.ISpaceService;
import alternativa.types.Long;
import flash.utils.IDataInput;
public class DispatcherModel implements IModel
{
private static const CHANNEL:String = "DISPATCHER";
private var _objectRegister:ObjectRegister;
private var classRegister:IClassService;
public function DispatcherModel()
{
super();
this.classRegister = IClassService(Main.osgi.getService(IClassService));
}
public function get interfaces() : Vector.<Class>
{
return Vector.<Class>([IModel]);
}
public function _initObject(clientObject:ClientObject, params:Object) : void
{
}
public function invoke(clientObject:ClientObject, methodId:String, codecFactory:ICodecFactory, dataInput:IDataInput, nullMap:NullMap) : void
{
var spaceId:Long = null;
var space:SpaceInfo = null;
var spaces:Array = null;
var i:int = 0;
switch(methodId)
{
case "a":
spaceId = Long(codecFactory.getCodec(Long).decode(dataInput,nullMap,true));
Main.writeVarsToConsoleChannel(CHANNEL,"DispatcherModel connected space id=%1",spaceId);
spaces = ISpaceService(Main.osgi.getService(ISpaceService)).spaceList;
for(i = 0; i < spaces.length; i++)
{
if(SpaceInfo(spaces[i]).objectRegister == this._objectRegister)
{
space = SpaceInfo(spaces[i]);
}
}
if(space != null)
{
ISpaceService(Main.osgi.getService(ISpaceService)).setIdForSpace(space,spaceId);
break;
}
throw new Error("DispatcherModel connected space не найден в реестре");
break;
case "s":
Main.writeVarsToConsoleChannel(CHANNEL,"[DispatcherModel.invoke] LOAD command recieved");
this.loadEntities(codecFactory,dataInput,nullMap);
break;
case "":
Main.writeVarsToConsoleChannel(CHANNEL,"[DispatcherModel.invoke] UNLOAD command recieved");
this.unloadEntities(codecFactory,dataInput,nullMap);
}
}
private function loadEntities(codecFactory:ICodecFactory, dataInput:IDataInput, nullMap:NullMap) : void
{
// EDITED
//var idx:int = 0;
//var modelRegister:IModelService = null;
//var model:IModel = null;
//var params:Object = null;
//var parentModelParams:Object = null;
//Main.writeVarsToConsoleChannel(CHANNEL,"");
//Main.writeVarsToConsoleChannel(CHANNEL,"Load object. Null map size=%1",nullMap.getSize());
//var idCodec:ICodec = Main.codecFactory.getCodec(Long);
//Main.writeVarsToConsoleChannel(CHANNEL,"Load object id=%1, class id=%2",null,null);
//var object:ClientObject = this._objectRegister.createObject(null,this.classRegister.getClass(null),"object " + null.toString());
//var parentClass:ClientClass = IClassService(Main.osgi.getService(IClassService)).getClass(null);
//var modelId:Vector.<String> = parentClass.models;
//var modelsCount:int = modelId.length;
//for(idx = 0; idx < modelsCount; idx++)
//{
// modelRegister = IModelService(Main.osgi.getService(IModelService));
// model = modelRegister.getModel(modelId[idx]);
// if(model == null)
// {
// Main.writeVarsToConsoleChannel(CHANNEL,"Model with id [%1] not found in registry",modelId[idx]);
// (Main.osgi.getService(ILogService) as ILogService).log(LogLevel.LOG_ERROR,"LOAD OBJECT ERROR: Model with id " + modelId[idx] + " not found in registry!");
// (Main.osgi.getService(IAlertService) as IAlertService).showAlert("A fatal error has occurred");
// }
// else
// {
// Main.writeVarsToConsoleChannel(CHANNEL,"Init object model id=%4, model=%1, data length=%2, null map size=%3",model,dataInput.bytesAvailable,nullMap.getSize(),model.id);
// parentModelParams = parentClass.modelsParams[modelId[idx]];
// params = parentModelParams;
// Main.writeVarsToConsoleChannel(CHANNEL,"Parent model params=%1",params);
// if(params != null)
// {
// object.putInitParams(model,params);
// model._initObject(object,params);
// }
// }
//}
//var listeners:Vector.<IModel> = IModelService(Main.osgi.getService(IModelService)).getModelsForObject(object,IObjectLoadListener);
//for(var l:int = 0; l < listeners.length; IObjectLoadListener(listeners[l]).objectLoaded(object),l++)
//{
//}
return
}
private function unloadEntities(codecFactory:ICodecFactory, dataInput:IDataInput, nullMap:NullMap) : void
{
var longCodec:LongCodec = LongCodec(codecFactory.getCodec(Long));
Main.writeToConsole("[DispatcherModel.invoke] unload " + null);
this._objectRegister.destroyObject(null);
}
public function set objectRegister(register:ObjectRegister) : void
{
this._objectRegister = register;
}
public function get id() : String
{
return "";
}
}
}
|
package _codec.projects.tanks.client.users.model.switchbattleinvite {
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.users.model.switchbattleinvite.NotificationEnabledCC;
public class VectorCodecNotificationEnabledCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecNotificationEnabledCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(NotificationEnabledCC,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.<NotificationEnabledCC> = new Vector.<NotificationEnabledCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = NotificationEnabledCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:NotificationEnabledCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<NotificationEnabledCC> = Vector.<NotificationEnabledCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package controls.caprefbutton {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.caprefbutton.CapRefButton_bitmapBG.png")]
public class CapRefButton_bitmapBG extends BitmapAsset {
public function CapRefButton_bitmapBG() {
super();
}
}
}
|
package alternativa.tanks.gui.settings.controls {
import alternativa.tanks.service.settings.SettingEnum;
import controls.Slider;
public class SliderSetting extends Slider implements SettingControl {
private var setting:SettingEnum;
public function SliderSetting(param1:SettingEnum) {
super();
this.setting = param1;
}
public function getSetting() : SettingEnum {
return this.setting;
}
public function getSettingValue() : Object {
return value * 100;
}
}
}
|
package platform.client.fp10.core.service.serverlog.impl {
import flash.display.Graphics;
import flash.display.Sprite;
import flash.display.Stage;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.system.System;
import flash.text.TextField;
import flash.text.TextFormat;
import flash.ui.Keyboard;
public class ServerLogPanel {
private var textFormat:TextFormat = new TextFormat("Courier",14);
private var textColor:uint = 0;
private var bgColor:uint = 14540253;
private var stage:Stage;
private var btnShowLog:ErrorLogButton;
private var btnCloseLog:ErrorLogButton;
private var btnCopyLog:ErrorLogButton;
private var btnClearLog:ErrorLogButton;
private var container:Sprite;
private var output:Sprite;
private var levelFilter:Object = {};
private var entries:Vector.<LogEntry> = new Vector.<LogEntry>();
private var filteredEntries:Vector.<LogEntry> = new Vector.<LogEntry>();
private var logLevels:Array = [];
private var textFields:Vector.<TextField> = new Vector.<TextField>();
private var filterButtons:Vector.<FilterButton> = new Vector.<FilterButton>();
private var charWidth:int;
private var charHeight:int;
private var hSpacing:int = 2;
private var numLines:int;
private var lineWidth:int;
private var currentLine:int;
public function ServerLogPanel(param1:Stage) {
super();
this.stage = param1;
this.container = new Sprite();
this.btnShowLog = new ErrorLogButton("[Click to view server log messages]",16776960,16711680);
this.btnShowLog.addEventListener(MouseEvent.CLICK,this.onBtnShowLogClick);
this.btnCloseLog = new ErrorLogButton("[Close]",65280,0);
this.btnCloseLog.addEventListener(MouseEvent.CLICK,this.onBtnCloseClick);
this.container.addChild(this.btnCloseLog);
this.btnCopyLog = new ErrorLogButton("[Copy to clipboard]",65280,0);
this.btnCopyLog.addEventListener(MouseEvent.CLICK,this.onBtnCopyClick);
this.btnCopyLog.x = this.btnCloseLog.width;
this.container.addChild(this.btnCopyLog);
this.btnClearLog = new ErrorLogButton("[Clear]",65280,0);
this.btnClearLog.addEventListener(MouseEvent.CLICK,this.onBtnClearClick);
this.btnClearLog.x = this.btnCopyLog.x + this.btnCopyLog.width;
this.container.addChild(this.btnClearLog);
this.container.addEventListener(KeyboardEvent.KEY_DOWN,this.onKey);
this.container.addEventListener(MouseEvent.MOUSE_WHEEL,this.onMouseWheel);
this.output = new Sprite();
this.container.addChild(this.output);
param1.addEventListener(Event.RESIZE,this.onStageResize);
this.calcTextMetrics(param1);
this.onStageResize(null);
}
public function addLogMessage(param1:String, param2:String) : void {
var local6:String = null;
var local7:int = 0;
this.updateLogLevels(param1);
var local3:int = this.currentLine;
var local4:int = this.lineWidth - param1.length - 3;
var local5:Array = param2.split(/\n|\r|\n\r/);
for each(local6 in local5) {
local7 = 0;
while(local7 < local6.length) {
this.addLogEntry(new LogEntry(param1,local6.substr(local7,local4)));
local7 += local4;
}
}
if(this.container.parent == null) {
this.stage.addChild(this.btnShowLog);
} else if(local3 != this.currentLine) {
this.updateOutput();
}
}
private function addLogEntry(param1:LogEntry) : void {
this.entries.push(param1);
if(this.levelFilter[param1.logLevel] != null) {
this.filteredEntries.push(param1);
if(this.currentLine == this.filteredEntries.length - 1) {
this.currentLine = this.filteredEntries.length;
}
}
}
private function updateOutput() : void {
if(this.container.parent != null) {
this.printEntries(this.filteredEntries,this.currentLine);
}
}
private function calcTextMetrics(param1:Stage) : void {
var local2:TextField = new TextField();
local2.defaultTextFormat = this.textFormat;
local2.text = "a";
param1.addChild(local2);
this.charWidth = local2.textWidth;
this.charHeight = local2.textHeight;
param1.removeChild(local2);
}
private function resizeOutput(param1:int, param2:int) : void {
this.numLines = param2 / (this.charHeight + this.hSpacing);
this.lineWidth = param1 / this.charWidth;
this.updateTextFields(param1);
this.scrollOutput(0);
var local3:Graphics = this.output.graphics;
local3.clear();
local3.beginFill(this.bgColor);
local3.drawRect(0,0,param1,param2);
local3.endFill();
}
private function updateTextFields(param1:int) : void {
var local4:TextField = null;
while(this.textFields.length > this.numLines) {
this.output.removeChild(this.textFields.pop());
}
while(this.textFields.length < this.numLines) {
this.createTextField();
}
var local2:int = this.charHeight + this.hSpacing;
var local3:int = 0;
while(local3 < this.textFields.length) {
local4 = this.textFields[local3];
local4.y = local3 * local2;
local4.width = param1;
local3++;
}
}
private function createTextField() : void {
var local1:TextField = new TextField();
local1.textColor = this.textColor;
local1.defaultTextFormat = this.textFormat;
this.output.addChild(local1);
this.textFields.push(local1);
}
private function printEntries(param1:Vector.<LogEntry>, param2:int) : void {
var local4:int = 0;
var local5:LogEntry = null;
var local3:int = param2 - this.numLines;
if(local3 < 0) {
local3 = 0;
} else {
param2 = this.numLines;
}
local4 = 0;
while(local4 < param2) {
local5 = param1[local3 + local4];
this.textFields[local4].text = local5.toString();
local4++;
}
while(local4 < this.numLines) {
this.textFields[local4++].text = "";
}
}
private function filterByLevels() : void {
var local1:LogEntry = null;
this.filteredEntries.length = 0;
for each(local1 in this.entries) {
if(this.levelFilter[local1.logLevel] != null) {
this.filteredEntries.push(local1);
}
}
this.scrollOutput(0);
}
private function updateLogLevels(param1:String) : void {
var local3:FilterButton = null;
var local2:int = int(this.logLevels.indexOf(param1));
if(local2 < 0) {
this.logLevels.push(param1);
this.logLevels.sort();
this.levelFilter[param1] = true;
local3 = new FilterButton("[" + param1 + "]",65280,21760,0,param1);
this.container.addChild(local3);
local3.addEventListener(MouseEvent.CLICK,this.onFilterButtonClick);
local3.y = 20;
this.filterButtons.push(local3);
this.filterButtons.sort(this.filterSort);
this.updateFilterButtons();
}
}
private function updateFilterButtons() : void {
var local2:FilterButton = null;
var local1:int = 0;
for each(local2 in this.filterButtons) {
local2.x = local1;
local1 += local2.width;
}
}
private function filterSort(param1:FilterButton, param2:FilterButton) : Number {
if(param1.filterString == param2.filterString) {
return 0;
}
if(param1.filterString > param2.filterString) {
return 1;
}
return -1;
}
private function onFilterButtonClick(param1:MouseEvent) : void {
var local2:FilterButton = FilterButton(param1.target);
local2.active = !local2.active;
if(local2.active) {
this.levelFilter[local2.filterString] = true;
} else {
delete this.levelFilter[local2.filterString];
}
this.filterByLevels();
this.updateOutput();
}
private function onBtnShowLogClick(param1:Event) : void {
this.stage.removeChild(this.btnShowLog);
this.stage.addChild(this.container);
this.onStageResize(null);
}
private function onStageResize(param1:Event) : void {
var local2:int = 40;
this.output.y = local2;
this.resizeOutput(this.stage.stageWidth,this.stage.stageHeight - local2);
this.printEntries(this.filteredEntries,this.currentLine);
}
private function onBtnCloseClick(param1:Event) : void {
this.stage.removeChild(this.container);
this.stage.focus = this.stage;
}
private function onBtnCopyClick(param1:Event) : void {
var local3:LogEntry = null;
var local2:String = "";
for each(local3 in this.filteredEntries) {
local2 += local3.toString() + "\n";
}
System.setClipboard(local2);
}
private function onBtnClearClick(param1:Event) : void {
var local2:FilterButton = null;
this.entries.length = 0;
this.filteredEntries.length = 0;
for each(local2 in this.filterButtons) {
local2.removeEventListener(MouseEvent.CLICK,this.onFilterButtonClick);
this.container.removeChild(local2);
}
this.filterButtons.length = 0;
this.logLevels.length = 0;
this.levelFilter = {};
this.currentLine = 0;
this.updateOutput();
}
private function onKey(param1:KeyboardEvent) : void {
switch(param1.keyCode) {
case Keyboard.PAGE_UP:
this.scrollOutput(-this.numLines);
break;
case Keyboard.PAGE_DOWN:
this.scrollOutput(this.numLines);
}
}
private function scrollOutput(param1:int) : void {
this.currentLine += param1;
if(this.currentLine < this.numLines) {
this.currentLine = this.numLines;
}
if(this.currentLine > this.filteredEntries.length) {
this.currentLine = this.filteredEntries.length;
}
this.updateOutput();
}
private function onMouseWheel(param1:MouseEvent) : void {
this.scrollOutput(-param1.delta);
}
}
}
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.InteractiveObject;
import flash.display.Sprite;
import flash.events.EventDispatcher;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
class LogEntry {
public var logLevel:String;
public var text:String;
public function LogEntry(param1:String, param2:String) {
super();
this.logLevel = param1;
this.text = param2;
}
public function toString() : String {
return "[" + this.logLevel + "] " + this.text;
}
}
class ErrorLogButton extends Sprite {
private var label:TextField;
public function ErrorLogButton(param1:String, param2:uint, param3:uint) {
super();
mouseChildren = false;
buttonMode = true;
this.label = new TextField();
this.label.defaultTextFormat = new TextFormat("Tahoma",12,param2);
this.label.autoSize = TextFieldAutoSize.LEFT;
this.label.text = param1;
this.label.background = true;
this.label.backgroundColor = param3;
addChild(this.label);
}
}
class FilterButton extends Sprite {
public var filterString:String;
private var _active:Boolean = true;
private var label:TextField;
private var activeBgColor:uint;
private var inactiveBgColor:uint;
public function FilterButton(param1:String, param2:uint, param3:uint, param4:uint, param5:String) {
super();
this.activeBgColor = param3;
this.inactiveBgColor = param4;
this.filterString = param5;
mouseChildren = false;
buttonMode = true;
this.label = new TextField();
this.label.defaultTextFormat = new TextFormat("Tahoma",12,param2);
this.label.autoSize = TextFieldAutoSize.LEFT;
this.label.text = param1;
this.label.background = true;
this.label.backgroundColor = param3;
addChild(this.label);
}
public function get active() : Boolean {
return this._active;
}
public function set active(param1:Boolean) : void {
this._active = param1;
this.label.backgroundColor = !!this._active ? uint(this.activeBgColor) : uint(this.inactiveBgColor);
}
}
|
package alternativa.tanks.models.clan.info {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
public class IClanInfoModelEvents implements IClanInfoModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IClanInfoModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getClanName() : String {
var result:String = null;
var i:int = 0;
var m:IClanInfoModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanInfoModel(this.impl[i]);
result = m.getClanName();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getClanTag() : String {
var result:String = null;
var i:int = 0;
var m:IClanInfoModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanInfoModel(this.impl[i]);
result = m.getClanTag();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getDescription() : String {
var result:String = null;
var i:int = 0;
var m:IClanInfoModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanInfoModel(this.impl[i]);
result = m.getDescription();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getClanFlag() : ClanFlag {
var result:ClanFlag = null;
var i:int = 0;
var m:IClanInfoModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanInfoModel(this.impl[i]);
result = m.getClanFlag();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getRankIndexForAddClan() : int {
var result:int = 0;
var i:int = 0;
var m:IClanInfoModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanInfoModel(this.impl[i]);
result = int(m.getRankIndexForAddClan());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function incomingRequestEnabled() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:IClanInfoModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanInfoModel(this.impl[i]);
result = Boolean(m.incomingRequestEnabled());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getCreatorId() : Long {
var result:Long = null;
var i:int = 0;
var m:IClanInfoModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanInfoModel(this.impl[i]);
result = m.getCreatorId();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getCreateTime() : Long {
var result:Long = null;
var i:int = 0;
var m:IClanInfoModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanInfoModel(this.impl[i]);
result = m.getCreateTime();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getUsersCount() : int {
var result:int = 0;
var i:int = 0;
var m:IClanInfoModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanInfoModel(this.impl[i]);
result = int(m.getUsersCount());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_5 extends BitmapAsset
{
public function BigRangIcon_rang_5()
{
super();
}
}
}
|
package controls.statassets {
import alternativa.osgi.service.locale.ILocaleService;
import flash.display.Sprite;
import flash.events.MouseEvent;
import forms.events.StatListEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class StatHeader extends Sprite {
[Inject]
public static var localeService:ILocaleService;
protected var tabs:Vector.<Number>;
protected var headers:Vector.<String>;
protected var _currentSort:int = 8;
protected var _oldSort:int = 8;
protected var _width:int = 800;
public function StatHeader() {
var local1:StatHeaderButton = null;
var local2:int = 0;
this.tabs = new Vector.<Number>();
super();
this.headers = Vector.<String>([localeService.getText(TanksLocale.TEXT_STATISTICS_HEADER_NUMBER),localeService.getText(TanksLocale.TEXT_STATISTICS_HEADER_RANK),localeService.getText(TanksLocale.TEXT_STATISTICS_HEADER_CALLSIGN),localeService.getText(TanksLocale.TEXT_STATISTICS_HEADER_SCORE),localeService.getText(TanksLocale.TEXT_STATISTICS_HEADER_KILLS),localeService.getText(TanksLocale.TEXT_STATISTICS_HEADER_DEATHS),localeService.getText(TanksLocale.TEXT_STATISTICS_HEADER_RATIO),localeService.getText(TanksLocale.TEXT_STATISTICS_HEADER_WEALTH),localeService.getText(TanksLocale.TEXT_STATISTICS_HEADER_RATING)]);
local2 = 0;
while(local2 < 9) {
local1 = new StatHeaderButton(local2 < 1 || local2 > 2);
local1.label = this.headers[local2];
local1.height = 18;
local1.numSort = local2;
addChild(local1);
if(local2 > 0) {
local1.addEventListener(MouseEvent.CLICK,this.changeSort);
}
local2++;
}
this.draw();
}
override public function set width(param1:Number) : void {
this._width = Math.floor(param1);
this.draw();
}
protected function draw() : void {
var local1:StatHeaderButton = null;
var local2:int = int(this._width - 365);
this.tabs = Vector.<Number>([0,55,180,local2,local2 + 60,local2 + 130,local2 + 180,local2 + 220,local2 + 285,this._width - 1]);
var local3:int = 0;
while(local3 < 9) {
local1 = getChildAt(local3) as StatHeaderButton;
local1.width = this.tabs[local3 + 1] - this.tabs[local3] - 2;
local1.x = this.tabs[local3];
local1.selected = local3 == this._currentSort;
local3++;
}
}
protected function changeSort(param1:MouseEvent) : void {
var local2:StatHeaderButton = param1.currentTarget as StatHeaderButton;
this._currentSort = local2.numSort;
if(this._currentSort != this._oldSort) {
this.draw();
dispatchEvent(new StatListEvent(this._currentSort));
this._oldSort = this._currentSort;
}
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_def_DOWN_RIGHT.png")]
public dynamic class button_def_DOWN_RIGHT extends BitmapData {
public function button_def_DOWN_RIGHT(param1:int = 7, param2:int = 30) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.service.device {
import flash.events.IEventDispatcher;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
public interface DeviceService extends IEventDispatcher {
function setAvailableDevices(param1:IGameObject, param2:Vector.<IGameObject>) : void;
function getAvailableDevices(param1:IGameObject) : Vector.<IGameObject>;
function getDeviceOwnType(param1:IGameObject) : DeviceOwningType;
function insertDevice(param1:IGameObject, param2:IGameObject) : void;
function removeDevice(param1:IGameObject) : void;
function isDevicesAvailable(param1:IGameObject) : Boolean;
function getInsertedDevice(param1:IGameObject) : IGameObject;
function getInsertedDevicePreview(param1:IGameObject) : ImageResource;
function isSale(param1:IGameObject) : Boolean;
function init() : void;
}
}
|
package projects.tanks.client.garage.models.item.mobilelootbox.lootbox {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class MobileLootBoxModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:MobileLootBoxModelServer;
private var client:IMobileLootBoxModelBase = IMobileLootBoxModelBase(this);
private var modelId:Long = Long.getLong(793986940,265050196);
private var _openSuccessfulId:Long = Long.getLong(812687689,208178107);
private var _openSuccessful_rewardsCodec:ICodec;
private var _openingFailedId:Long = Long.getLong(857495400,624501804);
private var _updateCountId:Long = Long.getLong(1398628694,-1349788069);
private var _updateCount_countCodec:ICodec;
public function MobileLootBoxModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new MobileLootBoxModelServer(IModel(this));
this._openSuccessful_rewardsCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(MobileLoot,false),false,1));
this._updateCount_countCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._openSuccessfulId:
this.client.openSuccessful(this._openSuccessful_rewardsCodec.decode(param2) as Vector.<MobileLoot>);
break;
case this._openingFailedId:
this.client.openingFailed();
break;
case this._updateCountId:
this.client.updateCount(int(this._updateCount_countCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.engine3d.objects {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Canvas;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
use namespace alternativa3d;
public class Bone extends Joint {
public var length:Number;
alternativa3d var lx:Number;
alternativa3d var ly:Number;
alternativa3d var lz:Number;
alternativa3d var ldot:Number;
public function Bone(param1:Number, param2:Number) {
super();
this.length = param1;
this.alternativa3d::distance = param2;
}
public function bindVerticesByDistance(param1:Skin) : void {
var local2:Vertex = param1.alternativa3d::vertexList;
while(local2 != null) {
this.bindVertexByDistance(local2);
local2 = local2.alternativa3d::next;
}
}
public function bindVertexByDistance(param1:Vertex) : void {
var local2:Number = param1.x - alternativa3d::md;
var local3:Number = param1.y - alternativa3d::mh;
var local4:Number = param1.z - alternativa3d::ml;
var local5:Number = local2 * this.alternativa3d::lx + local3 * this.alternativa3d::ly + local4 * this.alternativa3d::lz;
if(local5 > 0) {
if(this.alternativa3d::ldot > local5) {
local5 /= this.alternativa3d::ldot;
local2 = param1.x - alternativa3d::md - local5 * this.alternativa3d::lx;
local3 = param1.y - alternativa3d::mh - local5 * this.alternativa3d::ly;
local4 = param1.z - alternativa3d::ml - local5 * this.alternativa3d::lz;
} else {
local2 -= this.alternativa3d::lx;
local3 -= this.alternativa3d::ly;
local4 -= this.alternativa3d::lz;
}
}
bindVertex(param1,1 - Math.sqrt(local2 * local2 + local3 * local3 + local4 * local4) / alternativa3d::distance);
}
override alternativa3d function calculateBindingMatrix(param1:Object3D) : void {
super.alternativa3d::calculateBindingMatrix(param1);
this.alternativa3d::lx = alternativa3d::mc * this.length;
this.alternativa3d::ly = alternativa3d::mg * this.length;
this.alternativa3d::lz = alternativa3d::mk * this.length;
this.alternativa3d::ldot = this.alternativa3d::lx * this.alternativa3d::lx + this.alternativa3d::ly * this.alternativa3d::ly + this.alternativa3d::lz * this.alternativa3d::lz;
}
override alternativa3d function drawDebug(param1:Camera3D, param2:Canvas) : void {
var local3:Number = NaN;
var local4:Number = NaN;
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
if(numChildren == 0) {
local3 = alternativa3d::md * param1.alternativa3d::viewSizeX / alternativa3d::ml;
local4 = alternativa3d::mh * param1.alternativa3d::viewSizeY / alternativa3d::ml;
local5 = alternativa3d::mi * this.length + alternativa3d::ml;
local6 = (alternativa3d::ma * this.length + alternativa3d::md) * param1.alternativa3d::viewSizeX / local5;
local7 = (alternativa3d::me * this.length + alternativa3d::mh) * param1.alternativa3d::viewSizeY / local5;
if(alternativa3d::ml > 0 && local5 > 0) {
Debug.alternativa3d::drawBone(param2,local3,local4,local6,local7,10 * param1.alternativa3d::focalLength / alternativa3d::ml,39423);
}
} else {
super.alternativa3d::drawDebug(param1,param2);
}
}
}
}
|
package alternativa.init {
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.tanks.model.garage.Tank3DViewer;
import alternativa.tanks.model.garage.temperature.TemperatureConfig;
import alternativa.tanks.model.garage.temperature.TemperatureConfigImpl;
import alternativa.tanks.service.battery.BatteriesService;
import alternativa.tanks.service.battery.BatteriesServiceImpl;
import alternativa.tanks.service.delaymountcategory.DelayMountCategoryServiceImpl;
import alternativa.tanks.service.delaymountcategory.IDelayMountCategoryService;
import alternativa.tanks.service.device.DeviceService;
import alternativa.tanks.service.device.DeviceServiceImpl;
import alternativa.tanks.service.garage.GarageService;
import alternativa.tanks.service.garage.GarageServiceImpl;
import alternativa.tanks.service.item.ItemService;
import alternativa.tanks.service.item.ItemServiceImpl;
import alternativa.tanks.service.item3d.ITank3DViewer;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParamsService;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParamsServiceImpl;
import alternativa.tanks.service.resistance.ResistanceService;
import alternativa.tanks.service.resistance.ResistanceServiceImpl;
import alternativa.tanks.service.temporaryitem.ITemporaryItemService;
import alternativa.tanks.service.temporaryitem.TemporaryItemService;
import alternativa.tanks.service.temporaryitemnotify.ITemporaryItemNotifyService;
import alternativa.tanks.service.temporaryitemnotify.TemporaryItemNotifyService;
public class GarageModelActivator implements IBundleActivator {
public function GarageModelActivator() {
super();
}
public function start(param1:OSGi) : void {
param1.registerService(ItemService,new ItemServiceImpl());
param1.registerService(ITemporaryItemService,new TemporaryItemService());
param1.registerService(ITemporaryItemNotifyService,new TemporaryItemNotifyService());
param1.registerService(ITank3DViewer,new Tank3DViewer());
param1.registerService(ItemPropertyParamsService,new ItemPropertyParamsServiceImpl());
param1.registerService(GarageService,new GarageServiceImpl());
param1.registerService(IDelayMountCategoryService,new DelayMountCategoryServiceImpl());
param1.registerService(TemperatureConfig,new TemperatureConfigImpl());
param1.registerService(DeviceService,new DeviceServiceImpl());
param1.registerService(ResistanceService,new ResistanceServiceImpl());
param1.registerService(BatteriesService,new BatteriesServiceImpl());
}
public function stop(param1:OSGi) : void {
}
}
}
|
package projects.tanks.client.battleselect.model.battle.team {
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 TeamBattleInfoModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function TeamBattleInfoModelServer(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 platform.client.fp10.core.type {
public interface ISpaceListener {
function objectCreated(param1:IGameObject) : void;
function objectDestroyed(param1:IGameObject) : void;
function spaceClosed() : void;
}
}
|
package projects.tanks.client.tanksservices.model.notifier.referrals {
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 ReferralNotifierModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ReferralNotifierModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.models.weapon.railgun {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class RailgunCallbackEvents implements RailgunCallback {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function RailgunCallbackEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function onStartCharging(param1:int) : void {
var i:int = 0;
var m:RailgunCallback = null;
var time:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = RailgunCallback(this.impl[i]);
m.onStartCharging(time);
i++;
}
}
finally {
Model.popObject();
}
}
public function onShot(param1:int, param2:Vector3, param3:Vector.<Body>, param4:Vector.<Vector3>) : void {
var i:int = 0;
var m:RailgunCallback = null;
var time:int = param1;
var staticHitPoint:Vector3 = param2;
var targets:Vector.<Body> = param3;
var targetHitPoints:Vector.<Vector3> = param4;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = RailgunCallback(this.impl[i]);
m.onShot(time,staticHitPoint,targets,targetHitPoints);
i++;
}
}
finally {
Model.popObject();
}
}
public function onShotDummy(param1:int) : void {
var i:int = 0;
var m:RailgunCallback = null;
var time:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = RailgunCallback(this.impl[i]);
m.onShotDummy(time);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.engine3d.core
{
public class Sorting
{
public static const NONE:int = 0;
public static const AVERAGE_Z:int = 1;
public static const DYNAMIC_BSP:int = 2;
public function Sorting()
{
super();
}
}
}
|
package alternativa.engine3d.materials {
import flash.geom.Matrix;
public class UVMatrixProvider {
private var matrix:Matrix = new Matrix();
public function UVMatrixProvider() {
super();
}
public function getMatrix() : Matrix {
return this.matrix;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.group {
import alternativa.types.Long;
import flash.events.EventDispatcher;
public class GroupInfoService extends EventDispatcher implements IGroupInfoService {
private var group:Vector.<Long> = new Vector.<Long>();
private var _hasGroups:Boolean = false;
public function GroupInfoService() {
super();
}
public function addGroupUser(param1:Long) : * {
this._hasGroups = true;
this.group.push(param1);
}
public function isInSameGroup(param1:Long) : Boolean {
return this.group.indexOf(param1) != -1;
}
public function hasGroups() : Boolean {
return this._hasGroups;
}
public function setHasGroups(param1:Boolean) : * {
this._hasGroups = param1;
}
}
}
|
package alternativa.tanks.vehicles.tanks
{
public class SuspensionData
{
public var rayLength:Number = 0;
public var rayOptimalLength:Number = 0;
public var forceOffset:Number = 0;
public var dampingCoeff:Number = 0;
public var smallVel:Number = 100;
public var staticFriction:Number = 4;
public var dynamicFriction:Number = 0.2;
public function SuspensionData()
{
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapBigRank22.png")]
public class DefaultRanksBitmaps_bitmapBigRank22 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapBigRank22() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.terminator {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.types.Vector3d;
public class TerminatorModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:TerminatorModelServer;
private var client:ITerminatorModelBase = ITerminatorModelBase(this);
private var modelId:Long = Long.getLong(1596182265,-1705134735);
private var _primaryRemoteChargeId:Long = Long.getLong(1223833855,-1906776616);
private var _primaryRemoteCharge_shooterCodec:ICodec;
private var _primaryRemoteCharge_barrelIndexCodec:ICodec;
private var _primaryRemoteDummyId:Long = Long.getLong(653258149,752923388);
private var _primaryRemoteDummy_shooterCodec:ICodec;
private var _primaryRemoteDummy_barrelIndexCodec:ICodec;
private var _primaryRemoteShotId:Long = Long.getLong(1641495142,114693918);
private var _primaryRemoteShot_shooterCodec:ICodec;
private var _primaryRemoteShot_staticHitPointCodec:ICodec;
private var _primaryRemoteShot_targetsCodec:ICodec;
private var _primaryRemoteShot_targetHitPointsCodec:ICodec;
private var _primaryRemoteShot_barrelIndexCodec:ICodec;
private var _secondaryRemoteHideId:Long = Long.getLong(1755383946,-1270349656);
private var _secondaryRemoteHide_shootersCodec:ICodec;
private var _secondaryRemoteOpenId:Long = Long.getLong(1755383946,-1270564960);
private var _secondaryRemoteOpen_shooterCodec:ICodec;
public function TerminatorModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new TerminatorModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(TerminatorCC,false)));
this._primaryRemoteCharge_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._primaryRemoteCharge_barrelIndexCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._primaryRemoteDummy_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._primaryRemoteDummy_barrelIndexCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._primaryRemoteShot_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._primaryRemoteShot_staticHitPointCodec = this._protocol.getCodec(new TypeCodecInfo(Vector3d,true));
this._primaryRemoteShot_targetsCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(IGameObject,false),true,1));
this._primaryRemoteShot_targetHitPointsCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Vector3d,false),true,1));
this._primaryRemoteShot_barrelIndexCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._secondaryRemoteHide_shootersCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._secondaryRemoteOpen_shooterCodec = this._protocol.getCodec(new TypeCodecInfo(IGameObject,false));
}
protected function getInitParam() : TerminatorCC {
return TerminatorCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._primaryRemoteChargeId:
this.client.primaryRemoteCharge(IGameObject(this._primaryRemoteCharge_shooterCodec.decode(param2)),int(this._primaryRemoteCharge_barrelIndexCodec.decode(param2)));
break;
case this._primaryRemoteDummyId:
this.client.primaryRemoteDummy(IGameObject(this._primaryRemoteDummy_shooterCodec.decode(param2)),int(this._primaryRemoteDummy_barrelIndexCodec.decode(param2)));
break;
case this._primaryRemoteShotId:
this.client.primaryRemoteShot(IGameObject(this._primaryRemoteShot_shooterCodec.decode(param2)),Vector3d(this._primaryRemoteShot_staticHitPointCodec.decode(param2)),this._primaryRemoteShot_targetsCodec.decode(param2) as Vector.<IGameObject>,this._primaryRemoteShot_targetHitPointsCodec.decode(param2) as Vector.<Vector3d>,int(this._primaryRemoteShot_barrelIndexCodec.decode(param2)));
break;
case this._secondaryRemoteHideId:
this.client.secondaryRemoteHide(IGameObject(this._secondaryRemoteHide_shootersCodec.decode(param2)));
break;
case this._secondaryRemoteOpenId:
this.client.secondaryRemoteOpen(IGameObject(this._secondaryRemoteOpen_shooterCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank15.png")]
public class PremiumRankBitmaps_bitmapBigRank15 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank15() {
super();
}
}
}
|
package alternativa.tanks.model.payment.modes.onlyurl {
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.gui.shop.forms.GoToUrlForm;
import alternativa.tanks.model.payment.category.PayModeView;
import alternativa.tanks.model.payment.modes.CrystalsOnlyPaymentMode;
import alternativa.tanks.model.payment.modes.PayUrl;
import alternativa.tanks.model.payment.modes.asyncurl.AsyncUrlPayMode;
import alternativa.tanks.model.payment.paymentstate.PaymentWindowService;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.panel.model.payment.modes.onlyurl.IOnlyUrlPaymentModelBase;
import projects.tanks.client.panel.model.payment.modes.onlyurl.OnlyUrlPaymentModelBase;
import projects.tanks.client.panel.model.payment.types.PaymentRequestUrl;
[ModelInfo]
public class OnlyUrlPaymentModel extends OnlyUrlPaymentModelBase implements IOnlyUrlPaymentModelBase, AsyncUrlPayMode, ObjectLoadListener, PayModeView, ObjectUnloadListener, OnlyUrlPayMode, CrystalsOnlyPaymentMode {
[Inject]
public static var paymentWindowService:PaymentWindowService;
public function OnlyUrlPaymentModel() {
super();
}
public function requestAsyncUrl() : void {
var local1:Long = paymentWindowService.getChosenItem().id;
server.getPaymentUrl(local1);
}
public function receiveUrl(param1:PaymentRequestUrl) : void {
PayUrl(object.adapt(PayUrl)).forceGoToUrl(param1);
}
public function objectLoaded() : void {
putData(PayModeForm,new GoToUrlForm(object));
}
public function getView() : PayModeForm {
return PayModeForm(getData(PayModeForm));
}
public function objectUnloaded() : void {
this.getView().destroy();
clearData(PayModeForm);
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.machinegun.sfx {
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 MachineGunSFXModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function MachineGunSFXModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package controls.cellrenderer {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.cellrenderer.CellNormal_normalLeft.png")]
public class CellNormal_normalLeft extends BitmapAsset {
public function CellNormal_normalLeft() {
super();
}
}
}
|
package alternativa.tanks.model.item.discount {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ICollectDiscountEvents implements ICollectDiscount {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ICollectDiscountEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function collectDiscountsInfo(param1:IDiscountCollector) : void {
var i:int = 0;
var m:ICollectDiscount = null;
var collector:IDiscountCollector = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ICollectDiscount(this.impl[i]);
m.collectDiscountsInfo(collector);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.weapon.shotgun {
import alternativa.tanks.models.weapon.shotgun.aiming.ShotgunAiming;
import alternativa.tanks.models.weapons.discrete.DiscreteWeaponObject;
import platform.client.fp10.core.type.IGameObject;
public class ShotgunObject extends DiscreteWeaponObject {
public function ShotgunObject(param1:IGameObject) {
super(param1);
}
public function pelletDirectionCalculator() : PelletDirectionCalculator {
var local1:ShotgunAiming = ShotgunAiming(object.adapt(ShotgunAiming));
return local1.getPelletDirectionCalculator();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.shot {
public interface IShotgunShotModelBase {
function setRemainingShots(param1:int) : void;
}
}
|
package alternativa.tanks.battle.events {
import alternativa.tanks.models.battle.gui.inventory.InventoryItem;
public class InventoryItemActivationEvent {
public var item:InventoryItem;
public function InventoryItemActivationEvent(param1:InventoryItem) {
super();
this.item = param1;
}
}
}
|
package projects.tanks.client.garage.models.item.discount.proabonement {
public class ProAbonementRankDiscountCC {
private var _percentDiscountPerRank:Number;
public function ProAbonementRankDiscountCC(param1:Number = 0) {
super();
this._percentDiscountPerRank = param1;
}
public function get percentDiscountPerRank() : Number {
return this._percentDiscountPerRank;
}
public function set percentDiscountPerRank(param1:Number) : void {
this._percentDiscountPerRank = param1;
}
public function toString() : String {
var local1:String = "ProAbonementRankDiscountCC [";
local1 += "percentDiscountPerRank = " + this.percentDiscountPerRank + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.service.battlelist {
import alternativa.tanks.controllers.battlelist.BattleByURLNotFoundEvent;
import alternativa.tanks.controllers.battlelist.BattleListController;
import alternativa.tanks.controllers.battlelist.BattleSelectedEvent;
import alternativa.tanks.controllers.battlelist.CreateBattleClickEvent;
import alternativa.tanks.service.battlecreate.IBattleCreateFormService;
import alternativa.tanks.service.battleinfo.IBattleInfoFormService;
import alternativa.tanks.view.battleinfo.BattleInfoBaseParams;
import alternativa.types.Long;
import flash.events.EventDispatcher;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.model.types.BattleSuspicionLevel;
public class BattleListFormService extends EventDispatcher implements IBattleListFormService {
[Inject]
public static var battleCreateFormService:IBattleCreateFormService;
[Inject]
public static var battleInfoFormService:IBattleInfoFormService;
private var battleListController:BattleListController;
public function BattleListFormService() {
super();
}
public function createAndShow() : void {
this.battleListController = new BattleListController();
this.battleListController.showForm();
this.battleListController.addEventListener(CreateBattleClickEvent.CREATE_BATTLE_CLICK,this.onCreateBattleClick);
this.battleListController.addEventListener(BattleSelectedEvent.BATTLE_SELECTED,this.onBattleSelected);
this.battleListController.addEventListener(BattleByURLNotFoundEvent.BATTLE_BY_URL_NOT_FOUND,this.onBattleByURLNotFound);
}
public function hideAndDestroy() : void {
this.battleListController.removeEventListener(CreateBattleClickEvent.CREATE_BATTLE_CLICK,this.onCreateBattleClick);
this.battleListController.removeEventListener(BattleSelectedEvent.BATTLE_SELECTED,this.onBattleSelected);
this.battleListController.removeEventListener(BattleByURLNotFoundEvent.BATTLE_BY_URL_NOT_FOUND,this.onBattleByURLNotFound);
this.battleListController.hideForm();
this.battleListController.destroy();
this.battleListController = null;
}
public function battleItemRecord(param1:BattleInfoBaseParams) : void {
this.battleListController.battleItemRecord(param1);
}
public function selectBattleItemFromServer(param1:IGameObject) : void {
this.battleListController.selectBattleItemFromServer(param1);
}
public function updateSuspicious(param1:Long, param2:BattleSuspicionLevel) : void {
this.battleListController.updateSuspicious(param1,param2);
}
public function removeBattleItem(param1:Long) : void {
this.battleListController.removeBattle(param1);
}
public function updateUsersCount(param1:Long) : void {
this.battleListController.updateUsersCount(param1);
}
public function updateBattleName(param1:Long) : void {
this.battleListController.updateBattleName(param1);
}
private function onBattleSelected(param1:BattleSelectedEvent) : void {
dispatchEvent(new BattleListFormServiceEvent(BattleListFormServiceEvent.BATTLE_SELECTED,param1.selectedItem));
battleCreateFormService.hideForm();
}
private function onBattleByURLNotFound(param1:BattleByURLNotFoundEvent) : void {
dispatchEvent(new BattleByURLNotFoundEvent(BattleByURLNotFoundEvent.BATTLE_BY_URL_NOT_FOUND,param1.battleId));
}
public function swapTeams(param1:Long) : void {
this.battleListController.swapTeams(param1);
}
public function battleItemsPacketJoinSuccess() : void {
this.battleListController.battleItemsPacketJoinSuccess();
}
private function onCreateBattleClick(param1:CreateBattleClickEvent) : void {
battleCreateFormService.showForm();
battleInfoFormService.removeFormFromStage();
}
public function checkBattleButton() : void {
this.battleListController.resetBattleButtonState();
}
}
}
|
package alternativa.tanks.models.tank {
import alternativa.tanks.display.usertitle.UserTitle;
import alternativa.tanks.models.battle.battlefield.BattleUserInfoListener;
import alternativa.tanks.services.tankregistry.TankUsersRegistry;
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
public class TankUserInfoUpdater implements BattleUserInfoListener {
[Inject]
public static var usersRegistry:TankUsersRegistry;
public function TankUserInfoUpdater() {
super();
}
public function userInfoChanged(param1:Long, param2:String, param3:int, param4:Boolean) : void {
var local6:UserInfo = null;
var local7:UserTitle = null;
var local5:ITankModel = this.getTankModel(param1);
if(local5 != null) {
local6 = local5.getUserInfo();
local6.name = param2;
local6.rank = param3;
local7 = local5.getTitle();
if(local7 != null) {
local7.setLabelText(param2);
local7.setRank(param3);
local7.setSuspicious(param4);
}
}
}
public function userSuspiciousnessChanged(param1:Long, param2:Boolean) : void {
var local4:ITankModel = null;
var local5:UserTitle = null;
var local3:IGameObject = usersRegistry.getUser(param1);
if(local3 != null) {
local4 = ITankModel(local3.adapt(ITankModel));
local5 = local4.getTitle();
if(local5 != null) {
local5.setSuspicious(param2);
}
}
}
public function userRankChanged(param1:Long, param2:int) : void {
var local4:UserInfo = null;
var local5:UserTitle = null;
var local3:ITankModel = this.getTankModel(param1);
if(local3 != null) {
local4 = local3.getUserInfo();
local4.rank = param2;
local5 = local3.getTitle();
if(local5 != null) {
local5.setRank(param2);
}
}
}
private function getTankModel(param1:Long) : ITankModel {
var local2:IGameObject = usersRegistry.getUser(param1);
if(local2 != null) {
return ITankModel(local2.adapt(ITankModel));
}
return null;
}
}
}
|
package alternativa.osgi.bundle
{
import flash.utils.Dictionary;
public class Bundle
{
public var name:String;
public var activator:IBundleActivator;
public var params:Dictionary;
public function Bundle(name:String, activator:IBundleActivator, params:Dictionary)
{
super();
this.name = name;
this.activator = activator;
this.params = params;
}
}
}
|
package controls {
import flash.display.Graphics;
import flash.display.Sprite;
public class Hint extends Sprite {
private const MAX_WIDTH:* = 200;
private const COLOR:* = 16777215;
private const ALPHA:* = 0.4;
private var _label:Label = new Label();
public function Hint() {
super();
addChild(this._label);
this._label.size = 11;
}
public function set text(param1:String) : void {
var local2:Graphics = this.graphics;
this._label.text = param1;
if(this._label.textWidth > this.MAX_WIDTH) {
this._label.width = this.MAX_WIDTH;
this._label.multiline = true;
this._label.wordWrap = true;
}
local2.clear();
local2.beginFill(this.COLOR,this.ALPHA);
local2.drawRect(-3,-3,this._label.textWidth + 9,this._label.textHeight + 9);
local2.endFill();
}
}
}
|
package org.osflash.signals.events {
import org.osflash.signals.IPrioritySignal;
public class GenericEvent implements IEvent {
protected var _bubbles:Boolean;
protected var _target:Object;
protected var _currentTarget:Object;
protected var _signal:IPrioritySignal;
public function GenericEvent(bubbles:Boolean = false) {
super();
this._bubbles = bubbles;
}
public function get signal() : IPrioritySignal {
return this._signal;
}
public function set signal(value:IPrioritySignal) : void {
this._signal = value;
}
public function get target() : Object {
return this._target;
}
public function set target(value:Object) : void {
this._target = value;
}
public function get currentTarget() : Object {
return this._currentTarget;
}
public function set currentTarget(value:Object) : void {
this._currentTarget = value;
}
public function get bubbles() : Boolean {
return this._bubbles;
}
public function set bubbles(value:Boolean) : void {
this._bubbles = value;
}
public function clone() : IEvent {
return new GenericEvent(this._bubbles);
}
}
}
|
package alternativa.tanks.loader {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.loader.ModalLoader_WindowAlpha.png")]
public class ModalLoader_WindowAlpha extends BitmapAsset {
public function ModalLoader_WindowAlpha() {
super();
}
}
}
|
package projects.tanks.client.garage.models.premium {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class PremiumInDepotModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:PremiumInDepotModelServer;
private var client:IPremiumInDepotModelBase = IPremiumInDepotModelBase(this);
private var modelId:Long = Long.getLong(486679052,361206197);
public function PremiumInDepotModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new PremiumInDepotModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.panel.model.shop.androidspecialoffer.offers {
import platform.client.fp10.core.resource.types.ImageResource;
public class MediumTimeOfferCC {
private var _paintPreview:ImageResource;
public function MediumTimeOfferCC(param1:ImageResource = null) {
super();
this._paintPreview = param1;
}
public function get paintPreview() : ImageResource {
return this._paintPreview;
}
public function set paintPreview(param1:ImageResource) : void {
this._paintPreview = param1;
}
public function toString() : String {
var local1:String = "MediumTimeOfferCC [";
local1 += "paintPreview = " + this.paintPreview + " ";
return local1 + "]";
}
}
}
|
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.tanks.gui.friends {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.FriendsWindowStateBigButton_ButtonDownLeft.png")]
public class FriendsWindowStateBigButton_ButtonDownLeft extends BitmapAsset {
public function FriendsWindowStateBigButton_ButtonDownLeft() {
super();
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.videoads {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.videoads.VideoAdsItemUpgradeCC;
public class VectorCodecVideoAdsItemUpgradeCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecVideoAdsItemUpgradeCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(VideoAdsItemUpgradeCC,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = int(LengthCodecHelper.decodeLength(param1));
var local3:Vector.<VideoAdsItemUpgradeCC> = new Vector.<VideoAdsItemUpgradeCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = VideoAdsItemUpgradeCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:VideoAdsItemUpgradeCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<VideoAdsItemUpgradeCC> = Vector.<VideoAdsItemUpgradeCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.engine3d.loaders {
import alternativa.engine3d.loaders.events.LoaderErrorEvent;
import alternativa.engine3d.loaders.events.LoaderEvent;
import alternativa.engine3d.loaders.events.LoaderProgressEvent;
import alternativa.engine3d.materials.TextureMaterial;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BitmapDataChannel;
import flash.display.BlendMode;
import flash.display.Loader;
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.events.SecurityErrorEvent;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.net.URLRequest;
import flash.system.LoaderContext;
[Event(name="loaderError",type="alternativa.engine3d.loaders.events.LoaderErrorEvent")]
[Event(name="complete",type="flash.events.Event")]
[Event(name="partComplete",type="alternativa.engine3d.loaders.events.LoaderEvent")]
[Event(name="partOpen",type="alternativa.engine3d.loaders.events.LoaderEvent")]
public class MaterialLoader extends EventDispatcher {
private static var stub:BitmapData;
private var loader:Loader;
private var context:LoaderContext;
private var materials:Vector.<TextureMaterial>;
private var urls:Vector.<String>;
private var filesTotal:int;
private var filesLoaded:int;
private var diffuse:BitmapData;
private var currentURL:String;
private var index:int;
public function MaterialLoader() {
super();
}
public function load(param1:Vector.<TextureMaterial>, param2:LoaderContext = null) : void {
var local5:TextureMaterial = null;
this.context = param2;
this.materials = param1;
this.urls = new Vector.<String>();
var local3:int = 0;
var local4:int = 0;
while(local3 < param1.length) {
local5 = param1[local3];
var local6:* = local4++;
this.urls[local6] = local5.diffuseMapURL;
++this.filesTotal;
if(local5.opacityMapURL != null) {
var local7:* = local4++;
this.urls[local7] = local5.opacityMapURL;
++this.filesTotal;
} else {
local7 = local4++;
this.urls[local7] = null;
}
local3++;
}
this.filesLoaded = 0;
this.index = -1;
this.loadNext(null);
}
public function close() : void {
this.destroyLoader();
this.materials = null;
this.urls = null;
this.diffuse = null;
this.currentURL = null;
this.context = null;
}
private function destroyLoader() : void {
if(this.loader != null) {
this.loader.unload();
this.loader.contentLoaderInfo.removeEventListener(Event.OPEN,this.onPartOpen);
this.loader.contentLoaderInfo.removeEventListener(Event.COMPLETE,this.loadNext);
this.loader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS,this.onFileProgress);
this.loader.contentLoaderInfo.removeEventListener(IOErrorEvent.DISK_ERROR,this.loadNext);
this.loader.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,this.loadNext);
this.loader.contentLoaderInfo.removeEventListener(IOErrorEvent.NETWORK_ERROR,this.loadNext);
this.loader.contentLoaderInfo.removeEventListener(IOErrorEvent.VERIFY_ERROR,this.loadNext);
this.loader.contentLoaderInfo.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,this.loadNext);
this.loader = null;
}
}
private function loadNext(param1:Event) : void {
var local2:TextureMaterial = null;
if(this.index >= 0) {
if(this.index % 2 == 0) {
if(param1 is ErrorEvent) {
this.diffuse = this.getStub();
this.onFileError((param1 as ErrorEvent).text);
} else {
this.diffuse = (this.loader.content as Bitmap).bitmapData;
}
++this.filesLoaded;
} else {
local2 = this.materials[this.index - 1 >> 1];
if(param1 == null) {
local2.texture = this.diffuse;
} else {
if(param1 is ErrorEvent) {
local2.texture = this.diffuse;
this.onFileError((param1 as ErrorEvent).text);
} else {
local2.texture = this.merge(this.diffuse,(this.loader.content as Bitmap).bitmapData);
}
++this.filesLoaded;
}
this.onPartComplete(this.index - 1 >> 1,local2);
this.diffuse = null;
}
this.destroyLoader();
}
if(++this.index >= this.urls.length) {
this.close();
if(hasEventListener(Event.COMPLETE)) {
dispatchEvent(new Event(Event.COMPLETE));
}
} else {
this.currentURL = this.urls[this.index];
if(this.currentURL != null && (this.diffuse == null || this.diffuse != stub)) {
this.loader = new Loader();
if(this.index % 2 == 0) {
this.loader.contentLoaderInfo.addEventListener(Event.OPEN,this.onPartOpen);
}
this.loader.contentLoaderInfo.addEventListener(Event.COMPLETE,this.loadNext);
this.loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,this.onFileProgress);
this.loader.contentLoaderInfo.addEventListener(IOErrorEvent.DISK_ERROR,this.loadNext);
this.loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.loadNext);
this.loader.contentLoaderInfo.addEventListener(IOErrorEvent.NETWORK_ERROR,this.loadNext);
this.loader.contentLoaderInfo.addEventListener(IOErrorEvent.VERIFY_ERROR,this.loadNext);
this.loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.loadNext);
this.loader.load(new URLRequest(this.currentURL),this.context);
} else {
this.loadNext(null);
}
}
}
private function onPartOpen(param1:Event) : void {
if(hasEventListener(LoaderEvent.PART_OPEN)) {
dispatchEvent(new LoaderEvent(LoaderEvent.PART_OPEN,this.urls.length >> 1,this.index >> 1,this.materials[this.index >> 1]));
}
}
private function onPartComplete(param1:int, param2:TextureMaterial) : void {
if(hasEventListener(LoaderEvent.PART_COMPLETE)) {
dispatchEvent(new LoaderEvent(LoaderEvent.PART_COMPLETE,this.urls.length >> 1,param1,param2));
}
}
private function onFileProgress(param1:ProgressEvent) : void {
if(hasEventListener(LoaderProgressEvent.LOADER_PROGRESS)) {
dispatchEvent(new LoaderProgressEvent(LoaderProgressEvent.LOADER_PROGRESS,this.filesTotal,this.filesLoaded,(this.filesLoaded + param1.bytesLoaded / param1.bytesTotal) / this.filesTotal,param1.bytesLoaded,param1.bytesTotal));
}
}
private function onFileError(param1:String) : void {
dispatchEvent(new LoaderErrorEvent(LoaderErrorEvent.LOADER_ERROR,this.currentURL,param1));
}
private function merge(param1:BitmapData, param2:BitmapData) : BitmapData {
var local3:BitmapData = new BitmapData(param1.width,param1.height);
local3.copyPixels(param1,param1.rect,new Point());
if(param1.width != param2.width || param1.height != param2.height) {
param1.draw(param2,new Matrix(param1.width / param2.width,0,0,param1.height / param2.height),null,BlendMode.NORMAL,null,true);
param2.dispose();
param2 = param1;
} else {
param1.dispose();
}
local3.copyChannel(param2,param2.rect,new Point(),BitmapDataChannel.RED,BitmapDataChannel.ALPHA);
param2.dispose();
return local3;
}
private function getStub() : BitmapData {
var local1:uint = 0;
var local2:uint = 0;
var local3:uint = 0;
if(stub == null) {
local1 = 32;
stub = new BitmapData(local1,local1,false,0);
local2 = 0;
while(local2 < local1) {
local3 = 0;
while(local3 < local1) {
stub.setPixel(Boolean(local2 % 2) ? int(local3) : local3 + 1,local2,16711935);
local3 += 2;
}
local2++;
}
}
return stub;
}
}
}
|
package scpacker.resource
{
import alternativa.tanks.model.GarageModel;
import com.alternativaplatform.projects.tanks.client.commons.types.TankParts;
import flash.utils.Dictionary;
import scpacker.resource.images.ImageResourceList;
import scpacker.resource.images.ImageResourceLoader;
import scpacker.resource.listener.ResourceLoaderListener;
import scpacker.resource.tanks.TankResourceLoader;
import specter.utils.Logger;
public class ResourceUtil
{
public static var loading:Vector.<String>;
public static var isInBattle:Boolean = false;
private static var loaderSounds:SoundResourceLoader;
private static var loaderModels:TankResourceLoader;
private static var loaderImages:ImageResourceLoader;
private static var sfxMap:Dictionary;
public static var resourceLoaded:Boolean;
private static var resourcesLength:int;
public function ResourceUtil()
{
super();
throw new Error("пошел нахуй, кста");
}
public static function getResource(type:ResourceType, key:String) : Object
{
var returningResource:Object = null;
if(!resourceLoaded)
{
return null;
}
switch(type)
{
case ResourceType.IMAGE:
if(!isInBattle)
{
returningResource = loaderImages.list.getImage(key);
}
else
{
returningResource = loaderImages.inbattleList.getImage(key);
}
break;
case ResourceType.MODEL:
returningResource = loaderModels.list.getModel(key);
break;
case ResourceType.SOUND:
returningResource = loaderSounds.list.getSound(key);
}
return returningResource;
}
public static function checkBitmaps() : void
{
trace("finish");
}
public static function loadResource() : void
{
sfxMap = new Dictionary();
sfxMap["railgun"] = "shot, chargingPart1, chargingPart2, chargingPart3";
sfxMap["railgunxt"] = "shot, chargingPart1, chargingPart2, chargingPart3";
sfxMap["smoky"] = "shot, explosion";
sfxMap["smokyxt"] = "shot, explosion";
sfxMap["flamethrower"] = "fire";
sfxMap["twins"] = "explosionTexture, plasmaTexture, shotTexture";
sfxMap["twins_xt"] = "explosionTexture, plasmaTexture, shotTexture";
sfxMap["twinsxt"] = "explosionTexture, plasmaTexture, shotTexture";
sfxMap["isida"] = "damagingRayId, damagingTargetBallId, damagingWeaponBallId, healingRayId, healingTargetBallId, healingWeaponBallId, idleWeaponBallId";
sfxMap["thunder"] = "explosionResourceId, shotResourceId";
sfxMap["thunder_xt"] = "explosionResourceId, shotResourceId";
sfxMap["hwthunder"] = "explosionResourceId, shotResourceId";
sfxMap["frezee"] = "particleTextureResourceId, planeTextureResourceId";
sfxMap["frezeeny"] = "particleTextureResourceId, planeTextureResourceId";
sfxMap["ricochet"] = "bumpFlashTextureId, explosionTextureId, shotFlashTextureId, shotTextureId, tailTrailTextureId";
sfxMap["pumpkingun"] = "bumpFlashTextureId, explosionTextureId, shotFlashTextureId, shotTextureId, tailTrailTextureId";
sfxMap["shaft"] = "explosionTexture, shot, trail";
sfxMap["terminator"] = "shot, chargingPart1, chargingPart2, chargingPart3";
sfxMap["snowman"] = "shot, fire, snow";
loading = new Vector.<String>();
loaderSounds = new SoundResourceLoader("resourceSound.json?rand=" + Math.random());
loaderModels = new TankResourceLoader("resourceModels.json?rand=" + Math.random());
loaderImages = new ImageResourceLoader("resourceImages.json?rand=" + Math.random());
}
public static function loadImages() : void
{
isInBattle = false;
resourceLoaded = false;
loaderImages.reload();
}
public static function unloadImages(saveList:Vector.<String> = null) : void
{
var s:String = null;
var s1:String = null;
isInBattle = true;
loaderImages.inbattleList.clear();
loaderImages.inbattleList = new ImageResourceList();
if(GarageModel.mounted != null && loaderImages.list.getImage(GarageModel.mounted[2]))
{
loaderImages.inbattleList.add(loaderImages.list.getImage(GarageModel.mounted[0] + "_details").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage(GarageModel.mounted[1] + "_lightmap").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage(GarageModel.mounted[0] + "_details").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage(GarageModel.mounted[1] + "_lightmap").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage(GarageModel.mounted[2]).clone());
}
if(saveList)
{
for each(s in saveList)
{
if(loaderImages.list.getImage(s))
{
loaderImages.inbattleList.add(loaderImages.list.getImage(s).clone());
Logger.log("Refreshing colormap: " + s);
}
else
{
for each(s1 in getLoadListSingle(s))
{
if(loaderImages.list.getImage(s1))
{
Logger.log("Refreshing tank part: " + s1);
loaderImages.inbattleList.add(loaderImages.list.getImage(s1).clone());
}
}
}
}
}
loaderImages.inbattleList.add(loaderImages.list.getImage("flagRed").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("flagBlue").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("flagRedModel_img").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("flagBlueModel_img").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("pedestalRC").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("pedestalBC").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("pedestalNC").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("explosionTexture").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("shockWaveTexture").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("smokeTexture").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("criticalHitTexture").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("deadTank").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("cords").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("parachute").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("parachute_inner").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_lightmap").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_details").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_gold").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_spin").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_ruby").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_prize").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_crystall").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_armor").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_health").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_damage").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("bonus_box_nitro").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("blueMineTexture").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("enemyMineTexture").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("friendlyMineTexture_mine").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("idleExplosionTexture_mine").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("mainExplosionTextureId_mine").clone());
loaderImages.inbattleList.add(loaderImages.list.getImage("redMineTexture_mine").clone());
loaderImages.list.clear();
loaderImages.list = new ImageResourceList();
onCompleteLoading();
}
public static function onCompleteLoading() : void
{
if(loaderImages.status == 1 && loaderSounds.status == 1 && loaderModels.status == 1)
{
trace("загрузка завершена");
resourceLoaded = true;
ResourceLoaderListener.loadedComplete();
ResourceLoaderListener.clearListeners();
}
}
public static function addEventListener(src:Function) : Function
{
ResourceLoaderListener.addEventListener(src);
return src;
}
public static function loadGraphicsFor(parts:TankParts) : void
{
var s:String = null;
if(isDataPresent(parts))
{
onCompleteLoading();
}
var toLoad:Vector.<String> = getLoadList(parts);
for each(s in toLoad)
{
loaderImages.loadForBattle(s);
}
toLoad = null;
}
public static function loadGraphics(toLoad:Vector.<String>) : void
{
var s:String = null;
for each(s in toLoad)
{
if(loaderImages.inbattleList.isLoaded(s))
{
trace("Good");
}
loaderImages.loadFor(s);
}
}
public static function getLoadListSingle(id:String) : Vector.<String>
{
var s:String = null;
var toLoad:Vector.<String> = new Vector.<String>();
toLoad.push(id + "_lightmap");
toLoad.push(id + "_details");
var partID:String = id.split("_")[0];
if(sfxMap[partID])
{
for each(s in sfxMap[partID].split(", "))
{
toLoad.push(id + "_" + s);
}
}
return toLoad;
}
public static function getLoadList(parts:TankParts) : Vector.<String>
{
var s:String = null;
var toLoad:Vector.<String> = new Vector.<String>();
toLoad.push(parts.hullObjectId + "_lightmap");
toLoad.push(parts.hullObjectId + "_details");
toLoad.push(parts.turretObjectId + "_lightmap");
toLoad.push(parts.turretObjectId + "_details");
toLoad.push(parts.coloringObjectId);
for each(s in sfxMap[parts.turretObjectId.split("_")[0]].split(", "))
{
toLoad.push(parts.turretObjectId + "_" + s);
}
return toLoad;
}
public static function isDataPresent(parts:TankParts) : Boolean
{
var s:String = null;
var toCheck:Vector.<String> = new Vector.<String>();
toCheck.push(parts.hullObjectId + "_lightmap");
toCheck.push(parts.hullObjectId + "_details");
toCheck.push(parts.turretObjectId + "_lightmap");
toCheck.push(parts.turretObjectId + "_details");
toCheck.push(parts.coloringObjectId);
for each(s in toCheck)
{
if(!loaderImages.inbattleList.isLoaded(s))
{
return false;
}
}
toCheck = null;
return true;
}
}
}
|
package services.contextmenu {
import alternativa.types.Long;
import flash.events.Event;
public class ContextMenuServiceEvent extends Event {
public static const WRITE_IN_PUBLIC:String = "ContextMenuServiceEvent.WRITE_IN_PUBLIC";
public static const WRITE_IN_PRIVATE:String = "ContextMenuServiceEvent.WRITE_IN_PRIVATE";
public static const REMOVE_FROM_FRIENDS:String = "ContextMenuServiceEvent.REMOVE_FROM_FRIENDS";
public static const REJECT_REQUEST:String = "ContextMenuServiceEvent.REJECT_REQUEST";
public static const FOCUS_ON_USER:String = "ContextMenuServiceEvent.FOCUS_ON_USER";
public static const SHOW_CLAN:String = "ContextMenuServiceEvent.SHOW_CLAN";
public static const VOTE_USER:String = "ContextMenuServiceEvent.VOTE_USER";
public var userId:Long;
public var uid:String;
public var clanId:Long;
public function ContextMenuServiceEvent(param1:String, param2:Long, param3:String = null, param4:Long = null) {
this.userId = param2;
this.uid = param3;
this.clanId = param4;
super(param1);
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.