code stringlengths 57 237k |
|---|
package alternativa.tanks.battle.events {
import alternativa.tanks.battle.objects.tank.Tank;
public class TankLoadedEvent {
public var tank:Tank;
public var isLocal:Boolean;
public function TankLoadedEvent(param1:Tank, param2:Boolean) {
super();
this.tank = param1;
this.isLocal = param2;
}
}
}
|
package projects.tanks.client.tanksservices.model.logging.garage {
public class GarageAction {
public static const SELECT_ITEM:GarageAction = new GarageAction(0,"SELECT_ITEM");
public static const EQUIP_ITEM:GarageAction = new GarageAction(1,"EQUIP_ITEM");
public static const UNMOUNT_ITEM:GarageAction = new GarageAction(2,"UNMOUNT_ITEM");
public static const BUY_ITEM:GarageAction = new GarageAction(3,"BUY_ITEM");
public static const BUY_MODIFICATION:GarageAction = new GarageAction(4,"BUY_MODIFICATION");
public static const UPGRADE_ITEM:GarageAction = new GarageAction(5,"UPGRADE_ITEM");
public static const CHOOSE_COUNT:GarageAction = new GarageAction(6,"CHOOSE_COUNT");
public static const SHOW_BUY_CRYSTALS_WINDOW:GarageAction = new GarageAction(7,"SHOW_BUY_CRYSTALS_WINDOW");
public static const PURCHASE_ACCEPTED:GarageAction = new GarageAction(8,"PURCHASE_ACCEPTED");
public static const PURCHASE_DECLINED:GarageAction = new GarageAction(9,"PURCHASE_DECLINED");
private var _value:int;
private var _name:String;
public function GarageAction(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<GarageAction> {
var local1:Vector.<GarageAction> = new Vector.<GarageAction>();
local1.push(SELECT_ITEM);
local1.push(EQUIP_ITEM);
local1.push(UNMOUNT_ITEM);
local1.push(BUY_ITEM);
local1.push(BUY_MODIFICATION);
local1.push(UPGRADE_ITEM);
local1.push(CHOOSE_COUNT);
local1.push(SHOW_BUY_CRYSTALS_WINDOW);
local1.push(PURCHASE_ACCEPTED);
local1.push(PURCHASE_DECLINED);
return local1;
}
public function toString() : String {
return "GarageAction [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.models.weapon.railgun {
import alternativa.engine3d.materials.Material;
import alternativa.math.Vector3;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class ShotSmokeEffect extends PooledObject implements GraphicEffect {
private var container:Scene3DContainer;
private var smoke:ShotSmoke;
private var startPoint:Vector3 = new Vector3();
private var direction:Vector3 = new Vector3();
private var beginScale:Number;
private var endScale:Number;
private var moveDistance:Number;
private var lifeTime:int;
private var time:int;
public function ShotSmokeEffect(param1:Pool) {
super(param1);
this.smoke = new ShotSmoke();
}
public function init(param1:Vector3, param2:Vector3, param3:Material, param4:Number, param5:Number, param6:Number, param7:Number, param8:int) : void {
this.startPoint.copy(param1);
this.direction.diff(param2,param1);
var local9:Number = this.direction.length();
this.direction.scale(1 / local9);
this.beginScale = param5;
this.endScale = param6;
this.moveDistance = param7;
this.lifeTime = param8;
this.smoke.init(param4,local9,param3,param7);
this.time = 0;
}
public function play(param1:int, param2:GameCamera) : Boolean {
var local4:Number = NaN;
if(this.time > this.lifeTime) {
return false;
}
SFXUtils.alignObjectPlaneToView(this.smoke,this.startPoint,this.direction,param2.position);
var local3:Number = this.time / this.lifeTime;
local4 = Math.sqrt(local3);
this.smoke.scaleX = this.beginScale + (this.endScale - this.beginScale) * local4;
this.smoke.alpha = 1 - local3;
this.smoke.update(local4);
this.time += param1;
return true;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.smoke);
}
public function destroy() : void {
this.smoke.clear();
this.container.removeChild(this.smoke);
this.container = null;
recycle();
}
public function kill() : void {
this.time = this.lifeTime + 1;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_modulatorsofplasmaIconClass.png")]
public class DeviceIcons_modulatorsofplasmaIconClass extends BitmapAsset {
public function DeviceIcons_modulatorsofplasmaIconClass() {
super();
}
}
}
|
package alternativa.tanks.battle {
import flash.utils.getTimer;
public class PerformanceMonitor {
private var framesToAverage:int;
private var minFrameTimeInMs:int;
private var maxFrameTimeInMs:int;
private var averageFrameTimeInMs:Number = 0;
private var frameStartTime:int;
private var frameCounter:int;
private var cumulativeTimeInMs:int;
public function PerformanceMonitor(param1:int) {
super();
this.framesToAverage = param1;
this.reset();
}
public function beginFrame() : void {
this.frameStartTime = getTimer();
}
public function endFrame() : void {
var local1:int = getTimer() - this.frameStartTime;
this.cumulativeTimeInMs += local1;
this.updateMinMaxTime(local1);
if(++this.frameCounter >= this.framesToAverage) {
this.averageFrameTimeInMs = this.cumulativeTimeInMs / this.frameCounter;
this.cumulativeTimeInMs = 0;
this.frameCounter = 0;
}
}
public function getAverageFrameTimeInMs() : Number {
return this.averageFrameTimeInMs;
}
public function getAverageFps() : Number {
return 1000 / this.averageFrameTimeInMs;
}
private function updateMinMaxTime(param1:int) : void {
if(param1 > this.maxFrameTimeInMs) {
this.maxFrameTimeInMs = param1;
} else if(param1 < this.minFrameTimeInMs) {
this.minFrameTimeInMs = param1;
}
}
public function reset() : void {
this.minFrameTimeInMs = 0;
this.maxFrameTimeInMs = 0;
this.averageFrameTimeInMs = 0;
this.frameCounter = 0;
this.cumulativeTimeInMs = 0;
}
}
}
|
package alternativa.tanks.models.tank.support {
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.events.StateCorrectionEvent;
import alternativa.tanks.battle.events.TankAddedToBattleEvent;
import alternativa.tanks.battle.events.TankRemovedFromBattleEvent;
import alternativa.tanks.models.tank.ITankModel;
import platform.client.fp10.core.type.AutoClosable;
import platform.client.fp10.core.type.IGameObject;
public class StateCorrectionSupport implements AutoClosable {
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
private var localUser:IGameObject;
private var battleEventSupport:BattleEventSupport;
public function StateCorrectionSupport(param1:IGameObject) {
super();
this.localUser = param1;
this.battleEventSupport = new BattleEventSupport(battleEventDispatcher);
this.battleEventSupport.addEventHandler(TankAddedToBattleEvent,this.onTankAddedToBattle);
this.battleEventSupport.addEventHandler(TankRemovedFromBattleEvent,this.onTankRemovedFromBattle);
this.battleEventSupport.addEventHandler(StateCorrectionEvent,this.onStateCorrectionRequest);
this.battleEventSupport.addEventHandler(BattleFinishEvent,this.onBattleFinish);
this.battleEventSupport.activateHandlers();
}
private function onTankAddedToBattle(param1:TankAddedToBattleEvent) : void {
var local2:ITankModel = null;
if(param1.tank.getUser() == this.localUser) {
local2 = ITankModel(this.localUser.adapt(ITankModel));
local2.enableStateCorrection();
}
}
private function onTankRemovedFromBattle(param1:TankRemovedFromBattleEvent) : void {
var local2:ITankModel = null;
if(param1.tank.getUser() == this.localUser) {
local2 = ITankModel(this.localUser.adapt(ITankModel));
local2.disableStateCorrection();
}
}
private function onStateCorrectionRequest(param1:StateCorrectionEvent) : void {
var local2:ITankModel = ITankModel(this.localUser.adapt(ITankModel));
local2.sendStateCorrection(param1.mandatory);
}
private function onBattleFinish(param1:Object) : void {
var local2:ITankModel = ITankModel(this.localUser.adapt(ITankModel));
local2.disableStateCorrection();
}
[Obfuscation(rename="false")]
public function close() : void {
this.battleEventSupport.deactivateHandlers();
this.battleEventSupport = null;
this.localUser = null;
}
}
}
|
package com.lorentz.SVG.display {
import com.lorentz.SVG.data.path.SVGPathCommand;
import com.lorentz.SVG.display.base.SVGShape;
import com.lorentz.SVG.drawing.IDrawer;
import com.lorentz.SVG.drawing.SVGPathRenderer;
import com.lorentz.SVG.parser.SVGParserCommon;
public class SVGPath extends SVGShape {
private var _invalidPathFlag:Boolean = false;
private var _pathRenderer:SVGPathRenderer;
private var _path:Vector.<SVGPathCommand>;
public function SVGPath(){
super("path");
}
public function get svgPath():String {
return getAttribute("path") as String;
}
public function set svgPath(value:String):void {
setAttribute("path", value);
}
public function get path():Vector.<SVGPathCommand> {
return _path;
}
public function set path(value:Vector.<SVGPathCommand>):void {
_path = value;
_pathRenderer = null;
invalidateRender();
}
override protected function onAttributeChanged(attributeName:String, oldValue:Object, newValue:Object):void {
super.onAttributeChanged(attributeName, oldValue, newValue);
switch(attributeName){
case "path" :
_invalidPathFlag = true;
invalidateProperties();
}
}
override protected function commitProperties():void {
super.commitProperties();
if(_invalidPathFlag)
{
_invalidPathFlag = false;
path = SVGParserCommon.parsePathData(svgPath);
}
}
override protected function beforeDraw():void {
super.beforeDraw();
_pathRenderer = new SVGPathRenderer(path);
}
override protected function drawToDrawer(drawer:IDrawer):void {
_pathRenderer.render(drawer);
}
override public function clone():Object {
var c:SVGPath = super.clone() as SVGPath;
var pathCopy:Vector.<SVGPathCommand> = new Vector.<SVGPathCommand>();
for each(var command:SVGPathCommand in path){
pathCopy.push(command.clone());
}
c.path = pathCopy;
return c;
}
}
} |
package alternativa.tanks.model.gift.opened
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GiftOpenedView_Shine extends BitmapAsset
{
public function GiftOpenedView_Shine()
{
super();
}
}
}
|
package mx.core {
public interface ILayoutDirectionElement {
function get layoutDirection() : String;
function set layoutDirection(value:String) : void;
function invalidateLayoutDirection() : void;
}
}
|
package alternativa.tanks.models.clan.outgoing {
import alternativa.tanks.gui.clanmanagement.ClanOutgoingRequestsDialog;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.clans.clan.outgoing.ClanOutgoingModelBase;
import projects.tanks.client.clans.clan.outgoing.IClanOutgoingModelBase;
[ModelInfo]
public class ClanOutgoingModel extends ClanOutgoingModelBase implements IClanOutgoingModelBase, IClanOutgoingModel, ObjectLoadListener {
private var _outgoingWindow:ClanOutgoingRequestsDialog;
private var _users:Vector.<Long> = new Vector.<Long>();
public function ClanOutgoingModel() {
super();
}
public function objectLoaded() : void {
this._users = getInitParam().objects.concat();
}
public function setClanOutgoingWindow(param1:ClanOutgoingRequestsDialog) : void {
this._outgoingWindow = param1;
}
public function onAdding(param1:Long) : void {
this._users.push(param1);
if(this._outgoingWindow != null) {
this._outgoingWindow.addUser(param1);
}
}
public function onRemoved(param1:Long) : void {
var local2:Number = Number(this._users.indexOf(param1));
this._users.splice(local2,1);
if(this._outgoingWindow != null) {
this._outgoingWindow.removeUser(param1);
}
}
public function getUsers() : Vector.<Long> {
return this._users;
}
}
}
|
package alternativa.tanks.models.sfx.shoot.railgun
{
import alternativa.engine3d.materials.Material;
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.sfx.IGraphicEffect;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class BeamEffect extends PooledObject implements IGraphicEffect
{
private var container:Scene3DContainer;
private var trail:ShotTrail;
private var startPoint:Vector3;
private var direction:Vector3;
private var beginScale:Number;
private var endScale:Number;
private var moveDistance:Number;
private var lifeTime:int;
private var time:int;
public function BeamEffect(param1:ObjectPool)
{
this.startPoint = new Vector3();
this.direction = new Vector3();
super(param1);
this.trail = new ShotTrail();
}
public function init(param1:Vector3, param2:Vector3, param3:Material, param4:Number, param5:Number, param6:Number, param7:Number, param8:int) : void
{
this.startPoint.copyFrom(param1);
this.direction.vDiff(param2,param1);
var _loc9_:Number = this.direction.vLength();
this.direction.scale(1 / _loc9_);
this.beginScale = param5;
this.endScale = param6;
this.moveDistance = param7;
this.lifeTime = param8;
this.trail.init(param4,_loc9_,param3,param7);
this.time = 0;
}
public function play(param1:int, param2:GameCamera) : Boolean
{
var _loc4_:Number = NaN;
_loc4_ = NaN;
var _loc3_:Number = NaN;
_loc4_ = NaN;
if(this.time > this.lifeTime)
{
return false;
}
SFXUtils.alignObjectPlaneToView(this.trail,this.startPoint,this.direction,param2.pos);
_loc3_ = this.time / this.lifeTime;
_loc4_ = Math.sqrt(_loc3_);
this.trail.scaleX = this.beginScale + (this.endScale - this.beginScale) * _loc4_;
this.trail.alpha = 1 - _loc3_;
this.trail.update(_loc4_);
this.time += param1;
return true;
}
public function addToContainer(param1:Scene3DContainer) : void
{
this.container = param1;
param1.addChild(this.trail);
}
public function destroy() : void
{
this.trail.clear();
this.container.removeChild(this.trail);
this.trail.destroy();
this.container = null;
}
public function kill() : void
{
this.time = this.lifeTime + 1;
}
public function get owner() : ClientObject
{
return null;
}
}
}
|
package alternativa.tanks.view.icons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.icons.BattleParamsCheckButtonIcons_devicesClass.png")]
public class BattleParamsCheckButtonIcons_devicesClass extends BitmapAsset {
public function BattleParamsCheckButtonIcons_devicesClass() {
super();
}
}
}
|
package alternativa.engine3d.core
{
import alternativa.gfx.agal.VertexShader;
public class ShadowReceiverVertexShader extends VertexShader
{
public function ShadowReceiverVertexShader(param1:Boolean)
{
super();
dp4(vt0.x,va0,vc[11]);
dp4(vt0.y,va0,vc[12]);
dp4(vt0.z,va0,vc[13]);
mov(vt0.w,va0);
dp4(vt1,vt0,vc[15]);
dp4(vt1.y,vt0,vc[16]);
mul(vt1.xy,vt1,vc[19]);
add(v0.xy,vt1,vc[20]);
dp4(v0.zw,vt0,vc[17]);
div(vt1.z,vc[14].w,vt0);
add(vt1.z,vt1,vc[14]);
mul(vt1.z,vt1,vc[14].x);
sub(vt1.z,vt1,vc[14].y);
div(vt1.z,vt1,vc[14].x);
sub(vt1.z,vt1,vc[14]);
div(vt1.z,vc[14].w,vt1);
mov(vt2,vc[20]);
nrm(vt2.xyz,vt0.xyz);
sub(vt1.z,vt0,vt1);
div(vt1.z,vt1,vt2);
mul(vt2,vt2,vt1.z);
sub(vt0,vt0,vt2);
if(param1)
{
mul(vt0.xy,vt0,vc[18]);
mul(vt1.xy,vc[18].zw,vt0.z);
add(vt0.xy,vt0,vt1);
}
mov(op.xw,vt0.xz);
neg(op.y,vt0);
mul(vt0.z,vt0,vc[14]);
add(op.z,vt0,vc[14].w);
}
}
}
|
package alternativa.tanks.gui.components.flag {
import alternativa.tanks.models.panel.create.ClanCreateService;
import flash.display.Bitmap;
import flash.display.Sprite;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
public class Flag extends Sprite {
[Inject]
public static var clanCreateService:ClanCreateService;
public var country:ClanFlag;
private var flag:Bitmap;
public function Flag(param1:ClanFlag = null) {
super();
if(param1 == null) {
param1 = clanCreateService.defaultFlag;
}
this.setFlag(param1);
}
public static function getFlag(param1:ClanFlag) : Bitmap {
return new Bitmap(param1.flagImage.data);
}
public function setFlag(param1:ClanFlag) : void {
this.removeAllChildren();
this.flag = getFlag(param1);
this.country = param1;
addChild(this.flag);
}
private function removeAllChildren() : void {
while(numChildren > 0) {
removeChildAt(0);
}
}
}
}
|
package projects.tanks.client.users.model.friends.incoming {
import alternativa.types.Long;
public interface IFriendsIncomingModelBase {
function onAdding(param1:Long) : void;
function onRemoved(param1:Long) : void;
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased.rugby {
import platform.client.fp10.core.resource.types.SoundResource;
public class RugbySoundFX {
private var _ballDropNegativeSound:SoundResource;
private var _ballDropPositiveSound:SoundResource;
private var _ballFaceOffSound:SoundResource;
private var _ballTakeNegativeSound:SoundResource;
private var _ballTakePositiveSound:SoundResource;
private var _goalNegativeSound:SoundResource;
private var _goalPositiveSound:SoundResource;
public function RugbySoundFX(param1:SoundResource = null, param2:SoundResource = null, param3:SoundResource = null, param4:SoundResource = null, param5:SoundResource = null, param6:SoundResource = null, param7:SoundResource = null) {
super();
this._ballDropNegativeSound = param1;
this._ballDropPositiveSound = param2;
this._ballFaceOffSound = param3;
this._ballTakeNegativeSound = param4;
this._ballTakePositiveSound = param5;
this._goalNegativeSound = param6;
this._goalPositiveSound = param7;
}
public function get ballDropNegativeSound() : SoundResource {
return this._ballDropNegativeSound;
}
public function set ballDropNegativeSound(param1:SoundResource) : void {
this._ballDropNegativeSound = param1;
}
public function get ballDropPositiveSound() : SoundResource {
return this._ballDropPositiveSound;
}
public function set ballDropPositiveSound(param1:SoundResource) : void {
this._ballDropPositiveSound = param1;
}
public function get ballFaceOffSound() : SoundResource {
return this._ballFaceOffSound;
}
public function set ballFaceOffSound(param1:SoundResource) : void {
this._ballFaceOffSound = param1;
}
public function get ballTakeNegativeSound() : SoundResource {
return this._ballTakeNegativeSound;
}
public function set ballTakeNegativeSound(param1:SoundResource) : void {
this._ballTakeNegativeSound = param1;
}
public function get ballTakePositiveSound() : SoundResource {
return this._ballTakePositiveSound;
}
public function set ballTakePositiveSound(param1:SoundResource) : void {
this._ballTakePositiveSound = param1;
}
public function get goalNegativeSound() : SoundResource {
return this._goalNegativeSound;
}
public function set goalNegativeSound(param1:SoundResource) : void {
this._goalNegativeSound = param1;
}
public function get goalPositiveSound() : SoundResource {
return this._goalPositiveSound;
}
public function set goalPositiveSound(param1:SoundResource) : void {
this._goalPositiveSound = param1;
}
public function toString() : String {
var local1:String = "RugbySoundFX [";
local1 += "ballDropNegativeSound = " + this.ballDropNegativeSound + " ";
local1 += "ballDropPositiveSound = " + this.ballDropPositiveSound + " ";
local1 += "ballFaceOffSound = " + this.ballFaceOffSound + " ";
local1 += "ballTakeNegativeSound = " + this.ballTakeNegativeSound + " ";
local1 += "ballTakePositiveSound = " + this.ballTakePositiveSound + " ";
local1 += "goalNegativeSound = " + this.goalNegativeSound + " ";
local1 += "goalPositiveSound = " + this.goalPositiveSound + " ";
return local1 + "]";
}
}
}
|
package controls.buttons.h50px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h50px.GreyBigButtonSkin_middleUpClass.png")]
public class GreyBigButtonSkin_middleUpClass extends BitmapAsset {
public function GreyBigButtonSkin_middleUpClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.goldboxpackage {
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.goldboxpackage.GoldBoxPackageCC;
public class CodecGoldBoxPackageCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_count:ICodec;
public function CodecGoldBoxPackageCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_count = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:GoldBoxPackageCC = new GoldBoxPackageCC();
local2.count = this.codec_count.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:GoldBoxPackageCC = GoldBoxPackageCC(param2);
this.codec_count.encode(param1,local3.count);
}
}
}
|
package alternativa.tanks.models.weapon {
import alternativa.tanks.battle.objects.tank.Weapon;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IWeaponModelEvents implements IWeaponModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IWeaponModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function createLocalWeapon(param1:IGameObject) : Weapon {
var result:Weapon = null;
var i:int = 0;
var m:IWeaponModel = null;
var user:IGameObject = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IWeaponModel(this.impl[i]);
result = m.createLocalWeapon(user);
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function createRemoteWeapon(param1:IGameObject) : Weapon {
var result:Weapon = null;
var i:int = 0;
var m:IWeaponModel = null;
var user:IGameObject = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IWeaponModel(this.impl[i]);
result = m.createRemoteWeapon(user);
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.loader {
public interface ILoaderTipsService {
function getTip() : void;
}
}
|
package alternativa.tanks.controller.events.showform {
import flash.events.Event;
public class ShowFormEvent extends Event {
public static const SHOW_RESTORE_PASSWORD_FORM:String = "ShowFormEvent.SHOW_RESTORE_PASSWORD_FORM";
public static const SHOW_RECOVERY_HASH_IS_WRONG_ALERT:String = "ShowFormEvent.SHOW_RECOVERY_HASH_IS_WRONG_ALERT";
public static const SHOW_STAND_ALONE_CAPTCHA:String = "ShowFormEvent.SHOW_STAND_ALONE_CAPTCHA";
public static const SHOW_INVITE_FORM:String = "ShowFormEvent.SHOW_INVITE_FORM";
public static const SHOW_CHANGE_UID_AND_PASSWORD_FORM:String = "ShowFormEvent.SHOW_CHANGE_UID_AND_PASSWORD_FORM";
public static const SHOW_CHANGE_UID_FORM:String = "ShowFormEvent.SHOW_CHANGE_UID_FORM";
public function ShowFormEvent(param1:String) {
super(param1);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.utils {
import alternativa.osgi.service.locale.ILocaleService;
import flash.utils.Dictionary;
import projects.tanks.client.tanksservices.model.formatbattle.EquipmentConstraintsCC;
import projects.tanks.client.tanksservices.model.formatbattle.EquipmentConstraintsModeInfo;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class BattleFormatUtil {
[Inject]
public static var localeService:ILocaleService;
private var equipmentConstraintsModeNames:Dictionary;
private var equipmentConstraintsModes:Vector.<EquipmentConstraintsModeInfo>;
public function BattleFormatUtil() {
super();
}
public function init(param1:EquipmentConstraintsCC) : void {
var modeInfo:EquipmentConstraintsModeInfo = null;
var equipmentConstraintsCC:EquipmentConstraintsCC = param1;
if(this.equipmentConstraintsModeNames != null) {
return;
}
this.equipmentConstraintsModes = equipmentConstraintsCC.equipmentConstraintsModeInfos.concat().sort(function(param1:EquipmentConstraintsModeInfo, param2:EquipmentConstraintsModeInfo):int {
return param1.index - param2.index;
});
this.equipmentConstraintsModeNames = new Dictionary();
for each(modeInfo in this.equipmentConstraintsModes) {
this.equipmentConstraintsModeNames[modeInfo.mode] = modeInfo.name;
}
}
public function isFormatBattle(param1:String, param2:Boolean) : Boolean {
return param2 || param1 != null;
}
public function getShortFormatName(param1:String, param2:Boolean) : String {
if(param2) {
return this.getParkourFormatName();
}
return param1 != null ? this.equipmentConstraintsModeNames[param1] : "";
}
public function getParkourFormatName() : String {
return localeService.getText(TanksLocale.TEXT_FORMAT_NAME_PARKOUR);
}
public function getEquipmentConstraintsModes() : Vector.<EquipmentConstraintsModeInfo> {
return this.equipmentConstraintsModes;
}
public function getClanFormatName() : String {
return "Клановый";
}
}
}
|
package projects.tanks.client.panel.model.coin {
public interface ICoinInfoModelBase {
function changeBy(param1:int) : void;
function setCoins(param1:int) : void;
}
}
|
package alternativa.tanks.gui.friends.list {
import alternativa.tanks.gui.friends.IFriendsListState;
import alternativa.tanks.gui.friends.list.dataprovider.FriendsDataProvider;
import alternativa.tanks.gui.friends.list.renderer.FriendsAcceptedListRenderer;
import alternativa.tanks.gui.friends.list.renderer.HeaderAcceptedList;
import alternativa.tanks.service.socialnetwork.vk.SNFriendsService;
import alternativa.tanks.service.socialnetwork.vk.SNFriendsServiceData;
import alternativa.tanks.service.socialnetwork.vk.SNFriendsServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.model.friends.FriendState;
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.battle.BattleLinkData;
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.online.ClientOnlineNotifierData;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.BattleInfoServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.FriendStateChangeEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.NewFriendEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.battleinvite.BattleInviteServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.battleinvite.IBattleInviteService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.battle.IBattleNotifierService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.battle.LeaveBattleNotifierServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.battle.SetBattleNotifierServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.online.IOnlineNotifierService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.online.OnlineNotifierServiceEvent;
import services.contextmenu.ContextMenuServiceEvent;
import services.contextmenu.IContextMenuService;
public class AcceptedList extends FriendsList implements IFriendsListState {
[Inject]
public static var contextMenuService:IContextMenuService;
[Inject]
public static var onlineNotifierService:IOnlineNotifierService;
[Inject]
public static var battleNotifierService:IBattleNotifierService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var battleInviteService:IBattleInviteService;
[Inject]
public static var snFriendsService:SNFriendsService;
public static var SCROLL_ON:Boolean;
private var _header:HeaderAcceptedList;
public function AcceptedList() {
super();
init(FriendsAcceptedListRenderer);
_dataProvider.getItemAtHandler = this.markAsViewed;
this._header = new HeaderAcceptedList();
addChild(this._header);
}
private function markAsViewed(param1:Object) : void {
if(!isViewed(param1) && Boolean(param1.isNew)) {
friendInfoService.removeNewAcceptedFriend(param1.id);
setAsViewed(param1);
}
}
public function initList() : void {
snFriendsService.addEventListener(SNFriendsServiceEvent.GET_FRIENDS_COMPLETED,this.onGetFriends);
snFriendsService.requestFriends();
friendInfoService.addEventListener(FriendStateChangeEvent.CHANGE,this.onChangeFriendState);
friendInfoService.addEventListener(NewFriendEvent.ACCEPTED_CHANGE,this.onNewFriendChange);
contextMenuService.addEventListener(ContextMenuServiceEvent.REMOVE_FROM_FRIENDS,this.onRemoveFromFriends);
onlineNotifierService.addEventListener(OnlineNotifierServiceEvent.SET_ONLINE,this.onSetOnline);
battleNotifierService.addEventListener(SetBattleNotifierServiceEvent.SET_BATTLE,this.onSetBattle);
battleNotifierService.addEventListener(LeaveBattleNotifierServiceEvent.LEAVE,this.onLeaveBattle);
battleInfoService.addEventListener(BattleInfoServiceEvent.SELECTION_BATTLE,this.onSelectBattleInfo);
battleInfoService.addEventListener(BattleInfoServiceEvent.RESET_SELECTION_BATTLE,this.onResetSelectBattleInfo);
battleInviteService.addEventListener(BattleInviteServiceEvent.REMOVE_INVITE,this.onRemoveInvite);
_dataProvider.sortOn([FriendsDataProvider.IS_NEW,FriendsDataProvider.ONLINE,FriendsDataProvider.IS_BATTLE,FriendsDataProvider.UID],[Array.NUMERIC | Array.DESCENDING,Array.NUMERIC | Array.DESCENDING,Array.NUMERIC | Array.DESCENDING,Array.CASEINSENSITIVE]);
fillFriendsList(FriendState.ACCEPTED);
_list.scrollToIndex(0);
this.resize(_width,_height);
}
private function onGetFriends(param1:SNFriendsServiceEvent) : void {
var local4:Object = null;
var local2:SNFriendsServiceData = param1.getResult();
var local3:int = 0;
while(local3 < friendInfoService.acceptedFriendsLength) {
local4 = _dataProvider.getItemAt(local3);
if(local4.snUid != "") {
_dataProvider.setPropertiesById(local4.id,"isSNFriend",local2.areFriends(local4.snUid));
}
local3++;
}
}
private function onNewFriendChange(param1:NewFriendEvent) : void {
_dataProvider.setUserAsNew(param1.userId);
}
private function onChangeFriendState(param1:FriendStateChangeEvent) : void {
if(param1.state != FriendState.ACCEPTED) {
_dataProvider.removeUser(param1.userId);
this.resize(_width,_height);
return;
}
if(_dataProvider.getItemIndexByProperty("id",param1.userId,true) == -1) {
_dataProvider.addUser(param1.userId);
this.resize(_width,_height);
}
}
private function onRemoveFromFriends(param1:ContextMenuServiceEvent) : void {
_dataProvider.removeUser(param1.userId);
this.resize(_width,_height);
}
private function onSetOnline(param1:OnlineNotifierServiceEvent) : void {
var local6:int = 0;
var local2:Boolean = false;
var local3:Vector.<ClientOnlineNotifierData> = param1.users;
var local4:int = int(local3.length);
var local5:int = 0;
while(local5 < local4) {
local6 = _dataProvider.setOnlineUser(local3[local5],false);
local2 ||= local6 != -1;
local5++;
}
if(local2) {
_dataProvider.reSort();
}
}
private function onSetBattle(param1:SetBattleNotifierServiceEvent) : void {
var local6:int = 0;
var local2:Boolean = false;
var local3:Vector.<BattleLinkData> = param1.users;
var local4:int = int(local3.length);
var local5:int = 0;
while(local5 < local4) {
local6 = _dataProvider.setBattleUser(local3[local5],false);
local2 ||= local6 != -1;
local5++;
}
if(local2 > 0) {
_dataProvider.reSort();
}
}
private function onLeaveBattle(param1:LeaveBattleNotifierServiceEvent) : void {
_dataProvider.clearBattleUser(param1.userId);
}
private function onResetSelectBattleInfo(param1:BattleInfoServiceEvent) : void {
_dataProvider.updatePropertyAvailableInvite();
}
private function onSelectBattleInfo(param1:BattleInfoServiceEvent) : void {
_dataProvider.updatePropertyAvailableInvite();
}
private function onRemoveInvite(param1:BattleInviteServiceEvent) : void {
_dataProvider.updatePropertyAvailableInviteById(param1.userId);
}
override public function resize(param1:Number, param2:Number) : void {
_width = param1;
_height = param2;
AcceptedList.SCROLL_ON = _list.verticalScrollBar.visible;
this._header.width = _width;
_list.y = 20;
_list.width = AcceptedList.SCROLL_ON ? _width + 6 : _width;
_list.height = _height - 20;
}
public function hide() : void {
contextMenuService.removeEventListener(ContextMenuServiceEvent.REMOVE_FROM_FRIENDS,this.onRemoveFromFriends);
friendInfoService.removeEventListener(FriendStateChangeEvent.CHANGE,this.onChangeFriendState);
friendInfoService.removeEventListener(NewFriendEvent.ACCEPTED_CHANGE,this.onNewFriendChange);
onlineNotifierService.removeEventListener(OnlineNotifierServiceEvent.SET_ONLINE,this.onSetOnline);
battleNotifierService.removeEventListener(SetBattleNotifierServiceEvent.SET_BATTLE,this.onSetBattle);
battleNotifierService.removeEventListener(LeaveBattleNotifierServiceEvent.LEAVE,this.onLeaveBattle);
battleInfoService.removeEventListener(BattleInfoServiceEvent.SELECTION_BATTLE,this.onSelectBattleInfo);
battleInfoService.removeEventListener(BattleInfoServiceEvent.RESET_SELECTION_BATTLE,this.onResetSelectBattleInfo);
battleInviteService.removeEventListener(BattleInviteServiceEvent.REMOVE_INVITE,this.onRemoveInvite);
snFriendsService.removeEventListener(SNFriendsServiceEvent.GET_FRIENDS_COMPLETED,this.onGetFriends);
if(parent.contains(this)) {
parent.removeChild(this);
_dataProvider.removeAll();
}
}
public function filter(param1:String, param2:String) : void {
filterByProperty(param1,param2);
this.resize(_width,_height);
}
public function resetFilter() : void {
_dataProvider.resetFilter();
this.resize(_width,_height);
}
}
}
|
package _codec.projects.tanks.client.chat.models.news.showing {
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.chat.models.news.showing.NewsItemData;
public class VectorCodecNewsItemDataLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecNewsItemDataLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(NewsItemData,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.<NewsItemData> = new Vector.<NewsItemData>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = NewsItemData(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:NewsItemData = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<NewsItemData> = Vector.<NewsItemData>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.client.garage.models.item.premium {
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 PremiumItemModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function PremiumItemModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.view.bubbles {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Shape;
import flash.display.Sprite;
import flash.display.StageQuality;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.ColorTransform;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.text.AntiAliasType;
import flash.text.GridFitType;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperAlign;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperArrowDirection;
public class Bubble extends Sprite {
public static const r:int = 16;
private static const lineThickness:int = 1;
private static const lineColor:uint = 16777215;
private static const fillColor:uint = 0;
private static const lineAlpha:Number = 1;
private static const fillAlpha:Number = 0.85;
private static const arrowShift:int = r * 1.5;
private static const arrowWidth:int = r * 1.5;
private static var defaultTextFormat:TextFormat = new TextFormat("Tahoma",10,16777215,true);
private static var embededFont:Boolean = false;
private var back:Shape;
private var outline:Shape;
private var _arrowLehgth:int = 48;
private var _arrowAlign:int;
private var arrowP1:Point = new Point();
private var arrowP2:Point = new Point();
private var arrowTarget:Point = new Point();
private var outlineArrowP1:Point = new Point();
private var outlineArrowP2:Point = new Point();
private var outlineArrowTarget:Point = new Point();
private var arrowDirection:Boolean;
private var descriptionLabel:TextField;
private var margin:int = 12;
private var bmp:Bitmap;
private var backContainer:Sprite;
private var _size:Point;
public var relativePosition:Point;
public function Bubble(param1:Point) {
super();
this._size = new Point();
this.relativePosition = param1;
this.bmp = new Bitmap();
addChild(this.bmp);
this.backContainer = new Sprite();
this.backContainer.mouseEnabled = false;
this.backContainer.mouseChildren = false;
this.backContainer.tabEnabled = false;
this.backContainer.tabChildren = false;
this.outline = new Shape();
this.backContainer.addChild(this.outline);
this.back = new Shape();
this.backContainer.addChild(this.back);
this.arrowAlign = HelperAlign.MIDDLE_RIGHT;
this.descriptionLabel = new TextField();
this.descriptionLabel.defaultTextFormat = defaultTextFormat;
this.descriptionLabel.embedFonts = embededFont;
this.descriptionLabel.antiAliasType = AntiAliasType.ADVANCED;
this.descriptionLabel.gridFitType = GridFitType.SUBPIXEL;
this.descriptionLabel.autoSize = TextFieldAutoSize.LEFT;
this.descriptionLabel.sharpness = -150;
this.descriptionLabel.thickness = -150;
this.descriptionLabel.wordWrap = false;
this.descriptionLabel.multiline = true;
this.descriptionLabel.selectable = false;
addChild(this.descriptionLabel);
this.descriptionLabel.x = this.margin - 3;
this.descriptionLabel.y = this.margin - 4;
this.descriptionLabel.mouseEnabled = false;
this.descriptionLabel.tabEnabled = false;
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
}
private function onAddedToStage(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
this.draw();
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemovedFromStage);
addEventListener(MouseEvent.CLICK,this.onMouseClick);
stage.addEventListener(Event.RESIZE,this.onResize);
this.onResize();
}
private function onMouseClick(param1:MouseEvent) : void {
parent.removeChild(this);
}
private function onRemovedFromStage(param1:Event) : void {
removeEventListener(Event.REMOVED_FROM_STAGE,this.onRemovedFromStage);
stage.removeEventListener(Event.RESIZE,this.onResize);
stage.removeEventListener(MouseEvent.CLICK,this.onMouseClick);
}
private function onResize(param1:Event = null) : void {
this.doAlign();
}
public function hide() : void {
if(Boolean(parent)) {
parent.removeChild(this);
}
}
protected function draw() : void {
this.outline.graphics.clear();
this.outline.graphics.beginFill(lineColor,lineAlpha);
this.outline.graphics.drawRoundRect(-lineThickness,-lineThickness,this._size.x + lineThickness * 2,this._size.y + lineThickness * 2,r + 2,r + 2);
this.outline.graphics.drawRoundRect(0,0,this._size.x,this._size.y,r,r);
this.back.graphics.clear();
this.back.graphics.beginFill(fillColor,fillAlpha);
this.back.graphics.drawRoundRect(0,0,this._size.x,this._size.y,r,r);
var local1:Number = this._arrowLehgth / arrowWidth;
if(Boolean(this._arrowAlign & HelperAlign.TOP_MASK)) {
this.arrowP1.y = 0;
this.arrowP2.y = 0;
this.arrowTarget.y = -this._arrowLehgth;
this.outlineArrowP1.y = 0;
this.outlineArrowP2.y = 0;
this.outlineArrowTarget.y = -local1 * (arrowWidth + lineThickness * 2);
} else if(Boolean(this._arrowAlign & HelperAlign.MIDDLE_MASK)) {
this.arrowP1.y = this._size.y - arrowWidth >> 1;
this.arrowP2.y = this.arrowP1.y + arrowWidth;
this.arrowTarget.y = this.arrowP1.y;
this.outlineArrowP1.y = this.arrowP1.y - lineThickness;
this.outlineArrowP2.y = this.arrowP1.y + arrowWidth + lineThickness;
this.outlineArrowTarget.y = this.outlineArrowP1.y;
} else {
this.arrowP1.y = this._size.y;
this.arrowP2.y = this._size.y;
this.arrowTarget.y = this._size.y + this._arrowLehgth;
this.outlineArrowP1.y = this._size.y;
this.outlineArrowP2.y = this._size.y;
this.outlineArrowTarget.y = this._size.y + local1 * (arrowWidth + lineThickness * 2);
}
if(Boolean(this._arrowAlign & HelperAlign.LEFT_MASK)) {
if(this.arrowDirection == HelperArrowDirection.VERTICAL) {
this.arrowTarget.x = arrowShift;
this.arrowP1.x = arrowShift;
this.arrowP2.x = arrowShift + arrowWidth;
this.outlineArrowTarget.x = arrowShift - lineThickness;
this.outlineArrowP1.x = arrowShift - lineThickness;
this.outlineArrowP2.x = arrowShift + arrowWidth + lineThickness;
} else {
this.arrowTarget.x = -this._arrowLehgth;
this.arrowP1.x = 0;
this.arrowP2.x = 0;
this.outlineArrowTarget.x = -local1 * (arrowWidth + lineThickness * 2);
this.outlineArrowP1.x = 0;
this.outlineArrowP2.x = 0;
}
if(Boolean(this._arrowAlign & HelperAlign.TOP_MASK)) {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y - lineThickness,this.arrowP2.x - this.arrowP1.x,lineThickness);
} else if(Boolean(this._arrowAlign & HelperAlign.MIDDLE_MASK)) {
this.outline.graphics.drawRect(this.arrowP1.x - lineThickness,this.arrowP1.y,lineThickness,this.arrowP2.y - this.arrowP1.y);
} else {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y,this.arrowP2.x - this.arrowP1.x,lineThickness);
}
} else if(Boolean(this._arrowAlign & HelperAlign.CENTER_MASK)) {
this.arrowTarget.x = this._size.x - arrowWidth >> 1;
this.arrowP1.x = this.arrowTarget.x;
this.arrowP2.x = this.arrowTarget.x + arrowWidth;
this.outlineArrowTarget.x = this.arrowTarget.x - lineThickness;
this.outlineArrowP1.x = this.outlineArrowTarget.x;
this.outlineArrowP2.x = this.arrowP2.x + lineThickness;
if(Boolean(this._arrowAlign & HelperAlign.TOP_MASK)) {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y - lineThickness,this.arrowP2.x - this.arrowP1.x,lineThickness);
} else {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y,this.arrowP2.x - this.arrowP1.x,lineThickness);
}
} else {
if(this.arrowDirection == HelperArrowDirection.VERTICAL) {
this.arrowTarget.x = this._size.x - arrowShift;
this.arrowP1.x = this.arrowTarget.x;
this.arrowP2.x = this.arrowP1.x - arrowWidth;
this.outlineArrowTarget.x = this.arrowTarget.x + lineThickness;
this.outlineArrowP1.x = this.outlineArrowTarget.x;
this.outlineArrowP2.x = this.arrowTarget.x - arrowWidth - lineThickness;
} else {
this.arrowTarget.x = this._size.x + this._arrowLehgth;
this.arrowP1.x = this._size.x;
this.arrowP2.x = this._size.x;
this.outlineArrowTarget.x = this._size.x + local1 * (arrowWidth + lineThickness * 2);
this.outlineArrowP1.x = this._size.x;
this.outlineArrowP2.x = this._size.x;
}
if(Boolean(this._arrowAlign & HelperAlign.TOP_MASK)) {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y - lineThickness,this.arrowP2.x - this.arrowP1.x,lineThickness);
} else if(Boolean(this._arrowAlign & HelperAlign.MIDDLE_MASK)) {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y,lineThickness,this.arrowP2.y - this.arrowP1.y);
} else {
this.outline.graphics.drawRect(this.arrowP1.x,this.arrowP1.y,this.arrowP2.x - this.arrowP1.x,lineThickness);
}
}
this.back.graphics.moveTo(this.arrowTarget.x,this.arrowTarget.y);
this.back.graphics.lineTo(this.arrowP1.x,this.arrowP1.y);
this.back.graphics.lineTo(this.arrowP2.x,this.arrowP2.y);
this.back.graphics.lineTo(this.arrowTarget.x,this.arrowTarget.y);
this.outline.graphics.beginFill(lineColor,lineAlpha);
this.outline.graphics.moveTo(this.outlineArrowTarget.x,this.outlineArrowTarget.y);
this.outline.graphics.lineTo(this.outlineArrowP1.x,this.outlineArrowP1.y);
this.outline.graphics.lineTo(this.outlineArrowP2.x,this.outlineArrowP2.y);
this.outline.graphics.lineTo(this.outlineArrowTarget.x,this.outlineArrowTarget.y);
this.outline.graphics.moveTo(this.arrowTarget.x,this.arrowTarget.y);
this.outline.graphics.lineTo(this.arrowP1.x,this.arrowP1.y);
this.outline.graphics.lineTo(this.arrowP2.x,this.arrowP2.y);
this.outline.graphics.lineTo(this.arrowTarget.x,this.arrowTarget.y);
var local2:String = stage.quality;
stage.quality = StageQuality.HIGH;
var local3:Matrix = new Matrix();
if(this.outlineArrowTarget.x < 0) {
local3.tx = -Math.round(this.outlineArrowTarget.x);
this.bmp.x = Math.round(this.outlineArrowTarget.x);
} else {
local3.tx = lineThickness;
this.bmp.x = -lineThickness;
}
if(this.outlineArrowTarget.y < 0) {
local3.ty = -Math.round(this.outlineArrowTarget.y);
this.bmp.y = Math.round(this.outlineArrowTarget.y);
} else {
local3.ty = lineThickness;
this.bmp.y = -lineThickness;
}
this.bmp.bitmapData = new BitmapData(Math.round(this.outline.width),Math.round(this.outline.height),true,0);
this.bmp.bitmapData.draw(this.backContainer,local3,new ColorTransform(),BlendMode.NORMAL,null,true);
stage.quality = local2;
this.descriptionLabel.width = this._size.x - this.margin * 2;
}
protected function doAlign() : void {
this.x = Math.round(this.relativePosition.x - this.outlineArrowTarget.x);
this.y = Math.round(this.relativePosition.y - this.outlineArrowTarget.y);
}
public function get arrowLehgth() : int {
return this._arrowLehgth;
}
public function set arrowLehgth(param1:int) : void {
this._arrowLehgth = param1;
}
public function get arrowAlign() : int {
return this._arrowAlign;
}
public function set arrowAlign(param1:int) : void {
if(param1 == HelperAlign.MIDDLE_CENTER) {
this._arrowAlign = HelperAlign.BOTTOM_LEFT;
} else {
this._arrowAlign = param1;
}
if(Boolean(this._arrowAlign & HelperAlign.TOP_MASK) || Boolean(this._arrowAlign & HelperAlign.BOTTOM_MASK)) {
this.arrowDirection = HelperArrowDirection.VERTICAL;
} else {
this.arrowDirection = HelperArrowDirection.HORIZONTAL;
}
}
public function set text(param1:String) : void {
this.descriptionLabel.htmlText = param1;
this._size.x = Math.round(this.descriptionLabel.textWidth + this.margin * 2);
this._size.y = Math.round(this.descriptionLabel.textHeight + this.margin * 2) - 3;
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.levelup
{
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.sfx.IGraphicEffect;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.display.BlendMode;
public class LightBeamEffect extends PooledObject implements IGraphicEffect
{
private static const BASE_SIZE:Number = 300;
private var beam:LightBeam;
private var delay:int;
private var time:int;
private var height:Number;
private var maxHeight:Number;
private var heightSpeed:Number;
private var fadeSpeed:Number;
private var x:Number;
private var y:Number;
private var z:Number;
private var turret:Object3D;
private var container:Scene3DContainer;
public function LightBeamEffect(param1:ObjectPool)
{
super(param1);
this.beam = new LightBeam(BASE_SIZE);
this.beam.blendMode = BlendMode.ADD;
}
public function init(param1:int, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Object3D, param11:TextureMaterial) : void
{
this.delay = param1;
this.beam.scaleX = param2 / BASE_SIZE;
this.height = param3;
this.maxHeight = param4;
this.heightSpeed = param5;
this.fadeSpeed = param6;
this.x = param7;
this.y = param8;
this.z = param9;
this.turret = param10;
this.beam.init(param11);
this.beam.softAttenuation = 150;
this.beam.depthMapAlphaThreshold = 2;
this.beam.shadowMapAlphaThreshold = 2;
this.beam.useShadowMap = false;
this.beam.useLight = false;
this.beam.alpha = 0;
this.time = 0;
}
public function addToContainer(param1:Scene3DContainer) : void
{
this.container = param1;
param1.addChild(this.beam);
}
public function play(param1:int, param2:GameCamera) : Boolean
{
if(this.height >= this.maxHeight && this.beam.alpha <= 0)
{
return false;
}
this.beam.x = this.turret.x + this.x;
this.beam.y = this.turret.y + this.y;
this.beam.z = this.turret.z + this.z;
this.beam.rotationZ = param2.rotationZ;
this.time += param1;
if(this.time >= this.delay)
{
if(this.height < this.maxHeight)
{
this.height += this.maxHeight * this.heightSpeed * param1 * 0.001;
if(this.height >= this.maxHeight)
{
this.height = this.maxHeight;
}
this.beam.scaleZ = this.height / BASE_SIZE;
this.beam.alpha = this.height / this.maxHeight;
}
else
{
this.beam.alpha -= this.fadeSpeed * param1 * 0.001;
if(this.beam.alpha < 0)
{
this.beam.alpha = 0;
}
}
}
return true;
}
public function get owner() : ClientObject
{
return null;
}
public function destroy() : void
{
this.container.removeChild(this.beam);
this.container = null;
this.turret = null;
this.beam.clear();
}
public function kill() : void
{
this.height = this.maxHeight;
this.beam.alpha = 0;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.bonus.battle {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.bonus.battle.BonusSpawnData;
import projects.tanks.client.battlefield.types.Vector3d;
public class CodecBonusSpawnData implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_battleBonusObject:ICodec;
private var codec_bonusId:ICodec;
private var codec_lifeTime:ICodec;
private var codec_spawnPosition:ICodec;
public function CodecBonusSpawnData() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_battleBonusObject = param1.getCodec(new TypeCodecInfo(IGameObject,false));
this.codec_bonusId = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_lifeTime = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_spawnPosition = param1.getCodec(new TypeCodecInfo(Vector3d,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BonusSpawnData = new BonusSpawnData();
local2.battleBonusObject = this.codec_battleBonusObject.decode(param1) as IGameObject;
local2.bonusId = this.codec_bonusId.decode(param1) as Long;
local2.lifeTime = this.codec_lifeTime.decode(param1) as int;
local2.spawnPosition = this.codec_spawnPosition.decode(param1) as Vector3d;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BonusSpawnData = BonusSpawnData(param2);
this.codec_battleBonusObject.encode(param1,local3.battleBonusObject);
this.codec_bonusId.encode(param1,local3.bonusId);
this.codec_lifeTime.encode(param1,local3.lifeTime);
this.codec_spawnPosition.encode(param1,local3.spawnPosition);
}
}
}
|
package alternativa.tanks.models.battlefield.gamemode
{
import alternativa.engine3d.core.ShadowMap;
import alternativa.engine3d.lights.DirectionalLight;
import alternativa.init.Main;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.osgi.service.storage.IStorageService;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.model.panel.IBattleSettings;
import alternativa.tanks.models.battlefield.BattleView3D;
import flash.display.Bitmap;
import flash.display.BitmapData;
public class NightGameMode implements IGameMode
{
private var camera:GameCamera;
public function NightGameMode()
{
super();
}
public function applyChanges(viewport:BattleView3D) : void
{
var camera:GameCamera = null;
camera = null;
camera = viewport.camera;
this.camera = camera;
camera.directionalLightStrength = 1;
camera.ambientColor = 1382169;
camera.deferredLighting = true;
var light:DirectionalLight = new DirectionalLight(7559484);
light.useShadowMap = true;
var matrix:Matrix3 = new Matrix3();
matrix.setRotationMatrix(-1,0,-0.4);
var toPos:Vector3 = new Vector3(0,1,0);
toPos.vTransformBy3(matrix);
light.lookAt(toPos.x,toPos.y,toPos.z);
light.intensity = 0.3;
camera.directionalLight = light;
camera.shadowMap = new ShadowMap(2048,5000,10000,0,0);
camera.shadowMapStrength = 1;
camera.shadowMap.bias = 0.5;
camera.shadowMap.biasMultiplier = 30;
camera.shadowMap.additionalSpace = 10000;
camera.shadowMap.alphaThreshold = 0.1;
camera.useShadowMap = true;
}
public function applyChangesBeforeSettings(settings:IBattleSettings) : void
{
if(settings.fog && this.camera.fogStrength != 1)
{
this.camera.fogStrength = 1;
}
else if(!settings.fog)
{
this.camera.fogStrength = 0;
}
if(settings.shadows && !this.camera.useShadowMap)
{
this.camera.useShadowMap = true;
if(this.camera.directionalLight != null)
{
this.camera.directionalLight.useShadowMap = true;
}
this.camera.shadowMapStrength = 1;
}
else if(!settings.shadows)
{
this.camera.useShadowMap = false;
if(this.camera.directionalLight != null)
{
this.camera.directionalLight.useShadowMap = false;
}
this.camera.shadowMapStrength = 0;
}
if(settings.defferedLighting && this.camera.directionalLightStrength != 1)
{
this.camera.directionalLight.intensity = 1;
this.camera.directionalLightStrength = 1;
this.camera.deferredLighting = true;
this.camera.deferredLightingStrength = 1;
}
else if(!settings.defferedLighting)
{
this.camera.directionalLight.intensity = 0;
this.camera.directionalLightStrength = 0;
this.camera.deferredLighting = false;
this.camera.deferredLightingStrength = 0;
}
if(IStorageService(Main.osgi.getService(IStorageService)).getStorage().data["use_ssao"] != null)
{
this.camera.ssao = IStorageService(Main.osgi.getService(IStorageService)).getStorage().data["use_ssao"];
}
else
{
this.camera.ssao = false;
}
}
public function applyColorchangesToSkybox(skybox:BitmapData) : BitmapData
{
var btm:BitmapData = new BitmapData(1,1,false,1382169 + 7559484);
skybox.colorTransform(skybox.rect,new Bitmap(btm).transform.colorTransform);
return skybox;
}
}
}
|
package alternativa.tanks.gui.tankpreview {
import flash.events.IEventDispatcher;
import flash.events.MouseEvent;
import flash.utils.getTimer;
public class IdleState implements TankPreviewState {
private static const AUTO_ROTATION_DELAY_MS:int = 10000;
private var stateMachine:TankPreviewStateMachine;
private var eventSource:IEventDispatcher;
private var exitTime:int;
public function IdleState(param1:TankPreviewStateMachine, param2:IEventDispatcher) {
super();
this.stateMachine = param1;
this.eventSource = param2;
}
public function enter() : void {
this.eventSource.addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
this.exitTime = getTimer() + AUTO_ROTATION_DELAY_MS;
}
public function update() : void {
if(getTimer() >= this.exitTime) {
this.stateMachine.handleEvent(this,TankPreviewEvent.IDLE_STATE_TIMEOUT);
}
}
public function exit() : void {
this.eventSource.removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
}
private function onMouseDown(param1:MouseEvent) : void {
this.stateMachine.handleEvent(this,TankPreviewEvent.MOUSE_DOWN);
}
}
}
|
package alternativa.tanks.model.item.skins {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.garage.skins.IMountShotSkinModelBase;
import projects.tanks.client.garage.skins.MountShotSkinModelBase;
[ModelInfo]
public class MountShotSkinModel extends MountShotSkinModelBase implements IMountShotSkinModelBase, MountShotSkin {
public function MountShotSkinModel() {
super();
}
public function getMountedSkin() : IGameObject {
return getInitParam().item;
}
public function mount(param1:IGameObject) : void {
getInitParam().item = param1;
server.mountSkin(param1);
}
}
}
|
package projects.tanks.client.panel.model.bonus.showing.image {
import platform.client.fp10.core.resource.types.ImageResource;
public class BonusImageCC {
private var _image:ImageResource;
public function BonusImageCC(param1:ImageResource = null) {
super();
this._image = param1;
}
public function get image() : ImageResource {
return this._image;
}
public function set image(param1:ImageResource) : void {
this._image = param1;
}
public function toString() : String {
var local1:String = "BonusImageCC [";
local1 += "image = " + this.image + " ";
return local1 + "]";
}
}
}
|
package controls.statassets
{
import assets.stat.hall_NORMAL_ACTIVE;
import flash.display.BitmapData;
public class StatLineNormalActive extends StatLineBase
{
public function StatLineNormalActive()
{
super();
tl = new hall_NORMAL_ACTIVE(1,1);
px = new BitmapData(1,1,false,881920);
}
}
}
|
package utils.resource {
import platform.client.fp10.core.resource.IResourceLoadingListener;
import platform.client.fp10.core.resource.Resource;
public class ResourceLoadingWrapper implements IResourceLoadingListener {
private var listener:IResourceLoadingComplete;
public function ResourceLoadingWrapper(param1:IResourceLoadingComplete) {
super();
this.listener = param1;
}
public function onResourceLoadingStart(param1:Resource) : void {
}
public function onResourceLoadingProgress(param1:Resource, param2:int) : void {
}
public function onResourceLoadingComplete(param1:Resource) : void {
this.listener.onLoadingComplete(param1);
}
public function onResourceLoadingError(param1:Resource, param2:String) : void {
throw new Error("Ошибка загрузки ресурса (id: " + param1.id + ")");
}
public function onResourceLoadingFatalError(param1:Resource, param2:String) : void {
throw new Error("Ошибка загрузки ресурса (id: " + param1.id + ")");
}
}
}
|
package alternativa.tanks.display.usertitle {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.display.usertitle.ProgressBarSkin_hpLeftBgRedCls.png")]
public class ProgressBarSkin_hpLeftBgRedCls extends BitmapAsset {
public function ProgressBarSkin_hpLeftBgRedCls() {
super();
}
}
}
|
package alternativa.tanks.service.payment {
import projects.tanks.client.panel.model.payment.PaymentPackage;
public class PaymentPackageInfo {
private var _amountCrystals:int;
private var _bonusCrystals:int;
private var _price:Number;
private var _premiumDurationInDays:int;
public function PaymentPackageInfo(param1:PaymentPackage) {
super();
this._amountCrystals = param1.amountCrystals;
this._bonusCrystals = param1.bonusCrystals;
this._price = param1.price;
this._premiumDurationInDays = param1.premiumDurationInDays;
}
public function get amountCrystals() : int {
return this._amountCrystals;
}
public function set amountCrystals(param1:int) : void {
this._amountCrystals = param1;
}
public function get bonusCrystals() : int {
return this._bonusCrystals;
}
public function set bonusCrystals(param1:int) : void {
this._bonusCrystals = param1;
}
public function get price() : Number {
return this._price;
}
public function set price(param1:Number) : void {
this._price = param1;
}
public function get premiumDurationInDays() : int {
return this._premiumDurationInDays;
}
public function set premiumDurationInDays(param1:int) : void {
this._premiumDurationInDays = param1;
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.controls.bottompanel.PartnerLogo {
import flash.display.Bitmap;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.net.URLRequest;
import flash.net.navigateToURL;
import flash.ui.Mouse;
import flash.ui.MouseCursor;
import projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp;
public class PartnerLogo extends Sprite {
public static var VK:String = "VK";
public static var FB:String = "FB";
public static var GP:String = "G+";
public static var YOUTUBE:String = "YOUTUBE";
public static var TWITTER:String = "TWITTER";
public static var INSTAGRAM:String = "INSTAGRAM";
public static var TWITCH:String = "2TWITCH";
public static var OK:String = "OK";
public var actualWidth:Number = 0;
private var link:String = "";
private var type:String = "";
public function PartnerLogo(type:String, link:String) {
super();
this.link = link;
this.type = type;
addEventListener(MouseEvent.MOUSE_OVER,function(e:MouseEvent):void {
Mouse.cursor = MouseCursor.BUTTON;
});
addEventListener(MouseEvent.MOUSE_OUT,function(e:MouseEvent):void {
Mouse.cursor = MouseCursor.AUTO;
});
addEventListener(MouseEvent.CLICK,this.onClick);
switch(type) {
case VK:
this.addLogo(MakeUp.getVKIcon());
break;
case FB:
this.addLogo(MakeUp.getFacebookIcon());
break;
case GP:
this.addLogo(MakeUp.getGooglePlusIcon());
break;
case YOUTUBE:
this.addLogo(MakeUp.getYoutubeIcon());
break;
case TWITTER:
this.addLogo(MakeUp.getTwitterIcon());
break;
case TWITCH:
this.addLogo(MakeUp.getTwitchIcon());
break;
case INSTAGRAM:
this.addLogo(MakeUp.getInstagramIcon());
break;
case OK:
this.addLogo(MakeUp.getOKIcon());
}
}
private function addLogo(logo:Bitmap) : void {
this.actualWidth = logo.width;
addChild(logo);
logo.x = -logo.width >> 1;
logo.y = -logo.height >> 1;
}
private function onClick(e:MouseEvent) : void {
navigateToURL(new URLRequest(this.link));
}
}
}
|
package _codec.projects.tanks.client.panel.model.donationalert.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.donationalert.types.GoodInfoData;
public class VectorCodecGoodInfoDataLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecGoodInfoDataLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(GoodInfoData,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.<GoodInfoData> = new Vector.<GoodInfoData>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = GoodInfoData(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:GoodInfoData = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<GoodInfoData> = Vector.<GoodInfoData>(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.view {
import alternativa.tanks.controller.events.AuthorizationFailedEvent;
import alternativa.tanks.controller.events.CaptchaAnswerIsIncorrectEvent;
import alternativa.tanks.controller.events.CaptchaUpdatedEvent;
import alternativa.tanks.controller.events.GetNewCaptchaEvent;
import alternativa.tanks.controller.events.LoginButtonPressed;
import alternativa.tanks.controller.events.NavigationEvent;
import alternativa.tanks.controller.events.socialnetwork.ExternalLoginEvent;
import alternativa.tanks.tracker.ITrackerService;
import alternativa.tanks.view.forms.LinkExternalLoginForm;
import org.robotlegs.core.IInjector;
import org.robotlegs.mvcs.Mediator;
import projects.tanks.client.commons.models.captcha.CaptchaLocation;
import projects.tanks.clients.flash.commons.models.captcha.RefreshCaptchaClickedEvent;
public class LinkExternalLoginFormMediator extends Mediator {
private static const GA_CATEGORY:String = "entrance";
[Inject]
public var view:LinkExternalLoginForm;
[Inject]
public var injector:IInjector;
[Inject]
public var trackerService:ITrackerService;
public function LinkExternalLoginFormMediator() {
super();
}
override public function onRegister() : void {
this.injector.injectInto(this.view);
addViewListener(RefreshCaptchaClickedEvent.CLICKED,this.onRefreshCaptchaClicked,RefreshCaptchaClickedEvent);
addViewListener(NavigationEvent.GO_TO_LOGIN_FORM,dispatch,NavigationEvent);
addViewListener(LoginButtonPressed.EVENT_TYPE,this.onLoginClicked,LoginButtonPressed);
addContextListener(AuthorizationFailedEvent.PASSWORD_EXTERNAL_AUTHORIZATION_FAILED,this.onPasswordAuthorizationFailed);
addContextListener(AuthorizationFailedEvent.EXTERNAL_LINK_ALREADY_EXISTS,this.onExternalLinkAlreadyExists);
addContextListener(AuthorizationFailedEvent.EXTERNAL_VALIDATION_FAILED,this.onExternalValidation);
addContextListener(CaptchaUpdatedEvent.LOGIN_FORM_CAPTCHA_UPDATED,this.onCaptchaUpdated,CaptchaUpdatedEvent);
addContextListener(CaptchaAnswerIsIncorrectEvent.EVENT_TYPE,this.onCaptchaFailed);
}
private function onCaptchaFailed(param1:CaptchaAnswerIsIncorrectEvent) : void {
this.view.captchaFailed();
}
private function onRefreshCaptchaClicked(param1:RefreshCaptchaClickedEvent) : void {
dispatch(new GetNewCaptchaEvent(CaptchaLocation.LOGIN_FORM));
}
private function onLoginClicked(param1:LoginButtonPressed) : void {
this.trackerService.trackEvent(GA_CATEGORY,"externalLink","");
dispatch(new ExternalLoginEvent(ExternalLoginEvent.CHECK_CAPTCHA_AND_LOGIN,this.view.callsign,this.view.password,this.view.captchaAnswer));
}
private function onCaptchaUpdated(param1:CaptchaUpdatedEvent) : void {
this.view.showCaptchaSection();
this.view.captchaImage = param1.image;
}
private function onPasswordAuthorizationFailed(param1:AuthorizationFailedEvent) : void {
this.view.showAlertAboutWrongPassword();
}
private function onExternalLinkAlreadyExists(param1:AuthorizationFailedEvent) : void {
this.view.externalLinkAlreadyExists();
}
private function onExternalValidation(param1:AuthorizationFailedEvent) : void {
this.view.externalValidationFailed();
}
}
}
|
package alternativa.engine3d.containers {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Canvas;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Object3DContainer;
import alternativa.engine3d.core.VG;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
use namespace alternativa3d;
public class ConflictContainer extends Object3DContainer {
public var resolveByAABB:Boolean = true;
public var resolveByOOBB:Boolean = true;
public var threshold:Number = 0.01;
public function ConflictContainer() {
super();
}
override public function clone() : Object3D {
var local1:ConflictContainer = new ConflictContainer();
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
super.clonePropertiesFrom(param1);
var local2:ConflictContainer = param1 as ConflictContainer;
this.resolveByAABB = local2.resolveByAABB;
this.resolveByOOBB = local2.resolveByOOBB;
this.threshold = local2.threshold;
}
override alternativa3d function draw(param1:Camera3D, param2:Canvas) : void {
var local3:Canvas = null;
var local4:int = 0;
var local6:VG = null;
var local5:VG = alternativa3d::collectVG(param1);
if(local5 != null) {
if(param1.debug && (local4 = param1.alternativa3d::checkInDebug(this)) > 0) {
local3 = param2.alternativa3d::getChildCanvas(true,false);
if(Boolean(local4 & Debug.BOUNDS)) {
Debug.alternativa3d::drawBounds(param1,local3,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ);
}
}
local3 = param2.alternativa3d::getChildCanvas(false,true,this,alpha,blendMode,colorTransform,filters);
local3.alternativa3d::numDraws = 0;
if(local5.alternativa3d::next != null) {
alternativa3d::calculateInverseMatrix();
if(this.resolveByAABB) {
local6 = local5;
while(local6 != null) {
local6.alternativa3d::calculateAABB(alternativa3d::ima,alternativa3d::imb,alternativa3d::imc,alternativa3d::imd,alternativa3d::ime,alternativa3d::imf,alternativa3d::img,alternativa3d::imh,alternativa3d::imi,alternativa3d::imj,alternativa3d::imk,alternativa3d::iml);
local6 = local6.alternativa3d::next;
}
this.alternativa3d::drawAABBGeometry(param1,local3,local5);
} else if(this.resolveByOOBB) {
local6 = local5;
while(local6 != null) {
local6.alternativa3d::calculateOOBB(this);
local6 = local6.alternativa3d::next;
}
this.alternativa3d::drawOOBBGeometry(param1,local3,local5);
} else {
this.alternativa3d::drawConflictGeometry(param1,local3,local5);
}
} else {
local5.alternativa3d::draw(param1,local3,this.threshold,this);
local5.alternativa3d::destroy();
}
if(local3.alternativa3d::numDraws > 0) {
local3.alternativa3d::remChildren(local3.alternativa3d::numDraws);
} else {
--param2.alternativa3d::numDraws;
}
}
}
alternativa3d function drawAABBGeometry(param1:Camera3D, param2:Canvas, param3:VG, param4:Boolean = true, param5:Boolean = false, param6:Boolean = true, param7:int = -1) : void {
var local8:Boolean = false;
var local9:Boolean = false;
var local10:Boolean = false;
var local15:Boolean = false;
var local11:VG = param6 ? this.sortGeometry(param3,param4,param5) : param3;
var local12:VG = local11;
var local13:VG = local11.alternativa3d::next;
var local14:Number = Number(local11.alternativa3d::boundMax);
while(local13 != null) {
local15 = local13.alternativa3d::boundMin >= local14 - this.threshold;
if(local15 || local13.alternativa3d::next == null) {
if(local15) {
local12.alternativa3d::next = null;
param7 = 0;
} else {
local13 = null;
param7++;
}
if(param4) {
local8 = alternativa3d::imd < local14;
local9 = false;
local10 = true;
} else if(param5) {
local8 = alternativa3d::imh < local14;
local9 = false;
local10 = false;
} else {
local8 = alternativa3d::iml < local14;
local9 = true;
local10 = false;
}
if(local8) {
if(local11.alternativa3d::next != null) {
if(param7 < 2) {
this.alternativa3d::drawAABBGeometry(param1,param2,local11,local9,local10,true,param7);
} else if(this.resolveByOOBB) {
local12 = local11;
while(local12 != null) {
local12.alternativa3d::calculateOOBB(this);
local12 = local12.alternativa3d::next;
}
this.alternativa3d::drawOOBBGeometry(param1,param2,local11);
} else {
this.alternativa3d::drawConflictGeometry(param1,param2,local11);
}
} else {
local11.alternativa3d::draw(param1,param2,this.threshold,this);
local11.alternativa3d::destroy();
}
if(local13 != null) {
if(local13.alternativa3d::next != null) {
this.alternativa3d::drawAABBGeometry(param1,param2,local13,param4,param5,false,-1);
} else {
local13.alternativa3d::draw(param1,param2,this.threshold,this);
local13.alternativa3d::destroy();
}
}
} else {
if(local13 != null) {
if(local13.alternativa3d::next != null) {
this.alternativa3d::drawAABBGeometry(param1,param2,local13,param4,param5,false,-1);
} else {
local13.alternativa3d::draw(param1,param2,this.threshold,this);
local13.alternativa3d::destroy();
}
}
if(local11.alternativa3d::next != null) {
if(param7 < 2) {
this.alternativa3d::drawAABBGeometry(param1,param2,local11,local9,local10,true,param7);
} else if(this.resolveByOOBB) {
local12 = local11;
while(local12 != null) {
local12.alternativa3d::calculateOOBB(this);
local12 = local12.alternativa3d::next;
}
this.alternativa3d::drawOOBBGeometry(param1,param2,local11);
} else {
this.alternativa3d::drawConflictGeometry(param1,param2,local11);
}
} else {
local11.alternativa3d::draw(param1,param2,this.threshold,this);
local11.alternativa3d::destroy();
}
}
break;
}
if(local13.alternativa3d::boundMax > local14) {
local14 = Number(local13.alternativa3d::boundMax);
}
local12 = local13;
local13 = local13.alternativa3d::next;
}
}
private function sortGeometry(param1:VG, param2:Boolean, param3:Boolean) : VG {
var local4:VG = param1;
var local5:VG = param1.alternativa3d::next;
while(local5 != null && local5.alternativa3d::next != null) {
param1 = param1.alternativa3d::next;
local5 = local5.alternativa3d::next.alternativa3d::next;
}
local5 = param1.alternativa3d::next;
param1.alternativa3d::next = null;
if(local4.alternativa3d::next != null) {
local4 = this.sortGeometry(local4,param2,param3);
} else if(param2) {
local4.alternativa3d::boundMin = local4.alternativa3d::boundMinX;
local4.alternativa3d::boundMax = local4.alternativa3d::boundMaxX;
} else if(param3) {
local4.alternativa3d::boundMin = local4.alternativa3d::boundMinY;
local4.alternativa3d::boundMax = local4.alternativa3d::boundMaxY;
} else {
local4.alternativa3d::boundMin = local4.alternativa3d::boundMinZ;
local4.alternativa3d::boundMax = local4.alternativa3d::boundMaxZ;
}
if(local5.alternativa3d::next != null) {
local5 = this.sortGeometry(local5,param2,param3);
} else if(param2) {
local5.alternativa3d::boundMin = local5.alternativa3d::boundMinX;
local5.alternativa3d::boundMax = local5.alternativa3d::boundMaxX;
} else if(param3) {
local5.alternativa3d::boundMin = local5.alternativa3d::boundMinY;
local5.alternativa3d::boundMax = local5.alternativa3d::boundMaxY;
} else {
local5.alternativa3d::boundMin = local5.alternativa3d::boundMinZ;
local5.alternativa3d::boundMax = local5.alternativa3d::boundMaxZ;
}
var local6:Boolean = local4.alternativa3d::boundMin < local5.alternativa3d::boundMin;
if(local6) {
param1 = local4;
local4 = local4.alternativa3d::next;
} else {
param1 = local5;
local5 = local5.alternativa3d::next;
}
var local7:VG = param1;
while(true) {
if(local4 == null) {
local7.alternativa3d::next = local5;
return param1;
}
if(local5 == null) {
local7.alternativa3d::next = local4;
return param1;
}
if(local6) {
if(local4.alternativa3d::boundMin < local5.alternativa3d::boundMin) {
local7 = local4;
local4 = local4.alternativa3d::next;
} else {
local7.alternativa3d::next = local5;
local7 = local5;
local5 = local5.alternativa3d::next;
local6 = false;
}
} else if(local5.alternativa3d::boundMin < local4.alternativa3d::boundMin) {
local7 = local5;
local5 = local5.alternativa3d::next;
} else {
local7.alternativa3d::next = local4;
local7 = local4;
local4 = local4.alternativa3d::next;
local6 = true;
}
}
return null;
}
alternativa3d function drawOOBBGeometry(param1:Camera3D, param2:Canvas, param3:VG) : void {
var local4:Vertex = null;
var local5:Vertex = null;
var local6:Wrapper = null;
var local7:Number = NaN;
var local8:Number = NaN;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Boolean = false;
var local13:Boolean = false;
var local14:VG = null;
var local15:VG = null;
var local16:Boolean = false;
var local17:VG = null;
var local18:VG = null;
var local19:VG = null;
var local20:VG = null;
local14 = param3;
while(local14 != null) {
if(local14.alternativa3d::viewAligned) {
local11 = Number(local14.alternativa3d::object.alternativa3d::ml);
local15 = param3;
while(local15 != null) {
if(!local15.alternativa3d::viewAligned) {
local12 = false;
local13 = false;
local4 = local15.alternativa3d::boundVertexList;
while(local4 != null) {
if(local4.alternativa3d::cameraZ > local11) {
if(local12) {
break;
}
local13 = true;
} else {
if(local13) {
break;
}
local12 = true;
}
local4 = local4.alternativa3d::next;
}
if(local4 != null) {
break;
}
}
local15 = local15.alternativa3d::next;
}
if(local15 == null) {
break;
}
} else {
local5 = local14.alternativa3d::boundPlaneList;
while(local5 != null) {
local8 = Number(local5.alternativa3d::cameraX);
local9 = Number(local5.alternativa3d::cameraY);
local10 = Number(local5.alternativa3d::cameraZ);
local11 = Number(local5.alternativa3d::offset);
local16 = false;
local15 = param3;
while(local15 != null) {
if(local14 != local15) {
local12 = false;
local13 = false;
if(local15.alternativa3d::viewAligned) {
local6 = local15.alternativa3d::faceStruct.alternativa3d::wrapper;
while(local6 != null) {
local4 = local6.alternativa3d::vertex;
if(local4.alternativa3d::cameraX * local8 + local4.alternativa3d::cameraY * local9 + local4.alternativa3d::cameraZ * local10 >= local11 - this.threshold) {
if(local12) {
break;
}
local16 = true;
local13 = true;
} else {
if(local13) {
break;
}
local12 = true;
}
local6 = local6.alternativa3d::next;
}
if(local6 != null) {
break;
}
} else {
local4 = local15.alternativa3d::boundVertexList;
while(local4 != null) {
if(local4.alternativa3d::cameraX * local8 + local4.alternativa3d::cameraY * local9 + local4.alternativa3d::cameraZ * local10 >= local11 - this.threshold) {
if(local12) {
break;
}
local16 = true;
local13 = true;
} else {
if(local13) {
break;
}
local12 = true;
}
local4 = local4.alternativa3d::next;
}
if(local4 != null) {
break;
}
}
}
local15 = local15.alternativa3d::next;
}
if(local15 == null && local16) {
break;
}
local5 = local5.alternativa3d::next;
}
if(local5 != null) {
break;
}
}
local14 = local14.alternativa3d::next;
}
if(local14 != null) {
if(local14.alternativa3d::viewAligned) {
while(param3 != null) {
local17 = param3.alternativa3d::next;
if(param3.alternativa3d::viewAligned) {
local7 = param3.alternativa3d::object.alternativa3d::ml - local11;
if(local7 < -this.threshold) {
param3.alternativa3d::next = local20;
local20 = param3;
} else if(local7 > this.threshold) {
param3.alternativa3d::next = local18;
local18 = param3;
} else {
param3.alternativa3d::next = local19;
local19 = param3;
}
} else {
local4 = param3.alternativa3d::boundVertexList;
while(local4 != null) {
local7 = local4.alternativa3d::cameraZ - local11;
if(local7 < -this.threshold) {
param3.alternativa3d::next = local20;
local20 = param3;
break;
}
if(local7 > this.threshold) {
param3.alternativa3d::next = local18;
local18 = param3;
break;
}
local4 = local4.alternativa3d::next;
}
if(local4 == null) {
param3.alternativa3d::next = local19;
local19 = param3;
}
}
param3 = local17;
}
} else {
while(param3 != null) {
local17 = param3.alternativa3d::next;
if(param3.alternativa3d::viewAligned) {
local6 = param3.alternativa3d::faceStruct.alternativa3d::wrapper;
while(local6 != null) {
local4 = local6.alternativa3d::vertex;
local7 = local4.alternativa3d::cameraX * local8 + local4.alternativa3d::cameraY * local9 + local4.alternativa3d::cameraZ * local10 - local11;
if(local7 < -this.threshold) {
param3.alternativa3d::next = local18;
local18 = param3;
break;
}
if(local7 > this.threshold) {
param3.alternativa3d::next = local20;
local20 = param3;
break;
}
local6 = local6.alternativa3d::next;
}
if(local6 == null) {
param3.alternativa3d::next = local19;
local19 = param3;
}
} else {
local4 = param3.alternativa3d::boundVertexList;
while(local4 != null) {
local7 = local4.alternativa3d::cameraX * local8 + local4.alternativa3d::cameraY * local9 + local4.alternativa3d::cameraZ * local10 - local11;
if(local7 < -this.threshold) {
param3.alternativa3d::next = local18;
local18 = param3;
break;
}
if(local7 > this.threshold) {
param3.alternativa3d::next = local20;
local20 = param3;
break;
}
local4 = local4.alternativa3d::next;
}
if(local4 == null) {
param3.alternativa3d::next = local19;
local19 = param3;
}
}
param3 = local17;
}
}
if(Boolean(local14.alternativa3d::viewAligned) || local11 < 0) {
if(local20 != null) {
if(local20.alternativa3d::next != null) {
this.alternativa3d::drawOOBBGeometry(param1,param2,local20);
} else {
local20.alternativa3d::draw(param1,param2,this.threshold,this);
local20.alternativa3d::destroy();
}
}
while(local19 != null) {
local17 = local19.alternativa3d::next;
local19.alternativa3d::draw(param1,param2,this.threshold,this);
local19.alternativa3d::destroy();
local19 = local17;
}
if(local18 != null) {
if(local18.alternativa3d::next != null) {
this.alternativa3d::drawOOBBGeometry(param1,param2,local18);
} else {
local18.alternativa3d::draw(param1,param2,this.threshold,this);
local18.alternativa3d::destroy();
}
}
} else {
if(local18 != null) {
if(local18.alternativa3d::next != null) {
this.alternativa3d::drawOOBBGeometry(param1,param2,local18);
} else {
local18.alternativa3d::draw(param1,param2,this.threshold,this);
local18.alternativa3d::destroy();
}
}
while(local19 != null) {
local17 = local19.alternativa3d::next;
local19.alternativa3d::draw(param1,param2,this.threshold,this);
local19.alternativa3d::destroy();
local19 = local17;
}
if(local20 != null) {
if(local20.alternativa3d::next != null) {
this.alternativa3d::drawOOBBGeometry(param1,param2,local20);
} else {
local20.alternativa3d::draw(param1,param2,this.threshold,this);
local20.alternativa3d::destroy();
}
}
}
} else {
this.alternativa3d::drawConflictGeometry(param1,param2,param3);
}
}
alternativa3d function drawConflictGeometry(param1:Camera3D, param2:Canvas, param3:VG) : void {
var local4:Canvas = null;
var local5:Face = null;
var local6:Face = null;
var local7:VG = null;
var local8:VG = null;
var local9:VG = null;
var local10:Face = null;
var local11:Face = null;
var local12:Face = null;
var local13:Face = null;
var local14:Face = null;
var local15:Face = null;
var local16:Face = null;
var local17:Face = null;
var local18:Boolean = false;
while(param3 != null) {
local7 = param3.alternativa3d::next;
if(param3.alternativa3d::space == 1) {
param3.alternativa3d::transformStruct(param3.alternativa3d::faceStruct,++param3.alternativa3d::object.alternativa3d::transformId,alternativa3d::ma,alternativa3d::mb,alternativa3d::mc,alternativa3d::md,alternativa3d::me,alternativa3d::mf,alternativa3d::mg,alternativa3d::mh,alternativa3d::mi,alternativa3d::mj,alternativa3d::mk,alternativa3d::ml);
}
if(param3.alternativa3d::sorting == 3) {
param3.alternativa3d::next = local8;
local8 = param3;
} else {
if(param3.alternativa3d::sorting == 2) {
if(local10 != null) {
local11.alternativa3d::processNext = param3.alternativa3d::faceStruct;
} else {
local10 = param3.alternativa3d::faceStruct;
}
local11 = param3.alternativa3d::faceStruct;
local11.alternativa3d::geometry = param3;
while(local11.alternativa3d::processNext != null) {
local11 = local11.alternativa3d::processNext;
local11.alternativa3d::geometry = param3;
}
} else {
if(local12 != null) {
local13.alternativa3d::processNext = param3.alternativa3d::faceStruct;
} else {
local12 = param3.alternativa3d::faceStruct;
}
local13 = param3.alternativa3d::faceStruct;
local13.alternativa3d::geometry = param3;
while(local13.alternativa3d::processNext != null) {
local13 = local13.alternativa3d::processNext;
local13.alternativa3d::geometry = param3;
}
}
param3.alternativa3d::faceStruct = null;
param3.alternativa3d::next = local9;
local9 = param3;
}
param3 = local7;
}
if(local9 != null) {
param3 = local9;
while(param3.alternativa3d::next != null) {
param3 = param3.alternativa3d::next;
}
param3.alternativa3d::next = local8;
} else {
local9 = local8;
}
if(local10 != null) {
local14 = local10;
local11.alternativa3d::processNext = local12;
} else {
local14 = local12;
}
if(local8 != null) {
local8.alternativa3d::faceStruct.alternativa3d::geometry = local8;
local14 = this.collectNode(local8.alternativa3d::faceStruct,local14,param1,this.threshold,true);
local8.alternativa3d::faceStruct = null;
local8 = local8.alternativa3d::next;
while(local8 != null) {
local8.alternativa3d::faceStruct.alternativa3d::geometry = local8;
local14 = this.collectNode(local8.alternativa3d::faceStruct,local14,param1,this.threshold,false);
local8.alternativa3d::faceStruct = null;
local8 = local8.alternativa3d::next;
}
} else if(local10 != null) {
local14 = this.collectNode(null,local14,param1,this.threshold,true);
} else if(local12 != null) {
local14 = param1.alternativa3d::sortByAverageZ(local14);
}
local5 = local14;
while(local5 != null) {
local6 = local5.alternativa3d::processNext;
param3 = local5.alternativa3d::geometry;
local5.alternativa3d::geometry = null;
local18 = local6 == null || param3 != local6.alternativa3d::geometry;
if(local18 || local5.material != local6.material) {
local5.alternativa3d::processNext = null;
if(local18) {
if(local15 != null) {
local16.alternativa3d::processNegative = local14;
local15 = null;
local16 = null;
} else {
local14.alternativa3d::processPositive = local17;
local17 = local14;
local17.alternativa3d::geometry = param3;
}
} else {
if(local15 != null) {
local16.alternativa3d::processNegative = local14;
} else {
local14.alternativa3d::processPositive = local17;
local17 = local14;
local17.alternativa3d::geometry = param3;
local15 = local14;
}
local16 = local14;
}
local14 = local6;
}
local5 = local6;
}
if(param1.debug) {
local4 = param2.alternativa3d::getChildCanvas(true,false);
local14 = local17;
while(local14 != null) {
if(Boolean(local14.alternativa3d::geometry.alternativa3d::debug & Debug.EDGES)) {
local5 = local14;
while(local5 != null) {
Debug.alternativa3d::drawEdges(param1,local4,local5,16711680);
local5 = local5.alternativa3d::processNegative;
}
}
local14 = local14.alternativa3d::processPositive;
}
}
while(local17 != null) {
local14 = local17;
local17 = local14.alternativa3d::processPositive;
local14.alternativa3d::processPositive = null;
param3 = local14.alternativa3d::geometry;
local14.alternativa3d::geometry = null;
local4 = param2.alternativa3d::getChildCanvas(true,false,param3.alternativa3d::object,param3.alternativa3d::alpha,param3.alternativa3d::blendMode,param3.alternativa3d::colorTransform,param3.alternativa3d::filters);
while(local14 != null) {
local6 = local14.alternativa3d::processNegative;
local14.alternativa3d::processNegative = null;
if(local14.material != null) {
if(param3.alternativa3d::viewAligned) {
local14.material.alternativa3d::drawViewAligned(param1,local4,local14,param3.alternativa3d::object.alternativa3d::ml,param3.alternativa3d::tma,param3.alternativa3d::tmb,param3.alternativa3d::tmc,param3.alternativa3d::tmd,param3.alternativa3d::tmtx,param3.alternativa3d::tmty);
} else {
local14.material.alternativa3d::draw(param1,local4,local14,param3.alternativa3d::object.alternativa3d::ml);
}
} else {
while(local14 != null) {
local5 = local14.alternativa3d::processNext;
local14.alternativa3d::processNext = null;
local14 = local5;
}
}
local14 = local6;
}
}
param3 = local9;
while(param3 != null) {
local7 = param3.alternativa3d::next;
param3.alternativa3d::destroy();
param3 = local7;
}
}
private function collectNode(param1:Face, param2:Face, param3:Camera3D, param4:Number, param5:Boolean, param6:Face = null) : Face {
var local7:Wrapper = null;
var local8:Vertex = null;
var local9:Vertex = null;
var local10:Vertex = null;
var local11:Vertex = null;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Face = null;
var local17:Face = null;
var local18:Face = null;
var local19:VG = null;
var local22:Face = null;
var local23:Face = null;
var local24:Face = null;
var local25:Face = null;
var local26:Face = null;
var local28:Number = NaN;
var local29:Number = NaN;
var local30:Number = NaN;
var local31:Number = NaN;
var local32:Number = NaN;
var local33:Number = NaN;
var local34:Number = NaN;
var local35:Number = NaN;
var local36:Number = NaN;
var local37:Number = NaN;
var local38:Number = NaN;
var local39:Number = NaN;
var local40:Number = NaN;
var local41:Number = NaN;
var local42:Number = NaN;
var local43:Number = NaN;
var local44:Number = NaN;
var local45:Boolean = false;
var local46:Boolean = false;
var local47:Number = NaN;
var local48:Face = null;
var local49:Face = null;
var local50:Wrapper = null;
var local51:Wrapper = null;
var local52:Wrapper = null;
var local53:Boolean = false;
var local54:Number = NaN;
if(param1 != null) {
local19 = param1.alternativa3d::geometry;
if(param1.alternativa3d::offset < 0) {
local17 = param1.alternativa3d::processNegative;
local18 = param1.alternativa3d::processPositive;
local12 = Number(param1.alternativa3d::normalX);
local13 = Number(param1.alternativa3d::normalY);
local14 = Number(param1.alternativa3d::normalZ);
local15 = Number(param1.alternativa3d::offset);
} else {
local17 = param1.alternativa3d::processPositive;
local18 = param1.alternativa3d::processNegative;
local12 = -param1.alternativa3d::normalX;
local13 = -param1.alternativa3d::normalY;
local14 = -param1.alternativa3d::normalZ;
local15 = -param1.alternativa3d::offset;
}
param1.alternativa3d::processNegative = null;
param1.alternativa3d::processPositive = null;
if(param1.alternativa3d::wrapper != null) {
local16 = param1;
while(local16.alternativa3d::processNext != null) {
local16 = local16.alternativa3d::processNext;
local16.alternativa3d::geometry = local19;
}
} else {
param1.alternativa3d::geometry = null;
param1 = null;
}
} else {
param1 = param2;
param2 = param1.alternativa3d::processNext;
local16 = param1;
local7 = param1.alternativa3d::wrapper;
local8 = local7.alternativa3d::vertex;
local7 = local7.alternativa3d::next;
local9 = local7.alternativa3d::vertex;
local28 = Number(local8.alternativa3d::cameraX);
local29 = Number(local8.alternativa3d::cameraY);
local30 = Number(local8.alternativa3d::cameraZ);
local31 = local9.alternativa3d::cameraX - local28;
local32 = local9.alternativa3d::cameraY - local29;
local33 = local9.alternativa3d::cameraZ - local30;
local12 = 0;
local13 = 0;
local14 = 1;
local15 = local30;
local34 = 0;
local7 = local7.alternativa3d::next;
while(local7 != null) {
local11 = local7.alternativa3d::vertex;
local35 = local11.alternativa3d::cameraX - local28;
local36 = local11.alternativa3d::cameraY - local29;
local37 = local11.alternativa3d::cameraZ - local30;
local38 = local37 * local32 - local36 * local33;
local39 = local35 * local33 - local37 * local31;
local40 = local36 * local31 - local35 * local32;
local41 = local38 * local38 + local39 * local39 + local40 * local40;
if(local41 > param4) {
local41 = 1 / Math.sqrt(local41);
local12 = local38 * local41;
local13 = local39 * local41;
local14 = local40 * local41;
local15 = local28 * local12 + local29 * local13 + local30 * local14;
break;
}
if(local41 > local34) {
local41 = 1 / Math.sqrt(local41);
local12 = local38 * local41;
local13 = local39 * local41;
local14 = local40 * local41;
local15 = local28 * local12 + local29 * local13 + local30 * local14;
local34 = local41;
}
local7 = local7.alternativa3d::next;
}
}
var local20:Number = local15 - param4;
var local21:Number = local15 + param4;
var local27:Face = param2;
while(local27 != null) {
local26 = local27.alternativa3d::processNext;
local7 = local27.alternativa3d::wrapper;
local8 = local7.alternativa3d::vertex;
local7 = local7.alternativa3d::next;
local9 = local7.alternativa3d::vertex;
local7 = local7.alternativa3d::next;
local10 = local7.alternativa3d::vertex;
local7 = local7.alternativa3d::next;
local42 = local8.alternativa3d::cameraX * local12 + local8.alternativa3d::cameraY * local13 + local8.alternativa3d::cameraZ * local14;
local43 = local9.alternativa3d::cameraX * local12 + local9.alternativa3d::cameraY * local13 + local9.alternativa3d::cameraZ * local14;
local44 = local10.alternativa3d::cameraX * local12 + local10.alternativa3d::cameraY * local13 + local10.alternativa3d::cameraZ * local14;
local45 = local42 < local20 || local43 < local20 || local44 < local20;
local46 = local42 > local21 || local43 > local21 || local44 > local21;
while(local7 != null) {
local11 = local7.alternativa3d::vertex;
local47 = local11.alternativa3d::cameraX * local12 + local11.alternativa3d::cameraY * local13 + local11.alternativa3d::cameraZ * local14;
if(local47 < local20) {
local45 = true;
} else if(local47 > local21) {
local46 = true;
}
local11.alternativa3d::offset = local47;
local7 = local7.alternativa3d::next;
}
if(!local45) {
if(!local46) {
if(param1 != null) {
local16.alternativa3d::processNext = local27;
} else {
param1 = local27;
}
local16 = local27;
} else {
if(local24 != null) {
local25.alternativa3d::processNext = local27;
} else {
local24 = local27;
}
local25 = local27;
}
} else if(!local46) {
if(local22 != null) {
local23.alternativa3d::processNext = local27;
} else {
local22 = local27;
}
local23 = local27;
} else {
local8.alternativa3d::offset = local42;
local9.alternativa3d::offset = local43;
local10.alternativa3d::offset = local44;
local48 = local27.alternativa3d::create();
local48.material = local27.material;
local48.alternativa3d::geometry = local27.alternativa3d::geometry;
param3.alternativa3d::lastFace.alternativa3d::next = local48;
param3.alternativa3d::lastFace = local48;
local49 = local27.alternativa3d::create();
local49.material = local27.material;
local49.alternativa3d::geometry = local27.alternativa3d::geometry;
param3.alternativa3d::lastFace.alternativa3d::next = local49;
param3.alternativa3d::lastFace = local49;
local50 = null;
local51 = null;
local7 = local27.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next;
while(local7.alternativa3d::next != null) {
local7 = local7.alternativa3d::next;
}
local8 = local7.alternativa3d::vertex;
local42 = Number(local8.alternativa3d::offset);
local53 = local27.material != null && Boolean(local27.material.alternativa3d::useVerticesNormals);
local7 = local27.alternativa3d::wrapper;
while(local7 != null) {
local9 = local7.alternativa3d::vertex;
local43 = Number(local9.alternativa3d::offset);
if(local42 < local20 && local43 > local21 || local42 > local21 && local43 < local20) {
local54 = (local15 - local42) / (local43 - local42);
local11 = local9.alternativa3d::create();
param3.alternativa3d::lastVertex.alternativa3d::next = local11;
param3.alternativa3d::lastVertex = local11;
local11.alternativa3d::cameraX = local8.alternativa3d::cameraX + (local9.alternativa3d::cameraX - local8.alternativa3d::cameraX) * local54;
local11.alternativa3d::cameraY = local8.alternativa3d::cameraY + (local9.alternativa3d::cameraY - local8.alternativa3d::cameraY) * local54;
local11.alternativa3d::cameraZ = local8.alternativa3d::cameraZ + (local9.alternativa3d::cameraZ - local8.alternativa3d::cameraZ) * local54;
local11.u = local8.u + (local9.u - local8.u) * local54;
local11.v = local8.v + (local9.v - local8.v) * local54;
if(local53) {
local11.x = local8.x + (local9.x - local8.x) * local54;
local11.y = local8.y + (local9.y - local8.y) * local54;
local11.z = local8.z + (local9.z - local8.z) * local54;
local11.normalX = local8.normalX + (local9.normalX - local8.normalX) * local54;
local11.normalY = local8.normalY + (local9.normalY - local8.normalY) * local54;
local11.normalZ = local8.normalZ + (local9.normalZ - local8.normalZ) * local54;
}
local52 = local7.alternativa3d::create();
local52.alternativa3d::vertex = local11;
if(local50 != null) {
local50.alternativa3d::next = local52;
} else {
local48.alternativa3d::wrapper = local52;
}
local50 = local52;
local52 = local7.alternativa3d::create();
local52.alternativa3d::vertex = local11;
if(local51 != null) {
local51.alternativa3d::next = local52;
} else {
local49.alternativa3d::wrapper = local52;
}
local51 = local52;
}
if(local43 <= local21) {
local52 = local7.alternativa3d::create();
local52.alternativa3d::vertex = local9;
if(local50 != null) {
local50.alternativa3d::next = local52;
} else {
local48.alternativa3d::wrapper = local52;
}
local50 = local52;
}
if(local43 >= local20) {
local52 = local7.alternativa3d::create();
local52.alternativa3d::vertex = local9;
if(local51 != null) {
local51.alternativa3d::next = local52;
} else {
local49.alternativa3d::wrapper = local52;
}
local51 = local52;
}
local8 = local9;
local42 = local43;
local7 = local7.alternativa3d::next;
}
if(local22 != null) {
local23.alternativa3d::processNext = local48;
} else {
local22 = local48;
}
local23 = local48;
if(local24 != null) {
local25.alternativa3d::processNext = local49;
} else {
local24 = local49;
}
local25 = local49;
local27.alternativa3d::processNext = null;
local27.alternativa3d::geometry = null;
}
local27 = local26;
}
if(local18 != null) {
local18.alternativa3d::geometry = local19;
if(local25 != null) {
local25.alternativa3d::processNext = null;
}
param6 = this.collectNode(local18,local24,param3,param4,param5,param6);
} else if(local24 != null) {
if(param5 && local24 != local25) {
if(local25 != null) {
local25.alternativa3d::processNext = null;
}
if(local24.alternativa3d::geometry.alternativa3d::sorting == 2) {
param6 = this.collectNode(null,local24,param3,param4,param5,param6);
} else {
local24 = param3.alternativa3d::sortByAverageZ(local24);
local25 = local24.alternativa3d::processNext;
while(local25.alternativa3d::processNext != null) {
local25 = local25.alternativa3d::processNext;
}
local25.alternativa3d::processNext = param6;
param6 = local24;
}
} else {
local25.alternativa3d::processNext = param6;
param6 = local24;
}
}
if(param1 != null) {
local16.alternativa3d::processNext = param6;
param6 = param1;
}
if(local17 != null) {
local17.alternativa3d::geometry = local19;
if(local23 != null) {
local23.alternativa3d::processNext = null;
}
param6 = this.collectNode(local17,local22,param3,param4,param5,param6);
} else if(local22 != null) {
if(param5 && local22 != local23) {
if(local23 != null) {
local23.alternativa3d::processNext = null;
}
if(local22.alternativa3d::geometry.alternativa3d::sorting == 2) {
param6 = this.collectNode(null,local22,param3,param4,param5,param6);
} else {
local22 = param3.alternativa3d::sortByAverageZ(local22);
local23 = local22.alternativa3d::processNext;
while(local23.alternativa3d::processNext != null) {
local23 = local23.alternativa3d::processNext;
}
local23.alternativa3d::processNext = param6;
param6 = local22;
}
} else {
local23.alternativa3d::processNext = param6;
param6 = local22;
}
}
return param6;
}
}
}
|
package alternativa.register
{
import alternativa.types.Long;
public class ClassInfo
{
public var id:Long;
public var parent:Long;
public var name:String;
public var modelsToAdd:Array;
public var modelsToRemove:Array;
public function ClassInfo(id:Long, parent:Long, name:String, modelsToAdd:Array, modelsToRemove:Array)
{
super();
this.id = id;
this.parent = parent;
this.name = name;
this.modelsToAdd = modelsToAdd;
this.modelsToRemove = modelsToRemove;
}
}
}
|
package projects.tanks.client.entrance.model.entrance.changeuid {
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 ChangeUidModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _changeUidId:Long = Long.getLong(247566950,622966367);
private var _changeUid_emailCodec:ICodec;
private var _changeUid_hashCodec:ICodec;
private var _changeUid_newUidCodec:ICodec;
private var _changeUidAndPasswordId:Long = Long.getLong(789349339,-796680627);
private var _changeUidAndPassword_emailCodec:ICodec;
private var _changeUidAndPassword_hashCodec:ICodec;
private var _changeUidAndPassword_newUidCodec:ICodec;
private var _changeUidAndPassword_passwordCodec:ICodec;
private var _changeUidViaPartnerId:Long = Long.getLong(856618611,-953780377);
private var _changeUidViaPartner_newUidCodec:ICodec;
private var _checkChangeUidParamsId:Long = Long.getLong(1157412751,1480217791);
private var _checkChangeUidParams_changeUidHashCodec:ICodec;
private var _checkChangeUidParams_emailCodec:ICodec;
private var model:IModel;
public function ChangeUidModelServer(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._changeUid_emailCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._changeUid_hashCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._changeUid_newUidCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._changeUidAndPassword_emailCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._changeUidAndPassword_hashCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._changeUidAndPassword_newUidCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._changeUidAndPassword_passwordCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._changeUidViaPartner_newUidCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._checkChangeUidParams_changeUidHashCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._checkChangeUidParams_emailCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function changeUid(param1:String, param2:String, param3:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._changeUid_emailCodec.encode(this.protocolBuffer,param1);
this._changeUid_hashCodec.encode(this.protocolBuffer,param2);
this._changeUid_newUidCodec.encode(this.protocolBuffer,param3);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local4:SpaceCommand = new SpaceCommand(Model.object.id,this._changeUidId,this.protocolBuffer);
var local5:IGameObject = Model.object;
var local6:ISpace = local5.space;
local6.commandSender.sendCommand(local4);
this.protocolBuffer.optionalMap.clear();
}
public function changeUidAndPassword(param1:String, param2:String, param3:String, param4:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._changeUidAndPassword_emailCodec.encode(this.protocolBuffer,param1);
this._changeUidAndPassword_hashCodec.encode(this.protocolBuffer,param2);
this._changeUidAndPassword_newUidCodec.encode(this.protocolBuffer,param3);
this._changeUidAndPassword_passwordCodec.encode(this.protocolBuffer,param4);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local5:SpaceCommand = new SpaceCommand(Model.object.id,this._changeUidAndPasswordId,this.protocolBuffer);
var local6:IGameObject = Model.object;
var local7:ISpace = local6.space;
local7.commandSender.sendCommand(local5);
this.protocolBuffer.optionalMap.clear();
}
public function changeUidViaPartner(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._changeUidViaPartner_newUidCodec.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._changeUidViaPartnerId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function checkChangeUidParams(param1:String, param2:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._checkChangeUidParams_changeUidHashCodec.encode(this.protocolBuffer,param1);
this._checkChangeUidParams_emailCodec.encode(this.protocolBuffer,param2);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local3:SpaceCommand = new SpaceCommand(Model.object.id,this._checkChangeUidParamsId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p20 extends BitmapAsset
{
public function RangsIcon_p20()
{
super();
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _faa7699ec6a5ca1f66e860b3130cac15084d2d971ff9ba050717235992e0d090_flash_display_Sprite extends Sprite {
public function _faa7699ec6a5ca1f66e860b3130cac15084d2d971ff9ba050717235992e0d090_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package forms.premium {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.premium.PremiumItemLock_premiumItemLockClass.png")]
public class PremiumItemLock_premiumItemLockClass extends BitmapAsset {
public function PremiumItemLock_premiumItemLockClass() {
super();
}
}
}
|
package alternativa.tanks.service.achievement {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.service.achievement.AchievementService_bitmapPresent.png")]
public class AchievementService_bitmapPresent extends BitmapAsset {
public function AchievementService_bitmapPresent() {
super();
}
}
}
|
package alternativa.tanks.gui.present.give {
import flash.events.Event;
public class CheckUidEvent extends Event {
public static var CHECK_UID:String = "CheckUidEvent.CHECK_UID";
public var uid:String;
public function CheckUidEvent(param1:String) {
super(CHECK_UID);
this.uid = param1;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.gearscore {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.gearscore.BattleGearScoreCC;
public class VectorCodecBattleGearScoreCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattleGearScoreCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BattleGearScoreCC,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.<BattleGearScoreCC> = new Vector.<BattleGearScoreCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattleGearScoreCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattleGearScoreCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattleGearScoreCC> = Vector.<BattleGearScoreCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_mineBgdClass.png")]
public class HudInventoryIcon_mineBgdClass extends BitmapAsset {
public function HudInventoryIcon_mineBgdClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.shared.streamweapon {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.objects.tank.Weapon;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IStreamWeaponCallbackEvents implements IStreamWeaponCallback {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IStreamWeaponCallbackEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function start(param1:int) : void {
var i:int = 0;
var m:IStreamWeaponCallback = null;
var time:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IStreamWeaponCallback(this.impl[i]);
m.start(time);
i++;
}
}
finally {
Model.popObject();
}
}
public function stop(param1:int) : void {
var i:int = 0;
var m:IStreamWeaponCallback = null;
var time:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IStreamWeaponCallback(this.impl[i]);
m.stop(time);
i++;
}
}
finally {
Model.popObject();
}
}
public function onTick(param1:Weapon, param2:Vector.<Body>, param3:Vector.<Number>, param4:Vector.<Vector3>, param5:int) : void {
var i:int = 0;
var m:IStreamWeaponCallback = null;
var weapon:Weapon = param1;
var bodies:Vector.<Body> = param2;
var distances:Vector.<Number> = param3;
var hitPositions:Vector.<Vector3> = param4;
var time:int = param5;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IStreamWeaponCallback(this.impl[i]);
m.onTick(weapon,bodies,distances,hitPositions,time);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.gfx.agal
{
public class SamplerOption
{
public var mask:uint;
public var flag:uint;
public function SamplerOption(param1:uint, param2:uint)
{
super();
this.mask = param1;
this.flag = param2;
}
public function apply(param1:int) : int
{
param1 &= ~(15 << this.flag);
return int(param1 | this.mask << this.flag);
}
}
}
|
package scpacker.gui.en
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksIEN_coldload6 extends BitmapAsset
{
public function GTanksIEN_coldload6()
{
super();
}
}
}
|
package alternativa.tanks.gui.panel.buttons {
import alternativa.tanks.service.clan.ClanPanelNotificationEvent;
import alternativa.tanks.service.clan.ClanPanelNotificationService;
import controls.base.MainPanelClanButtonBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.events.Event;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.RestrictionJoinClanEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
public class ClanButton extends MainPanelClanButtonBase {
[Inject]
public static var clanPanelNotificationService:ClanPanelNotificationService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
public static var attentionIconClass:Class = ClanButton_attentionIconClass;
private static var attentionIconBitmapData:BitmapData = Bitmap(new attentionIconClass()).bitmapData;
private var _attentionIcon:Bitmap = new Bitmap(attentionIconBitmapData);
public function ClanButton() {
super();
clanPanelNotificationService.addEventListener(ClanPanelNotificationEvent.UPDATE,this.update);
clanPanelNotificationService.addEventListener(RestrictionJoinClanEvent.UPDATE,this.update);
this._attentionIcon.x = 72;
this._attentionIcon.y = -4;
addChild(this._attentionIcon);
this.update();
setIconCoords(8,3);
}
override public function set enable(param1:Boolean) : void {
if(lobbyLayoutService.getCurrentState() == LayoutState.CLAN && !clanUserInfoService.selfClan) {
param1 = true;
}
super.enable = param1;
this.update();
}
public function update(param1:Event = null) : void {
if(enable) {
this._attentionIcon.visible = clanPanelNotificationService.numberNotification() > 0;
} else {
this._attentionIcon.visible = false;
}
}
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased.flag {
public class FlagState {
public static const AT_BASE:FlagState = new FlagState(0,"AT_BASE");
public static const DROPPED:FlagState = new FlagState(1,"DROPPED");
public static const CARRIED:FlagState = new FlagState(2,"CARRIED");
public static const EXILED:FlagState = new FlagState(3,"EXILED");
public static const FLYING:FlagState = new FlagState(4,"FLYING");
private var _value:int;
private var _name:String;
public function FlagState(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<FlagState> {
var local1:Vector.<FlagState> = new Vector.<FlagState>();
local1.push(AT_BASE);
local1.push(DROPPED);
local1.push(CARRIED);
local1.push(EXILED);
local1.push(FLYING);
return local1;
}
public function toString() : String {
return "FlagState [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.resource
{
import alternativa.init.Main;
import alternativa.osgi.bundle.Bundle;
import alternativa.osgi.service.debug.IDebugService;
import flash.display.Loader;
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import flash.system.SecurityDomain;
public class LibraryResource extends Resource
{
private static const LOADING_STATE_MANIFEST:int = LOADING_STATE_INFO + 1;
private static const LOADING_STATE_LIBRARY:int = LOADING_STATE_INFO + 2;
private static const LIB_FILE_NAME:String = "library";
private static const LIB_FILE_NAME_DEBUG:String = "debug";
private var libraryLoader:Loader;
private var manifestLoader:URLLoader;
private var bundle:Bundle;
public function LibraryResource()
{
super("Библиотека");
}
override protected function doUnload() : void
{
if(this.libraryLoader == null)
{
return;
}
this.libraryLoader.unload();
this.destroyLibraryLoader();
this.destroyManifestLoader();
Main.osgi.uninstallBundle(this.bundle);
this.bundle = null;
}
override protected function doClose() : void
{
switch(loadingState)
{
case LOADING_STATE_MANIFEST:
this.manifestLoader.close();
this.destroyManifestLoader();
this.libraryLoader.unload();
this.destroyLibraryLoader();
break;
case LOADING_STATE_LIBRARY:
this.libraryLoader.close();
this.destroyLibraryLoader();
}
}
override protected function loadResourceData() : void
{
this.libraryLoader = new Loader();
this.libraryLoader.contentLoaderInfo.addEventListener(Event.OPEN,this.onLibraryLoadingOpen);
this.libraryLoader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,this.onLoadingProgress);
this.libraryLoader.contentLoaderInfo.addEventListener(Event.COMPLETE,this.onLibraryLoadingComplete);
this.libraryLoader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadingError);
this.libraryLoader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadingError);
var isDebug:Boolean = Main.osgi.getService(IDebugService) != null;
var libFileName:String = !!isDebug ? LIB_FILE_NAME_DEBUG : LIB_FILE_NAME;
if(locale_postfix != null)
{
libFileName += locale_postfix;
}
var libUrl:String = url + libFileName + ".swf";
this.libraryLoader.load(new URLRequest(libUrl),new LoaderContext(false,ApplicationDomain.currentDomain,SecurityDomain.currentDomain));
startTimeoutTimer();
}
private function onLibraryLoadingOpen(event:Event) : void
{
loadingState = LOADING_STATE_LIBRARY;
}
private function onLibraryLoadingComplete(e:Event) : void
{
setIdleLoadingState();
this.manifestLoader = new URLLoader();
this.manifestLoader.addEventListener(Event.OPEN,this.onManifestLoadingOpen);
this.manifestLoader.addEventListener(ProgressEvent.PROGRESS,this.onLoadingProgress);
this.manifestLoader.addEventListener(Event.COMPLETE,this.onManifestLoadingComplete);
this.manifestLoader.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadingError);
this.manifestLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadingError);
var manifestFileName:String = locale_postfix == null ? "MANIFEST.MF" : "MANIFEST" + locale_postfix + ".MF";
this.manifestLoader.load(new URLRequest(url + manifestFileName));
startTimeoutTimer();
}
private function onManifestLoadingOpen(event:Event) : void
{
loadingState = LOADING_STATE_MANIFEST;
}
private function onManifestLoadingComplete(e:Event) : void
{
setIdleLoadingState();
this.bundle = Main.osgi.installBundle(this.manifestLoader.data);
this.destroyManifestLoader();
completeLoading();
}
private function onLoadingProgress(e:ProgressEvent) : void
{
loadingProgress(e.bytesLoaded,e.bytesTotal);
}
private function onLoadingError(e:ErrorEvent) : void
{
reportFatalError(e.text);
}
private function destroyManifestLoader() : void
{
if(this.manifestLoader == null)
{
return;
}
this.manifestLoader.removeEventListener(Event.OPEN,this.onManifestLoadingOpen);
this.manifestLoader.removeEventListener(ProgressEvent.PROGRESS,this.onLoadingProgress);
this.manifestLoader.removeEventListener(Event.COMPLETE,this.onManifestLoadingComplete);
this.manifestLoader.removeEventListener(IOErrorEvent.IO_ERROR,this.onLoadingError);
this.manifestLoader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadingError);
this.manifestLoader = null;
}
private function destroyLibraryLoader() : void
{
if(this.libraryLoader == null)
{
return;
}
this.libraryLoader.contentLoaderInfo.removeEventListener(Event.OPEN,this.onLibraryLoadingOpen);
this.libraryLoader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS,this.onLoadingProgress);
this.libraryLoader.contentLoaderInfo.removeEventListener(Event.COMPLETE,this.onLibraryLoadingComplete);
this.libraryLoader.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,this.onLoadingError);
this.libraryLoader.contentLoaderInfo.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadingError);
this.libraryLoader = null;
}
}
}
|
package com.lorentz.SVG.data.path
{
public class SVGMoveToCommand extends SVGPathCommand
{
public var x:Number = 0;
public var y:Number = 0;
public var absolute:Boolean = false;
public function SVGMoveToCommand(absolute:Boolean, x:Number = 0, y:Number = 0)
{
super();
this.absolute = absolute;
this.x = x;
this.y = y;
}
override public function get type():String {
return absolute ? "M" : "m";
}
override public function clone():Object {
var copy:SVGMoveToCommand = new SVGMoveToCommand(absolute);
copy.x = x;
copy.y = y;
return copy;
}
}
} |
package alternativa.tanks.models.weapon.shaft.cameracontrollers {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.weapon.shaft.cameracontrollers.AimingCameraController_Cross.png")]
public class AimingCameraController_Cross extends BitmapAsset {
public function AimingCameraController_Cross() {
super();
}
}
}
|
package scpacker.test.anticheat
{
import alternativa.tanks.models.battlefield.BattlefieldModel;
import com.reygazu.anticheat.variables.SecureInt;
import flash.events.TimerEvent;
import flash.utils.Timer;
import flash.utils.getTimer;
public class SpeedHackChecker
{
private const checkInterval:SecureInt = new SecureInt("checkInterval");
private const threshold:SecureInt = new SecureInt("threshold");
private const maxErrors:SecureInt = new SecureInt("maxErrors");
private var errorCounter:SecureInt;
private var battleEventDispatcher:BattlefieldModel;
private var timer:Timer;
private var localTime:int;
private var systemTime:Number;
private var deltas:Array;
public function SpeedHackChecker(param1:BattlefieldModel)
{
this.errorCounter = new SecureInt("errorCounter");
super();
this.checkInterval.value = 5000;
this.threshold.value = 300;
this.maxErrors.value = 3;
this.errorCounter.value = 0;
this.deltas = [];
this.battleEventDispatcher = param1;
this.localTime = getTimer();
this.systemTime = new Date().time;
this.timer = new Timer(this.checkInterval.value);
this.timer.addEventListener(TimerEvent.TIMER,this.onTimer);
this.timer.start();
}
public function stop() : void
{
this.timer.stop();
}
private function onTimer(param1:TimerEvent) : void
{
var _timer:int = getTimer();
var _systemTime:Number = new Date().time;
var delta:Number = _timer - this.localTime - _systemTime + this.systemTime;
if(Math.abs(delta) > this.threshold.value)
{
this.deltas.push(delta);
this.errorCounter.value += 1;
if(this.errorCounter.value >= this.maxErrors.value)
{
this.stop();
this.battleEventDispatcher.cheatDetected();
}
}
else
{
this.errorCounter.value = 0;
this.deltas.length = 0;
}
this.localTime = _timer;
this.systemTime = _systemTime;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.sfx.smoke {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import projects.tanks.client.battlefield.models.tankparts.sfx.smoke.HullSmokeCC;
public class CodecHullSmokeCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_alpha:ICodec;
private var codec_density:ICodec;
private var codec_enabled:ICodec;
private var codec_fadeTime:ICodec;
private var codec_farDistance:ICodec;
private var codec_nearDistance:ICodec;
private var codec_particle:ICodec;
private var codec_size:ICodec;
public function CodecHullSmokeCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_alpha = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_density = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_enabled = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_fadeTime = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_farDistance = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_nearDistance = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_particle = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,true));
this.codec_size = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:HullSmokeCC = new HullSmokeCC();
local2.alpha = this.codec_alpha.decode(param1) as Number;
local2.density = this.codec_density.decode(param1) as Number;
local2.enabled = this.codec_enabled.decode(param1) as Boolean;
local2.fadeTime = this.codec_fadeTime.decode(param1) as int;
local2.farDistance = this.codec_farDistance.decode(param1) as Number;
local2.nearDistance = this.codec_nearDistance.decode(param1) as Number;
local2.particle = this.codec_particle.decode(param1) as MultiframeTextureResource;
local2.size = this.codec_size.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:HullSmokeCC = HullSmokeCC(param2);
this.codec_alpha.encode(param1,local3.alpha);
this.codec_density.encode(param1,local3.density);
this.codec_enabled.encode(param1,local3.enabled);
this.codec_fadeTime.encode(param1,local3.fadeTime);
this.codec_farDistance.encode(param1,local3.farDistance);
this.codec_nearDistance.encode(param1,local3.nearDistance);
this.codec_particle.encode(param1,local3.particle);
this.codec_size.encode(param1,local3.size);
}
}
}
|
package alternativa.tanks.model.garage.present {
import alternativa.tanks.gui.GarageWindowEvent;
import alternativa.tanks.gui.IGarageWindow;
import alternativa.tanks.service.garage.GarageService;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.type.impl.GameObject;
import projects.tanks.client.commons.types.ItemViewCategoryEnum;
import projects.tanks.client.garage.models.user.present.IPresentProfileModelBase;
import projects.tanks.client.garage.models.user.present.PresentItem;
import projects.tanks.client.garage.models.user.present.PresentProfileModelBase;
[ModelInfo]
public class PresentProfileModel extends PresentProfileModelBase implements IPresentProfileModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var garageService:GarageService;
public function PresentProfileModel() {
super();
}
public function objectLoaded() : void {
var local2:PresentItem = null;
var local3:GameObject = null;
var local1:IGarageWindow = garageService.getView();
for each(local2 in getInitParam().presents) {
local3 = new GameObject(local2.id,null,"",object.space);
local3.addComponent(new UserPresentComponent(local2));
local1.addItemToDepot(local3);
}
local1.setCategoryButtonVisibility(ItemViewCategoryEnum.GIVEN_PRESENTS,getInitParam().presents.length > 0);
local1.addEventListener(GarageWindowEvent.DELETE_PRESENT,getFunctionWrapper(this.onDeletePresentClick));
}
public function objectUnloaded() : void {
var local1:IGarageWindow = garageService.getView();
if(local1 != null) {
local1.removeEventListener(GarageWindowEvent.DELETE_PRESENT,getFunctionWrapper(this.onDeletePresentClick));
}
}
private function onDeletePresentClick(param1:GarageWindowEvent) : void {
PresentGiven(object.adapt(PresentGiven)).removePresent(param1.item.id);
}
}
}
|
package platform.client.fp10.core.service.errormessage.impl {
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.BitmapFilterQuality;
import flash.filters.DropShadowFilter;
import flash.geom.Point;
import flash.text.AntiAliasType;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFieldType;
import flash.text.TextFormat;
import platform.client.fp10.core.service.errormessage.IMessageBox;
import platform.client.fp10.core.service.errormessage.errors.ErrorType;
public class DefaultMessageWindow extends Sprite implements IMessageBox {
private var tfMessage:TextField;
private var buttonOk:Button;
private var _currentSize:Point;
public function DefaultMessageWindow() {
super();
mouseEnabled = false;
tabEnabled = false;
this.createMessageField();
this.createButton();
this._currentSize = new Point(300,200);
this.filters = [new DropShadowFilter(3,70,0,0.5,2,2,1,BitmapFilterQuality.MEDIUM,false,false,false)];
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
}
private function createButton() : void {
this.buttonOk = new Button("Close");
this.buttonOk.addEventListener(MouseEvent.CLICK,this.onOkButtonClick);
addChild(this.buttonOk);
}
public function hide() : void {
if(parent != null) {
parent.removeChild(this);
}
}
private function createMessageField() : void {
this.tfMessage = new TextField();
this.tfMessage.thickness = 50;
this.tfMessage.sharpness = -50;
this.tfMessage.width = 250;
this.tfMessage.y = 25;
this.tfMessage.defaultTextFormat = new TextFormat("Tahoma",11,0);
this.tfMessage.type = TextFieldType.DYNAMIC;
this.tfMessage.autoSize = TextFieldAutoSize.CENTER;
this.tfMessage.antiAliasType = AntiAliasType.ADVANCED;
this.tfMessage.embedFonts = false;
this.tfMessage.selectable = true;
this.tfMessage.multiline = true;
this.tfMessage.wordWrap = true;
addChild(this.tfMessage);
}
public function set text(param1:String) : void {
this.tfMessage.text = param1;
this._currentSize.x = Math.max(Math.round(this.tfMessage.length * 0.5),300);
this.tfMessage.width = this._currentSize.x - 50;
this.tfMessage.x = Math.round((this._currentSize.x - this.tfMessage.textWidth) * 0.5);
this.repaint();
this.align();
}
public function get currentSize() : Point {
return this._currentSize;
}
private function repaint() : void {
this._currentSize.y = 25 + this.tfMessage.textHeight + 30 + this.buttonOk.height;
this.graphics.clear();
this.graphics.beginFill(13421772,1);
this.graphics.drawRoundRect(0,0,this._currentSize.x,this._currentSize.y,5,5);
this.buttonOk.repaint();
this.buttonOk.x = Math.round((this._currentSize.x - this.buttonOk.width) * 0.5);
this.buttonOk.y = Math.round(this._currentSize.y - 15 - this.buttonOk.height);
}
private function onAddedToStage(param1:Event) : void {
this.repaint();
this.align();
}
private function align() : void {
if(stage != null) {
x = stage.stageWidth - width >> 1;
y = stage.stageHeight - height >> 1;
}
}
private function onOkButtonClick(param1:MouseEvent) : void {
this.hide();
}
public function getDisplayObject(param1:ErrorType) : DisplayObject {
this.text = param1.getMessage();
return this;
}
}
}
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.InteractiveObject;
import flash.display.Sprite;
import flash.events.EventDispatcher;
import flash.text.AntiAliasType;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFieldType;
import flash.text.TextFormat;
class Button extends Sprite {
private static const H_MARGIN:int = 20;
private static const V_MARGIN:int = 5;
private var tfCaption:TextField;
public function Button(param1:String) {
super();
this.createCaptionTextField();
this.caption = param1;
}
public function set caption(param1:String) : void {
this.tfCaption.text = param1;
this.repaint();
}
public function repaint() : void {
if(stage == null) {
return;
}
var local1:int = this.tfCaption.textWidth + 2 * H_MARGIN;
var local2:int = this.tfCaption.textHeight + 2 * V_MARGIN;
this.tfCaption.x = local1 - this.tfCaption.textWidth >> 1;
this.tfCaption.y = local2 - this.tfCaption.textHeight >> 1;
graphics.beginFill(16777215,1);
graphics.lineStyle(0,6710886);
graphics.drawRoundRect(0,0,local1,local2,5,5);
}
private function createCaptionTextField() : void {
this.tfCaption = new TextField();
this.tfCaption.thickness = 50;
this.tfCaption.sharpness = -50;
this.tfCaption.defaultTextFormat = new TextFormat("Tahoma",12,0,true);
this.tfCaption.type = TextFieldType.DYNAMIC;
this.tfCaption.autoSize = TextFieldAutoSize.LEFT;
this.tfCaption.antiAliasType = AntiAliasType.ADVANCED;
this.tfCaption.embedFonts = false;
this.tfCaption.selectable = false;
this.tfCaption.multiline = false;
this.tfCaption.mouseEnabled = false;
this.tfCaption.tabEnabled = false;
addChild(this.tfCaption);
}
}
|
package assets.input {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.input.InputLeftWrong.png")]
public dynamic class InputLeftWrong extends BitmapData {
public function InputLeftWrong(param1:int = 5, param2:int = 30) {
super(param1,param2);
}
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased.rugby {
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 RugbyModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:RugbyModelServer;
private var client:IRugbyModelBase = IRugbyModelBase(this);
private var modelId:Long = Long.getLong(609576527,-1597926084);
public function RugbyModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new RugbyModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(RugbyCC,false)));
}
protected function getInitParam() : RugbyCC {
return RugbyCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package com.lorentz.SVG.drawing
{
import com.lorentz.SVG.utils.ArcUtils;
import com.lorentz.SVG.utils.Bezier;
import com.lorentz.SVG.utils.FlashPlayerUtils;
import flash.display.GraphicsPathCommand;
import flash.geom.Point;
public class GraphicsPathDrawer implements IDrawer
{
public var commands:Vector.<int>;
public var pathData:Vector.<Number>;
private var _penX:Number = 0;
public function get penX():Number {
return _penX;
}
private var _penY:Number = 0;
public function get penY():Number {
return _penY;
}
public function GraphicsPathDrawer()
{
commands = new Vector.<int>();
pathData = new Vector.<Number>();
}
public function moveTo(x:Number, y:Number):void
{
commands.push(GraphicsPathCommand.MOVE_TO);
pathData.push(x, y);
_penX = x; _penY = y;
}
public function lineTo(x:Number, y:Number):void
{
commands.push(GraphicsPathCommand.LINE_TO);
pathData.push(x, y);
_penX = x; _penY = y;
}
public function curveTo(cx:Number, cy:Number, x:Number, y:Number):void
{
commands.push(GraphicsPathCommand.CURVE_TO);
pathData.push(cx, cy, x, y);
_penX = x; _penY = y;
}
public function cubicCurveTo(cx1:Number, cy1:Number, cx2:Number, cy2:Number, x:Number, y:Number):void
{
if(FlashPlayerUtils.supportsCubicCurves)
{
commands.push(GraphicsPathCommand["CUBIC_CURVE_TO"]);
pathData.push(cx1, cy1, cx2, cy2, x, y);
_penX = x; _penY = y;
} else {
//Convert cubic curve to quadratic curves
var anchor1:Point = new Point(_penX, _penY);
var control1:Point = new Point(cx1, cy1);
var control2:Point = new Point(cx2, cy2);
var anchor2:Point = new Point(x, y);
var bezier:Bezier = new Bezier(anchor1, control1, control2, anchor2);
for each (var quadP:Object in bezier.QPts)
curveTo(quadP.c.x, quadP.c.y, quadP.p.x, quadP.p.y);
}
}
public function arcTo(rx:Number, ry:Number, angle:Number, largeArcFlag:Boolean, sweepFlag:Boolean, x:Number, y:Number):void
{
var ellipticalArc:Object = ArcUtils.computeSvgArc(rx, ry, angle, largeArcFlag, sweepFlag, x, y, _penX, _penY);
var curves:Array = ArcUtils.convertToCurves(ellipticalArc.cx, ellipticalArc.cy, ellipticalArc.startAngle, ellipticalArc.arc, ellipticalArc.radius, ellipticalArc.yRadius, ellipticalArc.xAxisRotation);
// Loop for drawing arc segments
for (var i:int = 0; i<curves.length; i++)
curveTo(curves[i].c.x, curves[i].c.y, curves[i].p.x, curves[i].p.y);
}
}
} |
package alternativa.tanks.model.profile
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
import alternativa.tanks.model.challenge.greenpanel.GreenPanel;
import controls.DefaultButton;
import controls.Label;
import controls.TankWindow;
import controls.TankWindowInner;
import fl.events.ListEvent;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
public class UserGiftsView extends Sprite
{
public static const WINNER_ITEM_ID:int = 9;
private static const ANIMATE_DURATION:int = 9700;
[Embed(source="926.png")]
private static const emptyBitmap:Class;
private var empty:Bitmap;
private var localeService:ILocaleService;
private var window:TankWindow;
public var closeButton:DefaultButton;
private var giftInfoList:UserGiftsInfoList;
private var userInfo:GiftUserInfo;
private var panel:GreenPanel;
private var preview:Bitmap;
private var sender:Label;
private var senderText:Label;
private var nameG:Label;
private var nameText:Label;
private var date:Label;
private var dateText:Label;
private var message:Label;
private var messageText:Label;
private var status:Label;
private var statusText:Label;
private var emptyText:Label;
private var items:Array;
private var selectObj:Object;
private var bitmapData:Object;
public function UserGiftsView(data:Array, parserInfo:Object)
{
this.empty = new Bitmap(new emptyBitmap().bitmapData);
this.panel = new GreenPanel(450,210);
this.window = new TankWindow();
this.closeButton = new DefaultButton();
super();
this.items = data;
this.localeService = ILocaleService(Main.osgi.getService(ILocaleService));
this.window.width = 595 + 108;
this.window.height = this.items.length > 0 ? Number(450) : Number(325);
var inner:TankWindowInner = new TankWindowInner(0,0,TankWindowInner.GREEN);
inner.width = this.window.width - 20;
inner.height = this.window.height - 55;
inner.showBlink = true;
inner.x = 10;
inner.y = 10;
addChild(this.window);
addChild(inner);
this.panel.x = 30;
this.panel.y = 30;
inner.addChild(this.panel);
this.userInfo = new GiftUserInfo(parserInfo.userId,parserInfo.rank,parserInfo.spins,parserInfo.emeralds,parserInfo.incomingGifts,parserInfo.outcomingGifts);
this.userInfo.x = this.panel.x + this.panel.width + 10;
this.userInfo.y = this.panel.y;
inner.addChild(this.userInfo);
if(this.items.length <= 0)
{
this.emptyText = new Label();
this.emptyText.color = 5898034;
this.emptyText.size = 24;
this.emptyText.text = this.localeService.getText(TextConst.PROFILE_WINDOW_EMPTY_TEXT);
this.emptyText.x = this.panel.width / 2 - this.emptyText.width / 2;
this.emptyText.y = 15;
this.panel.addChild(this.emptyText);
this.empty.x = this.panel.width / 2 - this.empty.width / 2;
this.empty.y = this.emptyText.y + 40;
this.panel.addChild(this.empty);
}
this.giftInfoList = new UserGiftsInfoList();
this.giftInfoList.width = this.window.width - 60;
this.giftInfoList.height = 135;
this.giftInfoList.x = 30;
this.giftInfoList.y = inner.height - this.giftInfoList.height + 5;
this.giftInfoList.initData(data,this.successLoaded);
this.giftInfoList.addClickListener(this.selectItem);
addChild(this.giftInfoList);
this.closeButton.label = this.localeService.getText(TextConst.GIFT_WINDOW_CLOSE);
this.closeButton.x = this.window.width - this.closeButton.width - 10;
this.closeButton.y = this.window.height - this.closeButton.height - 11;
addChild(this.closeButton);
}
private function successLoaded(obj:Object) : void
{
this.selectObj = obj.item;
this.bitmapData = obj.preview.bitmapData;
this.loadPanel();
}
private function selectItem(e:ListEvent) : void
{
this.selectObj = e.item.dat.item;
this.bitmapData = e.item.dat.preview.bitmapData;
this.loadPanel();
}
private function loadPanel() : void
{
if(this.selectObj == null || this.bitmapData == null)
{
return;
}
this.showInfo(this.bitmapData);
}
private function showInfo(resource:Object) : void
{
this.removeOld();
this.preview = new Bitmap(this.bitmapData as BitmapData);
this.preview.x = 10;
this.preview.y = 10;
this.panel.addChild(this.preview);
this.sender = new Label();
this.sender.color = 5898034;
this.sender.text = this.localeService.getText(TextConst.PROFILE_WINDOW_SENDER_TEXT);
this.sender.x = this.preview.x + this.preview.width + 10;
this.sender.y = 20;
this.panel.addChild(this.sender);
this.senderText = new Label();
this.senderText.color = 16777215;
this.senderText.text = this.selectObj.userid;
this.senderText.x = this.sender.x + this.sender.width + 5;
this.senderText.y = this.sender.y;
this.panel.addChild(this.senderText);
this.nameG = new Label();
this.nameG.color = 5898034;
this.nameG.text = this.localeService.getText(TextConst.PROFILE_WINDOW_NAME_TEXT);
this.nameG.x = this.preview.x + this.preview.width + 10;
this.nameG.y = this.senderText.y + this.senderText.height + 5;
this.panel.addChild(this.nameG);
this.nameText = new Label();
this.nameText.color = 16777215;
this.nameText.text = this.selectObj.name;
this.nameText.x = this.nameG.x + this.nameG.width + 5;
this.nameText.y = this.nameG.y;
this.panel.addChild(this.nameText);
this.date = new Label();
this.date.color = 5898034;
this.date.text = this.localeService.getText(TextConst.PROFILE_WINDOW_DATE_TEXT);
this.date.x = this.preview.x + this.preview.width + 10;
this.date.y = this.nameText.y + this.nameText.height + 5;
this.panel.addChild(this.date);
this.dateText = new Label();
this.dateText.color = 16777215;
this.dateText.text = this.selectObj.date;
this.dateText.x = this.date.x + this.date.width + 5;
this.dateText.y = this.date.y;
this.panel.addChild(this.dateText);
this.status = new Label();
this.status.color = 5898034;
this.status.text = this.localeService.getText(TextConst.PROFILE_WINDOW_STATUS_TEXT);
this.status.x = this.preview.x + this.preview.width + 10;
this.status.y = this.dateText.y + this.dateText.height + 5;
this.panel.addChild(this.status);
this.statusText = new Label();
this.statusText.color = 16777215;
this.statusText.text = this.selectObj.status.indexOf("Уникаль") > -1 ? "Уникальный" : this.selectObj.status;
this.statusText.x = this.status.x + this.status.width + 5;
this.statusText.y = this.status.y;
this.panel.addChild(this.statusText);
this.message = new Label();
this.message.color = 5898034;
this.message.text = this.localeService.getText(TextConst.PROFILE_WINDOW_MESSAGE_TEXT);
this.message.x = this.preview.x;
this.message.y = this.preview.y + this.preview.height + 5;
this.panel.addChild(this.message);
this.messageText = new Label();
this.messageText.color = 16777215;
this.messageText.htmlText = this.selectObj.message;
this.messageText.x = this.message.x + this.message.width + 5;
this.messageText.y = this.message.y;
this.messageText.width = 350;
this.messageText.multiline = true;
this.messageText.wordWrap = true;
this.panel.addChild(this.messageText);
}
private function removeOld() : void
{
if(this.preview != null)
{
this.panel.removeChild(this.preview);
this.preview = null;
}
if(this.sender != null)
{
this.panel.removeChild(this.sender);
this.sender = null;
}
if(this.senderText != null)
{
this.panel.removeChild(this.senderText);
this.senderText = null;
}
if(this.nameG != null)
{
this.panel.removeChild(this.nameG);
this.nameG = null;
}
if(this.nameText != null)
{
this.panel.removeChild(this.nameText);
this.nameText = null;
}
if(this.date != null)
{
this.panel.removeChild(this.date);
this.date = null;
}
if(this.dateText != null)
{
this.panel.removeChild(this.dateText);
this.dateText = null;
}
if(this.status != null)
{
this.panel.removeChild(this.status);
this.status = null;
}
if(this.statusText != null)
{
this.panel.removeChild(this.statusText);
this.statusText = null;
}
if(this.message != null)
{
this.panel.removeChild(this.message);
this.message = null;
}
if(this.messageText != null)
{
this.panel.removeChild(this.messageText);
this.messageText = null;
}
}
}
}
|
package controls.chat {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.chat.BattleChatInput_bitmapRC.png")]
public class BattleChatInput_bitmapRC extends BitmapAsset {
public function BattleChatInput_bitmapRC() {
super();
}
}
}
|
package alternativa.tanks.utils {
public class NotEncryptedInt implements EncryptedInt {
private var value:int;
public function NotEncryptedInt(param1:int = 0) {
super();
this.value = param1;
}
public function setInt(param1:int) : void {
this.value = param1;
}
public function getInt() : int {
return this.value;
}
}
}
|
package projects.tanks.client.tanksservices.model.notifier.online {
import alternativa.types.Long;
import projects.tanks.client.tanksservices.model.notifier.AbstractNotifier;
public class OnlineNotifierData extends AbstractNotifier {
private var _online:Boolean;
private var _serverNumber:int;
private var _timeSinceLastVisitInSec:Long;
public function OnlineNotifierData(param1:Boolean = false, param2:int = 0, param3:Long = null) {
super();
this._online = param1;
this._serverNumber = param2;
this._timeSinceLastVisitInSec = param3;
}
public function get online() : Boolean {
return this._online;
}
public function set online(param1:Boolean) : void {
this._online = param1;
}
public function get serverNumber() : int {
return this._serverNumber;
}
public function set serverNumber(param1:int) : void {
this._serverNumber = param1;
}
public function get timeSinceLastVisitInSec() : Long {
return this._timeSinceLastVisitInSec;
}
public function set timeSinceLastVisitInSec(param1:Long) : void {
this._timeSinceLastVisitInSec = param1;
}
override public function toString() : String {
var local1:String = "OnlineNotifierData [";
local1 += "online = " + this.online + " ";
local1 += "serverNumber = " + this.serverNumber + " ";
local1 += "timeSinceLastVisitInSec = " + this.timeSinceLastVisitInSec + " ";
local1 += super.toString();
return local1 + "]";
}
}
}
|
package alternativa.tanks.services.battleinput {
import flash.events.Event;
public class BattleInputLockEvent extends Event {
public static const CHAT_LOCKED:String = "BattleInputLockEvent.CHAT_LOCKED";
public static const CHAT_UNLOCKED:String = "BattleInputLockEvent.CHAT_UNLOCKED";
public static const INPUT_LOCKED:String = "BattleInputLockEvent.INPUT_LOCKED";
public static const INPUT_UNLOCKED:String = "BattleInputLockEvent.INPUT_UNLOCKED";
public function BattleInputLockEvent(param1:String) {
super(param1);
}
}
}
|
package alternativa.tanks.models.drones {
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.tankskin.TankSkin;
import alternativa.tanks.service.settings.ISettingsService;
import flash.utils.getTimer;
public class DroneOnGoRenderer extends AbstractDroneRenderer {
private var speed:Number = 0;
private var targetPosition:* = new Vector3();
private var positionDelta:* = new Vector3();
private var localTargetPosition:* = new Vector3();
private const DISTANCE_THRESHOLD:* = 10;
private const MAX_DRONE_SPEED:* = 5;
public function DroneOnGoRenderer(param1:Boolean, param2:TankSkin, param3:Drone, param4:BattleService, param5:ISettingsService) {
super(param1,param2,param3,param4,param5);
}
override public function render(param1:int, param2:int) : void {
var local3:Number = NaN;
local3 = param2 * 0.001;
var local4:Number = 0.1;
var local5:* = local3 > local4 ? local4 : local3;
var local6:* = getTimer() - startTime;
this.localTargetPosition.copy(basePosition);
getTurretMatrix().transformVector(this.localTargetPosition,this.targetPosition);
this.positionDelta.diff(this.targetPosition,drone.getPosition());
local3 = Number(this.positionDelta.length());
if(local3 > this.DISTANCE_THRESHOLD) {
this.speed = (local3 - this.DISTANCE_THRESHOLD) * this.MAX_DRONE_SPEED;
}
var local7:* = this.speed * local5;
if(local7 > local3) {
local7 = local3;
}
this.positionDelta.normalize().scale(local7);
drone.getPosition().add(this.positionDelta);
setPositionAndRotation(param1,param2);
var local8:Number = local6 > 2000 ? 1 : local6 / 2000;
drone.getObject3D().z = drone.getObject3D().z + local8 * Math.sin(param1 / 1000) * 10;
updateVisibility();
}
override public function start() : void {
super.start();
targetAlpha = 1;
alpha = 1;
}
}
}
|
package projects.tanks.client.entrance.model.entrance.emailconfirm {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class EmailConfirmModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:EmailConfirmModelServer;
private var client:IEmailConfirmModelBase = IEmailConfirmModelBase(this);
private var modelId:Long = Long.getLong(284901932,-278416008);
private var _confirmEmailStatusId:Long = Long.getLong(1693893879,-709904107);
private var _confirmEmailStatus_statusCodec:ICodec;
public function EmailConfirmModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new EmailConfirmModelServer(IModel(this));
this._confirmEmailStatus_statusCodec = this._protocol.getCodec(new EnumCodecInfo(ConfirmEmailStatus,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._confirmEmailStatusId:
this.client.confirmEmailStatus(ConfirmEmailStatus(this._confirmEmailStatus_statusCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.service.referrals {
import flash.events.IEventDispatcher;
import projects.tanks.client.panel.model.referrals.ReferralIncomeData;
public interface ReferralsService extends IEventDispatcher {
function updateReferralsData(param1:Vector.<ReferralIncomeData>) : void;
function getReferrals() : Vector.<ReferralIncomeData>;
function setInviteLink(param1:String) : void;
function getInviteLink() : String;
function requestUpdatingReferralsData() : void;
}
}
|
package alternativa.tanks.models.dom.cp
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ControlPointSprite_charsC extends BitmapAsset
{
public function ControlPointSprite_charsC()
{
super();
}
}
}
|
package controls.statassets {
import flash.display.Bitmap;
import flash.display.Sprite;
public class StatLineBackgroundSelected extends Sprite {
public static var bg:Bitmap = new Bitmap();
public function StatLineBackgroundSelected() {
super();
addChild(new Bitmap(bg.bitmapData));
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.terminator.sfx {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
public class TerminatorSFXModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function TerminatorSFXModelServer(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.payment.androidspecialoffer {
import projects.tanks.client.panel.model.shop.androidspecialoffer.banner.AndroidBannerModelBase;
import projects.tanks.client.panel.model.shop.androidspecialoffer.banner.IAndroidBannerModelBase;
[ModelInfo]
public class AndroidBannerModel extends AndroidBannerModelBase implements IAndroidBannerModelBase {
public function AndroidBannerModel() {
super();
}
}
}
|
package platform.client.fp10.core.resource {
public final class ResourceType {
public static const SWF_LIBRARY:uint = 1;
public static const SOUND:uint = 4;
public static const TEXTURE:uint = 9;
public static const IMAGE:uint = 10;
public static const MULTIFRAME_IMAGE:uint = 11;
public static const LOCALIZED_IMAGE:uint = 13;
public function ResourceType() {
super();
}
}
}
|
package platform.client.fp10.core.resource {
public class ResourceFlags {
public static const LOADED:int = 1;
public static const LOCAL:int = 1 << 1;
public static const DUMMY_DATA:int = 1 << 2;
public static const IS_LOADING:int = 1 << 3;
public function ResourceFlags() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.smoky {
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleRunnerProvider;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.WeaponForces;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapon.common.HitInfo;
import alternativa.tanks.models.weapon.shared.SimpleWeaponController;
import alternativa.tanks.models.weapon.weakening.DistanceWeakening;
import alternativa.tanks.models.weapons.targeting.TargetingResult;
import alternativa.tanks.models.weapons.targeting.TargetingSystem;
import alternativa.tanks.utils.EncryptedInt;
import alternativa.tanks.utils.EncryptedIntImpl;
import alternativa.tanks.utils.MathUtils;
import flash.utils.getTimer;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class SmokyWeapon extends BattleRunnerProvider implements Weapon, LogicUnit {
private static const gunParams:AllGlobalGunParams = new AllGlobalGunParams();
private var enabled:Boolean;
private var nextTime:EncryptedInt = new EncryptedIntImpl();
private var weaponForces:WeaponForces;
private var controller:SimpleWeaponController;
private var targetingSystem:TargetingSystem;
private var weaponPlatform:WeaponPlatform;
private var weakening:DistanceWeakening;
private var callback:SmokyCallback;
private var effects:ISmokyEffects;
private var weaponObject:WeaponObject;
private var stunned:Boolean;
private var stunEnergy:Number;
public function SmokyWeapon(param1:WeaponObject, param2:WeaponForces, param3:TargetingSystem, param4:DistanceWeakening, param5:ISmokyEffects, param6:SmokyCallback, param7:SimpleWeaponController) {
super();
this.weaponForces = param2;
this.targetingSystem = param3;
this.weakening = param4;
this.effects = param5;
this.callback = param6;
this.controller = param7;
this.weaponObject = param1;
this.stunned = false;
}
public function init(param1:WeaponPlatform) : void {
this.weaponPlatform = param1;
this.controller.init();
this.reset();
}
public function destroy() : void {
this.weaponForces = null;
this.targetingSystem = null;
this.weakening = null;
this.effects = null;
this.callback = null;
this.controller.destroy();
this.controller = null;
}
public function activate() : void {
getBattleRunner().addLogicUnit(this);
}
public function deactivate() : void {
getBattleRunner().removeLogicUnit(this);
}
public function enable() : void {
this.enabled = true;
this.controller.discardStoredAction();
}
public function disable(param1:Boolean) : void {
this.enabled = false;
}
public function reset() : void {
this.nextTime.setInt(getTimer());
}
public function getStatus() : Number {
var local1:Number = NaN;
if(this.stunned) {
return this.stunEnergy;
}
local1 = 1 - (this.nextTime.getInt() - getTimer()) / this.weaponObject.getReloadTimeMS();
return MathUtils.clamp(local1,0,1);
}
public function runLogic(param1:int, param2:int) : void {
if(this.controller.wasActive()) {
if(this.enabled && param1 >= this.nextTime.getInt() && !this.stunned) {
this.shoot(param1);
}
this.controller.discardStoredAction();
}
}
private function shoot(param1:int) : void {
var local3:Tank = null;
var local4:Number = NaN;
this.nextTime.setInt(param1 + this.weaponObject.getReloadTimeMS());
this.weaponPlatform.getAllGunParams(gunParams);
this.weaponPlatform.getBody().addWorldForceScaled(gunParams.barrelOrigin,gunParams.direction,-this.weaponForces.getRecoilForce());
this.weaponPlatform.addDust();
this.effects.createShotEffects(this.weaponPlatform.getLocalMuzzlePosition(),this.weaponPlatform.getTurret3D());
var local2:HitInfo = new HitInfo();
if(BattleUtils.isTurretAboveGround(this.weaponPlatform.getBody(),gunParams) && this.getTarget(gunParams,local2)) {
this.effects.createExplosionEffects(local2.position);
if(BattleUtils.isTankBody(local2.body)) {
local3 = local2.body.tank;
local4 = this.weakening.getImpactCoeff(local2.distance);
local3.applyWeaponHit(local2.position,local2.direction,this.weaponForces.getImpactForce() * local4);
this.callback.onShotTarget(param1,local2.position,local2.body);
} else {
this.effects.createExplosionMark(gunParams.barrelOrigin,local2.position);
this.callback.onShotStatic(param1,local2.position);
}
} else {
this.callback.onShot(param1);
}
}
private function getTarget(param1:AllGlobalGunParams, param2:HitInfo) : Boolean {
var local3:TargetingResult = this.targetingSystem.target(param1);
param2.setResult(param1,local3);
return local3.hasAnyHit();
}
public function createCriticalHitEffect(param1:Vector3) : void {
this.effects.createCriticalHitEffects(param1);
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.SMOKY_RESISTANCE;
}
public function updateRecoilForce(param1:Number) : void {
this.weaponForces.setRecoilForce(param1);
}
public function fullyRecharge() : void {
this.nextTime.setInt(0);
this.stunEnergy = 1;
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
this.nextTime.setInt(this.nextTime.getInt() + param2 - param1);
}
public function stun() : void {
this.stunEnergy = this.getStatus();
this.stunned = true;
}
public function calm(param1:int) : void {
this.nextTime.setInt(this.nextTime.getInt() + param1);
this.stunned = false;
}
}
}
|
package alternativa.tanks.battle.objects.tank.tankskin.materialfactory {
import alternativa.tanks.battle.objects.tank.tankskin.SkinMaterials;
import alternativa.tanks.battle.objects.tank.tankskin.TankSkin;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.clients.flash.commons.models.coloring.IColoring;
public interface TankSkinMaterialsFactory {
function createSkinMaterials(param1:TankSkin, param2:IColoring) : SkinMaterials;
function createDeadSkinMaterials(param1:TankSkin, param2:TextureResource) : SkinMaterials;
}
}
|
package projects.tanks.clients.flash.commons.models.battlelinkactivator {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.commons.models.linkactivator.ILinkActivatorModelBase;
import projects.tanks.client.commons.models.linkactivator.LinkActivatorModelBase;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.activator.BattleLinkActivatorServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.activator.BattleLinkAliveEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.activator.IBattleLinkActivatorService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import services.alertservice.AlertAnswer;
[ModelInfo]
public class BattleLinkActivatorModel extends LinkActivatorModelBase implements ILinkActivatorModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var battleLinkActivatorService:IBattleLinkActivatorService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var userPropertyService:IUserPropertiesService;
public function BattleLinkActivatorModel() {
super();
}
public function objectLoaded() : void {
battleLinkActivatorService.addEventListener(BattleLinkActivatorServiceEvent.ACTIVATE_LINK,getFunctionWrapper(this.onActivateLink));
battleLinkActivatorService.addEventListener(BattleLinkAliveEvent.IS_ALIVE,getFunctionWrapper(this.onIsAlive));
}
private function onActivateLink(param1:BattleLinkActivatorServiceEvent) : void {
if(!lobbyLayoutService.isSwitchInProgress()) {
server.activateBattle(param1.battleId);
}
}
private function onIsAlive(param1:BattleLinkAliveEvent) : void {
server.isAlive(param1.battleId);
}
public function objectUnloaded() : void {
battleLinkActivatorService.removeEventListener(BattleLinkActivatorServiceEvent.ACTIVATE_LINK,getFunctionWrapper(this.onActivateLink));
battleLinkActivatorService.removeEventListener(BattleLinkAliveEvent.IS_ALIVE,getFunctionWrapper(this.onIsAlive));
}
public function battleNotFound() : void {
var local1:String = userPropertyService.userName;
if(storageService.getStorage().data.showAlertDeadBattle == local1 + "_true") {
alertService.showAlert(localeService.getText(TanksLocale.TEXT_BATTLE_CANNOT_BE_FOUND_ALERT),Vector.<String>([localeService.getText(AlertAnswer.OK)]));
storageService.getStorage().data.showAlertDeadBattle = local1 + "_false";
}
}
public function alive(param1:Long) : void {
battleLinkActivatorService.alive(param1);
}
public function dead(param1:Long) : void {
battleLinkActivatorService.dead(param1);
}
}
}
|
package alternativa.tanks.JPGencoder {
public class BitString {
public var len:int = 0;
public var val:int = 0;
public function BitString() {
super();
}
}
}
|
package projects.tanks.client.partners.impl.kongregate {
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 KongregatePaymentModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _getPaymentTransactionId:Long = Long.getLong(1273914983,1619025149);
private var _getPaymentTransaction_shopItemIdCodec:ICodec;
private var model:IModel;
public function KongregatePaymentModelServer(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._getPaymentTransaction_shopItemIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function getPaymentTransaction(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._getPaymentTransaction_shopItemIdCodec.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._getPaymentTransactionId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package assets.window.bitmaps {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.window.bitmaps.WindowBottom.png")]
public class WindowBottom extends BitmapData {
public function WindowBottom(param1:int, param2:int, param3:Boolean = true, param4:uint = 0) {
super(param1,param2,param3,param4);
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p14 extends BitmapAsset
{
public function RangIconNormal_p14()
{
super();
}
}
}
|
package alternativa.tanks.gui.frames {
public class GreenFrame extends FrameBase {
public function GreenFrame(param1:int, param2:int) {
super(param1,param2,new GreenFrameSkin());
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.blur {
import flash.events.Event;
public class BlurServiceEvent extends Event {
public static const CLICK_OVERLAY_BATTLE_CONTENT:String = "BlurServiceEvent.CLICK_OVERLAY_BATTLE_CONTENT";
public function BlurServiceEvent(param1:String, param2:Boolean = false, param3:Boolean = false) {
super(param1,param2,param3);
}
}
}
|
package projects.tanks.client.panel.model.socialnetwork {
public interface ISocialNetworkPanelModelBase {
function linkAlreadyExists(param1:String) : void;
function linkCreated(param1:String) : void;
function unlinkSuccess(param1:String) : void;
function validationFailed() : void;
}
}
|
package alternativa.tanks.models.weapon.artillery.sfx {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.engine3d.objects.Sprite3D;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class ArtillerySmoke extends PooledObject implements GraphicEffect {
private static const SCALE_STEP:Number = 0.006;
private static const ALPHA_STEP:Number = 0.007;
private var container:Scene3DContainer;
private var sprite:Sprite3D;
public function ArtillerySmoke(param1:Pool) {
super(param1);
this.sprite = new Sprite3D(60,60);
}
public function init(param1:Mesh, param2:TextureMaterial) : void {
this.sprite.material = param2;
this.sprite.rotation = Math.random() * Math.PI * 2;
this.sprite.scaleX = 1;
this.sprite.scaleY = 1;
this.sprite.scaleZ = 1;
this.sprite.alpha = 1;
this.sprite.x = param1.x;
this.sprite.y = param1.y;
this.sprite.z = param1.z;
}
public function play(param1:int, param2:GameCamera) : Boolean {
this.sprite.scaleX -= SCALE_STEP;
this.sprite.scaleY -= SCALE_STEP;
this.sprite.scaleZ -= SCALE_STEP;
this.sprite.alpha -= ALPHA_STEP;
if(this.sprite.alpha <= 0.05) {
this.container.removeChild(this.sprite);
return false;
}
return true;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.sprite);
}
public function destroy() : void {
if(Boolean(this.container)) {
this.container.removeChild(this.sprite);
}
this.container = null;
this.sprite.material = null;
recycle();
}
public function kill() : void {
this.sprite.alpha = 0;
}
}
}
|
package _codec.unsigned {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.UShort;
public class VectorCodecintLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecintLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(UShort,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.<uint> = new Vector.<uint>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = uint(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:uint = 0;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<uint> = Vector.<uint>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package controls.checkbox {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.checkbox.CheckBoxBase_checkboxOverClass.png")]
public class CheckBoxBase_checkboxOverClass extends BitmapAsset {
public function CheckBoxBase_checkboxOverClass() {
super();
}
}
}
|
package projects.tanks.clients.tankslauncershared.dishonestprogressbar {
import mx.core.BitmapAsset;
[Embed(source="/_assets/projects.tanks.clients.tankslauncershared.dishonestprogressbar.LoadingLabel_loadingLabelBrClass.png")]
public class LoadingLabel_loadingLabelBrClass extends BitmapAsset {
public function LoadingLabel_loadingLabelBrClass() {
super();
}
}
}
|
package platform.client.fp10.core.service.loadingprogress {
public interface ILoadingProgressListener {
function onLoadingStart() : void;
function onLoadingStop() : void;
function onLoadingProgress(param1:int, param2:int) : void;
}
}
|
package alternativa.tanks.models.tank.resistance {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.user.resistance.TankResistance;
public class TankResistancesEvents implements TankResistances {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function TankResistancesEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getResistance(param1:Boolean) : int {
var result:int = 0;
var i:int = 0;
var m:TankResistances = null;
var update:Boolean = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = TankResistances(this.impl[i]);
result = int(m.getResistance(update));
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getResistances() : Vector.<TankResistance> {
var result:Vector.<TankResistance> = null;
var i:int = 0;
var m:TankResistances = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = TankResistances(this.impl[i]);
result = m.getResistances();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function updateOthersResistances() : void {
var i:int = 0;
var m:TankResistances = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = TankResistances(this.impl[i]);
m.updateOthersResistances();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.animations {
public class KeyFrameAnimation {
private var track:AnimationTrack;
private var currentFrame:int;
private var time:Number;
private var animatedValue:AnimatedValue;
public function KeyFrameAnimation(param1:AnimationTrack, param2:AnimatedValue) {
super();
this.track = param1;
this.animatedValue = param2;
}
public function start() : void {
this.time = this.track.getMinTime();
this.currentFrame = 0;
}
public function isComplete() : Boolean {
return this.currentFrame == this.track.getNumFrames() - 1;
}
public function update(param1:Number) : void {
if(!this.isComplete()) {
this.time += param1;
while(this.time > this.track.getFrameTime(this.currentFrame + 1)) {
++this.currentFrame;
if(this.isComplete()) {
this.time = this.track.getMaxTime();
break;
}
}
this.animatedValue.setAnimatedValue(this.getValue());
}
}
private function getValue() : Number {
var local1:Number = NaN;
var local2:Number = NaN;
var local3:Number = NaN;
var local4:Number = NaN;
if(this.isComplete()) {
return this.track.getFrameTime(this.currentFrame);
}
local1 = this.track.getFrameTime(this.currentFrame);
local2 = this.track.getFrameTime(this.currentFrame + 1);
local3 = this.track.getFrameValue(this.currentFrame);
local4 = this.track.getFrameValue(this.currentFrame + 1);
return local3 + (local4 - local3) * (this.time - local1) / (local2 - local1);
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_bitmapFireResistance.png")]
public class ResistancesIcons_bitmapFireResistance extends BitmapAsset {
public function ResistancesIcons_bitmapFireResistance() {
super();
}
}
}
|
package controls.statassets
{
import assets.stat.hall_NORMAL;
import flash.display.BitmapData;
public class StatLineNormal extends StatLineBase
{
public function StatLineNormal()
{
super();
tl = new hall_NORMAL(1,1);
px = new BitmapData(1,1,false,543488);
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.terminator
{
import scpacker.Base;
public class TerminatorModelBase extends Base
{
public function TerminatorModelBase()
{
super();
}
}
}
|
package projects.tanks.client.commons.models.captcha {
public interface ICaptchaModelBase {
function captchaCorrect(param1:CaptchaLocation) : void;
function captchaFailed(param1:CaptchaLocation, param2:Vector.<int>) : void;
function showCaptcha(param1:CaptchaLocation, param2:Vector.<int>) : void;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.