code
stringlengths 57
237k
|
|---|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.bigbutton_OFF_LEFT.png")]
public dynamic class bigbutton_OFF_LEFT extends BitmapData {
public function bigbutton_OFF_LEFT(param1:int = 7, param2:int = 50) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.types {
import flash.utils.Dictionary;
import platform.client.fp10.core.type.IGameObject;
public class MultiGameObjectDictionary {
private var dictionary:Dictionary = new Dictionary(true);
public function MultiGameObjectDictionary() {
super();
}
public function put(param1:IGameObject, param2:IGameObject) : void {
var local3:Vector.<IGameObject> = null;
if(param1 in this.dictionary) {
this.dictionary[param1].push(param2);
} else {
local3 = new Vector.<IGameObject>();
local3.push(param2);
this.dictionary[param1] = local3;
}
}
public function getValues(param1:IGameObject) : Vector.<IGameObject> {
if(param1 in this.dictionary) {
return this.dictionary[param1];
}
return new Vector.<IGameObject>();
}
public function clear() : void {
this.dictionary = new Dictionary();
}
public function remove(param1:IGameObject, param2:IGameObject) : void {
var local3:Vector.<IGameObject> = null;
var local4:Number = NaN;
if(param1 in this.dictionary) {
local3 = this.dictionary[param1];
local4 = Number(local3.indexOf(param2));
if(local4 != -1) {
local3.splice(local4,1);
}
}
}
}
}
|
package platform.client.fp10.core.logging.serverlog {
import flash.display.Loader;
public interface UncaughtErrorServerLog {
function addLoader(param1:Loader) : void;
}
}
|
package alternativa.tanks.models.effects.ultimate {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Sprite3D;
import flash.display.BlendMode;
public class SparkleEffect extends Sprite3D {
public function SparkleEffect() {
super(512,512);
}
public function init(param1:TextureMaterial) : * {
material = param1;
calculateBounds();
blendMode = BlendMode.ADD;
softAttenuation = 100;
}
}
}
|
package alternativa.tanks.gui.icons {
import flash.display.Bitmap;
import flash.display.BitmapData;
public class SocialNetworkIcon {
private static const vkBitmap:Class = SocialNetworkIcon_vkBitmap;
private static const vkBd:BitmapData = new vkBitmap().bitmapData;
private static const fbBitmap:Class = SocialNetworkIcon_fbBitmap;
private static const fbBd:BitmapData = new fbBitmap().bitmapData;
private static const googleBitmap:Class = SocialNetworkIcon_googleBitmap;
private static const googleBd:BitmapData = new googleBitmap().bitmapData;
public function SocialNetworkIcon() {
super();
}
public static function createVk() : Bitmap {
return new Bitmap(vkBd);
}
public static function createFb() : Bitmap {
return new Bitmap(fbBd);
}
public static function createGoogle() : Bitmap {
return new Bitmap(googleBd);
}
}
}
|
package alternativa.tanks.models.weapon.gauss.state.targetselection {
public interface IGaussAimState {
function enter(param1:int, param2:GaussAimEventType, param3:*) : void;
function update(param1:int, param2:int) : void;
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased.rugby.explosion {
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 BallExplosionModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BallExplosionModelServer(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.model.mobilelootbox {
import projects.tanks.client.garage.models.item.mobilelootbox.lootbox.IMobileLootBoxModelBase;
import projects.tanks.client.garage.models.item.mobilelootbox.lootbox.MobileLoot;
import projects.tanks.client.garage.models.item.mobilelootbox.lootbox.MobileLootBoxModelBase;
[ModelInfo]
public class MobileLootBoxModel extends MobileLootBoxModelBase implements IMobileLootBoxModelBase {
public function MobileLootBoxModel() {
super();
}
public function openSuccessful(param1:Vector.<MobileLoot>) : void {
}
public function openingFailed() : void {
}
public function updateCount(param1:int) : void {
}
}
}
|
package alternativa.tanks.services.objectpool.impl
{
import alternativa.tanks.services.objectpool.IObjectPoolService;
import alternativa.tanks.utils.objectpool.ObjectPool;
public class ObjectPoolService implements IObjectPoolService
{
private var _objectPool:ObjectPool;
public function ObjectPoolService()
{
this._objectPool = new ObjectPool();
super();
}
public function get objectPool() : ObjectPool
{
return this._objectPool;
}
public function clear() : void
{
this._objectPool.clear();
}
}
}
|
package alternativa.tanks.models.battle.battlefield.mine {
import alternativa.math.Vector3;
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IBattleMinesModelAdapt implements IBattleMinesModel {
private var object:IGameObject;
private var impl:IBattleMinesModel;
public function IBattleMinesModelAdapt(param1:IGameObject, param2:IBattleMinesModel) {
super();
this.object = param1;
this.impl = param2;
}
public function getMinDistanceFromBase() : Number {
var result:Number = NaN;
try {
Model.object = this.object;
result = Number(this.impl.getMinDistanceFromBase());
}
finally {
Model.popObject();
}
return result;
}
public function getMinePosition(param1:Long) : Vector3 {
var result:Vector3 = null;
var mineId:Long = param1;
try {
Model.object = this.object;
result = this.impl.getMinePosition(mineId);
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.weapon.artillery.sfx {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ArtillerySfxEvents implements ArtillerySfx {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ArtillerySfxEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getSfxData() : ArtillerySfxData {
var result:ArtillerySfxData = null;
var i:int = 0;
var m:ArtillerySfx = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ArtillerySfx(this.impl[i]);
result = m.getSfxData();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.onetimepurchase {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.shop.onetimepurchase.ShopItemOneTimePurchaseCC;
public class CodecShopItemOneTimePurchaseCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_oneTimePurchase:ICodec;
private var codec_triedToBuy:ICodec;
public function CodecShopItemOneTimePurchaseCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_oneTimePurchase = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_triedToBuy = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ShopItemOneTimePurchaseCC = new ShopItemOneTimePurchaseCC();
local2.oneTimePurchase = this.codec_oneTimePurchase.decode(param1) as Boolean;
local2.triedToBuy = this.codec_triedToBuy.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ShopItemOneTimePurchaseCC = ShopItemOneTimePurchaseCC(param2);
this.codec_oneTimePurchase.encode(param1,local3.oneTimePurchase);
this.codec_triedToBuy.encode(param1,local3.triedToBuy);
}
}
}
|
package alternativa.tanks.model
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import com.alternativaplatform.projects.tanks.client.commons.models.itemtype.ItemTypeEnum;
import com.alternativaplatform.projects.tanks.client.garage.item.IItemModelBase;
import com.alternativaplatform.projects.tanks.client.garage.item.ItemModelBase;
import com.alternativaplatform.projects.tanks.client.garage.item.ModificationInfo;
import flash.utils.Dictionary;
public class ItemModel extends ItemModelBase implements IItemModelBase, IItem
{
private var params:Dictionary;
public function ItemModel()
{
super();
_interfaces.push(IModel);
_interfaces.push(IItem);
_interfaces.push(IItemModelBase);
this.params = new Dictionary();
}
public function initObject(clientObject:ClientObject, baseItemId:String, description:String, itemIndex:int, itemType:ItemTypeEnum, modificationIndex:int, modifications:Array, name:String, previewId:String) : void
{
var nextModInfo:ModificationInfo = null;
var i:int = 0;
var modInfo:ModificationInfo = ModificationInfo(modifications[modificationIndex]);
if(modifications[modificationIndex + 1] != null)
{
nextModInfo = ModificationInfo(modifications[modificationIndex + 1]);
}
this.params[clientObject] = new ItemParams(baseItemId,description,itemType == ItemTypeEnum.INVENTORY,itemIndex,modInfo.itemProperties,itemType,modificationIndex,name,nextModInfo != null ? int(int(nextModInfo.crystalPrice)) : int(int(0)),nextModInfo != null ? nextModInfo.itemProperties : null,nextModInfo != null ? int(int(nextModInfo.rankId)) : int(int(0)),previewId,modInfo.crystalPrice,modInfo.rankId,modifications);
Main.writeVarsToConsoleChannel("ITEM MODEL","initObject baseItemId: %1",baseItemId);
var modelRegister:IModelService = Main.osgi.getService(IModelService) as IModelService;
var listeners:Vector.<IModel> = modelRegister.getModelsByInterface(IItemListener);
if(listeners != null)
{
for(i = 0; i < listeners.length; i++)
{
(listeners[i] as IItemListener).itemLoaded(clientObject,this.params[clientObject]);
}
}
}
public function getParams(item:ClientObject) : ItemParams
{
return this.params[item];
}
}
}
|
package projects.tanks.client.clans.notifier {
public interface IClanNotifierModelBase {
function sendData(param1:Vector.<ClanNotifierData>) : void;
}
}
|
package alternativa.tanks.models.tank.bosstate {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.models.battle.ctf.MessageColor;
import alternativa.tanks.models.battle.gui.BattlefieldGUI;
import alternativa.tanks.models.battle.gui.inventory.IInventoryPanel;
import alternativa.tanks.models.inventory.IInventoryModel;
import alternativa.tanks.models.inventory.InventoryItemType;
import alternativa.tanks.models.inventory.InventoryLock;
import alternativa.tanks.models.tank.ITankModel;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.battlefield.models.user.bossstate.BossRelationRole;
import projects.tanks.client.battlefield.models.user.bossstate.BossStateModelBase;
import projects.tanks.client.battlefield.models.user.bossstate.IBossStateModelBase;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
[ModelInfo]
public class BossStateModel extends BossStateModelBase implements IBossStateModelBase, IBossState, ObjectLoadListener {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var inventoryPanel:IInventoryPanel;
private var inventoryLockMask:Vector.<int>;
public function BossStateModel() {
super();
this.inventoryLockMask = new Vector.<int>();
this.inventoryLockMask.push(InventoryItemType.FIRST_AID);
this.inventoryLockMask.push(InventoryItemType.ARMOR);
this.inventoryLockMask.push(InventoryItemType.DAMAGE);
this.inventoryLockMask.push(InventoryItemType.NITRO);
this.inventoryLockMask.push(InventoryItemType.MINE);
}
public function objectLoaded() : void {
putData(BossRelationRole,getInitParam().role);
}
public function changeRole(param1:BossRelationRole) : void {
var local3:IInventoryModel = null;
var local4:String = null;
putData(BossRelationRole,param1);
var local2:ITankModel = ITankModel(object.adapt(ITankModel));
if(local2.getUserInfo().isLocal) {
this.setInfiniteEffect(param1);
if(param1 == BossRelationRole.INCARNATION) {
local4 = localeService.getText(TanksLocale.TEXT_JGR_YOU_ARE_THE_BOSS);
this.getBattleGUI().showBattleMessage(MessageColor.POSITIVE,local4);
}
local3 = IInventoryModel(object.space.rootObject.adapt(IInventoryModel));
if(param1 == BossRelationRole.BOSS || param1 == BossRelationRole.INCARNATION) {
local3.lockItemsByMask(this.inventoryLockMask,InventoryLock.BOSS_STATE,true);
battleInfoService.enterGarageCausesExitBattle = true;
} else {
local3.lockItemsByMask(this.inventoryLockMask,InventoryLock.BOSS_STATE,false);
battleInfoService.enterGarageCausesExitBattle = false;
}
}
}
private function setInfiniteEffect(param1:BossRelationRole) : void {
var local2:Boolean = param1 == BossRelationRole.BOSS;
if(!local2) {
return;
}
inventoryPanel.setEffectInfinite(InventoryItemType.ARMOR,true);
inventoryPanel.setEffectInfinite(InventoryItemType.DAMAGE,true);
inventoryPanel.setEffectInfinite(InventoryItemType.NITRO,true);
}
public function role() : BossRelationRole {
var local1:BossRelationRole = BossRelationRole(getData(BossRelationRole));
return local1 != null ? local1 : BossRelationRole.VICTIM;
}
private function getBattleGUI() : BattlefieldGUI {
return BattlefieldGUI(object.space.rootObject.adapt(BattlefieldGUI));
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes.sms {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.payment.modes.sms.SMSPayModeCC;
import projects.tanks.client.panel.model.payment.modes.sms.types.Country;
public class CodecSMSPayModeCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_countries:ICodec;
public function CodecSMSPayModeCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_countries = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Country,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:SMSPayModeCC = new SMSPayModeCC();
local2.countries = this.codec_countries.decode(param1) as Vector.<Country>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:SMSPayModeCC = SMSPayModeCC(param2);
this.codec_countries.encode(param1,local3.countries);
}
}
}
|
package alternativa.tanks.models.weapon.gauss.sfx {
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.scene3d.RotationState;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.gauss.GaussWeaponCallback;
import alternativa.tanks.models.weapon.splash.Splash;
import alternativa.tanks.models.weapon.weakening.DistanceWeakening;
import alternativa.tanks.models.weapons.shell.InelasticShell;
import alternativa.tanks.models.weapons.shell.states.DummyShellStates;
import alternativa.tanks.models.weapons.shell.states.ShellStates;
import alternativa.tanks.sfx.AnimatedLightEffect;
import alternativa.tanks.sfx.AnimatedSpriteEffect;
import alternativa.tanks.sfx.ExternalObject3DPositionProvider;
import alternativa.tanks.sfx.MobileSound3DEffect;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.MathUtils;
import alternativa.tanks.utils.objectpool.Pool;
import projects.tanks.client.battlefield.models.tankparts.weapon.gauss.GaussCC;
public class GaussShell extends InelasticShell {
private static var shellMesh:Mesh;
private static const SHELL_SCALE:Number = 0.25;
private static const TRAIL_SIZE:Number = 50;
private static const TRAIL_FULL_SIZE:Number = 4800;
private static const EXPLOSION_OFFSET_TO_CAMERA:Number = 110;
private static const EXPLOSION_SPRITE_SIZE:Number = 500;
private static const HIT_MARK_RADIUS:Number = 250;
private var weakening:DistanceWeakening;
private var sfxData:GaussSFXData;
private var callback:GaussWeaponCallback;
private var gaussData:GaussCC;
private var impactForce:Number;
private var lightEffect:AnimatedLightEffect;
private var lightEffectPositionProvider:ExternalObject3DPositionProvider;
private var splash:Splash;
private var view:Mesh;
private var trailStart:Vector3 = new Vector3();
private var trailEnd:Vector3 = new Vector3();
private var gunParams:AllGlobalGunParams;
private var trail:GaussTrail = new GaussTrail();
private var shellSound:MobileSound3DEffect;
public function GaussShell(param1:Pool) {
super(param1);
}
override protected function createShellStates() : ShellStates {
return DummyShellStates.INSTANCE;
}
public function init(param1:Number, param2:GaussCC, param3:GaussSFXData, param4:DistanceWeakening, param5:GaussWeaponCallback, param6:Splash) : void {
this.impactForce = param1;
this.gaussData = param2;
this.weakening = param4;
this.sfxData = param3;
this.callback = param5;
this.splash = param6;
if(shellMesh == null) {
shellMesh = Mesh(param3.shellMesh);
shellMesh.scaleX = SHELL_SCALE;
shellMesh.scaleY = SHELL_SCALE;
shellMesh.scaleZ = SHELL_SCALE;
if(shellMesh.sorting != Sorting.DYNAMIC_BSP) {
shellMesh.sorting = Sorting.DYNAMIC_BSP;
shellMesh.calculateFacesNormals(true);
shellMesh.optimizeForDynamicBSP();
}
}
this.view = Mesh(shellMesh.clone());
this.lightEffect = AnimatedLightEffect(this.getObject(AnimatedLightEffect));
this.lightEffectPositionProvider = ExternalObject3DPositionProvider(this.getObject(ExternalObject3DPositionProvider));
this.lightEffect.init(this.lightEffectPositionProvider,param3.primaryShellLightAnimation,AnimatedLightEffect.DEFAULT_MAX_DISTANCE,true);
this.trail.size = TRAIL_SIZE;
this.trail.useLight = false;
this.trail.useShadowMap = false;
this.trail.alpha = 0.5;
this.trail.material = param3.tracerTextureMaterial;
}
override public function addToGame(param1:AllGlobalGunParams, param2:Vector3, param3:Body, param4:Boolean, param5:int) : void {
super.addToGame(param1,param2,param3,param4,param5);
this.gunParams = param1;
battleService.getBattleScene3D().addObject(this.view);
battleService.getBattleScene3D().addObject(this.trail);
battleService.addGraphicEffect(this.lightEffect);
var local6:Matrix3 = BattleUtils.tmpMatrix3;
local6.setDirectionVector(param2);
this.setShellRotation(local6);
this.playFlightSound();
}
private function setShellRotation(param1:Matrix3) : void {
var local2:Vector3 = BattleUtils.tmpVector;
param1.getEulerAngles(local2);
this.view.rotationX = local2.x;
this.view.rotationY = local2.y;
this.view.rotationZ = local2.z;
}
override protected function getSpeed() : Number {
return this.gaussData.primaryShellSpeed;
}
override protected function getMaxDistance() : Number {
return this.gaussData.shotRange;
}
override protected function processHitImpl(param1:Body, param2:Vector3, param3:Vector3, param4:Number, param5:int) : void {
var local8:Tank = null;
super.processHitImpl(param1,param2,param3,param4,param5);
var local6:Number = this.weakening.getImpactCoeff(param4);
this.createExplosionEffect(param2);
this.createExplosionLightEffect(param2);
this.shellSound.kill();
this.playHitSound();
var local7:Boolean = Boolean(this.splash.applySplashForce(param2,local6,param1));
if(BattleUtils.isTankBody(param1)) {
local8 = param1.tank;
local8.applyWeaponHit(param2,param3,this.impactForce * local6);
if(Boolean(this.callback)) {
this.callback.doPrimaryHitTarget(getShotId(),local8.user,param1.state.position,param2);
}
} else {
if(Boolean(this.callback) && local7) {
this.callback.doPrimaryHitStatic(getShotId(),param2);
}
this.createHitMark(param2);
}
this.destroy();
}
override public function render(param1:int, param2:int) : void {
BattleUtils.setObjectPosition3d(this.view,interpolatedPosition.toVector3d());
this.lightEffectPositionProvider.setPosition(interpolatedPosition);
var local3:Number = interpolatedPosition.distanceTo(this.gunParams.muzzlePosition);
var local4:Number = Math.min(local3,TRAIL_FULL_SIZE);
this.trail.scaleY = local4 / TRAIL_SIZE;
this.trailEnd.copy(interpolatedPosition);
this.trailStart.copy(this.trailEnd);
this.trailStart.addScaled(-local4,flightDirection);
SFXUtils.alignObjectPlaneToView(this.trail,this.trailStart,flightDirection,battleService.getBattleScene3D().getCamera().position);
}
override protected function destroy() : void {
super.destroy();
battleService.getBattleScene3D().removeObject(this.view);
battleService.getBattleScene3D().removeObject(this.trail);
this.gaussData = null;
this.callback = null;
shooterBody = null;
this.weakening = null;
this.sfxData = null;
this.lightEffect.kill();
this.lightEffect = null;
this.lightEffectPositionProvider = null;
}
override protected function getRadius() : Number {
return this.gaussData.primaryShellRadius;
}
private function createExplosionEffect(param1:Vector3) : void {
var local2:StaticObject3DPositionProvider = StaticObject3DPositionProvider(this.getObject(StaticObject3DPositionProvider));
local2.init(param1,EXPLOSION_OFFSET_TO_CAMERA);
var local3:AnimatedSpriteEffect = AnimatedSpriteEffect(this.getObject(AnimatedSpriteEffect));
var local4:Number = MathUtils.PI2 * Math.random();
local3.init(EXPLOSION_SPRITE_SIZE,EXPLOSION_SPRITE_SIZE,this.sfxData.explosionTextureAnimation,local4,local2,0.5,0.5);
battleService.addGraphicEffect(local3);
}
private function getObject(param1:Class) : Object {
return battleService.getObjectPool().getObject(param1);
}
private function createExplosionLightEffect(param1:Vector3) : void {
var local2:AnimatedLightEffect = AnimatedLightEffect(this.getObject(AnimatedLightEffect));
var local3:StaticObject3DPositionProvider = StaticObject3DPositionProvider(this.getObject(StaticObject3DPositionProvider));
local3.init(param1,EXPLOSION_OFFSET_TO_CAMERA);
local2.init(local3,this.sfxData.primaryExplosionLightAnimation);
battleService.addGraphicEffect(local2);
}
private function playFlightSound() : void {
this.shellSound = MobileSound3DEffect(this.getObject(MobileSound3DEffect));
this.shellSound.init(Sound3D.create(this.sfxData.shellFlightSound),this.view);
battleService.addSound3DEffect(this.shellSound);
}
private function playHitSound() : void {
var local1:MobileSound3DEffect = MobileSound3DEffect(this.getObject(MobileSound3DEffect));
local1.init(Sound3D.create(this.sfxData.primaryHitSound),this.view);
battleService.addSound3DEffect(local1);
}
private function createHitMark(param1:Vector3) : void {
battleService.getBattleScene3D().addDecal(param1,this.gunParams.barrelOrigin,HIT_MARK_RADIUS,this.sfxData.primaryHitMarkerMaterial,RotationState.USE_RANDOM_ROTATION);
}
}
}
|
package {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol47")]
public dynamic class focusRectSkin extends MovieClip {
public function focusRectSkin() {
super();
}
}
}
|
package projects.tanks.client.tanksservices.model.notifier.uid {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class UidNotifierModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:UidNotifierModelServer;
private var client:IUidNotifierModelBase = IUidNotifierModelBase(this);
private var modelId:Long = Long.getLong(990863444,376077627);
private var _setUidId:Long = Long.getLong(290132373,74250398);
private var _setUid_usersCodec:ICodec;
public function UidNotifierModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new UidNotifierModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(UidNotifierData,false)));
this._setUid_usersCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(UidNotifierData,false),false,1));
}
protected function getInitParam() : UidNotifierData {
return UidNotifierData(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._setUidId:
this.client.setUid(this._setUid_usersCodec.decode(param2) as Vector.<UidNotifierData>);
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package assets.window.elemets {
import flash.display.Sprite;
[Embed(source="/_assets/assets.swf", symbol="symbol34")]
public class WindowBottomRightCorner extends Sprite {
public function WindowBottomRightCorner() {
super();
}
}
}
|
package platform.client.fp10.core.model {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ObjectLoadPostListenerEvents implements ObjectLoadPostListener {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ObjectLoadPostListenerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function objectLoadedPost() : void {
var i:int = 0;
var m:ObjectLoadPostListener = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ObjectLoadPostListener(this.impl[i]);
m.objectLoadedPost();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.model.item.device {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.garage.models.item.device.ItemDevicesCC;
[ModelInterface]
public interface ItemDevicesGarage {
function buyDevice(param1:IGameObject, param2:int) : void;
function insertDevice(param1:IGameObject) : void;
function removeDevice() : void;
function getParams() : ItemDevicesCC;
}
}
|
package alternativa.tanks.locale.constants
{
public class ImageConst
{
public static const REFERAL_WINDOW_HEADER_IMAGE:String = "ReferalWindowHeaderImage";
public static const CONGRATULATION_WINDOW_TICKET_IMAGE:String = "CongratulationWindowTicketImage";
public function ImageConst()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.gauss.state.targetselection {
import alternativa.tanks.models.weapon.gauss.GaussEventType;
import alternativa.tanks.models.weapon.gauss.LocalGaussWeapon;
public class CancelledState implements IGaussAimState {
private var weapon:LocalGaussWeapon;
public function CancelledState(param1:LocalGaussWeapon) {
super();
this.weapon = param1;
}
public function enter(param1:int, param2:GaussAimEventType, param3:*) : void {
this.weapon.stopAiming();
this.weapon.hideAim();
this.weapon.processEvent(GaussEventType.DEACTIVATED);
}
public function update(param1:int, param2:int) : void {
}
}
}
|
package alternativa.tanks.models.weapon.flamethrower {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.engine3d.EffectsMaterialRegistry;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.sfx.colortransform.ColorTransformConsumer;
import alternativa.tanks.models.sfx.colortransform.ColorTransformEntry;
import alternativa.tanks.models.sfx.lighting.LightingSfx;
import alternativa.tanks.models.weapon.shared.streamweapon.StreamWeaponEffects;
import alternativa.tanks.models.weapon.streamweapon.StreamWeaponSFXData;
import alternativa.tanks.utils.GraphicsUtils;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import projects.tanks.client.battlefield.models.tankparts.sfx.firebird.FlameThrowingSFXCC;
import projects.tanks.client.battlefield.models.tankparts.sfx.firebird.FlameThrowingSFXModelBase;
import projects.tanks.client.battlefield.models.tankparts.sfx.firebird.IFlameThrowingSFXModelBase;
[ModelInfo]
public class FlamethrowerSFXModel extends FlameThrowingSFXModelBase implements IFlameThrowingSFXModelBase, ObjectLoadListener, ObjectUnloadListener, IFlamethrowerSFXModel, ColorTransformConsumer {
[Inject]
public static var materialRegistry:EffectsMaterialRegistry;
[Inject]
public static var battleService:BattleService;
public function FlamethrowerSFXModel() {
super();
}
private static function getParticleAnimation(param1:MultiframeTextureResource) : TextureAnimation {
var local2:TextureAnimation = GraphicsUtils.getTextureAnimationFromResource(materialRegistry,param1);
local2.material.resolution = FlamethrowerEffectsParams.PARTICLE_END_SIZE / param1.frameWidth;
return local2;
}
private static function getMuzzlePlaneAnimation(param1:MultiframeTextureResource) : TextureAnimation {
var local2:TextureAnimation = GraphicsUtils.getTextureAnimationFromResource(materialRegistry,param1);
local2.material.resolution = FlamethrowerEffectsParams.PLANE_LENGTH / param1.frameWidth;
return local2;
}
public function initColorTransform(param1:Vector.<ColorTransformEntry>) : void {
var local2:StreamWeaponSFXData = StreamWeaponSFXData(getData(StreamWeaponSFXData));
local2.particleColorTransformPoints = param1;
}
public function objectLoaded() : void {
var local1:FlameThrowingSFXCC = getInitParam();
var local2:StreamWeaponSFXData = new StreamWeaponSFXData();
local2.particleAnimation = getParticleAnimation(local1.fireTexture);
local2.muzzlePlaneAnimation = getMuzzlePlaneAnimation(local1.muzzlePlaneTexture);
local2.additionalElementTexture = materialRegistry.getMaterial(local1.buffedFireSparksTexture.data);
local2.shootingSound = local1.flameSound.sound;
local2.particleSpeed = FlamethrowerEffectsParams.PARTICLE_SPEED_PER_DISTANCE_METER;
var local3:LightingSfx = new LightingSfx(local1.lightingSFXEntity);
local2.startLightAnimation = local3.createAnimation("start");
local2.loopLightAnimation = local3.createAnimation("loop");
local2.startFireAnimation = local3.createAnimation("startFire");
local2.loopFireAnimation = local3.createAnimation("loopFire");
putData(StreamWeaponSFXData,local2);
}
public function objectUnloaded() : void {
var local4:TextureMaterial = null;
var local1:StreamWeaponSFXData = StreamWeaponSFXData(getData(StreamWeaponSFXData));
var local2:Array = local1.getMaterialsToRelease();
var local3:int = 0;
while(local3 < local2.length) {
local4 = local2[local3];
materialRegistry.releaseMaterial(local4);
local3++;
}
}
public function getFlamethrowerEffects(param1:Number, param2:Number) : StreamWeaponEffects {
var local3:StreamWeaponSFXData = StreamWeaponSFXData(getData(StreamWeaponSFXData));
return new FlamethrowerEffects(battleService.getObjectPool(),param1,param2,local3);
}
}
}
|
package alternativa.tanks.model.garage.present {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class PresentPurchaseAdapt implements PresentPurchase {
private var object:IGameObject;
private var impl:PresentPurchase;
public function PresentPurchaseAdapt(param1:IGameObject, param2:PresentPurchase) {
super();
this.object = param1;
this.impl = param2;
}
public function preparePresent(param1:IGameObject) : void {
var presentItem:IGameObject = param1;
try {
Model.object = this.object;
this.impl.preparePresent(presentItem);
}
finally {
Model.popObject();
}
}
public function confirmPresentPurchase(param1:IGameObject) : void {
var presentItem:IGameObject = param1;
try {
Model.object = this.object;
this.impl.confirmPresentPurchase(presentItem);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_capacitorpowerreductionIconClass.png")]
public class DeviceIcons_capacitorpowerreductionIconClass extends BitmapAsset {
public function DeviceIcons_capacitorpowerreductionIconClass() {
super();
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.ISourceData;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.SearchInputView;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.candidates.ClanOutgoingListRenderer;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.candidates.HeaderClanCandidateList;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.list.ClanMembersDataProvider;
import alternativa.tanks.gui.notinclan.dialogs.ClanDialog;
import alternativa.tanks.models.clan.outgoing.IClanOutgoingModel;
import alternativa.tanks.service.clan.ClanMembersListEvent;
import alternativa.types.Long;
import controls.windowinner.WindowInner;
import fl.controls.List;
import forms.Styles;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanFunctionsService;
import utils.ScrollStyleUtils;
public class ClanOutgoingRequestsDialog extends ClanDialog {
[Inject]
public static var clanFunctionsService:ClanFunctionsService;
[Inject]
public static var localeService:ILocaleService;
public static const WIDTH:Number = 550;
public static const HEIGHT:Number = 450;
private var inner:WindowInner;
private var list:List;
private var dataProvider:ClanMembersDataProvider;
private var _header:HeaderClanCandidateList;
private var outgoingModel:IClanOutgoingModel;
private var searchInput:SearchInputView;
public function ClanOutgoingRequestsDialog(param1:IGameObject) {
super();
this.outgoingModel = IClanOutgoingModel(param1.adapt(IClanOutgoingModel));
this.outgoingModel.setClanOutgoingWindow(this);
this.inner = new WindowInner(WIDTH,HEIGHT,WindowInner.GREEN);
window.addChild(this.inner);
this._header = new HeaderClanCandidateList();
this.inner.addChild(this._header);
this.dataProvider = new ClanMembersDataProvider();
this.list = new List();
this.list.rowHeight = 20;
this.list.setStyle(Styles.CELL_RENDERER,ClanOutgoingListRenderer);
this.list.focusEnabled = true;
this.list.selectable = false;
this.list.dataProvider = this.dataProvider;
ScrollStyleUtils.setGreenStyle(this.list);
this.inner.addChild(this.list);
var local2:ISourceData = ISourceData(param1.adapt(ISourceData));
this.searchInput = new SearchInputView(local2,localeService.getText(TanksLocale.TEXT_CLAN_SEND_INVITE),localeService.getText(TanksLocale.TEXT_FRIENDS_SEND_REQUEST_BUTTON),"","");
window.addChild(this.searchInput);
ScrollStyleUtils.setGreenStyle(this.list);
this.fillData();
this.list.addEventListener(ClanMembersListEvent.REVOKE_USER,this.onRevokeUser);
this.resize();
}
private function onRevokeUser(param1:ClanMembersListEvent) : void {
clanFunctionsService.revokeRequest(param1.userId);
}
public function resize() : void {
var local1:int = HEIGHT - closeButton.height - MARGIN;
this.inner.x = MARGIN;
this.inner.y = MARGIN;
this.inner.width = WIDTH - 2 * MARGIN;
this.inner.height = local1 - 2 * MARGIN;
this._header.x = 3;
this._header.y = 3;
this._header.width = this.inner.width - 6;
this.list.x = 3;
this.list.y = 23;
this.list.height = this.inner.height - 24;
var local2:Boolean = this.list.maxVerticalScrollPosition > 0;
this.list.width = local2 ? this.inner.width + 2 : this.inner.width - 6;
if(this.searchInput != null) {
this.searchInput.x = MARGIN;
this.searchInput.y = HEIGHT - MARGIN - 30;
this.searchInput.width = WIDTH - 2 * MARGIN - 2 * closeButton.width - 17;
}
}
public function fillData() : void {
var local1:Long = null;
this.dataProvider.removeAll();
for each(local1 in this.outgoingModel.getUsers()) {
this.dataProvider.addItem({"id":local1});
}
this.sort();
this.resize();
}
private function sort() : void {
this.dataProvider.sortOn(["id"],[Array.NUMERIC]);
}
public function addUser(param1:Long) : void {
this.dataProvider.addItem({"id":param1});
this.sort();
this.resize();
}
public function removeUser(param1:Long) : void {
var local2:int = this.dataProvider.getItemIndexById(param1);
if(local2 >= 0) {
this.dataProvider.removeItemAt(local2);
}
this.sort();
this.resize();
}
override public function updateActions() : void {
if(!clanUserInfoService.hasAction(ClanAction.INVITE_TO_CLAN)) {
this.destroy();
}
}
override public function destroy() : void {
this.searchInput.hide();
super.destroy();
}
override public function get height() : Number {
return HEIGHT;
}
override public function get width() : Number {
return WIDTH;
}
override protected function getImageHeaderId() : String {
return TanksLocale.TEXT_HEADER_CLAN_MANAGMENT;
}
}
}
|
package alternativa.tanks.models.battle.gui.drone {
import alternativa.tanks.battle.objects.tank.Tank;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.user.tank.TankLogicState;
public class IDroneModelAdapt implements IDroneModel {
private var object:IGameObject;
private var impl:IDroneModel;
public function IDroneModelAdapt(param1:IGameObject, param2:IDroneModel) {
super();
this.object = param1;
this.impl = param2;
}
public function initDrones(param1:Tank, param2:Boolean, param3:TankLogicState) : void {
var tank:Tank = param1;
var isLocal:Boolean = param2;
var logicState:TankLogicState = param3;
try {
Model.object = this.object;
this.impl.initDrones(tank,isLocal,logicState);
}
finally {
Model.popObject();
}
}
public function canOverheal() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.canOverheal());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen {
public interface FullscreenStateService {
function isFullscreen() : Boolean;
}
}
|
package alternativa.tanks.model.quest.common.gui.window.buttons.skin {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.quest.common.gui.window.buttons.skin.GreenBigButtonSkin_leftOverClass.png")]
public class GreenBigButtonSkin_leftOverClass extends BitmapAsset {
public function GreenBigButtonSkin_leftOverClass() {
super();
}
}
}
|
package alternativa.tanks.battle.objects.tank.tankchassis {
import alternativa.physics.Body;
import alternativa.physics.collision.IRayCollisionFilter;
internal class RayCollisionFilter implements IRayCollisionFilter {
private var body:Body;
public function RayCollisionFilter(param1:Body) {
super();
this.body = param1;
}
public function considerBody(param1:Body) : Boolean {
return this.body != param1;
}
}
}
|
package alternativa.tanks.models.weapon.machinegun.sfx {
import alternativa.math.Vector3;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.engine3d.AnimatedSprite3D;
import alternativa.tanks.engine3d.TextureAnimation;
public class Smoke extends ParticleSystem {
private static const MAX_COUNT:int = 5;
private var size:Number;
private var speed:Number;
private var top:Number;
private var emitterPosition:Vector3 = new Vector3();
private var animation:TextureAnimation;
private var container:Scene3DContainer;
public function Smoke(param1:Number, param2:Number, param3:Number, param4:Number) {
super(SmokeParticle,param4,MAX_COUNT);
this.size = param1;
this.speed = param2;
this.top = param3;
}
public function setAnimation(param1:TextureAnimation) : void {
this.animation = param1;
}
public function setContainer(param1:Scene3DContainer) : void {
this.container = param1;
}
public function setEmitterPosition(param1:Vector3) : void {
this.emitterPosition.copy(param1);
}
override protected function onCreateParticle(param1:Particle) : void {
var local2:SmokeParticle = SmokeParticle(param1);
local2.init(this.size,this.emitterPosition,Math.random() * Math.PI * 2,this.animation);
this.container.addChild(local2.sprite);
}
override protected function onUpdateParticle(param1:Particle, param2:Number) : void {
var local3:SmokeParticle = null;
local3 = SmokeParticle(param1);
var local4:AnimatedSprite3D = local3.sprite;
local4.update(param2);
local4.z += this.speed * param2;
var local5:Number = 1 - Math.abs(this.top / 2 - (local4.z - local3.initialZ)) * 2 / this.top;
local4.alpha = local5;
local4.rotation = local3.rotation + local5 * 0.3;
if(local4.z - local3.initialZ >= this.top) {
local3.alive = false;
}
}
override protected function onDeleteParticle(param1:Particle) : void {
this.container.removeChild(SmokeParticle(param1).sprite);
}
override public function clear() : void {
super.clear();
this.animation = null;
this.container = null;
}
}
}
|
package projects.tanks.client.clans.clan.block {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class ClanBlockModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ClanBlockModelServer;
private var client:IClanBlockModelBase = IClanBlockModelBase(this);
private var modelId:Long = Long.getLong(525873271,1744909560);
private var _clanBanedId:Long = Long.getLong(123212251,-1982333947);
private var _clanBaned_reasonCodec:ICodec;
public function ClanBlockModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ClanBlockModelServer(IModel(this));
this._clanBaned_reasonCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._clanBanedId:
this.client.clanBaned(String(this._clanBaned_reasonCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.osgi.service.command.impl {
public class CommandNotFoundError extends Error {
public function CommandNotFoundError(param1:String, param2:String) {
super(this.createMessage(param1,param2));
}
private function createMessage(param1:String, param2:String) : String {
var local3:String = "Command not found: " + param1;
if(param2 != null) {
local3 += "\n" + param2;
}
return local3;
}
}
}
|
package platform.client.models.commons.types {
public class ValidationStatus {
public static const TOO_SHORT:ValidationStatus = new ValidationStatus(0,"TOO_SHORT");
public static const TOO_LONG:ValidationStatus = new ValidationStatus(1,"TOO_LONG");
public static const NOT_UNIQUE:ValidationStatus = new ValidationStatus(2,"NOT_UNIQUE");
public static const NOT_MATCH_PATTERN:ValidationStatus = new ValidationStatus(3,"NOT_MATCH_PATTERN");
public static const FORBIDDEN:ValidationStatus = new ValidationStatus(4,"FORBIDDEN");
public static const CORRECT:ValidationStatus = new ValidationStatus(5,"CORRECT");
private var _value:int;
private var _name:String;
public function ValidationStatus(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<ValidationStatus> {
var local1:Vector.<ValidationStatus> = new Vector.<ValidationStatus>();
local1.push(TOO_SHORT);
local1.push(TOO_LONG);
local1.push(NOT_UNIQUE);
local1.push(NOT_MATCH_PATTERN);
local1.push(FORBIDDEN);
local1.push(CORRECT);
return local1;
}
public function toString() : String {
return "ValidationStatus [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package projects.tanks.client.partners.impl.rambler {
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 RamblerLoginModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:RamblerLoginModelServer;
private var client:IRamblerLoginModelBase = IRamblerLoginModelBase(this);
private var modelId:Long = Long.getLong(644147707,1740542175);
public function RamblerLoginModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new RamblerLoginModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.osgi.service.clientlog {
public interface IClientLogChannelListener {
function onLogEntryAdded(param1:String, param2:String) : void;
}
}
|
package alternativa.tanks.gui {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.model.bonus.showing.detach.BonusDetach;
import alternativa.tanks.newbieservice.NewbieUserService;
import alternativa.tanks.ymservice.YandexMetricaService;
import alternativa.types.Long;
import controls.TankWindowInner;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.events.MouseEvent;
import flash.geom.Point;
import flash.text.TextFormatAlign;
import forms.TankWindowWithHeader;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
import utils.preview.IImageResource;
import utils.preview.ImageResourceLoadingWrapper;
public class CongratulationsWindowPresent extends DialogWindow implements IDestroyWindow, IImageResource {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var ymService:YandexMetricaService;
[Inject]
public static var newbieUserService:NewbieUserService;
private static const YM_CONGRATULATION_WINDOW_CLOSED:String = "CongratulationsWindow:closed";
private var _loadingImageResourceId:Long;
private var _isInit:Boolean;
private var window:TankWindowWithHeader;
private var inner:TankWindowInner;
private var messageTopLabel:LabelBase;
private var messageBottomLabel:LabelBase;
private var presentBitmap:Bitmap;
private var closeButton:DefaultButtonBase;
private var windowWidth:int = 450;
private const windowMargin:int = 12;
private const margin:int = 9;
private const buttonSize:Point = new Point(104,33);
private const space:int = 8;
private const minWidth:int = 300;
private var _gameObject:IGameObject;
private var _imageResource:ImageResource;
private var _messageTop:String;
private var _messageBottom:String;
public function CongratulationsWindowPresent(param1:BitmapData, param2:ImageResource, param3:String = "", param4:String = "", param5:IGameObject = null) {
super();
this._imageResource = param2;
this._messageTop = param3;
this._messageBottom = param4;
this._gameObject = param5;
if(param1 != null) {
this.init(param1);
} else if(param2.isLazy && !param2.isLoaded) {
this._loadingImageResourceId = param2.id;
param2.loadLazyResource(new ImageResourceLoadingWrapper(this));
} else {
this.init(param2.data);
}
}
private function init(param1:BitmapData) : void {
this._isInit = true;
this.presentBitmap = new Bitmap(param1);
this.windowWidth = Math.max(this.presentBitmap.width + this.windowMargin * 2 + this.margin * 2,this.minWidth);
this.window = TankWindowWithHeader.createWindow(TanksLocale.TEXT_HEADER_CONGRATULATION,this.windowWidth,this.presentBitmap.height);
addChild(this.window);
this.inner = new TankWindowInner(0,0,TankWindowInner.GREEN);
addChild(this.inner);
this.inner.x = this.windowMargin;
this.inner.y = this.windowMargin;
if(this._messageTop != null && this._messageTop != "") {
this.messageTopLabel = new LabelBase();
this.messageTopLabel.align = TextFormatAlign.CENTER;
this.messageTopLabel.wordWrap = true;
this.messageTopLabel.multiline = true;
this.messageTopLabel.size = 12;
this.messageTopLabel.htmlText = this._messageTop;
this.messageTopLabel.color = 5898034;
this.messageTopLabel.x = this.windowMargin * 2;
this.messageTopLabel.y = this.windowMargin * 2;
this.messageTopLabel.width = this.windowWidth - this.windowMargin * 4;
addChild(this.messageTopLabel);
if(this.messageTopLabel.numLines > 2) {
this.messageTopLabel.align = TextFormatAlign.LEFT;
this.messageTopLabel.htmlText = this._messageTop;
this.messageTopLabel.width = this.windowWidth - this.windowMargin * 4;
}
}
this.presentBitmap.x = this.windowWidth - this.presentBitmap.width >> 1;
this.presentBitmap.y = this.messageTopLabel != null ? this.messageTopLabel.y + this.messageTopLabel.height + this.margin : this.windowMargin * 2;
addChild(this.presentBitmap);
if(this._messageBottom != null && this._messageBottom != "") {
this.messageBottomLabel = new LabelBase();
this.messageBottomLabel.align = TextFormatAlign.CENTER;
this.messageBottomLabel.wordWrap = true;
this.messageBottomLabel.multiline = true;
this.messageBottomLabel.size = 12;
this.messageBottomLabel.color = 5898034;
this.messageBottomLabel.htmlText = this._messageBottom;
this.messageBottomLabel.x = this.windowMargin * 2;
this.messageBottomLabel.y = this.presentBitmap.y + this.presentBitmap.height + this.margin;
this.messageBottomLabel.width = this.windowWidth - this.windowMargin * 4;
addChild(this.messageBottomLabel);
if(this.messageBottomLabel.numLines > 2) {
this.messageTopLabel.align = TextFormatAlign.LEFT;
this.messageBottomLabel.htmlText = this._messageBottom;
this.messageBottomLabel.width = this.windowWidth - this.windowMargin * 4;
}
}
this.closeButton = new DefaultButtonBase();
addChild(this.closeButton);
this.closeButton.label = localeService.getText(TanksLocale.TEXT_FREE_BONUSES_WINDOW_BUTTON_CLOSE_TEXT);
var local2:int = this.presentBitmap.height + this.closeButton.height + this.margin * 2 + this.windowMargin * 3;
if(this.messageTopLabel != null) {
local2 += this.messageTopLabel.height + this.margin;
}
if(this.messageBottomLabel != null) {
local2 += this.messageBottomLabel.height + this.margin;
}
this.window.height = local2;
this.closeButton.y = this.window.height - this.margin - 35;
this.closeButton.x = this.window.width - this.closeButton.width >> 1;
this.inner.width = this.window.width - this.windowMargin * 2;
this.inner.height = this.window.height - this.windowMargin - this.margin * 2 - this.buttonSize.y + 2;
this.closeButton.addEventListener(MouseEvent.CLICK,this.closeBonusWindow);
dialogService.enqueueDialog(this);
}
public function setPreviewResource(param1:ImageResource) : void {
if(this._loadingImageResourceId == param1.id) {
this.init(param1.data);
}
}
private function closeBonusWindow(param1:MouseEvent = null) : void {
if(newbieUserService.isNewbieUser) {
newbieUserService.isNewbieUser = false;
ymService.reachGoalIfPlayerWasInTutorial(YM_CONGRATULATION_WINDOW_CLOSED);
}
this.destroy();
}
public function destroy() : void {
var local1:BonusDetach = null;
if(this._isInit) {
this._isInit = false;
this.closeButton.removeEventListener(MouseEvent.CLICK,this.closeBonusWindow);
dialogService.removeDialog(this);
if(this._gameObject != null) {
local1 = new BonusDetach(this._gameObject);
local1.detach();
this._gameObject = null;
}
this._loadingImageResourceId = null;
}
}
override protected function cancelKeyPressed() : void {
this.closeBonusWindow();
}
override protected function confirmationKeyPressed() : void {
this.closeBonusWindow();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.battlefield.billboard.billboardimage {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.battle.battlefield.billboard.billboardimage.BillboardImageCC;
public class CodecBillboardImageCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_image:ICodec;
public function CodecBillboardImageCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_image = param1.getCodec(new TypeCodecInfo(TextureResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BillboardImageCC = new BillboardImageCC();
local2.image = this.codec_image.decode(param1) as TextureResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BillboardImageCC = BillboardImageCC(param2);
this.codec_image.encode(param1,local3.image);
}
}
}
|
package forms.userlabel {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.userlabel.ChatUserLabel_eventGoldStatusIconClass.png")]
public class ChatUserLabel_eventGoldStatusIconClass extends BitmapAsset {
public function ChatUserLabel_eventGoldStatusIconClass() {
super();
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class NewReferalWindow_bitmapIconCode extends BitmapAsset
{
public function NewReferalWindow_bitmapIconCode()
{
super();
}
}
}
|
package alternativa.tanks.service.logging {
import alternativa.osgi.OSGi;
import alternativa.tanks.service.panel.IPanelView;
import alternativa.tanks.service.panel.PanelInitedEvent;
import flash.events.EventDispatcher;
import forms.events.MainButtonBarEvents;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.client.tanksservices.model.logging.gamescreen.GameScreen;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.gamescreen.*;
public class UserChangeGameScreenServiceImpl extends EventDispatcher implements UserChangeGameScreenService {
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
private var panelView:IPanelView;
public function UserChangeGameScreenServiceImpl() {
super();
this.panelView = IPanelView(OSGi.getInstance().getService(IPanelView));
this.panelView.addEventListener(PanelInitedEvent.TYPE,this.onPanelInited);
}
private function onPanelInited(param1:PanelInitedEvent) : void {
this.panelView.getPanel().buttonBar.addEventListener(MainButtonBarEvents.PANEL_BUTTON_PRESSED,this.onButtonBarButtonClick);
this.panelView.removeEventListener(PanelInitedEvent.TYPE,this.onPanelInited);
}
public function switchGarage() : void {
if(lobbyLayoutService.getCurrentState() == LayoutState.GARAGE) {
dispatchEvent(new UserChangedGameScreenEvent(GameScreen.GARAGE,GameScreen.BATTLE));
} else {
dispatchEvent(new UserChangedGameScreenEvent(this.getScreenByCurrentState(),GameScreen.GARAGE));
}
}
public function switchClan() : void {
if(lobbyLayoutService.getCurrentState() == LayoutState.CLAN) {
dispatchEvent(new UserChangedGameScreenEvent(GameScreen.CLAN,GameScreen.BATTLE));
} else {
dispatchEvent(new UserChangedGameScreenEvent(this.getScreenByCurrentState(),GameScreen.CLAN));
}
}
public function switchBattleSelect() : void {
if(lobbyLayoutService.getCurrentState() == LayoutState.BATTLE_SELECT) {
dispatchEvent(new UserChangedGameScreenEvent(GameScreen.BATTLE_SELECT,GameScreen.BATTLE));
} else {
dispatchEvent(new UserChangedGameScreenEvent(this.getScreenByCurrentState(),GameScreen.BATTLE_SELECT));
}
}
public function switchMatchmaking() : void {
}
public function returnToBattle() : void {
dispatchEvent(new UserChangedGameScreenEvent(this.getScreenByCurrentState(),GameScreen.BATTLE));
}
public function questWindowOpened() : void {
dispatchEvent(new UserChangedGameScreenEvent(this.getScreenByCurrentState(),GameScreen.QUESTS));
}
public function exitFromBattleToMatchmaking() : void {
dispatchEvent(new UserChangedGameScreenEvent(GameScreen.BATTLE,GameScreen.MATCHMAKING));
}
public function exitFromBattleToGarage() : void {
dispatchEvent(new UserChangedGameScreenEvent(GameScreen.BATTLE,GameScreen.GARAGE));
}
public function exitFromBattleToClan() : void {
dispatchEvent(new UserChangedGameScreenEvent(GameScreen.BATTLE,GameScreen.CLAN));
}
public function exitFromGame() : void {
dispatchEvent(new UserChangedGameScreenEvent(this.getScreenByCurrentState(),GameScreen.EXIT_GAME));
}
public function enterBattle() : void {
dispatchEvent(new UserChangedGameScreenEvent(this.getScreenByCurrentState(),GameScreen.BATTLE));
}
public function paymentWindowOpened() : void {
dispatchEvent(new UserChangedGameScreenEvent(this.getScreenByCurrentState(),GameScreen.PAYMENT));
}
public function paymentWindowClosed() : void {
dispatchEvent(new UserChangedGameScreenEvent(GameScreen.PAYMENT,this.getScreenByCurrentState()));
}
public function questWindowClosed() : void {
dispatchEvent(new UserChangedGameScreenEvent(GameScreen.QUESTS,this.getScreenByCurrentState()));
}
public function friendWindowClosed() : void {
dispatchEvent(new UserChangedGameScreenEvent(GameScreen.FRIENDS,this.getScreenByCurrentState()));
}
public function settingsWindowClosed() : void {
dispatchEvent(new UserChangedGameScreenEvent(GameScreen.SETTINGS,this.getScreenByCurrentState()));
}
public function showUserStatistics() : void {
dispatchEvent(new UserChangedGameScreenEvent(this.getScreenByCurrentState(),GameScreen.STATISTICS));
}
private function onButtonBarButtonClick(param1:MainButtonBarEvents) : void {
if([MainButtonBarEvents.BATTLE,MainButtonBarEvents.GARAGE,MainButtonBarEvents.CLOSE,MainButtonBarEvents.QUESTS].indexOf(param1.typeButton) >= 0) {
return;
}
if([MainButtonBarEvents.FRIENDS,MainButtonBarEvents.SETTINGS].indexOf(param1.typeButton) < 0) {
return;
}
var local2:GameScreen = this.getScreenByCurrentState();
var local3:GameScreen = this.getScreenByButtonType(param1.typeButton);
dispatchEvent(new UserChangedGameScreenEvent(local2,local3));
}
private function getScreenByCurrentState() : GameScreen {
switch(lobbyLayoutService.getCurrentState()) {
case LayoutState.BATTLE:
return GameScreen.BATTLE;
case LayoutState.BATTLE_SELECT:
return GameScreen.BATTLE_SELECT;
case LayoutState.MATCHMAKING:
return GameScreen.MATCHMAKING;
case LayoutState.GARAGE:
return GameScreen.GARAGE;
case LayoutState.CLAN:
return GameScreen.CLAN;
default:
return GameScreen.BATTLE_SELECT;
}
}
private function getScreenByButtonType(param1:String) : GameScreen {
switch(param1) {
case MainButtonBarEvents.FRIENDS:
return GameScreen.FRIENDS;
case MainButtonBarEvents.SETTINGS:
return GameScreen.SETTINGS;
case MainButtonBarEvents.CLAN:
return GameScreen.CLAN;
default:
return GameScreen.BATTLE_SELECT;
}
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_firstAidBgdClass.png")]
public class HudInventoryIcon_firstAidBgdClass extends BitmapAsset {
public function HudInventoryIcon_firstAidBgdClass() {
super();
}
}
}
|
package projects.tanks.client.users.model.friends {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class FriendsModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _acceptId:Long = Long.getLong(615300036,-941734513);
private var _accept_userIdCodec:ICodec;
private var _addId:Long = Long.getLong(1307353856,-1978331782);
private var _add_userIdCodec:ICodec;
private var _addByUidId:Long = Long.getLong(1402151501,-2115283743);
private var _addByUid_uidCodec:ICodec;
private var _breakItOffId:Long = Long.getLong(1152146944,316147596);
private var _breakItOff_userIdCodec:ICodec;
private var _rejectId:Long = Long.getLong(615300036,-452983770);
private var _reject_userIdCodec:ICodec;
private var _rejectAllId:Long = Long.getLong(517020203,52182117);
private var model:IModel;
public function FriendsModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._accept_userIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._add_userIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._addByUid_uidCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._breakItOff_userIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._reject_userIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function accept(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._accept_userIdCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._acceptId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function add(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._add_userIdCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._addId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function addByUid(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._addByUid_uidCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._addByUidId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function breakItOff(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._breakItOff_userIdCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._breakItOffId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function reject(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._reject_userIdCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._rejectId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function rejectAll() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._rejectAllId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package _codec.projects.tanks.client.battleservice.model.statistics.dm {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battleservice.model.statistics.UserInfo;
import projects.tanks.client.battleservice.model.statistics.dm.StatisticsDMCC;
public class CodecStatisticsDMCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_usersInfo:ICodec;
public function CodecStatisticsDMCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_usersInfo = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(UserInfo,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:StatisticsDMCC = new StatisticsDMCC();
local2.usersInfo = this.codec_usersInfo.decode(param1) as Vector.<UserInfo>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:StatisticsDMCC = StatisticsDMCC(param2);
this.codec_usersInfo.encode(param1,local3.usersInfo);
}
}
}
|
package projects.tanks.client.garage.models.item.modification {
public interface IModificationModelBase {
}
}
|
package alternativa.init {
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
public class CommonsActivator implements IBundleActivator {
public function CommonsActivator() {
super();
}
public function start(param1:OSGi) : void {
}
public function stop(param1:OSGi) : void {
}
}
}
|
package alternativa.tanks.gui.panel.buttons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.panel.buttons.MainPanelFullscreenButton_activateFullscreenClass.png")]
public class MainPanelFullscreenButton_activateFullscreenClass extends BitmapAsset {
public function MainPanelFullscreenButton_activateFullscreenClass() {
super();
}
}
}
|
package alternativa.tanks.gui.communication.button {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.communication.button.TabIcons_newsIconClass.png")]
public class TabIcons_newsIconClass extends BitmapAsset {
public function TabIcons_newsIconClass() {
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank11.png")]
public class PremiumRankBitmaps_bitmapBigRank11 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank11() {
super();
}
}
}
|
package alternativa.tanks.models.tank.hullcommon {
import flash.display.BitmapData;
import flash.media.Sound;
import platform.client.fp10.core.resource.types.TextureResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.armor.common.HullCommonCC;
import projects.tanks.client.battlefield.models.tankparts.armor.common.HullCommonModelBase;
import projects.tanks.client.battlefield.models.tankparts.armor.common.IHullCommonModelBase;
[ModelInfo]
public class HullCommonModel extends HullCommonModelBase implements IHullCommonModelBase, HullCommon {
public function HullCommonModel() {
super();
}
public function getDeadColoring() : TextureResource {
return getInitParam().deadColoring;
}
public function getCC() : HullCommonCC {
return getInitParam();
}
public function getMass() : Number {
return getInitParam().mass;
}
public function setTankObject(param1:IGameObject) : void {
putData(IGameObject,param1);
}
public function getTankObject() : IGameObject {
return IGameObject(getData(IGameObject));
}
public function getStunEffectTexture() : BitmapData {
return getInitParam().stunEffectTexture.data;
}
public function getStunSound() : Sound {
return getInitParam().stunSound.sound;
}
public function getUltimateIconIndex() : int {
return getInitParam().ultimateIconIndex;
}
}
}
|
package alternativa.tanks.models.battlefield
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ViewportBorder_bmpClassBorderTop extends BitmapAsset
{
public function ViewportBorder_bmpClassBorderTop()
{
super();
}
}
}
|
package projects.tanks.client.entrance.model.entrance.invite {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class InviteEntranceModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:InviteEntranceModelServer;
private var client:IInviteEntranceModelBase = IInviteEntranceModelBase(this);
private var modelId:Long = Long.getLong(2122883443,1406559758);
private var _inviteAlreadyActivatedId:Long = Long.getLong(726287787,1758911497);
private var _inviteAlreadyActivated_uidCodec:ICodec;
private var _inviteFreeId:Long = Long.getLong(1017441927,966581788);
private var _inviteNotFoundId:Long = Long.getLong(1810857751,-34129889);
public function InviteEntranceModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new InviteEntranceModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(InviteEntranceCC,false)));
this._inviteAlreadyActivated_uidCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
}
protected function getInitParam() : InviteEntranceCC {
return InviteEntranceCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._inviteAlreadyActivatedId:
this.client.inviteAlreadyActivated(String(this._inviteAlreadyActivated_uidCodec.decode(param2)));
break;
case this._inviteFreeId:
this.client.inviteFree();
break;
case this._inviteNotFoundId:
this.client.inviteNotFound();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package controls.cellrenderer {
import flash.display.BitmapData;
import flash.display.Graphics;
import flash.display.Shape;
import flash.display.Sprite;
public class ButtonState extends Sprite {
public const l:Shape = new Shape();
public const c:Shape = new Shape();
public const r:Shape = new Shape();
public var bmpLeft:BitmapData = new BitmapData(1,1);
public var bmpCenter:BitmapData = new BitmapData(1,1);
public var bmpRight:BitmapData = new BitmapData(1,1);
public var _width:int;
public function ButtonState() {
super();
addChild(this.l);
addChild(this.c);
addChild(this.r);
}
override public function set width(param1:Number) : void {
this._width = int(param1);
this.draw();
}
public function draw() : void {
var local1:Graphics = null;
local1 = this.l.graphics;
local1.clear();
local1.beginBitmapFill(this.bmpLeft);
local1.drawRect(0,0,7,30);
local1.endFill();
this.l.x = 0;
this.l.y = 0;
local1 = this.c.graphics;
local1.clear();
local1.beginBitmapFill(this.bmpCenter);
local1.drawRect(0,0,this._width - 14,30);
local1.endFill();
this.c.x = 7;
this.c.y = 0;
local1 = this.r.graphics;
local1.clear();
local1.beginBitmapFill(this.bmpRight);
local1.drawRect(0,0,7,30);
local1.endFill();
this.r.x = this._width - 7;
this.r.y = 0;
}
}
}
|
package alternativa.tanks.models.weapon.angles.verticals {
[ModelInterface]
public interface VerticalAngles {
function getAngleUp() : Number;
function getAngleDown() : Number;
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.ActionOutputLine_cpPointBlueNeutralIcon.png")]
public class ActionOutputLine_cpPointBlueNeutralIcon extends BitmapAsset {
public function ActionOutputLine_cpPointBlueNeutralIcon() {
super();
}
}
}
|
package alternativa.tanks.battle.objects.tank {
public interface ValueSmoother {
function reset(param1:Number) : void;
function update(param1:Number) : Number;
function setTargetValue(param1:Number) : void;
function getTargetValue() : Number;
}
}
|
package projects.tanks.client.panel.model.videoads.containers {
public interface IVideoAdsMobileLootBoxModelBase {
}
}
|
package projects.tanks.client.commons.models.moveusertoclient {
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 MoveUserToServerModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function MoveUserToServerModelServer(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.model.info {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ShowInfoAdapt implements ShowInfo {
private var object:IGameObject;
private var impl:ShowInfo;
public function ShowInfoAdapt(param1:IGameObject, param2:ShowInfo) {
super();
this.object = param1;
this.impl = param2;
}
public function showInfo() : void {
try {
Model.object = this.object;
this.impl.showInfo();
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.statistics {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.model.statistics.UserReward;
public class IStatisticRoundEvents implements IStatisticRound {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IStatisticRoundEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function roundStart() : void {
var i:int = 0;
var m:IStatisticRound = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IStatisticRound(this.impl[i]);
m.roundStart();
i++;
}
}
finally {
Model.popObject();
}
}
public function roundFinish(param1:Boolean, param2:Boolean, param3:int, param4:Vector.<UserReward>) : void {
var i:int = 0;
var m:IStatisticRound = null;
var matchBattle:Boolean = param1;
var needShowScore:Boolean = param2;
var timeToRestart:int = param3;
var reward:Vector.<UserReward> = param4;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IStatisticRound(this.impl[i]);
m.roundFinish(matchBattle,needShowScore,timeToRestart,reward);
i++;
}
}
finally {
Model.popObject();
}
}
public function roundStop() : void {
var i:int = 0;
var m:IStatisticRound = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IStatisticRound(this.impl[i]);
m.roundStop();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.battle.gui.indicators {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.indicators.TurnOverIndicator_turnOverIconClass.png")]
public class TurnOverIndicator_turnOverIconClass extends BitmapAsset {
public function TurnOverIndicator_turnOverIconClass() {
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank16.png")]
public class PremiumRankBitmaps_bitmapSmallRank16 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank16() {
super();
}
}
}
|
package alternativa.tanks.model.useremailandpassword {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IUserEmailAndPasswordEvents implements IUserEmailAndPassword {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IUserEmailAndPasswordEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function changeEmail(param1:String) : void {
var i:int = 0;
var m:IUserEmailAndPassword = null;
var email:String = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IUserEmailAndPassword(this.impl[i]);
m.changeEmail(email);
i++;
}
}
finally {
Model.popObject();
}
}
public function getEmail() : String {
var result:String = null;
var i:int = 0;
var m:IUserEmailAndPassword = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IUserEmailAndPassword(this.impl[i]);
result = m.getEmail();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function sendChangeInstruction() : void {
var i:int = 0;
var m:IUserEmailAndPassword = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IUserEmailAndPassword(this.impl[i]);
m.sendChangeInstruction();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.weapons.shell {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class TargetShellWeaponListenerAdapt implements TargetShellWeaponListener {
private var object:IGameObject;
private var impl:TargetShellWeaponListener;
public function TargetShellWeaponListenerAdapt(param1:IGameObject, param2:TargetShellWeaponListener) {
super();
this.object = param1;
this.impl = param2;
}
public function onShotWithTarget(param1:int, param2:int, param3:Vector3, param4:Tank, param5:Vector3) : void {
var barrelIndex:int = param1;
var shotId:int = param2;
var direction:Vector3 = param3;
var target:Tank = param4;
var localTargetPoint:Vector3 = param5;
try {
Model.object = this.object;
this.impl.onShotWithTarget(barrelIndex,shotId,direction,target,localTargetPoint);
}
finally {
Model.popObject();
}
}
}
}
|
package scpacker.test.usertitles
{
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.tanks.display.usertitle.UserTitle;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.tank.TankData;
import flash.events.KeyboardEvent;
import flash.utils.Timer;
public class SpectatorUserTitlesRender implements UserTitlesRender
{
public var show:Boolean = true;
public var hideHUD:Boolean = false;
private var hideHUDTimer:Timer;
public function SpectatorUserTitlesRender()
{
super();
(Main.osgi.getService(IBattleField) as BattlefieldModel).toDestroy.push(this);
Main.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
Main.stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
}
public function destroy(b:Boolean) : void
{
Main.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
Main.stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
}
private function onKeyDown(e:KeyboardEvent) : void
{
if(e.keyCode == 220)
{
this.show = !this.show;
}
}
private function HUD() : void
{
if(this.hideHUD)
{
Main.contentUILayer.visible = false;
}
else
{
Main.contentUILayer.visible = true;
}
}
private function onKeyUp(e:KeyboardEvent) : void
{
}
public function render() : void
{
}
public function setBattlefield(model:IBattleField) : void
{
}
public function setLocalData(model:TankData) : void
{
}
public function updateTitle(tankData:TankData, cameraPos:Vector3) : void
{
if(this.show)
{
tankData.tank.title.show();
}
else
{
tankData.tank.title.hide();
}
}
public function configurateTitle(tankData:TankData) : void
{
var configFlags:int = UserTitle.BIT_LABEL | UserTitle.BIT_EFFECTS;
configFlags |= UserTitle.BIT_HEALTH;
var title:UserTitle = tankData.tank.title;
title.setLabelText(tankData.userName);
title.setRank(tankData.userRank);
title.setTeamType(tankData.teamType);
title.setHealth(tankData.health);
title.setConfiguration(configFlags);
}
}
}
|
package alternativa.tanks.display.usertitle {
public class AngleBar extends ArtilleryBar {
public function AngleBar() {
super();
}
public function setAngle(param1:Number) : void {
radialBar.setValue(param1 / 90);
label.text = param1.toFixed() + "°";
this.resize();
}
override protected function resize() : void {
label.x = -(label.width >> 1) - X_OFFSET;
label.y = (label.height >> 1) - Y_OFFSET;
}
}
}
|
package alternativa.tanks.gui.payment.forms.paymentstatus {
import assets.icons.InputCheckIcon;
import base.DiscreteSprite;
import controls.labels.MouseDisabledLabel;
public class PaymentStatusLine extends DiscreteSprite {
private var label:MouseDisabledLabel = new MouseDisabledLabel();
private var wait:InputCheckIcon = new InputCheckIcon();
public function PaymentStatusLine(param1:String) {
super();
mouseChildren = false;
mouseEnabled = false;
this.label.text = param1;
this.wait.gotoAndStop(1);
this.wait.x = this.label.width + 13;
this.wait.y = this.label.height - this.wait.height >> 1;
addChild(this.label);
addChild(this.wait);
}
public function showProgressWorking() : void {
this.wait.gotoAndStop(1);
}
public function showProgressDone() : void {
this.wait.gotoAndStop(2);
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.logging.battlelist {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.EnumCodecInfo;
import projects.tanks.client.tanksservices.model.logging.battlelist.BattleSelectAction;
public class VectorCodecBattleSelectActionLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattleSelectActionLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(BattleSelectAction,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.<BattleSelectAction> = new Vector.<BattleSelectAction>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattleSelectAction(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattleSelectAction = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattleSelectAction> = Vector.<BattleSelectAction>(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.garage.present {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class PresentGivenEvents implements PresentGiven {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function PresentGivenEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function removePresent(param1:Long) : void {
var i:int = 0;
var m:PresentGiven = null;
var present:Long = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PresentGiven(this.impl[i]);
m.removePresent(present);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p28 extends BitmapAsset
{
public function RangsIcon_p28()
{
super();
}
}
}
|
package alternativa.tanks.camera.controllers.spectator {
public interface UserInput {
function getForwardDirection() : int;
function getSideDirection() : int;
function getVerticalDirection() : int;
function isAccelerated() : Boolean;
function getYawDirection() : int;
function getPitchDirection() : int;
function isRotating() : Boolean;
function reset() : void;
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIcon_p21 extends BitmapAsset
{
public function RangIcon_p21()
{
super();
}
}
}
|
package alternativa.tanks.model.shop
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.model.shop.bugreport.PaymentBugReportBlock;
import alternativa.tanks.model.shop.items.crystallitem.CrystalPackageItem;
import controls.TankWindow;
import controls.base.DefaultButtonBase;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
public class ShopWindow extends Sprite
{
public static var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
public static const WINDOW_PADDING:int = 11;
public static const SPACE_MODULE:int = 7;
public static var haveDoubleCrystalls:Boolean = false;
private var tankWindow:TankWindow;
private var categories:ShopCategorysView;
private var bugReportBlock:PaymentBugReportBlock;
public var header:ShowWindowHeader;
private var closeButton:DefaultButtonBase;
public function ShopWindow()
{
this.tankWindow = new TankWindow();
this.categories = new ShopCategorysView();
this.header = new ShowWindowHeader();
super();
addChild(this.tankWindow);
this.tankWindow.width = 915;
this.tankWindow.height = 691;
this.header.x = WINDOW_PADDING;
this.header.y = WINDOW_PADDING;
this.header.resize(915 - WINDOW_PADDING * 2);
this.closeButton = new DefaultButtonBase();
this.closeButton.tabEnabled = false;
this.closeButton.label = "Закрыть";
this.closeButton.x = this.tankWindow.width - this.closeButton.width - 2 * WINDOW_PADDING;
this.closeButton.y = this.tankWindow.height - this.closeButton.height - WINDOW_PADDING;
this.closeButton.addEventListener(MouseEvent.CLICK,this.onClickClose);
addChild(this.closeButton);
this.bugReportBlock = new PaymentBugReportBlock();
this.bugReportBlock.x = WINDOW_PADDING;
this.bugReportBlock.y = this.closeButton.y - WINDOW_PADDING - this.bugReportBlock.height;
this.bugReportBlock.width = this.tankWindow.width - WINDOW_PADDING - this.bugReportBlock.x;
addChild(this.bugReportBlock);
this.tankWindow.addChild(this.categories);
this.tankWindow.addChild(this.header);
this.categories.x = WINDOW_PADDING;
this.categories.y = this.header.y + this.header.height + SPACE_MODULE - 2;
}
private function onClickClose(e:MouseEvent) : void
{
dispatchEvent(new Event(Event.CLOSE));
}
public function addCategory(header:String, description:String, categoryId:String) : void
{
this.categories.addCategory(new ShopCategoryView(header,description,categoryId));
this.categories.render(this.tankWindow.width - WINDOW_PADDING * 2,this.bugReportBlock.y - this.categories.y - WINDOW_PADDING);
}
public function addItem(categoryId:String, itemId:String, additionalData:Object) : void
{
if(itemId.indexOf("crystal") >= 0)
{
this.categories.addItem(categoryId,new CrystalPackageItem(itemId,additionalData));
}
this.categories.render(this.tankWindow.width - WINDOW_PADDING * 2,this.bugReportBlock.y - this.categories.y - WINDOW_PADDING);
}
}
}
|
package projects.tanks.client.battlefield.models.battle.gui.group {
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 MatchmakingGroupInfoModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:MatchmakingGroupInfoModelServer;
private var client:IMatchmakingGroupInfoModelBase = IMatchmakingGroupInfoModelBase(this);
private var modelId:Long = Long.getLong(1776691703,-1828525018);
public function MatchmakingGroupInfoModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new MatchmakingGroupInfoModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(MatchmakingGroupInfoCC,false)));
}
protected function getInitParam() : MatchmakingGroupInfoCC {
return MatchmakingGroupInfoCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.service {
import alternativa.tanks.models.clan.IClanModel;
import alternativa.types.Long;
import flash.events.EventDispatcher;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanFunctionsService;
public class ClanFunctionsServiceImpl extends EventDispatcher implements ClanFunctionsService {
[Inject]
public static var clanService:ClanService;
public function ClanFunctionsServiceImpl() {
super();
}
public function invite(param1:Long) : void {
clanService.clanPanelModel.sendInviteToClan(param1);
}
public function leave() : void {
this.clanModel().leaveClan();
}
public function exclude(param1:Long) : void {
this.clanModel().excludeClanMember(param1);
}
public function revokeRequest(param1:Long) : void {
this.clanModel().revokeRequest(param1);
}
public function acceptRequest(param1:Long) : void {
this.clanModel().acceptRequest(param1);
}
public function rejectRequest(param1:Long) : void {
this.clanModel().rejectRequest(param1);
}
public function rejectAllRequests() : void {
this.clanModel().rejectAllRequests();
}
private function clanModel() : IClanModel {
return IClanModel(clanService.clanObject.adapt(IClanModel));
}
}
}
|
package alternativa.tanks.models.effects.common.bonuscommon
{
import alternativa.engine3d.objects.Mesh;
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.resource.StubBitmapData;
import alternativa.service.IResourceService;
import alternativa.tanks.bonuses.IBonus;
import alternativa.tanks.engine3d.MaterialType;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.effects.common.IBonusCommonModel;
import alternativa.tanks.services.materialregistry.IMaterialRegistry;
import com.alternativaplatform.projects.tanks.client.warfare.models.common.bonuscommon.BonusCommonModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.common.bonuscommon.IBonusCommonModelBase;
import flash.display.BitmapData;
import scpacker.resource.ResourceType;
import scpacker.resource.ResourceUtil;
import scpacker.resource.images.ImageResource;
public class BonusCommonModel extends BonusCommonModelBase implements IBonusCommonModelBase, IBonusCommonModel, IObjectLoadListener
{
private static const MIPMAP_RESOLUTION:Number = 4;
private static var materialRegistry:IMaterialRegistry;
public function BonusCommonModel()
{
super();
_interfaces.push(IModel,IBonusCommonModelBase,IBonusCommonModel,IObjectLoadListener);
materialRegistry = IMaterialRegistry(Main.osgi.getService(IMaterialRegistry));
}
public function initObject(clientObject:ClientObject, boxResourceId:String, cordResourceId:String, disappearingTime:int, parachuteInnerResourceId:String, parachuteResourceId:String) : void
{
if(clientObject.getParams(BonusCommonModel) != null)
{
return;
}
var resourceService:IResourceService = Main.osgi.getService(IResourceService) as IResourceService;
var bonusData:BonusCommonData = new BonusCommonData();
bonusData.boxMesh = this.getMeshFromResource(resourceService,boxResourceId);
bonusData.parachuteMesh = this.getMeshFromResource(resourceService,parachuteResourceId,true);
bonusData.parachuteInnerMesh = this.getMeshFromResource(resourceService,parachuteInnerResourceId);
bonusData.cordMaterial = materialRegistry.textureMaterialRegistry.getMaterial(MaterialType.EFFECT,ResourceUtil.getResource(ResourceType.IMAGE,cordResourceId).bitmapData as BitmapData,MIPMAP_RESOLUTION);
bonusData.duration = disappearingTime * 1000;
clientObject.putParams(BonusCommonModel,bonusData);
}
public function objectLoaded(object:ClientObject) : void
{
}
public function objectUnloaded(object:ClientObject) : void
{
var data:BonusCommonData = BonusCommonData(object.getParams(BonusCommonModel));
ParaBonus.deletePool(data);
}
public function getBonus(clientObject:ClientObject, bonusId:String, livingTime:int, isFalling:Boolean) : IBonus
{
var data:BonusCommonData = BonusCommonData(clientObject.getParams(BonusCommonModel));
var bonus:ParaBonus = ParaBonus.create(data);
bonus.init(bonusId,data.duration - livingTime,isFalling);
return bonus;
}
private function getMeshFromResource(resourceService:IResourceService, resourceId:String, blacklisted:Boolean = false) : Mesh
{
var material:* = undefined;
var bfModel:BattlefieldModel = null;
var refMesh:Mesh = ResourceUtil.getResource(ResourceType.MODEL,resourceId).mesh as Mesh;
if(ResourceUtil.getResource(ResourceType.IMAGE,resourceId) == null)
{
trace(resourceId);
return null;
}
var texture:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,resourceId).bitmapData as BitmapData;
if(texture == null)
{
texture = new StubBitmapData(65280);
}
var res:ImageResource = ResourceUtil.getResource(ResourceType.IMAGE,resourceId) as ImageResource;
if(res.multiframeData != null)
{
material = materialRegistry.textureMaterialRegistry.getAnimatedPaint(res,ResourceUtil.getResource(ResourceType.IMAGE,"bonus_box_lightmap").bitmapData,ResourceUtil.getResource(ResourceType.IMAGE,"bonus_box_details").bitmapData,"bonus_box_details");
}
else
{
material = materialRegistry.textureMaterialRegistry.getMaterial(MaterialType.EFFECT,texture,MIPMAP_RESOLUTION);
}
if(blacklisted)
{
bfModel = BattlefieldModel(Main.osgi.getService(IBattleField));
if(bfModel.blacklist.indexOf(material.getTextureResource()) == -1)
{
bfModel.blacklist.push(material.getTextureResource());
}
}
var mesh:Mesh = Mesh(refMesh.clone());
mesh.setMaterialToAllFaces(material);
return mesh;
}
}
}
|
package alternativa.tanks.gui.crystalbutton {
import alternativa.tanks.gui.icons.CrystalIcon;
import controls.Money;
import controls.labels.MouseDisabledLabel;
import flash.display.Bitmap;
import flash.display.Graphics;
import flash.display.Shape;
import flash.display.Sprite;
public class CrystalLabel extends Sprite {
private var crystalIcon:Bitmap;
private var label:MouseDisabledLabel;
private var color:uint = 16777215;
private var strikeColor:uint = 11645361;
private var line:Shape = new Shape();
private var isStrike:Boolean = false;
public function CrystalLabel(param1:int = 0) {
super();
mouseEnabled = false;
this.label = new MouseDisabledLabel();
this.crystalIcon = CrystalIcon.createSmallInstance();
addChild(this.label);
addChild(this.crystalIcon);
this.crystalIcon.y = 4;
this.setCost(param1);
}
public function setText(param1:String) : void {
this.label.text = param1;
this.crystalIcon.x = this.label.x + this.label.textWidth + 5;
}
public function setCost(param1:int) : void {
this.label.text = Money.numToString(param1,false);
this.crystalIcon.x = this.label.x + this.label.textWidth + 5;
this.setStrike(false);
}
public function setColor(param1:int) : void {
this.color = param1;
if(!this.isStrike) {
this.label.textColor = param1;
}
}
public function setSharpness(param1:int) : void {
this.label.sharpness = param1;
}
public function setThickness(param1:int) : void {
this.label.thickness = param1;
}
public function setStrikeColor(param1:int) : void {
this.strikeColor = param1;
}
public function setStrike(param1:Boolean) : void {
var local2:Graphics = null;
var local3:int = 0;
this.isStrike = param1;
if(param1) {
this.label.textColor = this.strikeColor;
local2 = this.line.graphics;
local2.clear();
local2.lineStyle(1,this.strikeColor);
local3 = int(this.label.y + this.label.height * 0.5) + 1;
local2.moveTo(0,local3);
local2.lineTo(0 + width + 2,local3);
if(!contains(this.line)) {
addChild(this.line);
}
} else {
this.label.textColor = this.color;
if(contains(this.line)) {
removeChild(this.line);
}
}
}
}
}
|
package alternativa.tanks.service.payment {
import flash.events.Event;
public class PaymentPackageEvent extends Event {
public static const PACKAGES_ADDED:String = "PaymentPackageEventPACKAGES_ADDED";
public function PaymentPackageEvent(param1:String) {
super(param1,true);
}
}
}
|
package alternativa.tanks.models.weapons.shell {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.weapons.shell.states.ShellStates;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ShellWeaponCommunicationEvents implements ShellWeaponCommunication {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ShellWeaponCommunicationEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function tryToShoot(param1:int, param2:int, param3:int, param4:Vector3) : void {
var i:int = 0;
var m:ShellWeaponCommunication = null;
var clientTime:int = param1;
var barrelIndex:int = param2;
var shotId:int = param3;
var direction:Vector3 = param4;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShellWeaponCommunication(this.impl[i]);
m.tryToShoot(clientTime,barrelIndex,shotId,direction);
i++;
}
}
finally {
Model.popObject();
}
}
public function tryToShootWithTarget(param1:int, param2:int, param3:int, param4:Vector3, param5:Tank, param6:Vector3) : void {
var i:int = 0;
var m:ShellWeaponCommunication = null;
var clientTime:int = param1;
var barrelIndex:int = param2;
var shotId:int = param3;
var direction:Vector3 = param4;
var target:Tank = param5;
var localTargetPoint:Vector3 = param6;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShellWeaponCommunication(this.impl[i]);
m.tryToShootWithTarget(clientTime,barrelIndex,shotId,direction,target,localTargetPoint);
i++;
}
}
finally {
Model.popObject();
}
}
public function tryToDummyShoot(param1:int, param2:int) : void {
var i:int = 0;
var m:ShellWeaponCommunication = null;
var clientTime:int = param1;
var barrelIndex:int = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShellWeaponCommunication(this.impl[i]);
m.tryToDummyShoot(clientTime,barrelIndex);
i++;
}
}
finally {
Model.popObject();
}
}
public function tryToHit(param1:int, param2:ShellStates, param3:Tank = null) : void {
var i:int = 0;
var m:ShellWeaponCommunication = null;
var shotId:int = param1;
var states:ShellStates = param2;
var target:Tank = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShellWeaponCommunication(this.impl[i]);
m.tryToHit(shotId,states,target);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.clans.clan.acceptednotificator {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.client.clans.container.ContainerCC;
public class ClanAcceptedNotificatorModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ClanAcceptedNotificatorModelServer;
private var client:IClanAcceptedNotificatorModelBase = IClanAcceptedNotificatorModelBase(this);
private var modelId:Long = Long.getLong(1575927935,-367368112);
private var _onAddingId:Long = Long.getLong(946943636,-1512579195);
private var _onAdding_userIdCodec:ICodec;
private var _onRemovedId:Long = Long.getLong(709518332,1700494084);
private var _onRemoved_userIdCodec:ICodec;
public function ClanAcceptedNotificatorModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ClanAcceptedNotificatorModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ContainerCC,false)));
this._onAdding_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._onRemoved_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
}
protected function getInitParam() : ContainerCC {
return ContainerCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._onAddingId:
this.client.onAdding(Long(this._onAdding_userIdCodec.decode(param2)));
break;
case this._onRemovedId:
this.client.onRemoved(Long(this._onRemoved_userIdCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.view.battlelist.battleitem {
import flash.display.Bitmap;
import flash.display.BitmapData;
import projects.tanks.client.battleservice.BattleMode;
public class BattleItemIcon {
private static const dmNormalClass:Class = BattleItemIcon_dmNormalClass;
private static const dmNormalData:BitmapData = Bitmap(new dmNormalClass()).bitmapData;
private static const tdmNormalClass:Class = BattleItemIcon_tdmNormalClass;
private static const tdmNormalData:BitmapData = Bitmap(new tdmNormalClass()).bitmapData;
private static const ctfNormalClass:Class = BattleItemIcon_ctfNormalClass;
private static const ctfNormalData:BitmapData = Bitmap(new ctfNormalClass()).bitmapData;
private static const cpNormalClass:Class = BattleItemIcon_cpNormalClass;
private static const cpNormalData:BitmapData = Bitmap(new cpNormalClass()).bitmapData;
private static const dmGreyClass:Class = BattleItemIcon_dmGreyClass;
private static const dmGreyData:BitmapData = Bitmap(new dmGreyClass()).bitmapData;
private static const tdmGreyClass:Class = BattleItemIcon_tdmGreyClass;
private static const tdmGreyData:BitmapData = Bitmap(new tdmGreyClass()).bitmapData;
private static const ctfGreyClass:Class = BattleItemIcon_ctfGreyClass;
private static const ctfGreyData:BitmapData = Bitmap(new ctfGreyClass()).bitmapData;
private static const cpGreyClass:Class = BattleItemIcon_cpGreyClass;
private static const cpGreyData:BitmapData = Bitmap(new cpGreyClass()).bitmapData;
public function BattleItemIcon() {
super();
}
private static function getBattleModeIcon(param1:BattleMode) : Bitmap {
switch(param1) {
case BattleMode.DM:
return new Bitmap(dmNormalData);
case BattleMode.TDM:
return new Bitmap(tdmNormalData);
case BattleMode.CTF:
return new Bitmap(ctfNormalData);
case BattleMode.CP:
case BattleMode.AS:
return new Bitmap(cpNormalData);
default:
return new Bitmap(dmNormalData);
}
}
private static function getBattleModeGrayIcon(param1:BattleMode) : Bitmap {
switch(param1) {
case BattleMode.DM:
return new Bitmap(dmGreyData);
case BattleMode.TDM:
return new Bitmap(tdmGreyData);
case BattleMode.CTF:
return new Bitmap(ctfGreyData);
case BattleMode.CP:
case BattleMode.AS:
return new Bitmap(cpGreyData);
default:
return new Bitmap(dmGreyData);
}
}
public static function getBattleLimitIcon(param1:BattleMode) : Bitmap {
if(param1 == BattleMode.TDM) {
return new Bitmap(dmNormalData);
}
return getBattleModeIcon(param1);
}
public static function getBattleLimitGrayIcon(param1:BattleMode) : Bitmap {
if(param1 == BattleMode.TDM) {
return new Bitmap(dmGreyData);
}
return getBattleModeGrayIcon(param1);
}
}
}
|
package projects.tanks.client.clans.panel.clanpanel {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class ClanPanelModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _sendInviteToClanId:Long = Long.getLong(140074797,-2125952903);
private var _sendInviteToClan_userIdCodec:ICodec;
private var model:IModel;
public function ClanPanelModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._sendInviteToClan_userIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function sendInviteToClan(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._sendInviteToClan_userIdCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._sendInviteToClanId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package forms.ranks {
import flash.display.Bitmap;
import flash.display.BitmapData;
public class SmallRankIcon extends RankIcon {
private static const nullRankIcon:Bitmap = new Bitmap(new BitmapData(1,1));
public function SmallRankIcon(param1:int = 1) {
super();
setDefaultAccount(param1);
}
override protected function createDefaultRankBitmap(param1:int) : Bitmap {
if(param1 <= 0 || param1 > DefaultRanksBitmaps.smallRanks.length) {
return nullRankIcon;
}
return new Bitmap(DefaultRanksBitmaps.smallRanks[param1 - 1]);
}
override protected function createPremiumRankBitmap(param1:int) : Bitmap {
if(param1 <= 0 || param1 > PremiumRankBitmaps.smallRanks.length) {
return nullRankIcon;
}
return new Bitmap(PremiumRankBitmaps.smallRanks[param1 - 1]);
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.pointbased.rugby.explosion {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import platform.client.fp10.core.resource.types.SoundResource;
import projects.tanks.client.battlefield.models.battle.pointbased.rugby.explosion.BallExplosionCC;
import projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity.LightingSFXEntity;
public class CodecBallExplosionCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_explosionSound:ICodec;
private var codec_explosionTexture:ICodec;
private var codec_lightingSFXEntity:ICodec;
private var codec_smokeTextureId:ICodec;
public function CodecBallExplosionCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_explosionSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_explosionTexture = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
this.codec_lightingSFXEntity = param1.getCodec(new TypeCodecInfo(LightingSFXEntity,false));
this.codec_smokeTextureId = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BallExplosionCC = new BallExplosionCC();
local2.explosionSound = this.codec_explosionSound.decode(param1) as SoundResource;
local2.explosionTexture = this.codec_explosionTexture.decode(param1) as MultiframeTextureResource;
local2.lightingSFXEntity = this.codec_lightingSFXEntity.decode(param1) as LightingSFXEntity;
local2.smokeTextureId = this.codec_smokeTextureId.decode(param1) as MultiframeTextureResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BallExplosionCC = BallExplosionCC(param2);
this.codec_explosionSound.encode(param1,local3.explosionSound);
this.codec_explosionTexture.encode(param1,local3.explosionTexture);
this.codec_lightingSFXEntity.encode(param1,local3.lightingSFXEntity);
this.codec_smokeTextureId.encode(param1,local3.smokeTextureId);
}
}
}
|
package alternativa.tanks.models.tank.device {
import alternativa.types.Long;
import projects.tanks.client.battlefield.models.user.device.ITankDeviceModelBase;
import projects.tanks.client.battlefield.models.user.device.TankDeviceModelBase;
[ModelInfo]
public class TankDeviceModel extends TankDeviceModelBase implements ITankDeviceModelBase, TankDevice {
public function TankDeviceModel() {
super();
}
public function getDevice() : Long {
return getInitParam().deviceId;
}
}
}
|
package alternativa.tanks.view.battlelist.battleitem.renderer.normal {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battlelist.battleitem.renderer.normal.CellNormalSelected_normalCenter.png")]
public class CellNormalSelected_normalCenter extends BitmapAsset {
public function CellNormalSelected_normalCenter() {
super();
}
}
}
|
package projects.tanks.client.panel.model.profile.useremailpassword {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class UserEmailAndPasswordModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:UserEmailAndPasswordModelServer;
private var client:IUserEmailAndPasswordModelBase = IUserEmailAndPasswordModelBase(this);
private var modelId:Long = Long.getLong(740369199,944909632);
private var _activateMessageId:Long = Long.getLong(742786754,-588207711);
private var _activateMessage_messageCodec:ICodec;
private var _emailAlreadyUsedId:Long = Long.getLong(134865479,1344292238);
private var _emailConfirmedId:Long = Long.getLong(607961308,438757112);
private var _emailConfirmed_emailCodec:ICodec;
private var _incorrectEmailId:Long = Long.getLong(2070151898,-799055156);
private var _notifyCorrectPasswordId:Long = Long.getLong(639769619,1507772121);
private var _notifyIncorrectPasswordId:Long = Long.getLong(41003958,-1035229982);
private var _notifyPasswordIsNotSetId:Long = Long.getLong(21656026,-1373860270);
private var _notifyPasswordIsSetId:Long = Long.getLong(702539491,144211585);
private var _passwordChangedId:Long = Long.getLong(1455847234,-1429972580);
private var _updatePasswordErrorId:Long = Long.getLong(1807808543,-1997999313);
public function UserEmailAndPasswordModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new UserEmailAndPasswordModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(UserEmailCC,false)));
this._activateMessage_messageCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._emailConfirmed_emailCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
}
protected function getInitParam() : UserEmailCC {
return UserEmailCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._activateMessageId:
this.client.activateMessage(String(this._activateMessage_messageCodec.decode(param2)));
break;
case this._emailAlreadyUsedId:
this.client.emailAlreadyUsed();
break;
case this._emailConfirmedId:
this.client.emailConfirmed(String(this._emailConfirmed_emailCodec.decode(param2)));
break;
case this._incorrectEmailId:
this.client.incorrectEmail();
break;
case this._notifyCorrectPasswordId:
this.client.notifyCorrectPassword();
break;
case this._notifyIncorrectPasswordId:
this.client.notifyIncorrectPassword();
break;
case this._notifyPasswordIsNotSetId:
this.client.notifyPasswordIsNotSet();
break;
case this._notifyPasswordIsSetId:
this.client.notifyPasswordIsSet();
break;
case this._passwordChangedId:
this.client.passwordChanged();
break;
case this._updatePasswordErrorId:
this.client.updatePasswordError();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.partners.impl.idnet {
public interface IIdNetLoginModelBase {
}
}
|
package alternativa.tanks.model.payment.shop.featuring {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ShopItemFeaturingEvents implements ShopItemFeaturing {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ShopItemFeaturingEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function isLocatedInFeaturingCategory() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:ShopItemFeaturing = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShopItemFeaturing(this.impl[i]);
result = Boolean(m.isLocatedInFeaturingCategory());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function isHiddenInOriginalCategory() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:ShopItemFeaturing = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShopItemFeaturing(this.impl[i]);
result = Boolean(m.isHiddenInOriginalCategory());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getPosition() : int {
var result:int = 0;
var i:int = 0;
var m:ShopItemFeaturing = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShopItemFeaturing(this.impl[i]);
result = int(m.getPosition());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package com.hurlant.crypto.tls {
import alternativa.osgi.service.clientlog.IClientLog;
import com.hurlant.crypto.cert.X509Certificate;
import com.hurlant.crypto.cert.X509CertificateCollection;
import com.hurlant.crypto.prng.Random;
import com.hurlant.util.ArrayUtil;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.ProgressEvent;
import flash.utils.ByteArray;
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
[Event(name="data",type="com.hurlant.crypto.tls.TLSEvent")]
[Event(name="ready",type="com.hurlant.crypto.tls.TLSEvent")]
[Event(name="socketData",type="flash.events.ProgressEvent")]
[Event(name="close",type="flash.events.Event")]
public class TLSEngine extends EventDispatcher {
[Inject]
public static var clientLog:IClientLog;
public static const LOG_CHANNEL:String = "tlsengine";
public static const SERVER:uint = 0;
public static const CLIENT:uint = 1;
private static const PROTOCOL_HANDSHAKE:uint = 22;
private static const PROTOCOL_ALERT:uint = 21;
private static const PROTOCOL_CHANGE_CIPHER_SPEC:uint = 20;
private static const PROTOCOL_APPLICATION_DATA:uint = 23;
private static const STATE_NEW:uint = 0;
private static const STATE_NEGOTIATING:uint = 1;
private static const STATE_READY:uint = 2;
private static const STATE_CLOSED:uint = 3;
private static const HANDSHAKE_HELLO_REQUEST:uint = 0;
private static const HANDSHAKE_CLIENT_HELLO:uint = 1;
private static const HANDSHAKE_SERVER_HELLO:uint = 2;
private static const HANDSHAKE_CERTIFICATE:uint = 11;
private static const HANDSHAKE_SERVER_KEY_EXCHANGE:uint = 12;
private static const HANDSHAKE_CERTIFICATE_REQUEST:uint = 13;
private static const HANDSHAKE_HELLO_DONE:uint = 14;
private static const HANDSHAKE_CERTIFICATE_VERIFY:uint = 15;
private static const HANDSHAKE_CLIENT_KEY_EXCHANGE:uint = 16;
private static const HANDSHAKE_FINISHED:uint = 20;
public var protocol_version:uint;
private var _entity:uint;
private var _config:TLSConfig;
private var _state:uint;
private var _securityParameters:ISecurityParameters;
private var _currentReadState:IConnectionState;
private var _currentWriteState:IConnectionState;
private var _pendingReadState:IConnectionState;
private var _pendingWriteState:IConnectionState;
private var _handshakePayloads:ByteArray;
private var _handshakeRecords:ByteArray;
private var _iStream:IDataInput;
private var _oStream:IDataOutput;
private var _store:X509CertificateCollection;
private var _otherCertificate:X509Certificate;
private var _otherIdentity:String;
private var _myCertficate:X509Certificate;
private var _myIdentity:String;
private var _packetQueue:Array = [];
private var protocolHandlers:Object;
private var handshakeHandlersServer:Object;
private var handshakeHandlersClient:Object;
private var _entityHandshakeHandlers:Object;
private var _handshakeCanContinue:Boolean = true;
private var _handshakeQueue:Array = [];
private var sendClientCert:Boolean = false;
private var _writeScheduler:uint;
public function TLSEngine(param1:TLSConfig, param2:IDataInput, param3:IDataOutput, param4:String = null) {
this.protocolHandlers = {
23:this.parseApplicationData,
22:this.parseHandshake,
21:this.parseAlert,
20:this.parseChangeCipherSpec
};
this.handshakeHandlersServer = {
0:this.notifyStateError,
1:this.parseHandshakeClientHello,
2:this.notifyStateError,
11:this.loadCertificates,
12:this.notifyStateError,
13:this.notifyStateError,
14:this.notifyStateError,
15:this.notifyStateError,
16:this.parseHandshakeClientKeyExchange,
20:this.verifyHandshake
};
this.handshakeHandlersClient = {
0:this.parseHandshakeHello,
1:this.notifyStateError,
2:this.parseHandshakeServerHello,
11:this.loadCertificates,
12:this.parseServerKeyExchange,
13:this.setStateRespondWithCertificate,
14:this.sendClientAck,
15:this.notifyStateError,
16:this.notifyStateError,
20:this.verifyHandshake
};
super();
this._entity = param1.entity;
this._config = param1;
this._iStream = param2;
this._oStream = param3;
this._otherIdentity = param4;
this._state = STATE_NEW;
this._entityHandshakeHandlers = this._entity == CLIENT ? this.handshakeHandlersClient : this.handshakeHandlersServer;
if(this._config.version == SSLSecurityParameters.PROTOCOL_VERSION) {
this._securityParameters = new SSLSecurityParameters(this._entity);
} else {
this._securityParameters = new TLSSecurityParameters(this._entity,this._config.certificate,this._config.privateKey);
}
this.protocol_version = this._config.version;
var local5:Object = this._securityParameters.getConnectionStates();
this._currentReadState = local5.read;
this._currentWriteState = local5.write;
this._handshakePayloads = new ByteArray();
this._store = new X509CertificateCollection();
}
public function get peerCertificate() : X509Certificate {
return this._otherCertificate;
}
public function start() : void {
if(this._entity == CLIENT) {
try {
this.startHandshake();
}
catch(e:TLSError) {
handleTLSError(e);
}
}
}
public function dataAvailable(param1:* = null) : void {
var e:* = param1;
if(this._state == STATE_CLOSED) {
return;
}
try {
this.parseRecord(this._iStream);
}
catch(e:TLSError) {
handleTLSError(e);
}
}
public function close(param1:TLSError = null) : void {
if(this._state == STATE_CLOSED) {
return;
}
var local2:ByteArray = new ByteArray();
if(param1 == null && this._state != STATE_READY) {
local2[0] = 1;
local2[1] = TLSError.user_canceled;
this.sendRecord(PROTOCOL_ALERT,local2);
}
local2[0] = 2;
if(param1 == null) {
local2[1] = TLSError.close_notify;
} else {
local2[1] = param1.errorID;
}
this.sendRecord(PROTOCOL_ALERT,local2);
this._state = STATE_CLOSED;
dispatchEvent(new Event(Event.CLOSE));
}
private function parseRecord(param1:IDataInput) : void {
var local2:ByteArray = null;
var local3:uint = 0;
var local4:uint = 0;
var local5:uint = 0;
var local6:uint = 0;
var local7:Object = null;
while(this._state != STATE_CLOSED && param1.bytesAvailable > 4) {
if(this._packetQueue.length > 0) {
local7 = this._packetQueue.shift();
local2 = local7.data;
if(param1.bytesAvailable + local2.length >= local7.length) {
param1.readBytes(local2,local2.length,local7.length - local2.length);
this.parseOneRecord(local7.type,local7.length,local2);
} else {
param1.readBytes(local2,local2.length,param1.bytesAvailable);
this._packetQueue.push(local7);
}
} else {
local3 = uint(param1.readByte());
local4 = uint(param1.readShort());
local5 = uint(param1.readShort());
if(local5 > 16384 + 2048) {
throw new TLSError("Excessive TLS Record length: " + local5,TLSError.record_overflow);
}
if(local4 != this._securityParameters.version) {
throw new TLSError("Unsupported TLS version: " + local4.toString(16),TLSError.protocol_version);
}
local2 = new ByteArray();
local6 = Math.min(param1.bytesAvailable,local5);
param1.readBytes(local2,0,local6);
if(local6 == local5) {
this.parseOneRecord(local3,local5,local2);
} else {
this._packetQueue.push({
"type":local3,
"length":local5,
"data":local2
});
}
}
}
}
private function parseOneRecord(param1:uint, param2:uint, param3:ByteArray) : void {
param3 = this._currentReadState.decrypt(param1,param2,param3);
if(param3.length > 16384) {
throw new TLSError("Excessive Decrypted TLS Record length: " + param3.length,TLSError.record_overflow);
}
if(this.protocolHandlers.hasOwnProperty(param1)) {
while(param3 != null) {
param3 = this.protocolHandlers[param1](param3);
}
return;
}
throw new TLSError("Unsupported TLS Record Content Type: " + param1.toString(16),TLSError.unexpected_message);
}
private function startHandshake() : void {
this._state = STATE_NEGOTIATING;
this.sendClientHello();
}
private function parseHandshake(param1:ByteArray) : ByteArray {
var local6:ByteArray = null;
if(param1.length < 4) {
return null;
}
param1.position = 0;
var local2:ByteArray = param1;
var local3:uint = local2.readUnsignedByte();
var local4:uint = local2.readUnsignedByte();
var local5:uint = uint(local4 << 16 | local2.readUnsignedShort());
if(local5 + 4 > param1.length) {
return null;
}
if(local3 != HANDSHAKE_FINISHED) {
this._handshakePayloads.writeBytes(param1,0,local5 + 4);
}
if(this._entityHandshakeHandlers.hasOwnProperty(local3)) {
if(this._entityHandshakeHandlers[local3] is Function) {
this._entityHandshakeHandlers[local3](local2);
}
if(local5 + 4 < param1.length) {
local6 = new ByteArray();
local6.writeBytes(param1,local5 + 4,param1.length - (local5 + 4));
return local6;
}
return null;
}
throw new TLSError("Unimplemented or unknown handshake type!",TLSError.internal_error);
}
private function notifyStateError(param1:ByteArray) : void {
throw new TLSError("Invalid handshake state for a TLS Entity type of " + this._entity,TLSError.internal_error);
}
private function parseClientKeyExchange(param1:ByteArray) : void {
throw new TLSError("ClientKeyExchange is currently unimplemented!",TLSError.internal_error);
}
private function parseServerKeyExchange(param1:ByteArray) : void {
throw new TLSError("ServerKeyExchange is currently unimplemented!",TLSError.internal_error);
}
private function verifyHandshake(param1:ByteArray) : void {
var local2:ByteArray = new ByteArray();
if(this._securityParameters.version == SSLSecurityParameters.PROTOCOL_VERSION) {
param1.readBytes(local2,0,36);
} else {
param1.readBytes(local2,0,12);
}
var local3:ByteArray = this._securityParameters.computeVerifyData(1 - this._entity,this._handshakePayloads);
if(ArrayUtil.equals(local2,local3)) {
this._state = STATE_READY;
dispatchEvent(new TLSEvent(TLSEvent.READY));
return;
}
throw new TLSError("Invalid Finished mac.",TLSError.bad_record_mac);
}
private function parseHandshakeHello(param1:ByteArray) : void {
if(this._state != STATE_READY) {
return;
}
this._handshakePayloads = new ByteArray();
this.startHandshake();
}
private function parseHandshakeClientKeyExchange(param1:ByteArray) : void {
var local2:uint = 0;
var local3:ByteArray = null;
var local4:ByteArray = null;
var local5:Object = null;
if(this._securityParameters.useRSA) {
local2 = uint(param1.readShort());
local3 = new ByteArray();
param1.readBytes(local3,0,local2);
local4 = new ByteArray();
this._config.privateKey.decrypt(local3,local4,local2);
this._securityParameters.setPreMasterSecret(local4);
local5 = this._securityParameters.getConnectionStates();
this._pendingReadState = local5.read;
this._pendingWriteState = local5.write;
return;
}
throw new TLSError("parseHandshakeClientKeyExchange not implemented for DH modes.",TLSError.internal_error);
}
private function parseHandshakeServerHello(param1:IDataInput) : void {
var local2:uint = uint(param1.readShort());
if(local2 != this._securityParameters.version) {
throw new TLSError("Unsupported TLS version: " + local2.toString(16),TLSError.protocol_version);
}
var local3:ByteArray = new ByteArray();
param1.readBytes(local3,0,32);
var local4:uint = uint(param1.readByte());
var local5:ByteArray = new ByteArray();
if(local4 > 0) {
param1.readBytes(local5,0,local4);
}
this._securityParameters.setCipher(param1.readShort());
this._securityParameters.setCompression(param1.readByte());
this._securityParameters.setServerRandom(local3);
}
private function parseHandshakeClientHello(param1:IDataInput) : void {
var local2:Object = null;
var local14:uint = 0;
var local15:uint = 0;
var local16:uint = 0;
var local17:ByteArray = null;
var local3:uint = uint(param1.readShort());
if(local3 != this._securityParameters.version) {
throw new TLSError("Unsupported TLS version: " + local3.toString(16),TLSError.protocol_version);
}
var local4:ByteArray = new ByteArray();
param1.readBytes(local4,0,32);
var local5:uint = uint(param1.readByte());
var local6:ByteArray = new ByteArray();
if(local5 > 0) {
param1.readBytes(local6,0,local5);
}
var local7:Array = [];
var local8:uint = uint(param1.readShort());
var local9:uint = 0;
while(local9 < local8 / 2) {
local7.push(param1.readShort());
local9++;
}
var local10:Array = [];
var local11:uint = uint(param1.readByte());
local9 = 0;
while(local9 < local11) {
local10.push(param1.readByte());
local9++;
}
local2 = {
"random":local4,
"session":local6,
"suites":local7,
"compressions":local10
};
var local12:uint = uint(2 + 32 + 1 + local5 + 2 + local8 + 1 + local11);
var local13:Array = [];
if(local12 < length) {
local14 = uint(param1.readShort());
while(local14 > 0) {
local15 = uint(param1.readShort());
local16 = uint(param1.readShort());
local17 = new ByteArray();
param1.readBytes(local17,0,local16);
local14 -= 4 + local16;
local13.push({
"type":local15,
"length":local16,
"data":local17
});
}
}
local2.ext = local13;
this.sendServerHello(local2);
this.sendCertificate();
this.sendServerHelloDone();
}
private function sendClientHello() : void {
var local1:ByteArray = new ByteArray();
local1.writeShort(this._securityParameters.version);
var local2:Random = new Random();
var local3:ByteArray = new ByteArray();
local2.nextBytes(local3,32);
this._securityParameters.setClientRandom(local3);
local1.writeBytes(local3,0,32);
local1.writeByte(32);
local2.nextBytes(local1,32);
var local4:Array = this._config.cipherSuites;
local1.writeShort(2 * local4.length);
var local5:int = 0;
while(local5 < local4.length) {
local1.writeShort(local4[local5]);
local5++;
}
local4 = this._config.compressions;
local1.writeByte(local4.length);
local5 = 0;
while(local5 < local4.length) {
local1.writeByte(local4[local5]);
local5++;
}
local1.position = 0;
this.sendHandshake(HANDSHAKE_CLIENT_HELLO,local1.length,local1);
}
private function findMatch(param1:Array, param2:Array) : int {
var local4:uint = 0;
var local3:int = 0;
while(local3 < param1.length) {
local4 = uint(param1[local3]);
if(param2.indexOf(local4) > -1) {
return local4;
}
local3++;
}
return -1;
}
private function sendServerHello(param1:Object) : void {
var local2:int = this.findMatch(this._config.cipherSuites,param1.suites);
if(local2 == -1) {
throw new TLSError("No compatible cipher found.",TLSError.handshake_failure);
}
this._securityParameters.setCipher(local2);
var local3:int = this.findMatch(this._config.compressions,param1.compressions);
if(local3 == 1) {
throw new TLSError("No compatible compression method found.",TLSError.handshake_failure);
}
this._securityParameters.setCompression(local3);
this._securityParameters.setClientRandom(param1.random);
var local4:ByteArray = new ByteArray();
local4.writeShort(this._securityParameters.version);
var local5:Random = new Random();
var local6:ByteArray = new ByteArray();
local5.nextBytes(local6,32);
this._securityParameters.setServerRandom(local6);
local4.writeBytes(local6,0,32);
local4.writeByte(32);
local5.nextBytes(local4,32);
local4.writeShort(param1.suites[0]);
local4.writeByte(param1.compressions[0]);
local4.position = 0;
this.sendHandshake(HANDSHAKE_SERVER_HELLO,local4.length,local4);
}
private function setStateRespondWithCertificate(param1:ByteArray = null) : void {
this.sendClientCert = true;
}
private function sendCertificate(param1:ByteArray = null) : void {
var local3:uint = 0;
var local4:uint = 0;
var local2:ByteArray = this._config.certificate;
var local5:ByteArray = new ByteArray();
if(local2 != null) {
local3 = local2.length;
local4 = uint(local2.length + 3);
local5.writeByte(local4 >> 16);
local5.writeShort(local4 & 0xFFFF);
local5.writeByte(local3 >> 16);
local5.writeShort(local3 & 0xFFFF);
local5.writeBytes(local2);
} else {
local5.writeShort(0);
local5.writeByte(0);
}
local5.position = 0;
this.sendHandshake(HANDSHAKE_CERTIFICATE,local5.length,local5);
}
private function sendCertificateVerify() : void {
var local1:ByteArray = new ByteArray();
var local2:ByteArray = this._securityParameters.computeCertificateVerify(this._entity,this._handshakePayloads);
local2.position = 0;
this.sendHandshake(HANDSHAKE_CERTIFICATE_VERIFY,local2.length,local2);
}
private function sendServerHelloDone() : void {
var local1:ByteArray = new ByteArray();
this.sendHandshake(HANDSHAKE_HELLO_DONE,local1.length,local1);
}
private function sendClientKeyExchange() : void {
var local1:ByteArray = null;
var local2:Random = null;
var local3:ByteArray = null;
var local4:ByteArray = null;
var local5:ByteArray = null;
var local6:Object = null;
if(this._securityParameters.useRSA) {
local1 = new ByteArray();
local1.writeShort(this._securityParameters.version);
local2 = new Random();
local2.nextBytes(local1,46);
local1.position = 0;
local3 = new ByteArray();
local3.writeBytes(local1,0,local1.length);
local3.position = 0;
this._securityParameters.setPreMasterSecret(local3);
local4 = new ByteArray();
this._otherCertificate.getPublicKey().encrypt(local3,local4,local3.length);
local4.position = 0;
local5 = new ByteArray();
if(this._securityParameters.version > 768) {
local5.writeShort(local4.length);
}
local5.writeBytes(local4,0,local4.length);
local5.position = 0;
this.sendHandshake(HANDSHAKE_CLIENT_KEY_EXCHANGE,local5.length,local5);
local6 = this._securityParameters.getConnectionStates();
this._pendingReadState = local6.read;
this._pendingWriteState = local6.write;
return;
}
throw new TLSError("Non-RSA Client Key Exchange not implemented.",TLSError.internal_error);
}
private function sendFinished() : void {
var local1:ByteArray = this._securityParameters.computeVerifyData(this._entity,this._handshakePayloads);
local1.position = 0;
this.sendHandshake(HANDSHAKE_FINISHED,local1.length,local1);
}
private function sendHandshake(param1:uint, param2:uint, param3:IDataInput) : void {
var local4:ByteArray = new ByteArray();
local4.writeByte(param1);
local4.writeByte(0);
local4.writeShort(param2);
param3.readBytes(local4,local4.position,param2);
this._handshakePayloads.writeBytes(local4,0,local4.length);
this.sendRecord(PROTOCOL_HANDSHAKE,local4);
}
private function sendChangeCipherSpec() : void {
var local1:ByteArray = new ByteArray();
local1[0] = 1;
this.sendRecord(PROTOCOL_CHANGE_CIPHER_SPEC,local1);
this._currentWriteState = this._pendingWriteState;
this._pendingWriteState = null;
}
public function sendApplicationData(param1:ByteArray, param2:uint = 0, param3:uint = 0) : void {
var local4:ByteArray = new ByteArray();
var local5:uint = param3;
if(local5 == 0) {
local5 = param1.length;
}
while(local5 > 16384) {
local4.position = 0;
local4.writeBytes(param1,param2,16384);
local4.position = 0;
this.sendRecord(PROTOCOL_APPLICATION_DATA,local4);
param2 += 16384;
local5 -= 16384;
}
local4.position = 0;
local4.writeBytes(param1,param2,local5);
local4.position = 0;
this.sendRecord(PROTOCOL_APPLICATION_DATA,local4);
}
private function sendRecord(param1:uint, param2:ByteArray) : void {
param2 = this._currentWriteState.encrypt(param1,param2);
this._oStream.writeByte(param1);
this._oStream.writeShort(this._securityParameters.version);
this._oStream.writeShort(param2.length);
this._oStream.writeBytes(param2,0,param2.length);
this.scheduleWrite();
}
private function scheduleWrite() : void {
if(this._writeScheduler != 0) {
return;
}
this._writeScheduler = setTimeout(this.commitWrite,0);
}
private function commitWrite() : void {
clearTimeout(this._writeScheduler);
this._writeScheduler = 0;
if(this._state != STATE_CLOSED) {
dispatchEvent(new ProgressEvent(ProgressEvent.SOCKET_DATA));
}
}
private function sendClientAck(param1:ByteArray) : void {
if(this._handshakeCanContinue) {
if(this.sendClientCert) {
this.sendCertificate();
}
this.sendClientKeyExchange();
if(this._config.certificate != null) {
this.sendCertificateVerify();
}
this.sendChangeCipherSpec();
this.sendFinished();
}
}
private function loadCertificates(param1:ByteArray) : void {
var local7:Boolean = false;
var local8:uint = 0;
var local9:ByteArray = null;
var local10:X509Certificate = null;
var local11:String = null;
var local12:RegExp = null;
var local2:uint = uint(param1.readByte());
var local3:uint = uint(local2 << 16 | param1.readShort());
var local4:Array = [];
while(local3 > 0) {
local2 = uint(param1.readByte());
local8 = uint(local2 << 16 | param1.readShort());
local9 = new ByteArray();
param1.readBytes(local9,0,local8);
local4.push(local9);
local3 -= 3 + local8;
}
var local5:X509Certificate = null;
var local6:int = 0;
while(local6 < local4.length) {
local10 = new X509Certificate(local4[local6]);
this._store.addCertificate(local10);
if(local5 == null) {
local5 = local10;
}
local6++;
}
if(this._config.trustAllCertificates) {
local7 = true;
} else if(this._config.trustSelfSignedCertificates) {
local7 = local5.isSelfSigned(new Date());
} else {
local7 = local5.isSigned(this._store,this._config.CAStore);
}
if(local7) {
if(this._otherIdentity == null || this._config.ignoreCommonNameMismatch) {
this._otherCertificate = local5;
} else {
local11 = local5.getCommonName();
local12 = new RegExp(local11.replace(/[\^\\\-$.[\]|()?+{}]/g,"\\$&").replace(/\*/g,"[^.]+"),"gi");
if(local12.exec(this._otherIdentity)) {
this._otherCertificate = local5;
} else {
if(!this._config.promptUserForAcceptCert) {
throw new TLSError("Invalid common name: " + local5.getCommonName() + ", expected " + this._otherIdentity,TLSError.bad_certificate);
}
this._handshakeCanContinue = false;
dispatchEvent(new TLSEvent(TLSEvent.PROMPT_ACCEPT_CERT));
}
}
} else {
if(!this._config.promptUserForAcceptCert) {
throw new TLSError("Cannot verify certificate",TLSError.bad_certificate);
}
this._handshakeCanContinue = false;
dispatchEvent(new TLSEvent(TLSEvent.PROMPT_ACCEPT_CERT));
}
}
public function acceptPeerCertificate() : void {
this._handshakeCanContinue = true;
this.sendClientAck(null);
}
public function rejectPeerCertificate() : void {
throw new TLSError("Peer certificate not accepted!",TLSError.bad_certificate);
}
private function parseAlert(param1:ByteArray) : void {
this.close();
}
private function parseChangeCipherSpec(param1:ByteArray) : void {
param1.readUnsignedByte();
if(this._pendingReadState == null) {
throw new TLSError("Not ready to Change Cipher Spec, damnit.",TLSError.unexpected_message);
}
this._currentReadState = this._pendingReadState;
this._pendingReadState = null;
}
private function parseApplicationData(param1:ByteArray) : void {
if(this._state != STATE_READY) {
throw new TLSError("Too soon for data!",TLSError.unexpected_message);
}
dispatchEvent(new TLSEvent(TLSEvent.DATA,param1));
}
private function handleTLSError(param1:TLSError) : void {
this.close(param1);
}
}
}
|
package alternativa.tanks.gui.clanmanagement.clanmemberlist {
public interface IClanActionListener {
function updateActions() : void;
}
}
|
package _codec.projects.tanks.client.garage.models.item.discount {
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.discount.DiscountCC;
public class VectorCodecDiscountCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecDiscountCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(DiscountCC,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.<DiscountCC> = new Vector.<DiscountCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = DiscountCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:DiscountCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<DiscountCC> = Vector.<DiscountCC>(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.garage.models.item.container {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.garage.models.item.container.ContainerGivenItem;
import projects.tanks.client.garage.models.item.container.ContainerItemCategory;
public class CodecContainerGivenItem implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_category:ICodec;
private var codec_count:ICodec;
private var codec_image:ICodec;
private var codec_name:ICodec;
public function CodecContainerGivenItem() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_category = param1.getCodec(new EnumCodecInfo(ContainerItemCategory,false));
this.codec_count = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_image = param1.getCodec(new TypeCodecInfo(ImageResource,false));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ContainerGivenItem = new ContainerGivenItem();
local2.category = this.codec_category.decode(param1) as ContainerItemCategory;
local2.count = this.codec_count.decode(param1) as int;
local2.image = this.codec_image.decode(param1) as ImageResource;
local2.name = this.codec_name.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ContainerGivenItem = ContainerGivenItem(param2);
this.codec_category.encode(param1,local3.category);
this.codec_count.encode(param1,local3.count);
this.codec_image.encode(param1,local3.image);
this.codec_name.encode(param1,local3.name);
}
}
}
|
package mx.core
{
use namespace mx_internal;
public class MovieClipAsset extends FlexMovieClip implements IFlexAsset, IFlexDisplayObject, IBorder
{
mx_internal static const VERSION:String = "4.6.0.23201";
private var _measuredHeight:Number;
private var _measuredWidth:Number;
public function MovieClipAsset()
{
super();
this._measuredWidth = width;
this._measuredHeight = height;
}
public function get measuredHeight() : Number
{
return this._measuredHeight;
}
public function get measuredWidth() : Number
{
return this._measuredWidth;
}
public function get borderMetrics() : EdgeMetrics
{
if(scale9Grid == null)
{
return EdgeMetrics.EMPTY;
}
return new EdgeMetrics(scale9Grid.left,scale9Grid.top,Math.ceil(this.measuredWidth - scale9Grid.right),Math.ceil(this.measuredHeight - scale9Grid.bottom));
}
public function move(x:Number, y:Number) : void
{
this.x = x;
this.y = y;
}
public function setActualSize(newWidth:Number, newHeight:Number) : void
{
width = newWidth;
height = newHeight;
}
}
}
|
package scpacker.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksI_coldload2 extends BitmapAsset
{
public function GTanksI_coldload2()
{
super();
}
}
}
|
package controls.buttons {
import base.DiscreteSprite;
import flash.display.Bitmap;
public class FixedHeightRectangle extends DiscreteSprite {
private var left:Bitmap;
private var middle:Bitmap;
private var right:Bitmap;
public function FixedHeightRectangle(param1:FixedHeightRectangleSkin) {
super();
this.left = new Bitmap(param1.left);
this.middle = new Bitmap(param1.middle);
this.right = new Bitmap(param1.right);
this.setSkin(param1);
addChild(this.left);
addChild(this.right);
addChild(this.middle);
mouseEnabled = false;
}
public function setSkin(param1:FixedHeightRectangleSkin) : void {
this.left.bitmapData = param1.left;
this.middle.bitmapData = param1.middle;
this.right.bitmapData = param1.right;
this.align(width);
}
override public function set width(param1:Number) : void {
param1 = int(param1);
this.align(param1);
super.width = param1;
}
private function align(param1:int) : void {
this.middle.x = this.left.width;
this.right.x = param1 - this.right.width;
this.middle.width = param1 - this.left.width - this.right.width;
}
}
}
|
package alternativa.engine3d.loaders {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.animation.AnimationClip;
import alternativa.engine3d.animation.keys.Track;
import alternativa.engine3d.containers.LODContainer;
import alternativa.engine3d.core.Light3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Object3DContainer;
import alternativa.engine3d.loaders.collada.DaeDocument;
import alternativa.engine3d.loaders.collada.DaeMaterial;
import alternativa.engine3d.loaders.collada.DaeNode;
import alternativa.engine3d.loaders.collada.DaeObject;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.materials.TextureMaterial;
import flash.utils.Dictionary;
use namespace alternativa3d;
public class ParserCollada {
public static const STATIC_OBJECT:uint = 0;
public static const STATIC_GEOMETRY:uint = 1;
public static const SPLITTER:uint = 2;
public var objects:Vector.<Object3D>;
public var parents:Vector.<Object3D>;
public var hierarchy:Vector.<Object3D>;
public var lights:Vector.<Light3D>;
public var materials:Vector.<Material>;
public var textureMaterials:Vector.<TextureMaterial>;
public var animations:Vector.<AnimationClip>;
private var layers:Dictionary;
private var bspContainerChildrenTypes:Dictionary;
public function ParserCollada() {
super();
}
public static function parseAnimation(param1:XML) : AnimationClip {
var local2:DaeDocument = new DaeDocument(param1);
var local3:AnimationClip = new AnimationClip();
collectAnimation(local3,local2.scene.nodes);
return local3.numTracks > 0 ? local3 : null;
}
private static function collectAnimation(param1:AnimationClip, param2:Vector.<DaeNode>) : void {
var local5:DaeNode = null;
var local6:AnimationClip = null;
var local7:int = 0;
var local8:int = 0;
var local9:Track = null;
var local3:int = 0;
var local4:int = int(param2.length);
while(local3 < local4) {
local5 = param2[local3];
local6 = local5.parseAnimation();
if(local6 != null) {
local7 = 0;
local8 = local6.numTracks;
while(local7 < local8) {
local9 = local6.getTrackAt(local7);
param1.addTrack(local9);
local7++;
}
} else {
param1.addTrack(local5.createStaticTransformTrack());
}
collectAnimation(param1,local5.nodes);
local3++;
}
}
public function clean() : void {
this.objects = null;
this.parents = null;
this.hierarchy = null;
this.lights = null;
this.animations = null;
this.materials = null;
this.textureMaterials = null;
this.layers = null;
this.bspContainerChildrenTypes = null;
}
public function getObjectLayer(param1:Object3D) : String {
return this.layers[param1];
}
public function getBspContainerChildType(param1:Object3D) : uint {
return this.bspContainerChildrenTypes[param1];
}
private function init(param1:XML) : DaeDocument {
this.clean();
this.objects = new Vector.<Object3D>();
this.parents = new Vector.<Object3D>();
this.hierarchy = new Vector.<Object3D>();
this.lights = new Vector.<Light3D>();
this.animations = new Vector.<AnimationClip>();
this.materials = new Vector.<Material>();
this.textureMaterials = new Vector.<TextureMaterial>();
this.layers = new Dictionary();
this.bspContainerChildrenTypes = new Dictionary();
return new DaeDocument(param1);
}
public function parse(param1:XML, param2:String = null, param3:Boolean = false) : void {
var local4:DaeDocument = this.init(param1);
if(local4.scene != null) {
this.parseNodes(local4.scene.nodes,null,false);
this.parseMaterials(local4.materials,param2,param3);
}
}
private function hasSignifiantChildren(param1:DaeNode, param2:Boolean) : Boolean {
var local6:DaeNode = null;
var local3:Vector.<DaeNode> = param1.nodes;
var local4:int = 0;
var local5:int = int(local3.length);
while(local4 < local5) {
local6 = local3[local4];
local6.parse();
if(local6.skins != null) {
return true;
}
if(local6.skinOrTopmostJoint == false) {
if(param2 == false) {
return true;
}
}
if(this.hasSignifiantChildren(local6,true)) {
return true;
}
local4++;
}
return false;
}
private function addObject(param1:DaeObject, param2:Object3D, param3:String) : Object3D {
var local6:LODContainer = null;
var local7:Number = NaN;
var local4:Object3D = param1.object as Object3D;
this.objects.push(local4);
this.parents.push(param2);
if(param2 == null) {
this.hierarchy.push(local4);
}
var local5:Object3DContainer = param2 as Object3DContainer;
if(local5 != null) {
local5.addChild(local4);
local6 = local5 as LODContainer;
if(local6 != null) {
local7 = param1.lodDistance;
if(local7 != 0) {
local6.setChildDistance(local4,local7);
}
}
}
if(local4 is Light3D) {
this.lights.push(Light3D(local4));
}
if(param1.animation != null) {
this.animations.push(param1.animation);
}
if(Boolean(param3)) {
this.layers[local4] = param3;
}
if(param1.isStaticGeometry) {
this.bspContainerChildrenTypes[local4] = STATIC_GEOMETRY;
} else if(param1.isSplitter) {
this.bspContainerChildrenTypes[local4] = SPLITTER;
}
return local4;
}
private function addObjects(param1:Vector.<DaeObject>, param2:Object3D, param3:String) : Object3D {
var local4:Object3D = this.addObject(param1[0],param2,param3);
var local5:int = 1;
var local6:int = int(param1.length);
while(local5 < local6) {
this.addObject(param1[local5],param2,param3);
local5++;
}
return local4;
}
private function parseNodes(param1:Vector.<DaeNode>, param2:Object3DContainer, param3:Boolean = false) : void {
var local6:DaeNode = null;
var local7:Object3DContainer = null;
var local8:Boolean = false;
var local9:Object3D = null;
var local4:int = 0;
var local5:int = int(param1.length);
while(local4 < local5) {
local6 = param1[local4];
local6.parse();
local7 = null;
local8 = false;
if(local6.skins != null) {
this.addObjects(local6.skins,param2,local6.layer);
} else if(param3 == false && local6.skinOrTopmostJoint == false) {
if(local6.objects != null) {
local7 = this.addObjects(local6.objects,param2,local6.layer) as Object3DContainer;
} else {
local8 = true;
}
}
if(local7 == null) {
if(this.hasSignifiantChildren(local6,param3 || local6.skinOrTopmostJoint)) {
local7 = new Object3DContainer();
local7.name = local6.name;
this.addObject(local6.applyAnimation(local6.applyTransformations(local7)),param2,local6.layer);
this.parseNodes(local6.nodes,local7,param3 || local6.skinOrTopmostJoint);
local7.calculateBounds();
} else if(local8) {
local9 = new Object3D();
local9.name = local6.name;
this.addObject(local6.applyAnimation(local6.applyTransformations(local9)),param2,local6.layer);
}
} else {
this.parseNodes(local6.nodes,local7,param3 || local6.skinOrTopmostJoint);
local7.calculateBounds();
}
local4++;
}
}
private function trimPath(param1:String) : String {
var local2:int = int(param1.lastIndexOf("/"));
return local2 < 0 ? param1 : param1.substr(local2 + 1);
}
private function parseMaterials(param1:Object, param2:String, param3:Boolean) : void {
var local4:TextureMaterial = null;
var local5:DaeMaterial = null;
var local6:String = null;
var local7:int = 0;
for each(local5 in param1) {
if(local5.used) {
local5.parse();
this.materials.push(local5.material);
local4 = local5.material as TextureMaterial;
if(local4 != null) {
this.textureMaterials.push(local4);
}
}
}
if(param3) {
for each(local4 in this.textureMaterials) {
if(local4.diffuseMapURL != null) {
local4.diffuseMapURL = this.trimPath(this.fixURL(local4.diffuseMapURL));
}
if(local4.opacityMapURL != null) {
local4.opacityMapURL = this.trimPath(this.fixURL(local4.opacityMapURL));
}
}
} else {
for each(local4 in this.textureMaterials) {
if(local4.diffuseMapURL != null) {
local4.diffuseMapURL = this.fixURL(local4.diffuseMapURL);
}
if(local4.opacityMapURL != null) {
local4.opacityMapURL = this.fixURL(local4.opacityMapURL);
}
}
}
if(param2 != null) {
param2 = this.fixURL(param2);
local7 = int(param2.lastIndexOf("/"));
local6 = local7 < 0 ? "" : param2.substr(0,local7);
for each(local4 in this.textureMaterials) {
if(local4.diffuseMapURL != null) {
local4.diffuseMapURL = this.resolveURL(local4.diffuseMapURL,local6);
}
if(local4.opacityMapURL != null) {
local4.opacityMapURL = this.resolveURL(local4.opacityMapURL,local6);
}
}
}
}
private function fixURL(param1:String) : String {
var local2:int = int(param1.indexOf("://"));
local2 = local2 < 0 ? 0 : local2 + 3;
var local3:int = int(param1.indexOf("?",local2));
local3 = local3 < 0 ? int(param1.indexOf("#",local2)) : local3;
var local4:String = param1.substring(local2,local3 < 0 ? 2147483647 : local3);
local4 = local4.replace(/\\/g,"/");
var local5:int = int(param1.indexOf("file://"));
if(local5 >= 0) {
if(param1.charAt(local2) == "/") {
return "file://" + local4 + (local3 >= 0 ? param1.substring(local3) : "");
}
return "file:///" + local4 + (local3 >= 0 ? param1.substring(local3) : "");
}
return param1.substring(0,local2) + local4 + (local3 >= 0 ? param1.substring(local3) : "");
}
private function mergePath(param1:String, param2:String, param3:Boolean = false) : String {
var local8:String = null;
var local9:String = null;
var local4:Array = param2.split("/");
var local5:Array = param1.split("/");
var local6:int = 0;
var local7:int = int(local5.length);
while(local6 < local7) {
local8 = local5[local6];
if(local8 == "..") {
local9 = local4.pop();
while(local9 == "." || local9 == "" && local9 != null) {
local9 = local4.pop();
}
if(param3) {
if(local9 == "..") {
local4.push("..","..");
} else if(local9 == null) {
local4.push("..");
}
}
} else {
local4.push(local8);
}
local6++;
}
return local4.join("/");
}
private function resolveURL(param1:String, param2:String) : String {
var local5:int = 0;
var local6:String = null;
var local7:String = null;
var local8:String = null;
var local9:int = 0;
var local10:int = 0;
var local11:int = 0;
var local12:String = null;
var local13:String = null;
if(param2 == "") {
return param1;
}
if(param1.charAt(0) == "." && param1.charAt(1) == "/") {
return param2 + param1.substr(1);
}
if(param1.charAt(0) == "/") {
return param1;
}
if(param1.charAt(0) == "." && param1.charAt(1) == ".") {
local5 = int(param1.indexOf("?"));
local5 = local5 < 0 ? int(param1.indexOf("#")) : local5;
if(local5 < 0) {
local7 = "";
local6 = param1;
} else {
local7 = param1.substring(local5);
local6 = param1.substring(0,local5);
}
local9 = int(param2.indexOf("/"));
local10 = int(param2.indexOf(":"));
local11 = int(param2.indexOf("//"));
if(local11 < 0 || local11 > local9) {
if(local10 >= 0 && local10 < local9) {
local12 = param2.substring(0,local10 + 1);
local8 = param2.substring(local10 + 1);
if(local8.charAt(0) == "/") {
return local12 + "/" + this.mergePath(local6,local8.substring(1),false) + local7;
}
return local12 + this.mergePath(local6,local8,false) + local7;
}
if(param2.charAt(0) == "/") {
return "/" + this.mergePath(local6,param2.substring(1),false) + local7;
}
return this.mergePath(local6,param2,true) + local7;
}
local9 = int(param2.indexOf("/",local11 + 2));
if(local9 >= 0) {
local13 = param2.substring(0,local9 + 1);
local8 = param2.substring(local9 + 1);
return local13 + this.mergePath(local6,local8,false) + local7;
}
local13 = param2;
return local13 + "/" + this.mergePath(local6,"",false);
}
var local3:int = int(param1.indexOf(":"));
var local4:int = int(param1.indexOf("/"));
if(local3 >= 0 && (local3 < local4 || local4 < 0)) {
return param1;
}
return param2 + "/" + param1;
}
public function getObjectByName(param1:String) : Object3D {
var local2:Object3D = null;
for each(local2 in this.objects) {
if(local2.name == param1) {
return local2;
}
}
return null;
}
public function getAnimationByObject(param1:Object) : AnimationClip {
var local2:AnimationClip = null;
var local3:Array = null;
for each(local2 in this.animations) {
local3 = local2.alternativa3d::_objects;
if(local3.indexOf(param1) >= 0) {
return local2;
}
}
return null;
}
}
}
|
package alternativa.physics.collision {
import alternativa.physics.collision.types.AABB;
public class CollisionKdNode {
public var indices:Vector.<int>;
public var splitIndices:Vector.<int>;
public var boundBox:AABB;
public var parent:CollisionKdNode;
public var splitTree:CollisionKdTree2D;
public var axis:int = -1;
public var coord:Number;
public var positiveNode:CollisionKdNode;
public var negativeNode:CollisionKdNode;
public function CollisionKdNode() {
super();
}
public function destroy() : void {
if(Boolean(this.positiveNode)) {
this.positiveNode.destroy();
this.positiveNode = null;
}
if(Boolean(this.negativeNode)) {
this.negativeNode.destroy();
this.negativeNode = null;
}
if(Boolean(this.splitTree)) {
this.splitTree.destroyTree();
this.splitTree = null;
}
this.parent = null;
this.boundBox = null;
this.indices = null;
this.splitIndices = null;
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.