code
stringlengths 57
237k
|
|---|
package alternativa.engine3d.core {
import alternativa.engine3d.alternativa3d;
import flash.events.Event;
import flash.geom.Vector3D;
use namespace alternativa3d;
public class MouseEvent3D extends Event {
public static const CLICK:String = "click3D";
public static const DOUBLE_CLICK:String = "doubleClick3D";
public static const MOUSE_DOWN:String = "mouseDown3D";
public static const MOUSE_UP:String = "mouseUp3D";
public static const MOUSE_OVER:String = "mouseOver3D";
public static const MOUSE_OUT:String = "mouseOut3D";
public static const ROLL_OVER:String = "rollOver3D";
public static const ROLL_OUT:String = "rollOut3D";
public static const MOUSE_MOVE:String = "mouseMove3D";
public static const MOUSE_WHEEL:String = "mouseWheel3D";
public var ctrlKey:Boolean;
public var altKey:Boolean;
public var shiftKey:Boolean;
public var buttonDown:Boolean;
public var delta:int;
public var relatedObject:Object3D;
public var localOrigin:Vector3D = new Vector3D();
public var localDirection:Vector3D = new Vector3D();
alternativa3d var _target:Object3D;
alternativa3d var _currentTarget:Object3D;
alternativa3d var _bubbles:Boolean;
alternativa3d var _eventPhase:uint = 3;
alternativa3d var stop:Boolean = false;
alternativa3d var stopImmediate:Boolean = false;
public function MouseEvent3D(param1:String, param2:Boolean = true, param3:Object3D = null, param4:Boolean = false, param5:Boolean = false, param6:Boolean = false, param7:Boolean = false, param8:int = 0) {
super(param1,param2);
this.relatedObject = param3;
this.altKey = param4;
this.ctrlKey = param5;
this.shiftKey = param6;
this.buttonDown = param7;
this.delta = param8;
}
alternativa3d function calculateLocalRay(param1:Number, param2:Number, param3:Object3D, param4:Camera3D) : void {
param4.calculateRay(this.localOrigin,this.localDirection,param1,param2);
param3.alternativa3d::composeMatrix();
var local5:Object3D = param3;
while(local5.alternativa3d::_parent != null) {
local5 = local5.alternativa3d::_parent;
local5.alternativa3d::composeMatrix();
param3.alternativa3d::appendMatrix(local5);
}
param3.alternativa3d::invertMatrix();
var local6:Number = this.localOrigin.x;
var local7:Number = this.localOrigin.y;
var local8:Number = this.localOrigin.z;
var local9:Number = this.localDirection.x;
var local10:Number = this.localDirection.y;
var local11:Number = this.localDirection.z;
this.localOrigin.x = param3.alternativa3d::ma * local6 + param3.alternativa3d::mb * local7 + param3.alternativa3d::mc * local8 + param3.alternativa3d::md;
this.localOrigin.y = param3.alternativa3d::me * local6 + param3.alternativa3d::mf * local7 + param3.alternativa3d::mg * local8 + param3.alternativa3d::mh;
this.localOrigin.z = param3.alternativa3d::mi * local6 + param3.alternativa3d::mj * local7 + param3.alternativa3d::mk * local8 + param3.alternativa3d::ml;
this.localDirection.x = param3.alternativa3d::ma * local9 + param3.alternativa3d::mb * local10 + param3.alternativa3d::mc * local11;
this.localDirection.y = param3.alternativa3d::me * local9 + param3.alternativa3d::mf * local10 + param3.alternativa3d::mg * local11;
this.localDirection.z = param3.alternativa3d::mi * local9 + param3.alternativa3d::mj * local10 + param3.alternativa3d::mk * local11;
}
override public function get bubbles() : Boolean {
return this.alternativa3d::_bubbles;
}
override public function get eventPhase() : uint {
return this.alternativa3d::_eventPhase;
}
override public function get target() : Object {
return this.alternativa3d::_target;
}
override public function get currentTarget() : Object {
return this.alternativa3d::_currentTarget;
}
override public function stopPropagation() : void {
this.alternativa3d::stop = true;
}
override public function stopImmediatePropagation() : void {
this.alternativa3d::stopImmediate = true;
}
override public function clone() : Event {
return new MouseEvent3D(type,this.alternativa3d::_bubbles,this.relatedObject,this.altKey,this.ctrlKey,this.shiftKey,this.buttonDown,this.delta);
}
override public function toString() : String {
return formatToString("MouseEvent3D","type","bubbles","eventPhase","relatedObject","altKey","ctrlKey","shiftKey","buttonDown","delta");
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.reconnect {
public interface ReconnectCallback {
function onReconnectCancel() : void;
function onReconnectError() : void;
function onReconnectStarted() : void;
}
}
|
package platform.client.fp10.core.type {
import alternativa.types.Long;
public interface IGameClass {
function get id() : Long;
function get models() : Vector.<Long>;
}
}
|
package platform.client.fp10.core.service.clientparam {
public class ClientParamEnum {
public static const OS:String = "os";
public static const FLASH_PLAYER_VERSION:String = "flash_player_version";
public static const FLASH_PLAYER_TYPE:String = "flash_player_type";
public static const BROWSER_USER_AGENT:String = "browser_user_agent";
public static const TYPE:String = "client_type";
public function ClientParamEnum() {
super();
}
}
}
|
package alternativa.tanks.gui.friends.list.renderer.background {
import controls.cellrenderer.ButtonState;
import flash.display.Sprite;
public class RendererBackGroundOutgoingList extends Sprite {
private var _width:int = 100;
public function RendererBackGroundOutgoingList(param1:Boolean) {
var local2:ButtonState = null;
super();
if(param1) {
local2 = new FriendCellSelected();
} else {
local2 = new FriendCellNormal();
}
addChild(local2);
this.resize();
}
protected function resize() : void {
var local1:ButtonState = getChildAt(0) as ButtonState;
local1.width = this._width - 3;
local1.height = 18;
}
override public function set width(param1:Number) : void {
this._width = Math.floor(param1);
this.resize();
}
}
}
|
package projects.tanks.client.garage.models.user.present {
public class PresentsCC {
private var _presents:Vector.<PresentItem>;
public function PresentsCC(param1:Vector.<PresentItem> = null) {
super();
this._presents = param1;
}
public function get presents() : Vector.<PresentItem> {
return this._presents;
}
public function set presents(param1:Vector.<PresentItem>) : void {
this._presents = param1;
}
public function toString() : String {
var local1:String = "PresentsCC [";
local1 += "presents = " + this.presents + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.tank.ultimate {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IUltimateModelAdapt implements IUltimateModel {
private var object:IGameObject;
private var impl:IUltimateModel;
public function IUltimateModelAdapt(param1:IGameObject, param2:IUltimateModel) {
super();
this.object = param1;
this.impl = param2;
}
public function resetCharge() : void {
try {
Model.object = this.object;
this.impl.resetCharge();
}
finally {
Model.popObject();
}
}
public function initIndicator() : void {
try {
Model.object = this.object;
this.impl.initIndicator();
}
finally {
Model.popObject();
}
}
public function isUltimateEnabled() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.isUltimateEnabled());
}
finally {
Model.popObject();
}
return result;
}
public function effectDeactivated() : void {
try {
Model.object = this.object;
this.impl.effectDeactivated();
}
finally {
Model.popObject();
}
}
public function effectActivatedOrMerged(param1:int) : void {
var leftTimeInMs:int = param1;
try {
Model.object = this.object;
this.impl.effectActivatedOrMerged(leftTimeInMs);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.battle.hidablegraphicobjects {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
public class HidableObject3DWrapper implements HidableGraphicObject {
private var object:Object3D;
public function HidableObject3DWrapper(param1:Object3D) {
super();
this.object = param1;
}
public function readPosition(param1:Vector3) : void {
param1.x = this.object.x;
param1.y = this.object.y;
param1.z = this.object.z;
}
public function setAlphaMultiplier(param1:Number) : void {
this.object.alpha = param1;
}
}
}
|
package alternativa.engine3d.loaders.collada {
use namespace collada;
public class DaeParam extends DaeElement {
public function DaeParam(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
public function get ref() : String {
var local1:XML = data.@ref[0];
return local1 == null ? null : local1.toString();
}
public function getFloat() : Number {
var local1:XML = data.float[0];
if(local1 != null) {
return parseNumber(local1);
}
return NaN;
}
public function getFloat4() : Array {
var local2:Array = null;
var local1:XML = data.float4[0];
if(local1 == null) {
local1 = data.float3[0];
if(local1 != null) {
local2 = parseNumbersArray(local1);
local2[3] = 1;
}
} else {
local2 = parseNumbersArray(local1);
}
return local2;
}
public function get surfaceSID() : String {
var local1:XML = data.sampler2D.source[0];
return local1 == null ? null : local1.text().toString();
}
public function get wrap_s() : String {
var local1:XML = data.sampler2D.wrap_s[0];
return local1 == null ? null : local1.text().toString();
}
public function get image() : DaeImage {
var local2:DaeImage = null;
var local3:XML = null;
var local4:XML = null;
var local1:XML = data.surface[0];
if(local1 != null) {
local3 = local1.init_from[0];
if(local3 == null) {
return null;
}
local2 = document.findImageByID(local3.text().toString());
} else {
local4 = data.instance_image.@url[0];
if(local4 == null) {
return null;
}
local2 = document.findImage(local4);
}
return local2;
}
}
}
|
package alternativa.tanks.controller.events.partners {
import flash.events.Event;
public class PartnerStartEvent extends Event {
public static const START_REGISTRATION:String = "PartnerStartEvent.START_REGISTRATION";
public static const START_LOGIN:String = "PartnerStartEvent.START_LOGIN";
public var rememberMe:Boolean;
public function PartnerStartEvent(param1:String, param2:Boolean, param3:Boolean = false, param4:Boolean = false) {
this.rememberMe = param2;
super(param1,param3,param4);
}
override public function clone() : Event {
return new PartnerStartEvent(type,this.rememberMe,bubbles,cancelable);
}
}
}
|
package projects.tanks.client.partners.impl.china.chinamobilesdk.auth {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class ChinaMobileSDKEntranceModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ChinaMobileSDKEntranceModelServer;
private var client:IChinaMobileSDKEntranceModelBase = IChinaMobileSDKEntranceModelBase(this);
private var modelId:Long = Long.getLong(1898566617,539298235);
public function ChinaMobileSDKEntranceModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ChinaMobileSDKEntranceModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.panel.model.bonus.showing.info {
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 BonusInfoModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BonusInfoModelServer(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.garage.rankupsupplybonus {
import alternativa.tanks.gui.RankUpSupplyBonusAlert;
import projects.tanks.client.panel.model.garage.rankupsupplybonus.IRankUpSupplyBonusModelBase;
import projects.tanks.client.panel.model.garage.rankupsupplybonus.RankUpSupplyBonusInfo;
import projects.tanks.client.panel.model.garage.rankupsupplybonus.RankUpSupplyBonusModelBase;
[ModelInfo]
public class RankUpSupplyBonusModel extends RankUpSupplyBonusModelBase implements IRankUpSupplyBonusModelBase {
public function RankUpSupplyBonusModel() {
super();
}
public function showRankUpSupplyBonusAlerts(param1:Vector.<RankUpSupplyBonusInfo>) : void {
var local2:RankUpSupplyBonusInfo = null;
for each(local2 in param1) {
new RankUpSupplyBonusAlert(local2);
}
}
}
}
|
package alternativa.engine3d.materials
{
import alternativa.gfx.agal.VertexShader;
public class TextureMaterialVertexShader extends VertexShader
{
public function TextureMaterialVertexShader(param1:Boolean, param2:Boolean, param3:Boolean, param4:Boolean, param5:Boolean, param6:Boolean, param7:Boolean, param8:Boolean, param9:Boolean, param10:Boolean)
{
super();
mov(vt0,vc[4]);
if(param1)
{
dp4(vt0.x,va0,vc[0]);
dp4(vt0.y,va0,vc[1]);
dp4(vt0.z,va0,vc[2]);
mul(v0,va1,vc[4]);
}
else
{
mov(vt0.xyz,cc.rel(va0.x,0));
mov(vt1,cc.rel(va0.x,1));
mul(v0,vt1,vc[4]);
}
if(param2 || param3)
{
mov(v1,vt0);
}
if(param3)
{
if(param1)
{
if(param4)
{
mul(vt1,va2,vc[11]);
nrm(vt1.xyz,vt1.xyz);
div(vt1,vt1,vc[11]);
}
else
{
mov(vt1,vc[4]);
dp3(vt1.x,va2,vc[0]);
dp3(vt1.y,va2,vc[1]);
dp3(vt1.z,va2,vc[2]);
}
}
else
{
mov(vt2,vc[4]);
mov(vt2.x,cc.rel(va0.x,0).w);
mov(vt2.y,cc.rel(va0.x,1).z);
mov(vt2.z,cc.rel(va0.x,1).w);
if(param4)
{
mul(vt1,vt2,vc[11]);
nrm(vt1.xyz,vt1.xyz);
div(vt1,vt1,vc[11]);
}
else
{
mov(vt1,vc[4]);
dp3(vt1.x,vt2,vc[0]);
dp3(vt1.y,vt2,vc[1]);
dp3(vt1.z,vt2,vc[2]);
}
}
dp3(vt1.w,vt1,vc[10]);
if(param4)
{
sub(vt1.w,vc[4],vt1);
mul(v1.w,vt1,vc[11]);
}
else
{
sub(v1.w,vc[4],vt1);
}
}
else if(param5 || param6 || param9 || param10)
{
mov(vt1,vc[4]);
}
if(param5)
{
dp4(v2.x,vt0,vc[6]);
dp4(v2.y,vt0,vc[7]);
dp4(v2.z,vt0,vc[8]);
sub(vt1.w,vt0.z,vc[9].x);
div(vt1.w,vt1,vc[9].y);
sub(v2.w,vc[4],vt1);
}
if(param6)
{
sub(vt1.w,vt0.z,vc[5].z);
div(v0.w,vt1,vc[5]);
}
if(param8)
{
mov(vt1,vt0);
mul(vt1.x,vt1,vc[11].w);
mul(vt1.y,vt1,vc[12].w);
sub(vt1,vt1,vc[11]);
dp3(v0.z,vt1,vc[12]);
}
if(param7)
{
mul(vt0.xyz,vt0,vc[11]);
}
if(param9)
{
div(vt1.z,vc[3].w,vt0);
add(vt1.z,vt1,vc[3]);
mul(vt1.z,vt1,vc[3].x);
sub(vt1.z,vt1,vc[3].y);
div(vt1.z,vt1,vc[3].x);
sub(vt1.z,vt1,vc[3]);
div(vt1.z,vc[3].w,vt1);
mov(vt2,vc[4]);
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(param10)
{
mul(vt0.xy,vt0,vc[13]);
mul(vt1.xy,vc[13].zw,vt0.z);
add(vt0.xy,vt0,vt1);
}
mov(op.xw,vt0.xz);
neg(op.y,vt0);
mul(vt0.z,vt0,vc[3]);
add(op.z,vt0,vc[3].w);
}
}
}
|
package alternativa.tanks.controller.events.partners {
import flash.events.Event;
public class PartnerLoginEvent extends Event {
public static const CHECK_CAPTCHA_AND_LOGIN:String = "PartnerLoginEvent.CHECK_CAPTCHA_AND_LOGIN";
public static const LOGIN_AFTER_CAPTCHA_CHECKED:String = "PartnerLoginEvent.LOGIN_AFTER_CAPTCHA_CHECKED";
private var _callsign:String;
private var _password:String;
private var _captchaAnswer:String;
public function PartnerLoginEvent(param1:String, param2:String, param3:String, param4:String) {
super(param1);
this._callsign = param2;
this._password = param3;
this._captchaAnswer = param4;
}
public function get callsign() : String {
return this._callsign;
}
public function get password() : String {
return this._password;
}
public function get captchaAnswer() : String {
return this._captchaAnswer;
}
override public function clone() : Event {
return new PartnerLoginEvent(this.type,this.callsign,this.password,this.captchaAnswer);
}
}
}
|
package _codec.projects.tanks.client.partners.impl.asiasoft {
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.partners.impl.asiasoft.AsiasoftLoginCC;
public class VectorCodecAsiasoftLoginCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecAsiasoftLoginCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(AsiasoftLoginCC,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.<AsiasoftLoginCC> = new Vector.<AsiasoftLoginCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = AsiasoftLoginCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:AsiasoftLoginCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<AsiasoftLoginCC> = Vector.<AsiasoftLoginCC>(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 com.lorentz.SVG.data.path
{
public class SVGCurveToQuadraticSmoothCommand extends SVGPathCommand
{
public var x:Number = 0;
public var y:Number = 0;
public var absolute:Boolean = false;
public function SVGCurveToQuadraticSmoothCommand(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 ? "T" : "t";
}
override public function clone():Object {
var copy:SVGCurveToQuadraticSmoothCommand = new SVGCurveToQuadraticSmoothCommand(absolute);
copy.x = x;
copy.y = y;
return copy;
}
}
}
|
package projects.tanks.client.tanksservices.model.proabonementnotifier {
public class ProAbonementNotifierCC {
private var _abonementRemainingTimeInSec:int;
public function ProAbonementNotifierCC(param1:int = 0) {
super();
this._abonementRemainingTimeInSec = param1;
}
public function get abonementRemainingTimeInSec() : int {
return this._abonementRemainingTimeInSec;
}
public function set abonementRemainingTimeInSec(param1:int) : void {
this._abonementRemainingTimeInSec = param1;
}
public function toString() : String {
var local1:String = "ProAbonementNotifierCC [";
local1 += "abonementRemainingTimeInSec = " + this.abonementRemainingTimeInSec + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.battle.gui.userlabel {
import alternativa.tanks.battle.objects.tank.ClientTankState;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.display.resistance.ResistanceShieldIcon;
import alternativa.tanks.models.battle.battlefield.BattleUserInfoService;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.resistance.TankResistances;
import alternativa.tanks.services.tankregistry.TankUsersRegistry;
import alternativa.types.Long;
import controls.base.LabelBase;
import controls.chat.MessageColor;
import filters.Filters;
import flash.display.Bitmap;
import flash.events.MouseEvent;
import flash.text.AntiAliasType;
import forms.userlabel.ChatUserLabel;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
public class BattleChatUserLabel extends ChatUserLabel {
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var tankUsersRegistry:TankUsersRegistry;
[Inject]
public static var userInfoService:BattleUserInfoService;
private var resitanceLabel:LabelBase;
public function BattleChatUserLabel(param1:Long, param2:Boolean = true) {
var local4:IGameObject = null;
var local5:Tank = null;
this.resitanceLabel = new LabelBase();
_uid = userInfoService.getUserName(param1);
_rank = userInfoService.getUserRank(param1);
_chatModeratorLevel = userInfoService.getChatModeratorLevel(param1);
_writeInPublicChat = false;
_writePrivateInChat = false;
_blockUserEnable = param2;
var local3:Boolean = false;
if(battleInfoService.isSpectatorMode()) {
local4 = tankUsersRegistry.getUser(param1);
if(local4 != null) {
local5 = ITankModel(local4.adapt(ITankModel)).getTank();
if(local5 != null) {
local3 = local5.state == ClientTankState.ACTIVE;
}
}
}
this._focusOnUserEnabled = local3;
super(param1);
if(!_self) {
addEventListener(MouseEvent.MOUSE_OVER,this.onMouseOver);
addEventListener(MouseEvent.MOUSE_OUT,this.onMouseOut);
}
}
[Obfuscation(rename="false")]
override protected function getShadowFilters() : Array {
return Filters.SHADOW_FILTERS;
}
[Obfuscation(rename="false")]
protected function getShadowFiltersOnOver() : Array {
return Filters.SHADOW_ON_OVER_FILTERS;
}
private function onMouseOut(param1:MouseEvent) : void {
shadowContainer.filters = this.getShadowFilters();
this.resitanceLabel.filters = this.getShadowFilters();
}
private function onMouseOver(param1:MouseEvent) : void {
shadowContainer.filters = this.getShadowFiltersOnOver();
this.resitanceLabel.filters = this.getShadowFiltersOnOver();
}
[Obfuscation(rename="false")]
override protected function onMouseClick(param1:MouseEvent) : void {
showClanProfile = true;
super.onMouseClick(param1);
}
[Obfuscation(rename="false")]
override protected function updateProperties() : void {
var local2:TankResistances = null;
var local3:int = 0;
var local4:Bitmap = null;
setUid(_uid);
setRank(_rank);
setFriendState(_friendInfoUpdater.state);
var local1:IGameObject = tankUsersRegistry.getUser(super.userId);
if(local1 != null) {
local2 = TankResistances(local1.adapt(TankResistances));
local3 = int(local2.getResistance(false));
if(local3 > 0) {
local4 = ResistanceShieldIcon.getBitmapFor(local1);
local4.y += 4;
local4.x = _uidLabel.x + _uidLabel.textWidth + 7;
shadowContainer.addChild(local4);
this.resitanceLabel.text = local3 == 100 ? "??" : local3.toString();
addChild(this.resitanceLabel);
this.resitanceLabel.x = local4.x + 3;
this.resitanceLabel.color = MessageColor.YELLOW;
this.resitanceLabel.filters = this.getShadowFilters();
}
}
}
[Obfuscation(rename="false")]
override protected function createUidLabel() : void {
super.createUidLabel();
_uidLabel.antiAliasType = AntiAliasType.ADVANCED;
_uidLabel.thickness = 150;
_uidLabel.sharpness = 200;
}
}
}
|
package alternativa.tanks.models.effects.common.bonuscommon
{
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
public class BonusCommonData
{
public var boxMesh:Mesh;
public var parachuteMesh:Mesh;
public var parachuteInnerMesh:Mesh;
public var cordMaterial:Material;
public var duration:int;
public function BonusCommonData()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.referrals {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
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 ReferralsModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _updateReferralsDataId:Long = Long.getLong(519584404,1037059086);
private var model:IModel;
public function ReferralsModelServer(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());
}
public function updateReferralsData() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._updateReferralsDataId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.model.quest.common.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.quest.common.gui.NoQuestBitmap_BITMAP.png")]
public class NoQuestBitmap_BITMAP extends BitmapAsset {
public function NoQuestBitmap_BITMAP() {
super();
}
}
}
|
package alternativa.tanks.gui.friends.list.renderer {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.list.renderer.FriendsAcceptedListRenderer_gradientGreyIconClass.png")]
public class FriendsAcceptedListRenderer_gradientGreyIconClass extends BitmapAsset {
public function FriendsAcceptedListRenderer_gradientGreyIconClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.common.charging {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class WeaponChargingCommunicationModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:WeaponChargingCommunicationModelServer;
private var client:IWeaponChargingCommunicationModelBase = IWeaponChargingCommunicationModelBase(this);
private var modelId:Long = Long.getLong(1249124405,67678961);
private var _handleChargingFinishId:Long = Long.getLong(1333946959,1231462256);
private var _handleChargingFinish_durationMsCodec:ICodec;
private var _handleChargingStartId:Long = Long.getLong(95516785,249691333);
public function WeaponChargingCommunicationModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new WeaponChargingCommunicationModelServer(IModel(this));
this._handleChargingFinish_durationMsCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._handleChargingFinishId:
this.client.handleChargingFinish(int(this._handleChargingFinish_durationMsCodec.decode(param2)));
break;
case this._handleChargingStartId:
this.client.handleChargingStart();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.service.temporaryitemnotify {
import platform.client.fp10.core.type.IGameObject;
public interface ITemporaryItemNotifyService {
function addListener(param1:ITemporaryItemNotifyServiceListener) : void;
function removeListener(param1:ITemporaryItemNotifyServiceListener) : void;
function notifyTimeIsUp(param1:IGameObject) : void;
}
}
|
package alternativa.tanks.gui
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.containers.KDContainer;
import alternativa.engine3d.core.Object3DContainer;
import alternativa.engine3d.core.View;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.Tank3D;
import alternativa.tanks.Tank3DPart;
import alternativa.tanks.bg.IBackgroundService;
import alternativa.tanks.camera.GameCamera;
import alternativa.types.Long;
import controls.TankWindow2;
import controls.TankWindowHeader;
import controls.TankWindowInner;
import flash.display.Shape;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.geom.Rectangle;
import flash.utils.Timer;
import flash.utils.clearInterval;
import flash.utils.getTimer;
import flash.utils.setInterval;
import scpacker.resource.ResourceType;
import scpacker.resource.ResourceUtil;
import scpacker.resource.images.ImageResource;
import scpacker.resource.tanks.TankResource;
import specter.utils.Logger;
public class TankPreview extends Sprite
{
private var window:TankWindow2;
private const windowMargin:int = 11;
private var inner:TankWindowInner;
private var rootContainer:Object3DContainer;
private var cameraContainer:Object3DContainer;
private var camera:GameCamera;
private var timer:Timer;
private var tank:Tank3D;
private var rotationSpeed:Number;
private var lastTime:int;
private var loadedCounter:int = 0;
private var holdMouseX:int;
private var lastMouseX:int;
private var prelastMouseX:int;
private var rate:Number;
private var startAngle:Number = -150;
private var holdAngle:Number;
private var slowdownTimer:Timer;
private var resetRateInt:uint;
private var autoRotationDelay:int = 10000;
private var autoRotationTimer:Timer;
public var overlay:Shape;
private var firstAutoRotation:Boolean = true;
private var first_resize:Boolean = true;
public function TankPreview(garageBoxId:Long, rotationSpeed:Number = 5)
{
var box:Mesh = null;
var material:TextureMaterial = null;
this.overlay = new Shape();
super();
this.rotationSpeed = rotationSpeed;
this.window = new TankWindow2(400,300);
var localeService:ILocaleService = ILocaleService(Main.osgi.getService(ILocaleService));
this.window.header = TankWindowHeader.YOUR_TANK;
addChild(this.window);
this.rootContainer = new KDContainer();
var boxResource:TankResource = ResourceUtil.getResource(ResourceType.MODEL,"garage_box_model") as TankResource;
Main.writeVarsToConsoleChannel("TANK PREVIEW","\tgarageBoxId: %1",garageBoxId);
Main.writeVarsToConsoleChannel("TANK PREVIEW","\tboxResource: %1",boxResource);
var boxes:Vector.<Mesh> = new Vector.<Mesh>();
var numObjects:int = boxResource.objects.length;
Logger.log("Garage: " + numObjects + " " + boxResource.id);
for(var i:int = 0; i < numObjects; i++)
{
box = boxResource.objects[i] as Mesh;
if(box != null)
{
material = TextureMaterial(box.alternativa3d::faceList.material);
Main.writeVarsToConsoleChannel("TEST","TankPreview::TankPreview() box texture=%1","E");
material.texture = ResourceUtil.getResource(ResourceType.IMAGE,"garage_box_img").bitmapData;
boxes.push(box);
}
}
this.rootContainer.addChild(boxes[0]);
this.rootContainer.addChild(boxes[2]);
this.rootContainer.addChild(boxes[1]);
this.rootContainer.addChild(boxes[3]);
this.tank = new Tank3D(null,null,null);
this.rootContainer.addChild(this.tank);
this.tank.matrix.appendTranslation(-17,0,0);
this.camera = new GameCamera();
this.camera.view = new View(100,100,false);
this.camera.view.hideLogo();
this.camera.useShadowMap = true;
this.camera.useLight = true;
addChild(this.camera.view);
addChild(this.overlay);
this.overlay.x = 0;
this.overlay.y = 9;
this.overlay.width = 1500;
this.overlay.height = 1300;
this.overlay.graphics.clear();
this.cameraContainer = new Object3DContainer();
this.rootContainer.addChild(this.cameraContainer);
this.cameraContainer.addChild(this.camera);
this.camera.z = -740;
this.cameraContainer.rotationX = -135 * Math.PI / 180;
this.cameraContainer.rotationZ = this.startAngle * Math.PI / 180;
this.inner = new TankWindowInner(0,0,TankWindowInner.TRANSPARENT);
addChild(this.inner);
this.inner.mouseEnabled = true;
this.resize(400,300);
this.autoRotationTimer = new Timer(this.autoRotationDelay,1);
this.autoRotationTimer.addEventListener(TimerEvent.TIMER_COMPLETE,this.start);
this.timer = new Timer(50);
this.slowdownTimer = new Timer(20,1000000);
this.slowdownTimer.addEventListener(TimerEvent.TIMER,this.slowDown);
this.inner.addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
Main.stage.addEventListener(Event.ENTER_FRAME,this.onRender);
this.start();
}
public function hide() : void
{
var bgService:IBackgroundService = Main.osgi.getService(IBackgroundService) as IBackgroundService;
if(bgService != null)
{
bgService.drawBg();
}
this.stopAll();
this.window = null;
this.inner = null;
this.rootContainer = null;
this.cameraContainer = null;
this.camera = null;
this.timer = null;
this.tank = null;
Main.stage.removeEventListener(Event.ENTER_FRAME,this.onRender);
}
private function onMouseDown(e:MouseEvent) : void
{
if(this.autoRotationTimer.running)
{
this.autoRotationTimer.stop();
}
if(this.timer.running)
{
this.stop();
}
if(this.slowdownTimer.running)
{
this.slowdownTimer.stop();
}
this.resetRate();
this.holdMouseX = Main.stage.mouseX;
this.lastMouseX = this.holdMouseX;
this.prelastMouseX = this.holdMouseX;
this.holdAngle = this.cameraContainer.rotationZ;
Main.writeToConsole("TankPreview onMouseMove holdAngle: " + this.holdAngle.toString());
Main.stage.addEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
Main.stage.addEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
}
private function onMouseMove(e:MouseEvent) : void
{
this.cameraContainer.rotationZ = this.holdAngle - (Main.stage.mouseX - this.holdMouseX) * 0.01;
this.camera.render();
this.rate = (Main.stage.mouseX - this.prelastMouseX) * 0.5;
this.prelastMouseX = this.lastMouseX;
this.lastMouseX = Main.stage.mouseX;
clearInterval(this.resetRateInt);
this.resetRateInt = setInterval(this.resetRate,50);
}
private function resetRate() : void
{
this.rate = 0;
}
private function onMouseUp(e:MouseEvent) : void
{
clearInterval(this.resetRateInt);
Main.stage.removeEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
Main.stage.removeEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
if(Math.abs(this.rate) > 0)
{
this.slowdownTimer.reset();
this.slowdownTimer.start();
}
else
{
this.autoRotationTimer.reset();
this.autoRotationTimer.start();
}
}
private function slowDown(e:TimerEvent) : void
{
this.cameraContainer.rotationZ -= this.rate * 0.01;
this.camera.render();
this.rate *= Math.exp(-0.02);
if(Math.abs(this.rate) < 0.1)
{
this.slowdownTimer.stop();
this.autoRotationTimer.reset();
this.autoRotationTimer.start();
}
}
public function setHull(hull:String) : void
{
if(hull.indexOf("HD_") != -1)
{
hull = hull.replace("HD_","");
}
var hullPart:Tank3DPart = new Tank3DPart();
hullPart.details = ResourceUtil.getResource(ResourceType.IMAGE,hull + "_details").bitmapData;
hullPart.lightmap = ResourceUtil.getResource(ResourceType.IMAGE,hull + "_lightmap").bitmapData;
hullPart.mesh = ResourceUtil.getResource(ResourceType.MODEL,hull).mesh;
hullPart.turretMountPoint = ResourceUtil.getResource(ResourceType.MODEL,hull).turretMount;
this.tank.setHull(hullPart);
if(this.loadedCounter < 3)
{
++this.loadedCounter;
}
if(this.loadedCounter == 3)
{
if(this.firstAutoRotation && !this.timer.running && !this.slowdownTimer.running)
{
this.start();
}
this.camera.render();
}
}
public function setTurret(turret:String) : void
{
var turretPart:Tank3DPart = new Tank3DPart();
turretPart.details = ResourceUtil.getResource(ResourceType.IMAGE,turret + "_details").bitmapData;
turretPart.lightmap = ResourceUtil.getResource(ResourceType.IMAGE,turret + "_lightmap").bitmapData;
if(turret.indexOf("HD_") != -1)
{
turret = turret.replace("HD_","");
}
turretPart.mesh = ResourceUtil.getResource(ResourceType.MODEL,turret).mesh;
turretPart.turretMountPoint = ResourceUtil.getResource(ResourceType.MODEL,turret).turretMount;
this.tank.setTurret(turretPart);
if(this.loadedCounter < 3)
{
++this.loadedCounter;
}
if(this.loadedCounter == 3)
{
if(this.firstAutoRotation && !this.timer.running && !this.slowdownTimer.running)
{
this.start();
this.camera.addShadow(this.tank.shadow);
}
this.camera.render();
}
}
public function setColorMap(map:ImageResource) : void
{
this.tank.setColorMap(map);
if(this.loadedCounter < 3)
{
++this.loadedCounter;
}
if(this.loadedCounter == 3)
{
if(this.firstAutoRotation && !this.timer.running && !this.slowdownTimer.running)
{
this.start();
}
this.camera.render();
}
}
public function resize(width:Number, height:Number, i:int = 0, j:int = 0) : void
{
this.window.width = width;
this.window.height = height;
this.window.alpha = 1;
this.inner.width = width - this.windowMargin * 2;
this.inner.height = height - this.windowMargin * 2;
this.inner.x = this.windowMargin;
this.inner.y = this.windowMargin;
var bgService:IBackgroundService = Main.osgi.getService(IBackgroundService) as IBackgroundService;
if(Main.stage.stageWidth >= 800 && !this.first_resize)
{
if(bgService != null)
{
bgService.drawBg(new Rectangle(Math.round(int(Math.max(1000,Main.stage.stageWidth)) / 3) + this.windowMargin,60 + this.windowMargin,this.inner.width,this.inner.height));
}
}
this.first_resize = false;
this.camera.view.width = width - this.windowMargin * 2 - 2;
this.camera.view.height = height - this.windowMargin * 2 - 2;
this.camera.view.x = this.windowMargin;
this.camera.view.y = this.windowMargin;
this.camera.render();
}
public function start(e:TimerEvent = null) : void
{
if(this.loadedCounter < 3)
{
this.autoRotationTimer.reset();
this.autoRotationTimer.start();
}
else
{
this.firstAutoRotation = false;
this.timer.addEventListener(TimerEvent.TIMER,this.onTimer);
this.timer.reset();
this.lastTime = getTimer();
this.timer.start();
}
}
public function onRender(e:Event) : void
{
this.camera.render();
}
public function stop() : void
{
this.timer.stop();
this.timer.removeEventListener(TimerEvent.TIMER,this.onTimer);
}
public function stopAll() : void
{
this.timer.stop();
this.timer.removeEventListener(TimerEvent.TIMER,this.onTimer);
this.slowdownTimer.stop();
this.slowdownTimer.removeEventListener(TimerEvent.TIMER,this.slowDown);
this.autoRotationTimer.stop();
this.slowdownTimer.removeEventListener(TimerEvent.TIMER_COMPLETE,this.start);
}
private function onTimer(e:TimerEvent) : void
{
var time:int = this.lastTime;
this.lastTime = getTimer();
this.cameraContainer.rotationZ -= this.rotationSpeed * (this.lastTime - time) * 0.001 * (Math.PI / 180);
}
}
}
|
package alternativa.tanks.view.mainview.grouplist.item.background {
import alternativa.tanks.gui.friends.list.renderer.background.FriendCellNormal;
public class GroupListBackgroundRendererNormal extends GroupListBackgroundRenderer {
public function GroupListBackgroundRendererNormal() {
super(FriendCellNormal);
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_red_OVER_CENTER.png")]
public dynamic class button_red_OVER_CENTER extends BitmapData {
public function button_red_OVER_CENTER(param1:int = 201, param2:int = 30) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.engine3d
{
public class UVFrame
{
public var topLeftU:Number;
public var topLeftV:Number;
public var bottomRightU:Number;
public var bottomRightV:Number;
public function UVFrame(param1:Number, param2:Number, param3:Number, param4:Number)
{
super();
this.topLeftU = param1;
this.topLeftV = param2;
this.bottomRightU = param3;
this.bottomRightV = param4;
}
}
}
|
package _codec.projects.tanks.client.panel.model.challenge.stars {
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.challenge.stars.StarsInfoCC;
public class VectorCodecStarsInfoCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecStarsInfoCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(StarsInfoCC,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.<StarsInfoCC> = new Vector.<StarsInfoCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = StarsInfoCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:StarsInfoCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<StarsInfoCC> = Vector.<StarsInfoCC>(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 scpacker.gui.en
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksIEN_coldload10 extends BitmapAsset
{
public function GTanksIEN_coldload10()
{
super();
}
}
}
|
package alternativa.engine3d.containers {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Canvas;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Object3DContainer;
use namespace alternativa3d;
public class DistanceSortContainer extends Object3DContainer {
private static const sortingStack:Vector.<int> = new Vector.<int>();
public var sortByZ:Boolean = false;
public function DistanceSortContainer() {
super();
}
override public function clone() : Object3D {
var local1:DistanceSortContainer = new DistanceSortContainer();
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
super.clonePropertiesFrom(param1);
var local2:DistanceSortContainer = param1 as DistanceSortContainer;
this.sortByZ = local2.sortByZ;
}
override alternativa3d function drawVisibleChildren(param1:Camera3D, param2:Canvas) : void {
var local3:int = 0;
var local4:int = 0;
var local5:Object3D = null;
var local8:int = 0;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local6:int = 0;
var local7:int = alternativa3d::numVisibleChildren - 1;
sortingStack[0] = local6;
sortingStack[1] = local7;
local8 = 2;
if(this.sortByZ) {
while(local8 > 0) {
local7 = sortingStack[--local8];
local6 = sortingStack[--local8];
local4 = local7;
local3 = local6;
local5 = alternativa3d::visibleChildren[local7 + local6 >> 1];
local10 = Number(local5.alternativa3d::ml);
do {
while(true) {
local9 = Number((alternativa3d::visibleChildren[local3] as Object3D).alternativa3d::ml);
if(local9 <= local10) {
break;
}
local3++;
}
while(true) {
local11 = Number((alternativa3d::visibleChildren[local4] as Object3D).alternativa3d::ml);
if(local11 >= local10) {
break;
}
local4--;
}
if(local3 <= local4) {
local5 = alternativa3d::visibleChildren[local3];
var local14:* = local3++;
alternativa3d::visibleChildren[local14] = alternativa3d::visibleChildren[local4];
var local15:* = local4--;
alternativa3d::visibleChildren[local15] = local5;
}
}
while(local3 <= local4);
if(local6 < local4) {
local14 = local8++;
sortingStack[local14] = local6;
local15 = local8++;
sortingStack[local15] = local4;
}
if(local3 < local7) {
local14 = local8++;
sortingStack[local14] = local3;
local15 = local8++;
sortingStack[local15] = local7;
}
}
} else {
local3 = 0;
while(local3 < alternativa3d::numVisibleChildren) {
local5 = alternativa3d::visibleChildren[local3];
local12 = local5.alternativa3d::md * param1.alternativa3d::viewSizeX / param1.alternativa3d::focalLength;
local13 = local5.alternativa3d::mh * param1.alternativa3d::viewSizeY / param1.alternativa3d::focalLength;
local5.alternativa3d::distance = local12 * local12 + local13 * local13 + local5.alternativa3d::ml * local5.alternativa3d::ml;
local3++;
}
while(local8 > 0) {
local7 = sortingStack[--local8];
local6 = sortingStack[--local8];
local4 = local7;
local3 = local6;
local5 = alternativa3d::visibleChildren[local7 + local6 >> 1];
local10 = Number(local5.alternativa3d::distance);
do {
while(true) {
local9 = Number((alternativa3d::visibleChildren[local3] as Object3D).alternativa3d::distance);
if(local9 <= local10) {
break;
}
local3++;
}
while(true) {
local11 = Number((alternativa3d::visibleChildren[local4] as Object3D).alternativa3d::distance);
if(local11 >= local10) {
break;
}
local4--;
}
if(local3 <= local4) {
local5 = alternativa3d::visibleChildren[local3];
local14 = local3++;
alternativa3d::visibleChildren[local14] = alternativa3d::visibleChildren[local4];
local15 = local4--;
alternativa3d::visibleChildren[local15] = local5;
}
}
while(local3 <= local4);
if(local6 < local4) {
local14 = local8++;
sortingStack[local14] = local6;
local15 = local8++;
sortingStack[local15] = local4;
}
if(local3 < local7) {
local14 = local8++;
sortingStack[local14] = local3;
local15 = local8++;
sortingStack[local15] = local7;
}
}
}
local3 = alternativa3d::numVisibleChildren - 1;
while(local3 >= 0) {
local5 = alternativa3d::visibleChildren[local3];
local5.alternativa3d::draw(param1,param2);
alternativa3d::visibleChildren[local3] = null;
local3--;
}
}
}
}
|
package alternativa.tanks.gui.communication {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.chat.dropdown.ChatDropDownList;
import alternativa.tanks.gui.communication.button.CommunicationPanelTabButton;
import alternativa.tanks.gui.communication.button.CommunicationPanelTabControl;
import alternativa.tanks.gui.communication.button.TabButtonTypes;
import alternativa.tanks.gui.communication.button.TabIcons;
import alternativa.tanks.gui.communication.tabs.AbstractCommunicationPanelTab;
import alternativa.tanks.gui.communication.tabs.chat.ChatTab;
import alternativa.tanks.gui.communication.tabs.chat.ChatTabEvent;
import alternativa.tanks.gui.communication.tabs.chat.ChatTabViewEvent;
import alternativa.tanks.gui.communication.tabs.chat.IChatTabView;
import alternativa.tanks.gui.communication.tabs.clanchat.ClanChatTab;
import alternativa.tanks.gui.communication.tabs.clanchat.ClanChatTabNewMessageEvent;
import alternativa.tanks.gui.communication.tabs.clanchat.ClanChatViewEvent;
import alternativa.tanks.gui.communication.tabs.clanchat.IClanChatView;
import alternativa.tanks.gui.communication.tabs.news.NewsTab;
import alternativa.tanks.gui.communication.tabs.news.NewsTabNewsItemAddedEvent;
import alternativa.tanks.gui.friends.button.friends.NewRequestIndicator;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.services.NewsService;
import base.DiscreteSprite;
import flash.display.Bitmap;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.utils.Dictionary;
import forms.TankWindowWithHeader;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
public class CommunicationPanel extends DiscreteSprite {
[Inject]
public static var chatTabView:IChatTabView;
[Inject]
public static var clanChatView:IClanChatView;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var settingsService:ISettingsService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var newsService:NewsService;
private static const WINDOW_MARGIN:int = 12;
private static const BUTTON_WIDTH:int = 102;
private static const GAP:int = 5;
private static const LAST_SHOWN_COMMUNICATOR_TAB:String = "LAST_SHOWED_COMMUNICATOR_TAB";
private var window:TankWindowWithHeader;
private var buttonsPanel:Sprite = new Sprite();
private var buttonsPanelVisibleHeight:int;
private var category2tab:Dictionary = new Dictionary();
private var category2button:Dictionary = new Dictionary();
private var activeTab:AbstractCommunicationPanelTab;
private var activeTabWidth:int;
private var activeTabHeight:int;
private var newsNotifier:Bitmap = new NewRequestIndicator.attentionIconClass();
private var clanChatNotifier:Bitmap = new NewRequestIndicator.attentionIconClass();
private var previousTabCategory:String;
public function CommunicationPanel() {
super();
addEventListener(Event.ADDED_TO_STAGE,this.configUI);
addEventListener(Event.ADDED_TO_STAGE,this.addResizeListener);
addEventListener(Event.REMOVED_FROM_STAGE,this.destroy);
clanUserInfoService.addEventListener(ClanUserInfoEvent.ON_LEAVE_CLAN,this.onLeaveClan);
clanUserInfoService.addEventListener(ClanUserInfoEvent.ON_JOIN_CLAN,this.onJoinClan);
this.setPreviousTabCategory();
newsService.setHasUnreadNewsCallback(this.showNewsIfHasUnread);
}
private function setPreviousTabCategory() : void {
this.previousTabCategory = !!storageService.getStorage().data.hasOwnProperty(LAST_SHOWN_COMMUNICATOR_TAB) ? storageService.getStorage().data[LAST_SHOWN_COMMUNICATOR_TAB] : TabButtonTypes.NEWS_TAB;
}
private function showNewsIfHasUnread() : void {
this.previousTabCategory = TabButtonTypes.NEWS_TAB;
if(Boolean(this.category2tab.hasOwnProperty(this.previousTabCategory)) && !this.category2tab[this.previousTabCategory].isActive) {
this.selectCategory(this.previousTabCategory);
}
}
private function onJoinClan(param1:ClanUserInfoEvent) : void {
clanChatView.updateClanChatView();
}
private function onLeaveClan(param1:ClanUserInfoEvent) : void {
var local2:DisplayObject = null;
if(this.activeTab == this.category2tab[TabButtonTypes.CLAN_CHAT_TAB]) {
this.selectCategory(TabButtonTypes.NEWS_TAB);
}
if(this.category2button.hasOwnProperty(TabButtonTypes.CLAN_CHAT_TAB)) {
local2 = this.category2button[TabButtonTypes.CLAN_CHAT_TAB];
this.buttonsPanel.removeChild(local2);
delete this.category2button[TabButtonTypes.CLAN_CHAT_TAB];
}
removeChild(this.clanChatNotifier);
}
public function configUI(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.configUI);
this.buttonsPanel.x = WINDOW_MARGIN;
this.buttonsPanel.y = WINDOW_MARGIN;
this.buttonsPanelVisibleHeight = new CommunicationPanelTabButton("","",TabIcons.newsIconClass).height;
addChild(this.buttonsPanel);
this.window = TankWindowWithHeader.createWindow(TanksLocale.TEXT_HEADER_COMMUNICATOR);
addChild(this.window);
this.addNewsItemsTab();
var local2:ChatTab = chatTabView.getChatTab();
if(local2 != null) {
this.addChatTab(local2);
} else {
chatTabView.addEventListener(ChatTabViewEvent.CHAT_TAB_CREATED,this.onChatTabCreated);
}
var local3:ClanChatTab = clanChatView.getClanChat();
if(local3 != null) {
this.addClanChatTab(local3);
} else {
clanChatView.addEventListener(ClanChatViewEvent.CLAN_CHAT_ADDED,this.onClanChatTabCreated);
}
this.moveButtonsAndNotifiersToTop();
this.onResize();
}
private function onClanChatTabCreated(param1:ClanChatViewEvent) : void {
clanChatView.removeEventListener(ClanChatViewEvent.CLAN_CHAT_ADDED,this.onClanChatTabCreated);
this.addClanChatTab(clanChatView.getClanChat());
}
private function onChatTabCreated(param1:ChatTabViewEvent) : void {
chatTabView.removeEventListener(ChatTabViewEvent.CHAT_TAB_CREATED,this.onChatTabCreated);
this.addChatTab(chatTabView.getChatTab());
}
private function addNewsItemsTab() : void {
this.addNewsNotifier();
var local1:CommunicationPanelTabButton = new CommunicationPanelTabButton(TabButtonTypes.NEWS_TAB,localeService.getText(TanksLocale.TEXT_NEWS_TAB_HEADER),TabIcons.newsIconClass);
this.addTabControl(TabButtonTypes.NEWS_TAB,local1,0,false);
var local2:NewsTab = new NewsTab();
this.category2tab[TabButtonTypes.NEWS_TAB] = local2;
local2.x = WINDOW_MARGIN;
local2.y = this.buttonsPanel.y + this.buttonsPanelVisibleHeight + GAP;
local2.isActive = true;
local2.addEventListener(NewsTabNewsItemAddedEvent.NEWS_ITEM_ADDED,this.onNewsItemAdded);
addChild(local2);
this.activeTab = local2;
this.activeTab.resize(this.activeTabWidth,this.activeTabHeight);
}
private function addNewsNotifier() : void {
this.newsNotifier.y = WINDOW_MARGIN >> 1;
this.newsNotifier.x = BUTTON_WIDTH;
this.newsNotifier.visible = false;
addChild(this.newsNotifier);
}
private function addChatTab(param1:ChatTab) : void {
var local2:DisplayObject = null;
var local4:ChatDropDownList = null;
var local5:int = 0;
var local6:String = null;
var local7:Object = null;
chatTabView.clear();
this.category2tab[TabButtonTypes.CHAT_TAB] = param1;
param1.addEventListener(ChatTabEvent.HIDE_CHAT,this.onHideChat);
param1.addEventListener(ChatTabEvent.SHOW_CHAT,this.onShowChat);
param1.x = WINDOW_MARGIN;
param1.y = this.buttonsPanel.y + this.buttonsPanelVisibleHeight + GAP;
var local3:Vector.<String> = param1.getChannels();
if(local3.length <= 1) {
local2 = new CommunicationPanelTabButton(TabButtonTypes.CHAT_TAB,localeService.getText(TanksLocale.TEXT_CHAT_TAB_HEADER),TabIcons.chatIconClass);
} else {
local4 = new ChatDropDownList(TabButtonTypes.CHAT_TAB);
local2 = local4;
local5 = 0;
while(local5 < local3.length) {
local6 = local3[local5];
local7 = {
"gameName":local6,
"rang":0
};
local4.addItem(local7);
local5++;
}
local4.selectItemByField("gameName",param1.getCurrentChannel());
local4.addEventListener(Event.CHANGE,param1.onChangeChannel);
}
this.addTabControl(TabButtonTypes.CHAT_TAB,local2,BUTTON_WIDTH + GAP,true);
addChild(param1);
if(!settingsService.showChat) {
this.onHideChat();
return;
}
if(this.previousTabCategory == TabButtonTypes.CHAT_TAB) {
this.selectCategory(TabButtonTypes.CHAT_TAB);
}
}
private function addClanChatTab(param1:ClanChatTab) : void {
clanChatView.clear();
var local2:CommunicationPanelTabButton = new CommunicationPanelTabButton(TabButtonTypes.CLAN_CHAT_TAB,localeService.getText(TanksLocale.TEXT_CLAN_CHAT),TabIcons.clanChatIconClass);
this.addTabControl(TabButtonTypes.CLAN_CHAT_TAB,local2,!!settingsService.showChat ? (BUTTON_WIDTH + GAP) * 2 : BUTTON_WIDTH + GAP,true);
this.category2tab[TabButtonTypes.CLAN_CHAT_TAB] = param1;
param1.x = WINDOW_MARGIN;
param1.y = this.buttonsPanel.y + this.buttonsPanelVisibleHeight + GAP;
addChild(param1);
if(this.previousTabCategory == TabButtonTypes.CLAN_CHAT_TAB) {
this.selectCategory(TabButtonTypes.CLAN_CHAT_TAB);
}
this.addClanChatNotifier();
param1.addEventListener(ClanChatTabNewMessageEvent.NEW_MESSAGE,this.onNewClanChatMessage);
}
private function addClanChatNotifier() : void {
var local1:DisplayObject = this.category2button[TabButtonTypes.CLAN_CHAT_TAB];
this.clanChatNotifier.x = local1.x + BUTTON_WIDTH;
this.clanChatNotifier.y = WINDOW_MARGIN >> 1;
this.clanChatNotifier.visible = false;
addChild(this.clanChatNotifier);
}
private function onNewClanChatMessage(param1:ClanChatTabNewMessageEvent) : void {
var local2:ClanChatTab = this.category2tab[TabButtonTypes.CLAN_CHAT_TAB];
if(!local2.isActive) {
this.clanChatNotifier.visible = true;
}
}
private function addTabControl(param1:String, param2:DisplayObject, param3:Number, param4:Boolean) : void {
param2.width = BUTTON_WIDTH;
param2.x = param3;
param2.addEventListener(MouseEvent.CLICK,this.onTabButtonClick);
(param2 as CommunicationPanelTabControl).enabled = param4;
this.buttonsPanel.addChild(param2);
this.category2button[param1] = param2;
}
private function onNewsItemAdded(param1:NewsTabNewsItemAddedEvent) : void {
var local2:NewsTab = this.category2tab[TabButtonTypes.NEWS_TAB];
if(!local2.isActive) {
this.newsNotifier.visible = true;
}
}
private function onShowChat(param1:ChatTabEvent) : void {
var local2:DisplayObject = this.category2button[TabButtonTypes.CHAT_TAB];
if(!this.buttonsPanel.contains(local2)) {
this.buttonsPanel.addChild(local2);
this.selectCategory(TabButtonTypes.CHAT_TAB);
this.moveClanChatButtonIfExists((BUTTON_WIDTH + GAP) * 2);
}
}
private function onHideChat(param1:ChatTabEvent = null) : void {
if(this.activeTab == this.category2tab[TabButtonTypes.CHAT_TAB]) {
this.selectCategory(TabButtonTypes.NEWS_TAB);
}
var local2:DisplayObject = this.category2button[TabButtonTypes.CHAT_TAB];
if(local2 != null && this.buttonsPanel.contains(local2)) {
this.buttonsPanel.removeChild(local2);
this.moveClanChatButtonIfExists(BUTTON_WIDTH + GAP);
}
}
private function moveClanChatButtonIfExists(param1:int) : void {
var local2:DisplayObject = null;
if(this.category2button.hasOwnProperty(TabButtonTypes.CLAN_CHAT_TAB)) {
local2 = this.category2button[TabButtonTypes.CLAN_CHAT_TAB];
local2.x = param1;
this.clanChatNotifier.x = param1 + BUTTON_WIDTH;
}
}
private function onTabButtonClick(param1:MouseEvent) : void {
var local2:CommunicationPanelTabControl = null;
if(param1.target is CommunicationPanelTabControl) {
local2 = CommunicationPanelTabControl(param1.target);
this.selectCategory(local2.getCategory());
}
}
private function selectCategory(param1:String) : void {
var local4:CommunicationPanelTabControl = null;
var local5:AbstractCommunicationPanelTab = null;
removeChild(this.activeTab);
this.activeTab = this.category2tab[param1];
addChild(this.activeTab);
this.activeTab.resize(this.activeTabWidth,this.activeTabHeight);
this.activeTab.render();
this.activeTab.isActive = true;
var local2:CommunicationPanelTabControl = this.category2button[param1];
local2.enabled = false;
var local3:int = 0;
while(local3 < this.buttonsPanel.numChildren) {
local4 = this.buttonsPanel.getChildAt(local3) as CommunicationPanelTabControl;
if(local2 != local4) {
local4.enabled = true;
local5 = this.category2tab[local4.getCategory()];
local5.isActive = false;
local5.hide();
}
local3++;
}
storageService.getStorage().data[LAST_SHOWN_COMMUNICATOR_TAB] = param1;
if(param1 == TabButtonTypes.NEWS_TAB) {
this.newsNotifier.visible = false;
}
if(param1 == TabButtonTypes.CLAN_CHAT_TAB) {
this.clanChatNotifier.visible = false;
}
this.moveButtonsAndNotifiersToTop();
}
private function moveButtonsAndNotifiersToTop() : void {
if(contains(this.buttonsPanel)) {
removeChild(this.buttonsPanel);
addChild(this.buttonsPanel);
}
if(contains(this.newsNotifier)) {
removeChild(this.newsNotifier);
addChild(this.newsNotifier);
}
if(contains(this.clanChatNotifier)) {
removeChild(this.clanChatNotifier);
addChild(this.clanChatNotifier);
}
}
private function addResizeListener(param1:Event) : void {
stage.addEventListener(Event.RESIZE,this.onResize);
}
private function destroy(param1:Event) : void {
stage.removeEventListener(Event.RESIZE,this.onResize);
var local2:ChatTab = this.category2tab[TabButtonTypes.CHAT_TAB];
if(local2 != null) {
local2.removeEventListener(ChatTabEvent.HIDE_CHAT,this.onHideChat);
local2.removeEventListener(ChatTabEvent.SHOW_CHAT,this.onShowChat);
}
var local3:ClanChatTab = this.category2tab[TabButtonTypes.CLAN_CHAT_TAB];
if(local3 != null) {
local3.removeEventListener(ClanChatTabNewMessageEvent.NEW_MESSAGE,this.onNewClanChatMessage);
}
newsService.resetHasUnreadNewsCallback();
var local4:NewsTab = this.category2tab[TabButtonTypes.NEWS_TAB];
local4.removeEventListener(NewsTabNewsItemAddedEvent.NEWS_ITEM_ADDED,this.onNewsItemAdded);
local4.destroy();
chatTabView.removeEventListener(ChatTabViewEvent.CHAT_TAB_CREATED,this.onChatTabCreated);
clanChatView.removeEventListener(ClanChatViewEvent.CLAN_CHAT_ADDED,this.onClanChatTabCreated);
clanUserInfoService.removeEventListener(ClanUserInfoEvent.ON_LEAVE_CLAN,this.onLeaveClan);
clanUserInfoService.removeEventListener(ClanUserInfoEvent.ON_JOIN_CLAN,this.onJoinClan);
}
private function onResize(param1:Event = null) : void {
x = 0;
y = 60;
var local2:int = int(Math.max(970,stage.stageWidth));
this.window.width = local2 / 3;
this.window.height = Math.max(stage.stageHeight - 60,530);
this.activeTabWidth = this.window.width - WINDOW_MARGIN * 2;
this.activeTabHeight = this.window.height - WINDOW_MARGIN * 2 - GAP - this.buttonsPanelVisibleHeight;
this.activeTab.resize(this.activeTabWidth,this.activeTabHeight);
}
}
}
|
package alternativa.tanks.sfx
{
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.objects.Mesh;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.engine3d.UVFrame;
public class AnimatedPlane extends Mesh
{
private var a:Vertex;
private var b:Vertex;
private var c:Vertex;
private var d:Vertex;
private var uvFrames:Vector.<UVFrame>;
private var numFrames:int = 0;
private var framesPerTimeUnit:Number = 0;
private var currFrame:Number = 0;
public function AnimatedPlane(param1:Number, param2:Number, param3:Number = 0, param4:Number = 0, param5:Number = 10)
{
super();
this.createFaces(param1,param2,param3,param4,param5);
sorting = Sorting.DYNAMIC_BSP;
calculateBounds();
calculateFacesNormals();
this.writeVertices();
this.shadowMapAlphaThreshold = 2;
this.depthMapAlphaThreshold = 2;
}
private function createFaces(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number) : void
{
var _loc6_:Number = param1 / 2;
var _loc7_:Number = param2 / 2;
var _loc8_:Vector.<Number> = Vector.<Number>([param3 - _loc6_,param4 + _loc7_,param5,param3 - _loc6_,param4 - _loc7_,param5,param3 + _loc6_,param4 - _loc7_,param5,param3 + _loc6_,param4 + _loc7_,param5]);
var _loc9_:Vector.<Number> = Vector.<Number>([0,0,0,1,1,1,1,0]);
var _loc10_:Vector.<int> = Vector.<int>([4,0,1,2,3,4,0,3,2,1]);
addVerticesAndFaces(_loc8_,_loc9_,_loc10_,true);
}
private function writeVertices() : void
{
var _loc1_:Vector.<Vertex> = this.vertices;
this.a = _loc1_[0];
this.b = _loc1_[1];
this.c = _loc1_[2];
this.d = _loc1_[3];
}
public function init(param1:TextureAnimation, param2:Number) : void
{
setMaterialToAllFaces(param1.material);
this.uvFrames = param1.frames;
this.numFrames = this.uvFrames.length;
this.framesPerTimeUnit = param2;
}
public function setTime(param1:Number) : void
{
this.setFrame(this.uvFrames[int(this.currFrame)]);
this.currFrame += this.framesPerTimeUnit * param1;
while(this.currFrame >= this.numFrames)
{
this.currFrame -= this.numFrames;
}
}
public function clear() : void
{
setMaterialToAllFaces(null);
this.uvFrames = null;
this.numFrames = 0;
this.a = null;
this.b = null;
this.c = null;
this.d = null;
this.destroy();
}
public function getOneLoopTime() : Number
{
return this.numFrames / this.framesPerTimeUnit;
}
private function setFrame(param1:UVFrame) : void
{
this.a.u = param1.topLeftU;
this.a.v = param1.topLeftV;
this.b.u = param1.topLeftU;
this.b.v = param1.bottomRightV;
this.c.u = param1.bottomRightU;
this.c.v = param1.bottomRightV;
this.d.u = param1.bottomRightU;
this.d.v = param1.topLeftV;
}
}
}
|
package projects.tanks.client.clans.user {
import platform.client.fp10.core.type.IGameObject;
public interface IClanUserModelBase {
function alreadyInAccepted(param1:String) : void;
function alreadyInClan() : void;
function alreadyInClanOutgoing(param1:String, param2:IGameObject) : void;
function alreadyInIncoming(param1:String, param2:IGameObject) : void;
function alreadyInOutgoing(param1:String) : void;
function clanBlocked() : void;
function clanExist() : void;
function clanIncomingRequestDisabled() : void;
function clanNotExist() : void;
function creatorLeaveOfClanIfEmptyClan() : void;
function joinClan() : void;
function leftClan(param1:int) : void;
function removeClanBonuses() : void;
function showAlertFullClan() : void;
function updateStatusBonusesClan(param1:Boolean) : void;
function userLowRank() : void;
}
}
|
package alternativa.tanks.models.battlefield.inventory
{
public interface IInventoryPanel
{
function assignItemToSlot(param1:InventoryItem, param2:int) : void;
function itemActivated(param1:InventoryItem) : void;
}
}
|
package forms.battlelist
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
import assets.cellrenderer.battlelist.Abris;
import assets.cellrenderer.battlelist.PaydIcon;
import assets.scroller.color.ScrollThumbSkinGreen;
import assets.scroller.color.ScrollTrackGreen;
import controls.DefaultButton;
import controls.Label;
import controls.TankWindow;
import controls.TankWindowHeader;
import controls.TankWindowInner;
import fl.controls.List;
import fl.controls.ScrollBar;
import fl.data.DataProvider;
import fl.events.ListEvent;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Shape;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.text.TextFormatAlign;
import flash.ui.Keyboard;
import flash.utils.Timer;
import forms.events.BattleListEvent;
public class ViewBattleList extends Sprite
{
[Embed(source="888.png")]
private static const dm:Class;
[Embed(source="1020.png")]
private static const tdm:Class;
[Embed(source="1022.png")]
private static const ctf:Class;
[Embed(source="895.png")]
private static const cp:Class;
private var mainBackground:TankWindow;
private var inner:TankWindowInner;
private var format:TextFormat;
private var battleList:List;
private var dp:DataProvider;
private var filterDP:DataProvider;
private var _selectedBattleID:Object;
private var delayTimer:Timer;
private var iconWidth:int = 100;
private var onStage:Boolean = false;
private var dmButton:DefaultButton;
private var tdmButton:DefaultButton;
private var ctfButton:DefaultButton;
private var domButton:DefaultButton;
private var dmBitmap:Sprite;
private var tdmBitmap:Sprite;
private var ctfBitmap:Sprite;
private var domBitmap:Sprite;
public var createButton:DefaultButton;
private var oldIconWidth:int = 0;
public function ViewBattleList()
{
this.mainBackground = new TankWindow();
this.inner = new TankWindowInner(100,100,TankWindowInner.GREEN);
this.format = new TextFormat("MyriadPro",13);
this.battleList = new List();
this.dp = new DataProvider();
this.filterDP = new DataProvider();
this.dmButton = new DefaultButton();
this.tdmButton = new DefaultButton();
this.ctfButton = new DefaultButton();
this.domButton = new DefaultButton();
this.dmBitmap = new Sprite();
this.tdmBitmap = new Sprite();
this.ctfBitmap = new Sprite();
this.domBitmap = new Sprite();
this.createButton = new DefaultButton();
super();
addEventListener(Event.ADDED_TO_STAGE,this.ConfigUI);
addEventListener(Event.ADDED_TO_STAGE,this.addResizeListener);
addEventListener(Event.REMOVED_FROM_STAGE,this.removeResizeListener);
}
public function get selectedBattleID() : Object
{
return this._selectedBattleID;
}
private function addResizeListener(e:Event) : void
{
stage.addEventListener(Event.RESIZE,this.onResize);
this.onStage = true;
this.onResize(null);
}
private function removeResizeListener(e:Event) : void
{
stage.removeEventListener(Event.RESIZE,this.onResize);
this.onStage = false;
}
private function ConfigUI(e:Event) : void
{
var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
removeEventListener(Event.ADDED_TO_STAGE,this.ConfigUI);
addChild(this.mainBackground);
addChild(this.inner);
this.inner.showBlink = true;
this.mainBackground.headerLang = localeService.getText(TextConst.GUI_LANG);
this.mainBackground.header = TankWindowHeader.CURRENT_BATTLES;
this.battleList.rowHeight = 20;
this.battleList.setStyle("cellRenderer",BattleListRenderer);
this.battleList.dataProvider = this.dp;
this.battleList.addEventListener(ListEvent.ITEM_CLICK,this.selectItem);
this.battleList.addEventListener(KeyboardEvent.KEY_UP,this.selectCurrentItem);
this.battleList.focusEnabled = true;
this.confScroll();
addChild(this.battleList);
this.battleList.move(15,15);
addChild(this.createButton);
this.createButton.addEventListener(MouseEvent.CLICK,this.createGame);
this.createButton.label = localeService.getText(TextConst.BATTLELIST_PANEL_BUTTON_CREATE);
this.dmBitmap.addChild(new dm());
this.tdmBitmap.addChild(new tdm());
this.ctfBitmap.addChild(new ctf());
this.domBitmap.addChild(new cp());
addChild(this.dmButton);
this.dmButton.width = this.dmButton.height;
addChild(this.dmBitmap);
this.dmBitmap.addEventListener(MouseEvent.CLICK,this.filterBattle);
addChild(this.tdmButton);
this.tdmButton.width = this.tdmButton.height;
addChild(this.tdmBitmap);
this.tdmBitmap.addEventListener(MouseEvent.CLICK,this.filterBattle);
addChild(this.ctfButton);
this.ctfButton.width = this.ctfButton.height;
addChild(this.ctfBitmap);
this.ctfBitmap.addEventListener(MouseEvent.CLICK,this.filterBattle);
addChild(this.domButton);
this.domButton.width = this.domButton.height;
addChild(this.domBitmap);
this.domBitmap.addEventListener(MouseEvent.CLICK,this.filterBattle);
this.inner.y = 11;
this.inner.x = 11;
}
private function filterBattle(e:MouseEvent = null) : void
{
var target:Sprite = null;
var i:int = 0;
if(e.currentTarget as Sprite != null)
{
this.battleList.selectedItem = null;
target = e.currentTarget as Sprite;
if(target == this.dmBitmap)
{
this.dmButton.enable = !this.dmButton.enable;
}
else if(target == this.tdmBitmap)
{
this.tdmButton.enable = !this.tdmButton.enable;
}
else if(target == this.ctfBitmap)
{
this.ctfButton.enable = !this.ctfButton.enable;
}
else if(target == this.domBitmap)
{
this.domButton.enable = !this.domButton.enable;
}
this.filterDP.removeAll();
for(i = 0; i < this.dp.length; i++)
{
if(!this.dmButton.enable && this.dp.getItemAt(i).dat.type == "DM")
{
this.filterDP.addItem(this.dp.getItemAt(i));
}
if(!this.tdmButton.enable && this.dp.getItemAt(i).dat.type == "TDM")
{
this.filterDP.addItem(this.dp.getItemAt(i));
}
if(!this.ctfButton.enable && this.dp.getItemAt(i).dat.type == "CTF")
{
this.filterDP.addItem(this.dp.getItemAt(i));
}
if(!this.domButton.enable && this.dp.getItemAt(i).dat.type == "DOM")
{
this.filterDP.addItem(this.dp.getItemAt(i));
}
}
this.filterDP.sortOn(["accessible","id"],[Array.DESCENDING,Array.DESCENDING]);
if(this.filterDP.length > 0 && (this.dmButton.enable || this.tdmButton.enable || this.ctfButton.enable || this.domButton.enable))
{
this.battleList.dataProvider = this.filterDP;
}
else
{
this.battleList.dataProvider = this.dp;
}
}
}
private function confScroll() : void
{
var bar:ScrollBar = this.battleList.verticalScrollBar;
this.battleList.setStyle("downArrowUpSkin",ScrollArrowDownGreen);
this.battleList.setStyle("downArrowDownSkin",ScrollArrowDownGreen);
this.battleList.setStyle("downArrowOverSkin",ScrollArrowDownGreen);
this.battleList.setStyle("downArrowDisabledSkin",ScrollArrowDownGreen);
this.battleList.setStyle("upArrowUpSkin",ScrollArrowUpGreen);
this.battleList.setStyle("upArrowDownSkin",ScrollArrowUpGreen);
this.battleList.setStyle("upArrowOverSkin",ScrollArrowUpGreen);
this.battleList.setStyle("upArrowDisabledSkin",ScrollArrowUpGreen);
this.battleList.setStyle("trackUpSkin",ScrollTrackGreen);
this.battleList.setStyle("trackDownSkin",ScrollTrackGreen);
this.battleList.setStyle("trackOverSkin",ScrollTrackGreen);
this.battleList.setStyle("trackDisabledSkin",ScrollTrackGreen);
this.battleList.setStyle("thumbUpSkin",ScrollThumbSkinGreen);
this.battleList.setStyle("thumbDownSkin",ScrollThumbSkinGreen);
this.battleList.setStyle("thumbOverSkin",ScrollThumbSkinGreen);
this.battleList.setStyle("thumbDisabledSkin",ScrollThumbSkinGreen);
}
private function createGame(e:MouseEvent) : void
{
this.battleList.selectedItem = null;
dispatchEvent(new BattleListEvent(BattleListEvent.CREATE_GAME));
}
private function selectItem(e:ListEvent) : void
{
this._selectedBattleID = e.item.id;
dispatchEvent(new BattleListEvent(BattleListEvent.SELECT_BATTLE));
}
private function selectCurrentItem(e:KeyboardEvent) : void
{
if(!this.battleList.selectedItem || e.keyCode != Keyboard.UP && e.keyCode != Keyboard.DOWN)
{
return;
}
this._selectedBattleID = this.battleList.selectedItem.id;
dispatchEvent(new BattleListEvent(BattleListEvent.SELECT_BATTLE));
}
private function getItem(id:Object, name:String, deathMatch:Boolean = true, reds:int = 0, blues:int = 0, all:int = 0, map:String = "", totalfull:Boolean = false, redful:Boolean = false, bluefull:Boolean = false, accessible:Boolean = true, closed:Boolean = false) : Object
{
var data:Object = new Object();
var item:Object = new Object();
data.gamename = name;
data.id = id;
data.dmatch = deathMatch;
data.reds = reds;
data.blues = blues;
data.all = all;
data.nmap = map;
data.allfull = totalfull;
data.redfull = redful;
data.bluefull = bluefull;
data.accessible = accessible;
data.closed = closed;
item.id = id;
item.accessible = accessible;
item.iconNormal = this.myIcon(false,data);
item.iconSelected = this.myIcon(true,data);
item.dat = data;
return item;
}
public function addItem(id:Object, name:String, deathMatch:Boolean = true, reds:int = 0, blues:int = 0, all:int = 0, map:String = "", totalfull:Boolean = false, redful:Boolean = false, bluefull:Boolean = false, accessible:Boolean = true, closed:Boolean = false, type:String = "") : void
{
var data:Object = new Object();
var item:Object = new Object();
var index:int = this.indexById(id);
data.gamename = name;
data.id = id;
data.type = type;
data.dmatch = deathMatch;
data.reds = reds;
data.blues = blues;
data.all = all;
data.nmap = map;
data.allfull = totalfull;
data.redfull = redful;
data.bluefull = bluefull;
data.accessible = accessible;
data.closed = closed;
item.id = id;
item.accessible = accessible;
item.iconNormal = this.myIcon(false,data);
item.iconSelected = this.myIcon(true,data);
item.dat = data;
if(index < 0)
{
this.dp.addItem(item);
this.dp.sortOn(["accessible","id"],[Array.DESCENDING,Array.DESCENDING]);
}
if(this.onStage)
{
this.onResize();
}
}
public function setBattleAccessibility(id:Object, accessible:Boolean) : void
{
var d:Object = null;
var newItem:Object = null;
var i:Object = new Object();
var index:int = this.indexById(id);
if(index >= 0)
{
i = this.dp.getItemAt(index);
d = i.dat;
newItem = this.getItem(i.id,d.gamename,d.dmatch,d.reds,d.blues,d.all,d.nmap,d.allfull,d.redfull,d.bluefull,accessible,d.closed);
this.dp.replaceItemAt(newItem,index);
this.dp.invalidateItemAt(index);
}
}
public function updatePlayersTotal(id:Object, num:int, full:Boolean) : void
{
var d:Object = null;
var newItem:Object = null;
var i:Object = new Object();
var index:int = this.indexById(id);
if(index >= 0)
{
i = this.dp.getItemAt(index);
d = i.dat;
newItem = this.getItem(i.id,d.gamename,d.dmatch,d.reds,d.blues,num,d.nmap,full,d.redfull,d.bluefull,d.accessible,d.closed);
this.dp.replaceItemAt(newItem,index);
this.dp.invalidateItemAt(index);
}
}
public function updatePlayersRed(id:Object, num:int, full:Boolean) : void
{
var d:Object = null;
var newItem:Object = null;
var i:Object = new Object();
var index:int = this.indexById(id);
if(index >= 0)
{
i = this.dp.getItemAt(index);
d = i.dat;
newItem = this.getItem(i.id,d.gamename,d.dmatch,num,d.blues,d.all,d.nmap,d.allfull,full,d.bluefull,d.accessible,d.closed);
this.dp.replaceItemAt(newItem,index);
this.dp.invalidateItemAt(index);
}
}
public function updatePlayersBlue(id:Object, num:int, full:Boolean) : void
{
var d:Object = null;
var newItem:Object = null;
var i:Object = new Object();
var index:int = this.indexById(id);
if(index >= 0)
{
i = this.dp.getItemAt(index);
d = i.dat;
newItem = this.getItem(i.id,d.gamename,d.dmatch,d.reds,num,d.all,d.nmap,d.allfull,d.redfull,full,d.accessible,d.closed);
this.dp.replaceItemAt(newItem,index);
this.dp.invalidateItemAt(index);
}
}
public function select(id:Object) : void
{
var index:int = this.indexById(id);
if(index > -1)
{
this.battleList.selectedIndex = index;
this.battleList.scrollToSelected();
this._selectedBattleID = id;
}
}
public function removeItem(id:Object) : void
{
var index:int = this.indexById(id);
if(index >= 0)
{
this.dp.removeItemAt(index);
}
}
private function indexById(id:Object) : int
{
var obj:Object = null;
for(var i:int = 0; i < this.dp.length; i++)
{
obj = this.dp.getItemAt(i);
if(obj.id == id)
{
return i;
}
}
return -1;
}
private function myIcon(select:Boolean, data:Object) : Sprite
{
var icon:Bitmap = null;
var tf:Label = null;
var abris:Abris = null;
var cont:Sprite = new Sprite();
var shape:Shape = new Shape();
var access:Boolean = data.accessible;
var closed_icon:PaydIcon = new PaydIcon();
var _width:int = this.iconWidth;
var bmp:BitmapData = new BitmapData(_width,20,true,0);
var abrisX:int = int(_width * 0.55);
if(data.closed)
{
closed_icon.y = 3;
closed_icon.x = -2;
cont.addChild(closed_icon);
closed_icon.gotoAndStop(!!select ? (!!access ? 2 : 4) : (!!access ? 1 : 3));
}
tf = new Label();
tf.size = 12;
tf.color = !!select ? (!!access ? uint(TankWindowInner.GREEN) : uint(5789784)) : (!!access ? uint(5898034) : uint(11645361));
tf.text = data.gamename;
tf.autoSize = TextFieldAutoSize.NONE;
tf.width = abrisX - 6;
tf.height = 18;
tf.x = 8;
tf.y = -1;
cont.addChild(tf);
tf = new Label();
tf.size = 12;
tf.color = !!select ? (!!access ? uint(TankWindowInner.GREEN) : uint(5789784)) : (!!access ? uint(5898034) : uint(11645361));
tf.autoSize = TextFieldAutoSize.RIGHT;
tf.align = TextFormatAlign.RIGHT;
tf.text = String(data.nmap);
tf.x = _width - tf.textWidth + 2;
tf.y = -1;
cont.addChild(tf);
if(data.dmatch)
{
abris = new Abris();
abris.gotoAndStop(!data.allfull ? 2 : 1);
abris.x = abrisX;
abris.y = 1;
cont.addChild(abris);
tf = new Label();
tf.autoSize = TextFieldAutoSize.NONE;
tf.size = 12;
tf.color = !data.allfull ? uint(16777215) : uint(8816262);
tf.align = TextFormatAlign.CENTER;
tf.text = String(data.all);
tf.x = abrisX - 0.5;
tf.y = -1;
tf.width = 52;
cont.addChild(tf);
}
else
{
abris = new Abris();
abris.gotoAndStop(!data.redfull ? 5 : 3);
abris.x = abrisX;
abris.y = 1;
cont.addChild(abris);
abris = new Abris();
abris.gotoAndStop(!data.bluefull ? 6 : 4);
abris.x = abrisX + 27;
abris.y = 1;
cont.addChild(abris);
tf = new Label();
tf.autoSize = TextFieldAutoSize.NONE;
tf.size = 12;
tf.align = TextFormatAlign.CENTER;
tf.color = !data.redfull ? uint(16777215) : uint(8816262);
tf.text = String(data.reds);
tf.x = abrisX - 0.5;
tf.y = -1;
tf.width = 27;
cont.addChild(tf);
tf = new Label();
tf.autoSize = TextFieldAutoSize.NONE;
tf.align = TextFormatAlign.CENTER;
tf.color = !data.bluefull ? uint(16777215) : uint(8816262);
tf.text = String(data.blues);
tf.x = abrisX + 26.5;
tf.y = -1;
tf.width = 25;
cont.addChild(tf);
}
bmp.draw(cont,null,null,null,null,true);
icon = new Bitmap(bmp);
return cont;
}
private function resizeAll(___width:int) : void
{
var i:Object = null;
var d:Object = null;
this.iconWidth = ___width - (this.battleList.maxVerticalScrollPosition > 0 ? 32 : 20);
if(this.iconWidth == this.oldIconWidth)
{
return;
}
this.oldIconWidth = this.iconWidth;
for(var j:int = 0; j < this.dp.length; j++)
{
i = this.dp.getItemAt(j);
d = i.dat;
i.iconNormal = this.myIcon(false,d);
i.iconSelected = this.myIcon(true,d);
this.dp.replaceItemAt(i,j);
this.dp.invalidateItemAt(j);
}
}
private function onResize(e:Event = null) : void
{
var listWidth:int = 0;
var minWidth:int = int(Math.max(1000,stage.stageWidth));
var index:int = this.battleList.selectedIndex;
if(this.delayTimer == null)
{
this.delayTimer = new Timer(400,1);
this.delayTimer.addEventListener(TimerEvent.TIMER,this.resizeList);
}
this.mainBackground.width = minWidth / 3;
this.mainBackground.height = Math.max(stage.stageHeight - 60,530);
this.x = this.mainBackground.width;
this.y = 60;
this.inner.width = this.mainBackground.width - 22;
this.inner.height = this.mainBackground.height - 58;
this.createButton.x = this.mainBackground.width - this.createButton.width - 11;
this.createButton.y = this.mainBackground.height - 42;
this.dmButton.x = this.inner.x;
this.dmButton.y = this.mainBackground.height - 42;
this.tdmButton.x = this.dmButton.x + 11 / 2 + this.dmButton.width;
this.tdmButton.y = this.mainBackground.height - 42;
this.ctfButton.x = this.tdmButton.x + 11 / 2 + this.tdmButton.width;
this.ctfButton.y = this.mainBackground.height - 42;
this.domButton.x = this.ctfButton.x + 11 / 2 + this.ctfButton.width;
this.domButton.y = this.mainBackground.height - 42;
this.dmBitmap.x = this.dmButton.x + (this.dmButton.width - this.dmBitmap.width) / 2;
this.dmBitmap.y = this.dmButton.y + (this.dmButton.height - this.dmBitmap.height) / 2;
this.tdmBitmap.x = this.tdmButton.x + (this.tdmButton.width - this.tdmBitmap.width) / 2;
this.tdmBitmap.y = this.tdmButton.y + (this.tdmButton.height - this.tdmBitmap.height) / 2;
this.ctfBitmap.x = this.ctfButton.x + (this.ctfButton.width - this.ctfBitmap.width) / 2;
this.ctfBitmap.y = this.ctfButton.y + (this.ctfButton.height - this.ctfBitmap.height) / 2;
this.domBitmap.x = this.domButton.x + (this.domButton.width - this.domBitmap.width) / 2;
this.domBitmap.y = this.domButton.y + (this.domButton.height - this.domBitmap.height) / 2;
this.createButton.x = this.mainBackground.width - this.createButton.width - 11;
this.createButton.y = this.mainBackground.height - 42;
listWidth = this.inner.width - (this.battleList.maxVerticalScrollPosition > 0 ? 0 : 4);
this.battleList.setSize(listWidth,this.inner.height - 8);
this.resizeAll(listWidth);
this.delayTimer.stop();
this.delayTimer.start();
}
private function resizeList(e:TimerEvent) : void
{
var index:int = this.battleList.selectedIndex;
var listWidth:int = this.inner.width - (this.battleList.maxVerticalScrollPosition > 0 ? 0 : 4);
this.battleList.setSize(listWidth,this.inner.height - 8);
this.resizeAll(listWidth);
this.battleList.selectedIndex = index;
this.battleList.scrollToSelected();
this.delayTimer.removeEventListener(TimerEvent.TIMER,this.resizeList);
this.delayTimer = null;
}
public function destroy() : *
{
this.mainBackground = null;
}
}
}
|
package alternativa.engine3d.animation.keys {
import alternativa.engine3d.alternativa3d;
use namespace alternativa3d;
public class Keyframe {
alternativa3d var _time:Number = 0;
public function Keyframe() {
super();
}
public function get time() : Number {
return this.alternativa3d::_time;
}
public function get value() : Object {
return null;
}
public function set value(param1:Object) : void {
}
alternativa3d function get nextKeyFrame() : Keyframe {
return null;
}
alternativa3d function set nextKeyFrame(param1:Keyframe) : void {
}
public function toString() : String {
return "[Keyframe time = " + this.alternativa3d::_time.toFixed(2) + " value = " + this.value + "]";
}
}
}
|
package base {
import flash.display.MovieClip;
public class DiscreteMovieClip extends MovieClip {
public function DiscreteMovieClip() {
super();
}
override public function set x(param1:Number) : void {
super.x = int(param1);
}
override public function set y(param1:Number) : void {
super.y = int(param1);
}
override public function set width(param1:Number) : void {
super.width = Math.ceil(param1);
}
override public function set height(param1:Number) : void {
super.height = Math.ceil(param1);
}
}
}
|
package platform.client.fp10.core.network.command.control.client {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
public class HashRequestCommandCodec implements ICodec {
private var arrayCodec:ICodec;
public function HashRequestCommandCodec(param1:IProtocol) {
super();
this.init(param1);
}
public function init(param1:IProtocol) : void {
this.arrayCodec = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(String,false),false,1));
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local3:HashRequestCommand = HashRequestCommand(param2);
this.arrayCodec.encode(param1,local3.parameterNames);
this.arrayCodec.encode(param1,local3.parameterValues);
}
public function decode(param1:ProtocolBuffer) : Object {
return null;
}
}
}
|
package alternativa.tanks.models.weapon.common {
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IWeaponCommonModelEvents implements IWeaponCommonModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IWeaponCommonModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getCommonData() : WeaponCommonData {
var result:WeaponCommonData = null;
var i:int = 0;
var m:IWeaponCommonModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IWeaponCommonModel(this.impl[i]);
result = m.getCommonData();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function storeTank(param1:Tank) : void {
var i:int = 0;
var m:IWeaponCommonModel = null;
var tank:Tank = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IWeaponCommonModel(this.impl[i]);
m.storeTank(tank);
i++;
}
}
finally {
Model.popObject();
}
}
public function getTank() : Tank {
var result:Tank = null;
var i:int = 0;
var m:IWeaponCommonModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IWeaponCommonModel(this.impl[i]);
result = m.getTank();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getGunParams(param1:int = 0) : AllGlobalGunParams {
var result:AllGlobalGunParams = null;
var i:int = 0;
var m:IWeaponCommonModel = null;
var barrelIndex:int = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IWeaponCommonModel(this.impl[i]);
result = m.getGunParams(barrelIndex);
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.physics.collision
{
import alternativa.physics.collision.types.BoundBox;
public class CollisionKdNode
{
public var indices:Vector.<int>;
public var splitIndices:Vector.<int>;
public var boundBox:BoundBox;
public var parent:CollisionKdNode;
public var splitTree:CollisionKdTree2D;
public var axis:int = -1;
public var coord:Number;
public var positiveNode:CollisionKdNode;
public var negativeNode:CollisionKdNode;
public function CollisionKdNode()
{
super();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.blur {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.display.IDisplay;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.MouseEvent;
import flash.geom.Point;
import flash.utils.Dictionary;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.IHelpService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.removeDisplayObject;
public class BlurService extends EventDispatcher implements IBlurService {
[Inject]
public static var helperService:IHelpService;
private static const OVERLAY_COLOR:uint = 0;
private static const OVERLAY_ALPHA:Number = 0.5;
private var isBlurGameContent:Boolean;
private var isBlurBattleContent:Boolean;
private var isBlurDialogContent:Boolean;
private var isBlurAllContent:Boolean;
private var overlay:Sprite;
private var mainContainerService:IDisplay;
private var componentOverlays:Dictionary;
private var blurredComponentsCount:uint = 0;
public function BlurService() {
super();
this.mainContainerService = IDisplay(OSGi.getInstance().getService(IDisplay));
this.overlay = new Sprite();
this.overlay.mouseEnabled = true;
this.componentOverlays = new Dictionary();
}
private static function lockHelpService() : void {
helperService.pushState();
helperService.hideAllHelpers();
helperService.lock();
}
private static function unLockHelpService() : void {
helperService.popState();
helperService.unlock();
}
public function blurComponent(param1:DisplayObject) : void {
if(param1 in this.componentOverlays) {
return;
}
var local2:Sprite = this.createComponentOverlay(param1);
this.componentOverlays[param1] = local2;
++this.blurredComponentsCount;
if(this.blurredComponentsCount == 1) {
this.mainContainerService.stage.addEventListener(Event.RESIZE,this.onStageResize);
}
this.mainContainerService.dialogsLayer.addChildAt(local2,0);
}
private function createComponentOverlay(param1:DisplayObject) : Sprite {
var local2:Sprite = new Sprite();
param1.addEventListener(Event.REMOVED_FROM_STAGE,this.onRemovedFromStage);
this.redrawComponentOverlay(local2,param1);
return local2;
}
public function blurBattleContent() : void {
if(!this.isBlurBattleContent) {
this.isBlurBattleContent = true;
this.addOverlay();
}
this.mainContainerService.systemLayer.addChildAt(this.overlay,0);
}
public function blurGameContent() : void {
if(!this.isBlurGameContent) {
this.isBlurGameContent = true;
this.addOverlay();
}
this.mainContainerService.dialogsLayer.addChildAt(this.overlay,0);
}
public function blurDialogContent() : void {
if(!this.isBlurDialogContent) {
this.isBlurDialogContent = true;
this.addOverlay();
}
this.mainContainerService.noticesLayer.addChildAt(this.overlay,0);
}
public function blurAllContent() : void {
if(!this.isBlurAllContent) {
this.isBlurAllContent = true;
this.addOverlay();
}
this.mainContainerService.stage.addChild(this.overlay);
}
public function unblurBattleContent() : void {
if(this.isBlurBattleContent) {
this.isBlurBattleContent = false;
if(this.isBlurAllContent) {
return;
}
if(this.isBlurDialogContent) {
this.blurDialogContent();
return;
}
if(this.isBlurGameContent) {
this.blurGameContent();
return;
}
this.removeOverlay();
}
}
public function unblurGameContent() : void {
if(this.isBlurGameContent) {
this.isBlurGameContent = false;
if(this.isBlurAllContent) {
return;
}
if(this.isBlurDialogContent) {
this.blurDialogContent();
return;
}
if(this.isBlurBattleContent) {
this.blurBattleContent();
return;
}
this.removeOverlay();
}
}
public function unblurDialogContent() : void {
if(this.isBlurDialogContent) {
this.isBlurDialogContent = false;
if(this.isBlurAllContent) {
return;
}
if(this.isBlurGameContent) {
this.blurGameContent();
return;
}
if(this.isBlurBattleContent) {
this.blurBattleContent();
return;
}
this.removeOverlay();
}
}
public function unblurAllContent() : void {
if(this.isBlurAllContent) {
this.isBlurAllContent = false;
if(this.isBlurDialogContent) {
this.blurDialogContent();
return;
}
if(this.isBlurGameContent) {
this.blurGameContent();
return;
}
if(this.isBlurBattleContent) {
this.blurBattleContent();
return;
}
this.removeOverlay();
}
}
public function unblurAllComponents() : void {
var local1:Object = null;
for(local1 in this.componentOverlays) {
this.unblurComponent(DisplayObject(local1));
}
}
public function unblurComponent(param1:DisplayObject) : void {
if(param1 in this.componentOverlays) {
param1.removeEventListener(Event.REMOVED_FROM_STAGE,this.onRemovedFromStage);
removeDisplayObject(this.componentOverlays[param1]);
delete this.componentOverlays[param1];
--this.blurredComponentsCount;
if(this.blurredComponentsCount == 0) {
this.mainContainerService.stage.removeEventListener(Event.RESIZE,this.onStageResize);
}
}
}
private function addOverlay() : void {
if(this.overlay.parent == null) {
this.mainContainerService.stage.addEventListener(Event.RESIZE,this.redrawOverlay);
this.overlay.addEventListener(MouseEvent.CLICK,this.onClickOverlay);
this.redrawOverlay();
lockHelpService();
}
}
private function redrawOverlay(param1:Event = null) : void {
var local2:int = int(this.mainContainerService.stage.stageWidth);
var local3:int = int(this.mainContainerService.stage.stageHeight);
this.overlay.graphics.clear();
this.overlay.graphics.beginFill(OVERLAY_COLOR,OVERLAY_ALPHA);
this.overlay.graphics.drawRect(0,0,local2,local3);
}
private function onClickOverlay(param1:MouseEvent) : void {
if(this.isClickOverlayBattleContent()) {
dispatchEvent(new BlurServiceEvent(BlurServiceEvent.CLICK_OVERLAY_BATTLE_CONTENT));
}
}
private function isClickOverlayBattleContent() : Boolean {
return this.isBlurBattleContent && !this.isBlurGameContent && !this.isBlurDialogContent && !this.isBlurAllContent;
}
private function removeOverlay() : void {
if(this.overlay.parent != null) {
this.overlay.removeEventListener(MouseEvent.CLICK,this.onClickOverlay);
removeDisplayObject(this.overlay);
this.mainContainerService.stage.removeEventListener(Event.RESIZE,this.redrawOverlay);
unLockHelpService();
}
}
private function onStageResize(param1:Event) : void {
var local2:Object = null;
for(local2 in this.componentOverlays) {
this.redrawComponentOverlay(this.componentOverlays[local2],DisplayObject(local2));
}
}
private function redrawComponentOverlay(param1:Sprite, param2:DisplayObject) : void {
var local3:Point = param2.localToGlobal(new Point(0,0));
param1.graphics.clear();
param1.graphics.beginFill(0,0);
param1.graphics.drawRect(local3.x,local3.y,param2.width,param2.height);
param1.graphics.endFill();
}
private function onRemovedFromStage(param1:Event) : void {
var local2:DisplayObject = DisplayObject(param1.target);
this.unblurComponent(local2);
}
}
}
|
package projects.tanks.client.partners.impl.china.partner360platform {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class Partner360PlatformModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:Partner360PlatformModelServer;
private var client:IPartner360PlatformModelBase = IPartner360PlatformModelBase(this);
private var modelId:Long = Long.getLong(601165383,1506017039);
public function Partner360PlatformModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new Partner360PlatformModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_buttonRedOver.png")]
public class MakeUp_buttonRedOver extends BitmapAsset {
public function MakeUp_buttonRedOver() {
super();
}
}
}
|
package utils.tweener.easing {
public class Quart {
public static const power:uint = 3;
public function Quart() {
super();
}
public static function easeIn(param1:Number, param2:Number, param3:Number, param4:Number) : Number {
return param3 * (param1 = param1 / param4) * param1 * param1 * param1 + param2;
}
public static function easeOut(param1:Number, param2:Number, param3:Number, param4:Number) : Number {
return -param3 * ((param1 = param1 / param4 - 1) * param1 * param1 * param1 - 1) + param2;
}
public static function easeInOut(param1:Number, param2:Number, param3:Number, param4:Number) : Number {
param1 = param1 / (param4 * 0.5);
if(param1 < 1) {
return param3 * 0.5 * param1 * param1 * param1 * param1 + param2;
}
return -param3 * 0.5 * ((param1 = param1 - 2) * param1 * param1 * param1 - 2) + param2;
}
}
}
|
package alternativa.tanks.gui.payment.controls {
import controls.base.BigButtonBase;
import platform.client.fp10.core.resource.types.ImageResource;
public class PaymentButton extends BigButtonBase {
private var _url:String;
public function PaymentButton(param1:ImageResource) {
super();
icon = param1.data;
this.width = 155;
}
override public function set width(param1:Number) : void {
super.width = param1;
_info.width = _label.width = _width - 4;
if(_icon != null) {
_icon.x = int(_width / 2 - _icon.width / 2);
_icon.y = int(25 - _icon.height / 2);
}
}
public function get url() : String {
return this._url;
}
public function set url(param1:String) : void {
this._url = param1;
}
}
}
|
package alternativa.engine3d.loaders.collada {
public namespace daeAlternativa3DMesh = "http://alternativaplatform.com/a3d/Mesh";
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_SELECTED_RED_PIXEL.png")]
public dynamic class bres_SELECTED_RED_PIXEL extends BitmapData {
public function bres_SELECTED_RED_PIXEL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.battle.scene3d {
public class CameraFovCalculator {
private static const NARROW_SCREEN:Number = 12;
private static const WIDE_SCREEN:Number = 16;
private static const DIVIDER:Number = 9;
private static const DEFAULT_FOV:Number = Math.PI / 2;
public function CameraFovCalculator() {
super();
}
public static function getCameraFov(param1:Number, param2:Number) : Number {
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
var local3:Number = param2 / DIVIDER;
var local4:Number = param1 / local3;
if(local4 <= NARROW_SCREEN) {
return DEFAULT_FOV;
}
local5 = local4 - (WIDE_SCREEN - NARROW_SCREEN);
if(local5 < NARROW_SCREEN) {
local5 = NARROW_SCREEN;
}
local6 = local5 * local3;
local7 = Math.sqrt(local6 * local6 + param2 * param2) * 0.5 / Math.tan(DEFAULT_FOV * 0.5);
return Math.atan(Math.sqrt(param1 * param1 + param2 * param2) * 0.5 / local7) * 2;
}
}
}
|
package alternativa.engine3d.core {
import alternativa.engine3d.alternativa3d;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
use namespace alternativa3d;
public class Object3DContainer extends Object3D {
public var mouseChildren:Boolean = true;
alternativa3d var childrenList:Object3D;
alternativa3d var lightList:Light3D;
alternativa3d var visibleChildren:Vector.<Object3D> = new Vector.<Object3D>();
alternativa3d var numVisibleChildren:int = 0;
public function Object3DContainer() {
super();
}
public function addChild(param1:Object3D) : Object3D {
if(param1 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1 == this) {
throw new ArgumentError("An object cannot be added as a child of itself.");
}
var local2:Object3DContainer = alternativa3d::_parent;
while(local2 != null) {
if(local2 == param1) {
throw new ArgumentError("An object cannot be added as a child to one of it\'s children (or children\'s children, etc.).");
}
local2 = local2.alternativa3d::_parent;
}
if(param1.alternativa3d::_parent != null) {
param1.alternativa3d::_parent.removeChild(param1);
}
this.alternativa3d::addToList(param1);
return param1;
}
public function removeChild(param1:Object3D) : Object3D {
var local2:Object3D = null;
var local3:Object3D = null;
if(param1 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1.alternativa3d::_parent != this) {
throw new ArgumentError("The supplied Object3D must be a child of the caller.");
}
local3 = this.alternativa3d::childrenList;
while(local3 != null) {
if(local3 == param1) {
if(local2 != null) {
local2.alternativa3d::next = local3.alternativa3d::next;
} else {
this.alternativa3d::childrenList = local3.alternativa3d::next;
}
local3.alternativa3d::next = null;
local3.alternativa3d::setParent(null);
return param1;
}
local2 = local3;
local3 = local3.alternativa3d::next;
}
throw new ArgumentError("Cannot remove child.");
}
public function addChildAt(param1:Object3D, param2:int) : Object3D {
if(param1 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1 == this) {
throw new ArgumentError("An object cannot be added as a child of itself.");
}
if(param2 < 0) {
throw new RangeError("The supplied index is out of bounds.");
}
var local3:Object3DContainer = alternativa3d::_parent;
while(local3 != null) {
if(local3 == param1) {
throw new ArgumentError("An object cannot be added as a child to one of it\'s children (or children\'s children, etc.).");
}
local3 = local3.alternativa3d::_parent;
}
var local4:Object3D = this.alternativa3d::childrenList;
var local5:int = 0;
while(local5 < param2) {
if(local4 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
local4 = local4.alternativa3d::next;
local5++;
}
if(param1.alternativa3d::_parent != null) {
param1.alternativa3d::_parent.removeChild(param1);
}
this.alternativa3d::addToList(param1,local4);
return param1;
}
public function removeChildAt(param1:int) : Object3D {
if(param1 < 0) {
throw new RangeError("The supplied index is out of bounds.");
}
var local2:Object3D = this.alternativa3d::childrenList;
var local3:int = 0;
while(local3 < param1) {
if(local2 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
local2 = local2.alternativa3d::next;
local3++;
}
if(local2 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
this.removeChild(local2);
return local2;
}
public function getChildAt(param1:int) : Object3D {
if(param1 < 0) {
throw new RangeError("The supplied index is out of bounds.");
}
var local2:Object3D = this.alternativa3d::childrenList;
var local3:int = 0;
while(local3 < param1) {
if(local2 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
local2 = local2.alternativa3d::next;
local3++;
}
if(local2 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
return local2;
}
public function getChildIndex(param1:Object3D) : int {
if(param1 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1.alternativa3d::_parent != this) {
throw new ArgumentError("The supplied Object3D must be a child of the caller.");
}
var local2:int = 0;
var local3:Object3D = this.alternativa3d::childrenList;
while(local3 != null) {
if(local3 == param1) {
return local2;
}
local2++;
local3 = local3.alternativa3d::next;
}
throw new ArgumentError("Cannot get child index.");
}
public function setChildIndex(param1:Object3D, param2:int) : void {
if(param1 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1.alternativa3d::_parent != this) {
throw new ArgumentError("The supplied Object3D must be a child of the caller.");
}
if(param2 < 0) {
throw new RangeError("The supplied index is out of bounds.");
}
var local3:Object3D = this.alternativa3d::childrenList;
var local4:int = 0;
while(local4 < param2) {
if(local3 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
local3 = local3.alternativa3d::next;
local4++;
}
this.removeChild(param1);
this.alternativa3d::addToList(param1,local3);
}
public function swapChildren(param1:Object3D, param2:Object3D) : void {
var local3:Object3D = null;
if(param1 == null || param2 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1.alternativa3d::_parent != this || param2.alternativa3d::_parent != this) {
throw new ArgumentError("The supplied Object3D must be a child of the caller.");
}
if(param1 != param2) {
if(param1.alternativa3d::next == param2) {
this.removeChild(param2);
this.alternativa3d::addToList(param2,param1);
} else if(param2.alternativa3d::next == param1) {
this.removeChild(param1);
this.alternativa3d::addToList(param1,param2);
} else {
local3 = param1.alternativa3d::next;
this.removeChild(param1);
this.alternativa3d::addToList(param1,param2);
this.removeChild(param2);
this.alternativa3d::addToList(param2,local3);
}
}
}
public function swapChildrenAt(param1:int, param2:int) : void {
var local3:int = 0;
var local4:Object3D = null;
var local5:Object3D = null;
var local6:Object3D = null;
if(param1 < 0 || param2 < 0) {
throw new RangeError("The supplied index is out of bounds.");
}
if(param1 != param2) {
local4 = this.alternativa3d::childrenList;
local3 = 0;
while(local3 < param1) {
if(local4 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
local4 = local4.alternativa3d::next;
local3++;
}
if(local4 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
local5 = this.alternativa3d::childrenList;
local3 = 0;
while(local3 < param2) {
if(local5 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
local5 = local5.alternativa3d::next;
local3++;
}
if(local5 == null) {
throw new RangeError("The supplied index is out of bounds.");
}
if(local4 != local5) {
if(local4.alternativa3d::next == local5) {
this.removeChild(local5);
this.alternativa3d::addToList(local5,local4);
} else if(local5.alternativa3d::next == local4) {
this.removeChild(local4);
this.alternativa3d::addToList(local4,local5);
} else {
local6 = local4.alternativa3d::next;
this.removeChild(local4);
this.alternativa3d::addToList(local4,local5);
this.removeChild(local5);
this.alternativa3d::addToList(local5,local6);
}
}
}
}
public function getChildByName(param1:String) : Object3D {
if(param1 == null) {
throw new TypeError("Parameter name must be non-null.");
}
var local2:Object3D = this.alternativa3d::childrenList;
while(local2 != null) {
if(local2.name == param1) {
return local2;
}
local2 = local2.alternativa3d::next;
}
return null;
}
public function contains(param1:Object3D) : Boolean {
if(param1 == null) {
throw new TypeError("Parameter child must be non-null.");
}
if(param1 == this) {
return true;
}
var local2:Object3D = this.alternativa3d::childrenList;
while(local2 != null) {
if(local2 is Object3DContainer) {
if((local2 as Object3DContainer).contains(param1)) {
return true;
}
} else if(local2 == param1) {
return true;
}
local2 = local2.alternativa3d::next;
}
return false;
}
public function get numChildren() : int {
var local1:int = 0;
var local2:Object3D = this.alternativa3d::childrenList;
while(local2 != null) {
local1++;
local2 = local2.alternativa3d::next;
}
return local1;
}
override public function intersectRay(param1:Vector3D, param2:Vector3D, param3:Dictionary = null, param4:Camera3D = null) : RayIntersectionData {
var local5:Vector3D = null;
var local6:Vector3D = null;
var local7:RayIntersectionData = null;
var local10:RayIntersectionData = null;
if(param3 != null && Boolean(param3[this])) {
return null;
}
if(!alternativa3d::boundIntersectRay(param1,param2,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ)) {
return null;
}
var local8:Number = 1e+22;
var local9:Object3D = this.alternativa3d::childrenList;
while(local9 != null) {
local9.alternativa3d::composeMatrix();
local9.alternativa3d::invertMatrix();
if(local5 == null) {
local5 = new Vector3D();
local6 = new Vector3D();
}
local5.x = local9.alternativa3d::ma * param1.x + local9.alternativa3d::mb * param1.y + local9.alternativa3d::mc * param1.z + local9.alternativa3d::md;
local5.y = local9.alternativa3d::me * param1.x + local9.alternativa3d::mf * param1.y + local9.alternativa3d::mg * param1.z + local9.alternativa3d::mh;
local5.z = local9.alternativa3d::mi * param1.x + local9.alternativa3d::mj * param1.y + local9.alternativa3d::mk * param1.z + local9.alternativa3d::ml;
local6.x = local9.alternativa3d::ma * param2.x + local9.alternativa3d::mb * param2.y + local9.alternativa3d::mc * param2.z;
local6.y = local9.alternativa3d::me * param2.x + local9.alternativa3d::mf * param2.y + local9.alternativa3d::mg * param2.z;
local6.z = local9.alternativa3d::mi * param2.x + local9.alternativa3d::mj * param2.y + local9.alternativa3d::mk * param2.z;
local10 = local9.intersectRay(local5,local6,param3,param4);
if(local10 != null && local10.time < local8) {
local8 = local10.time;
local7 = local10;
}
local9 = local9.alternativa3d::next;
}
return local7;
}
override alternativa3d function checkIntersection(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Dictionary) : Boolean {
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local9:Object3D = this.alternativa3d::childrenList;
while(local9 != null) {
if(param8 != null && !param8[local9]) {
local9.alternativa3d::composeMatrix();
local9.alternativa3d::invertMatrix();
local10 = local9.alternativa3d::ma * param1 + local9.alternativa3d::mb * param2 + local9.alternativa3d::mc * param3 + local9.alternativa3d::md;
local11 = local9.alternativa3d::me * param1 + local9.alternativa3d::mf * param2 + local9.alternativa3d::mg * param3 + local9.alternativa3d::mh;
local12 = local9.alternativa3d::mi * param1 + local9.alternativa3d::mj * param2 + local9.alternativa3d::mk * param3 + local9.alternativa3d::ml;
local13 = local9.alternativa3d::ma * param4 + local9.alternativa3d::mb * param5 + local9.alternativa3d::mc * param6;
local14 = local9.alternativa3d::me * param4 + local9.alternativa3d::mf * param5 + local9.alternativa3d::mg * param6;
local15 = local9.alternativa3d::mi * param4 + local9.alternativa3d::mj * param5 + local9.alternativa3d::mk * param6;
if(Boolean(alternativa3d::boundCheckIntersection(local10,local11,local12,local13,local14,local15,param7,local9.boundMinX,local9.boundMinY,local9.boundMinZ,local9.boundMaxX,local9.boundMaxY,local9.boundMaxZ)) && Boolean(local9.alternativa3d::checkIntersection(local10,local11,local12,local13,local14,local15,param7,param8))) {
return true;
}
}
local9 = local9.alternativa3d::next;
}
return false;
}
override alternativa3d function collectPlanes(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Vector3D, param5:Vector3D, param6:Vector.<Face>, param7:Dictionary = null) : void {
if(param7 != null && Boolean(param7[this])) {
return;
}
var local8:Vector3D = alternativa3d::calculateSphere(param1,param2,param3,param4,param5);
if(!alternativa3d::boundIntersectSphere(local8,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ)) {
return;
}
var local9:Object3D = this.alternativa3d::childrenList;
while(local9 != null) {
local9.alternativa3d::composeAndAppend(this);
local9.alternativa3d::collectPlanes(param1,param2,param3,param4,param5,param6,param7);
local9 = local9.alternativa3d::next;
}
}
override public function clone() : Object3D {
var local1:Object3DContainer = new Object3DContainer();
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
var local4:Object3D = null;
var local5:Object3D = null;
super.clonePropertiesFrom(param1);
var local2:Object3DContainer = param1 as Object3DContainer;
this.mouseChildren = local2.mouseChildren;
var local3:Object3D = local2.alternativa3d::childrenList;
while(local3 != null) {
local5 = local3.clone();
if(this.alternativa3d::childrenList != null) {
local4.alternativa3d::next = local5;
} else {
this.alternativa3d::childrenList = local5;
}
local4 = local5;
local5.alternativa3d::setParent(this);
local3 = local3.alternativa3d::next;
}
}
override alternativa3d function draw(param1:Camera3D) : void {
var local2:int = 0;
this.alternativa3d::numVisibleChildren = 0;
var local3:Object3D = this.alternativa3d::childrenList;
while(local3 != null) {
if(local3.visible) {
local3.alternativa3d::composeAndAppend(this);
if(local3.alternativa3d::cullingInCamera(param1,alternativa3d::culling) >= 0) {
local3.alternativa3d::concat(this);
this.alternativa3d::visibleChildren[this.alternativa3d::numVisibleChildren] = local3;
++this.alternativa3d::numVisibleChildren;
}
}
local3 = local3.alternativa3d::next;
}
if(this.alternativa3d::numVisibleChildren > 0) {
if(param1.debug && (local2 = int(param1.alternativa3d::checkInDebug(this))) > 0) {
if(Boolean(local2 & Debug.BOUNDS)) {
Debug.alternativa3d::drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ);
}
}
this.alternativa3d::drawVisibleChildren(param1);
}
}
alternativa3d function drawVisibleChildren(param1:Camera3D) : void {
var local3:Object3D = null;
var local2:int = this.alternativa3d::numVisibleChildren - 1;
while(local2 >= 0) {
local3 = this.alternativa3d::visibleChildren[local2];
local3.alternativa3d::draw(param1);
this.alternativa3d::visibleChildren[local2] = null;
local2--;
}
}
override alternativa3d function getVG(param1:Camera3D) : VG {
var local2:VG = null;
var local3:VG = null;
var local5:VG = null;
var local4:Object3D = this.alternativa3d::childrenList;
while(local4 != null) {
if(local4.visible) {
local4.alternativa3d::composeAndAppend(this);
if(local4.alternativa3d::cullingInCamera(param1,alternativa3d::culling) >= 0) {
local4.alternativa3d::concat(this);
local5 = local4.alternativa3d::getVG(param1);
if(local5 != null) {
if(local2 != null) {
local3.alternativa3d::next = local5;
} else {
local2 = local5;
local3 = local5;
}
while(local3.alternativa3d::next != null) {
local3 = local3.alternativa3d::next;
}
}
}
}
local4 = local4.alternativa3d::next;
}
return local2;
}
override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void {
var local3:Object3D = this.alternativa3d::childrenList;
while(local3 != null) {
if(param2 != null) {
local3.alternativa3d::composeAndAppend(param2);
} else {
local3.alternativa3d::composeMatrix();
}
local3.alternativa3d::updateBounds(param1,local3);
local3 = local3.alternativa3d::next;
}
}
override alternativa3d function split(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Number) : Vector.<Object3D> {
var local10:Object3D = null;
var local11:Object3D = null;
var local13:Object3D = null;
var local14:Vector3D = null;
var local15:Vector3D = null;
var local16:Vector3D = null;
var local17:int = 0;
var local18:Vector.<Object3D> = null;
var local19:Number = NaN;
var local5:Vector.<Object3D> = new Vector.<Object3D>(2);
var local6:Vector3D = alternativa3d::calculatePlane(param1,param2,param3);
var local7:Object3D = this.alternativa3d::childrenList;
this.alternativa3d::childrenList = null;
var local8:Object3DContainer = this.clone() as Object3DContainer;
var local9:Object3DContainer = this.clone() as Object3DContainer;
var local12:Object3D = local7;
while(local12 != null) {
local13 = local12.alternativa3d::next;
local12.alternativa3d::next = null;
local12.alternativa3d::setParent(null);
local12.alternativa3d::composeMatrix();
local12.alternativa3d::calculateInverseMatrix();
local14 = new Vector3D(local12.alternativa3d::ima * param1.x + local12.alternativa3d::imb * param1.y + local12.alternativa3d::imc * param1.z + local12.alternativa3d::imd,local12.alternativa3d::ime * param1.x + local12.alternativa3d::imf * param1.y + local12.alternativa3d::img * param1.z + local12.alternativa3d::imh,local12.alternativa3d::imi * param1.x + local12.alternativa3d::imj * param1.y + local12.alternativa3d::imk * param1.z + local12.alternativa3d::iml);
local15 = new Vector3D(local12.alternativa3d::ima * param2.x + local12.alternativa3d::imb * param2.y + local12.alternativa3d::imc * param2.z + local12.alternativa3d::imd,local12.alternativa3d::ime * param2.x + local12.alternativa3d::imf * param2.y + local12.alternativa3d::img * param2.z + local12.alternativa3d::imh,local12.alternativa3d::imi * param2.x + local12.alternativa3d::imj * param2.y + local12.alternativa3d::imk * param2.z + local12.alternativa3d::iml);
local16 = new Vector3D(local12.alternativa3d::ima * param3.x + local12.alternativa3d::imb * param3.y + local12.alternativa3d::imc * param3.z + local12.alternativa3d::imd,local12.alternativa3d::ime * param3.x + local12.alternativa3d::imf * param3.y + local12.alternativa3d::img * param3.z + local12.alternativa3d::imh,local12.alternativa3d::imi * param3.x + local12.alternativa3d::imj * param3.y + local12.alternativa3d::imk * param3.z + local12.alternativa3d::iml);
local17 = int(local12.alternativa3d::testSplit(local14,local15,local16,param4));
if(local17 < 0) {
if(local10 != null) {
local10.alternativa3d::next = local12;
} else {
local8.alternativa3d::childrenList = local12;
}
local10 = local12;
local12.alternativa3d::setParent(local8);
} else if(local17 > 0) {
if(local11 != null) {
local11.alternativa3d::next = local12;
} else {
local9.alternativa3d::childrenList = local12;
}
local11 = local12;
local12.alternativa3d::setParent(local9);
} else {
local18 = local12.alternativa3d::split(local14,local15,local16,param4);
local19 = Number(local12.alternativa3d::distance);
if(local18[0] != null) {
local12 = local18[0];
if(local10 != null) {
local10.alternativa3d::next = local12;
} else {
local8.alternativa3d::childrenList = local12;
}
local10 = local12;
local12.alternativa3d::setParent(local8);
local12.alternativa3d::distance = local19;
}
if(local18[1] != null) {
local12 = local18[1];
if(local11 != null) {
local11.alternativa3d::next = local12;
} else {
local9.alternativa3d::childrenList = local12;
}
local11 = local12;
local12.alternativa3d::setParent(local9);
local12.alternativa3d::distance = local19;
}
}
local12 = local13;
}
if(local10 != null) {
local8.calculateBounds();
local5[0] = local8;
}
if(local11 != null) {
local9.calculateBounds();
local5[1] = local9;
}
return local5;
}
alternativa3d function addToList(param1:Object3D, param2:Object3D = null) : void {
var local3:Object3D = null;
param1.alternativa3d::next = param2;
param1.alternativa3d::setParent(this);
if(param2 == this.alternativa3d::childrenList) {
this.alternativa3d::childrenList = param1;
} else {
local3 = this.alternativa3d::childrenList;
while(local3 != null) {
if(local3.alternativa3d::next == param2) {
local3.alternativa3d::next = param1;
break;
}
local3 = local3.alternativa3d::next;
}
}
}
override alternativa3d function setParent(param1:Object3DContainer) : void {
var local2:Object3DContainer = null;
var local3:Light3D = null;
if(param1 == null) {
local2 = alternativa3d::_parent;
while(local2.alternativa3d::_parent != null) {
local2 = local2.alternativa3d::_parent;
}
if(local2.alternativa3d::lightList != null) {
this.transferLights(local2,this);
}
} else if(this.alternativa3d::lightList != null) {
local2 = param1;
while(local2.alternativa3d::_parent != null) {
local2 = local2.alternativa3d::_parent;
}
local3 = this.alternativa3d::lightList;
while(local3.alternativa3d::nextLight != null) {
local3 = local3.alternativa3d::nextLight;
}
local3.alternativa3d::nextLight = local2.alternativa3d::lightList;
local2.alternativa3d::lightList = this.alternativa3d::lightList;
this.alternativa3d::lightList = null;
}
alternativa3d::_parent = param1;
}
private function transferLights(param1:Object3DContainer, param2:Object3DContainer) : void {
var local4:Light3D = null;
var local5:Light3D = null;
var local6:Light3D = null;
var local3:Object3D = this.alternativa3d::childrenList;
while(local3 != null) {
if(local3 is Light3D) {
local4 = local3 as Light3D;
local5 = null;
local6 = param1.alternativa3d::lightList;
while(local6 != null) {
if(local6 == local4) {
if(local5 != null) {
local5.alternativa3d::nextLight = local6.alternativa3d::nextLight;
} else {
param1.alternativa3d::lightList = local6.alternativa3d::nextLight;
}
local6.alternativa3d::nextLight = param2.alternativa3d::lightList;
param2.alternativa3d::lightList = local6;
break;
}
local5 = local6;
local6 = local6.alternativa3d::nextLight;
}
} else if(local3 is Object3DContainer) {
(local3 as Object3DContainer).transferLights(param1,param2);
}
if(param1.alternativa3d::lightList == null) {
break;
}
local3 = local3.alternativa3d::next;
}
}
}
}
|
package alternativa.tanks.models.battle.gui.chat {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.model.chat.ChatSettingsTracker;
import alternativa.tanks.services.battlegui.BattleGUIService;
import alternativa.types.Long;
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.battlefield.models.battle.gui.chat.BattleChatModelBase;
import projects.tanks.client.battlefield.models.battle.gui.chat.IBattleChatModelBase;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import services.contextmenu.ContextMenuServiceEvent;
import services.contextmenu.IContextMenuService;
[ModelInfo]
public class BattleChatModel extends BattleChatModelBase implements IBattleChatModelBase, IBattleChat, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var display:IDisplay;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var battleGuiService:BattleGUIService;
[Inject]
public static var contextMenuService:IContextMenuService;
private var battleChat:BattleChat;
private var teamHeaderText:String;
private const VOTE_CMD:* = "/vote ";
public function BattleChatModel() {
super();
this.battleChat = new BattleChat();
}
[Obfuscation(rename="false")]
public function objectLoaded() : void {
this.battleChat.setBattleObject(object);
this.battleChat.clear();
this.battleChat.locked = false;
this.battleChat.addEventListener(BattleChatEvent.SEND_MESSAGE,getFunctionWrapper(this.onSendMessage));
battleGuiService.getGuiContainer().addChild(this.battleChat);
display.stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
this.teamHeaderText = "";
putData(ChatLocker,new ChatLocker(this.battleChat));
putData(ChatSettingsTracker,new ChatSettingsTracker(this.battleChat));
contextMenuService.addEventListener(ContextMenuServiceEvent.VOTE_USER,getFunctionWrapper(this.onSendCmd));
}
[Obfuscation(rename="false")]
public function objectUnloaded() : void {
this.battleChat.removeEventListener(BattleChatEvent.SEND_MESSAGE,getFunctionWrapper(this.onSendMessage));
contextMenuService.removeEventListener(ContextMenuServiceEvent.VOTE_USER,getFunctionWrapper(this.onSendCmd));
this.battleChat.clear();
if(this.battleChat.parent != null) {
this.battleChat.parent.removeChild(this.battleChat);
}
display.stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
}
[Obfuscation(rename="false")]
public function addMessage(param1:Long, param2:String, param3:BattleTeam) : void {
this.addUserMessageWithMessageLabel(param1,param2,param3);
}
[Obfuscation(rename="false")]
public function addTeamMessage(param1:Long, param2:String, param3:BattleTeam) : void {
this.addUserMessageWithMessageLabel(param1,param2,param3,true);
}
private function addUserMessageWithMessageLabel(param1:Long, param2:String, param3:BattleTeam, param4:Boolean = false) : void {
var local5:Boolean = param1.low == -1 && param1.high == -1;
this.battleChat.addUserMessage(param1,param3,param2 + "\n",param4,local5);
}
[Obfuscation(rename="false")]
public function addSpectatorTeamMessage(param1:String, param2:String) : void {
this.battleChat.addUserMessage(Long.getLong(-1,-1),BattleTeam.NONE,param2 + "\n",true,true);
}
[Obfuscation(rename="false")]
public function addSystemMessage(param1:String) : void {
this.battleChat.addSystemMessage(param1);
}
private function onKeyUp(param1:KeyboardEvent) : void {
if(param1.keyCode == Keyboard.ENTER) {
if(battleInfoService.isSpectatorMode()) {
this.battleChat.setSpectatorList(this.teamHeaderText);
}
this.battleChat.openChat();
}
}
private function onSendMessage(param1:BattleChatEvent) : void {
server.sendMessage(param1.message,param1.teamOnly);
}
private function onSendCmd(param1:ContextMenuServiceEvent) : void {
server.sendMessage(this.VOTE_CMD + param1.uid,false);
}
[Obfuscation(rename="false")]
public function updateTeamHeader(param1:String) : void {
this.teamHeaderText = param1;
}
public function getChat() : BattleChat {
return this.battleChat;
}
}
}
|
package alternativa.tanks.models.battlefield.skybox
{
import alternativa.engine3d.core.Object3D;
import alternativa.math.Quaternion;
import alternativa.math.Vector3;
public class Object3DRevolver
{
private static const eulerAngles:Vector3 = new Vector3();
private var object:Object3D;
private var axis:Vector3;
private var angularSpeed:Number;
private var orientation:Quaternion;
public function Object3DRevolver(param1:Object3D, param2:Vector3, param3:Number)
{
this.orientation = new Quaternion();
super();
this.object = param1;
this.axis = param2.vClone().vNormalize();
this.angularSpeed = param3 / 1000;
this.orientation.setFromEulerAnglesXYZ(param1.rotationX,param1.rotationY,param1.rotationZ);
}
public function setAxis(param1:Number, param2:Number, param3:Number) : void
{
this.axis.reset(param1,param2,param3).vNormalize();
}
public function setAngularSpeed(param1:Number) : void
{
this.angularSpeed = param1 / 1000;
}
public function render(param1:int, param2:int) : void
{
if(this.angularSpeed != 0)
{
this.orientation.addScaledVector(this.axis,this.angularSpeed * param2);
this.orientation.getEulerAngles(eulerAngles);
this.object.rotationX = eulerAngles.x;
this.object.rotationY = eulerAngles.y;
this.object.rotationZ = eulerAngles.z;
}
}
}
}
|
package alternativa.tanks.models.tank.criticalhit
{
import alternativa.object.ClientObject;
import alternativa.tanks.models.tank.TankData;
public interface ITankCriticalHitModel
{
function createExplosionEffects(param1:ClientObject, param2:TankData) : void;
}
}
|
package _codec.projects.tanks.client.panel.model.shop.challenges.battlepass {
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.challenges.battlepass.BattlePassPackageCC;
public class CodecBattlePassPackageCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_description:ICodec;
private var codec_name:ICodec;
public function CodecBattlePassPackageCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_description = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BattlePassPackageCC = new BattlePassPackageCC();
local2.description = this.codec_description.decode(param1) as String;
local2.name = this.codec_name.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BattlePassPackageCC = BattlePassPackageCC(param2);
this.codec_description.encode(param1,local3.description);
this.codec_name.encode(param1,local3.name);
}
}
}
|
package alternativa.tanks.models.weapon.common {
import platform.client.fp10.core.type.IGameObject;
public function asWeaponCommon(param1:IGameObject) : IWeaponCommonModel {
return IWeaponCommonModel(param1.adapt(IWeaponCommonModel));
}
}
|
package alternativa.tanks.model.item.category {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.types.ItemCategoryEnum;
public class IItemCategoryAdapt implements IItemCategory {
private var object:IGameObject;
private var impl:IItemCategory;
public function IItemCategoryAdapt(param1:IGameObject, param2:IItemCategory) {
super();
this.object = param1;
this.impl = param2;
}
public function getCategory() : ItemCategoryEnum {
var result:ItemCategoryEnum = null;
try {
Model.object = this.object;
result = this.impl.getCategory();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package forms
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
import flash.text.TextFormatAlign;
public class ServerRedirectAlert extends ServerStopAlert
{
public function ServerRedirectAlert(time:int)
{
super(time);
}
override protected function init() : void
{
var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
timeLimitLabel.align = TextFormatAlign.CENTER;
str = localeService.getText(TextConst.REDIRECT_ALERT_TEXT);
timeLimitLabel.text = getText(str,"88");
addChild(bg);
addChild(timeLimitLabel);
timeLimitLabel.x = PADDING;
timeLimitLabel.y = PADDING;
bg.width = timeLimitLabel.width + PADDING * 2;
bg.height = timeLimitLabel.height + PADDING * 2;
showCountDown();
}
}
}
|
package assets.windowinner.bitmaps {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.windowinner.bitmaps.WindowComboBG.png")]
public class WindowComboBG extends BitmapData {
public function WindowComboBG() {
super(0,0);
}
}
}
|
package alternativa.tanks.models.battlefield.gui.statistics.field
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class CTFScoreIndicator_flagBlueLostClass extends BitmapAsset
{
public function CTFScoreIndicator_flagBlueLostClass()
{
super();
}
}
}
|
package alternativa.tanks.models.tank.speedcharacteristics {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class SpeedCharacteristicsEvents implements SpeedCharacteristics {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function SpeedCharacteristicsEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function setInitialTankState() : void {
var i:int = 0;
var m:SpeedCharacteristics = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpeedCharacteristics(this.impl[i]);
m.setInitialTankState();
i++;
}
}
finally {
Model.popObject();
}
}
public function getMaxHullTurnSpeed() : Number {
var result:Number = NaN;
var i:int = 0;
var m:SpeedCharacteristics = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpeedCharacteristics(this.impl[i]);
result = Number(m.getMaxHullTurnSpeed());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getMaxTurretTurnSpeed() : Number {
var result:Number = NaN;
var i:int = 0;
var m:SpeedCharacteristics = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpeedCharacteristics(this.impl[i]);
result = Number(m.getMaxTurretTurnSpeed());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getTurretRotationCoefficient() : Number {
var result:Number = NaN;
var i:int = 0;
var m:SpeedCharacteristics = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpeedCharacteristics(this.impl[i]);
result = Number(m.getTurretRotationCoefficient());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.entrance.model.entrance.loginwithoutregistration {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
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 LoginWithoutRegistrationModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _loginWithoutRegistrationId:Long = Long.getLong(843367251,-1030612413);
private var model:IModel;
public function LoginWithoutRegistrationModelServer(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());
}
public function loginWithoutRegistration() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._loginWithoutRegistrationId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package platform.client.fp10.core.network.command.control.server {
import platform.client.fp10.core.network.ControlChannelContext;
import platform.client.fp10.core.network.command.ControlCommand;
import platform.client.fp10.core.network.command.IServerControlCommand;
public class MessageCommand extends ControlCommand implements IServerControlCommand {
private var message:String;
public function MessageCommand(param1:String) {
super(ControlCommand.SV_MESSAGE,"Message command");
this.message = param1;
}
public function execute(param1:ControlChannelContext) : void {
}
}
}
|
package alternativa.tanks.model.payment.shop.kit {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.shop.kitpackage.KitPackageItemInfo;
public class KitPackageEvents implements KitPackage {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function KitPackageEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getName() : String {
var result:String = null;
var i:int = 0;
var m:KitPackage = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = KitPackage(this.impl[i]);
result = m.getName();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getItemInfos() : Vector.<KitPackageItemInfo> {
var result:Vector.<KitPackageItemInfo> = null;
var i:int = 0;
var m:KitPackage = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = KitPackage(this.impl[i]);
result = m.getItemInfos();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package _codec.projects.tanks.client.commons.socialnetwork {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.commons.socialnetwork.SocialNetworkEnum;
public class CodecSocialNetworkEnum implements ICodec {
public function CodecSocialNetworkEnum() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:SocialNetworkEnum = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = SocialNetworkEnum.VKONTAKTE_INTERNAL;
break;
case 1:
local2 = SocialNetworkEnum.ODNOKLASSNIKI_INTERNAL;
break;
case 2:
local2 = SocialNetworkEnum.MAIN;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p28 extends BitmapAsset
{
public function RangIconNormal_p28()
{
super();
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.itempersonaldiscount {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.itempersonaldiscount.DiscountData;
import projects.tanks.client.garage.models.item.itempersonaldiscount.ItemPersonalDiscountCC;
public class CodecItemPersonalDiscountCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_discounts:ICodec;
public function CodecItemPersonalDiscountCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_discounts = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(DiscountData,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ItemPersonalDiscountCC = new ItemPersonalDiscountCC();
local2.discounts = this.codec_discounts.decode(param1) as Vector.<DiscountData>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ItemPersonalDiscountCC = ItemPersonalDiscountCC(param2);
this.codec_discounts.encode(param1,local3.discounts);
}
}
}
|
package alternativa.tanks.models.clan.info {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.models.panel.create.ClanCreateService;
import alternativa.tanks.models.service.ClanService;
import alternativa.tanks.models.service.ClanServiceEvent;
import alternativa.tanks.models.service.ClanServiceUpdateEvent;
import alternativa.types.Long;
import flash.events.Event;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
import projects.tanks.client.clans.clan.info.ClanInfoCC;
import projects.tanks.client.clans.clan.info.ClanInfoModelBase;
import projects.tanks.client.clans.clan.info.IClanInfoModelBase;
import projects.tanks.clients.flash.commons.services.datetime.DateFormatter;
[ModelInfo]
public class ClanInfoModel extends ClanInfoModelBase implements IClanInfoModelBase, IClanInfoModel, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var clanService:ClanService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var createClanService:ClanCreateService;
private var description:String;
public function ClanInfoModel() {
super();
}
public function objectLoaded() : void {
clanService.addEventListener(ClanServiceUpdateEvent.UPDATE,getFunctionWrapper(this.onUpdateInfo));
var local1:ClanInfoCC = getInitParam();
var local2:Date = new Date(local1.createTime);
clanService.clanMembers = local1.users.concat();
clanService.name = local1.name;
clanService.tag = local1.tag;
clanService.minRankForRequest = local1.minRankForAddClan;
clanService.creatorId = local1.creatorId;
clanService.creationDate = DateFormatter.formatDateToLocalized(local2);
clanService.isSelf = local1.self;
putData(Boolean,local1.blocked);
putData(String,local1.reasonForBlocking);
clanService.isBlocked = local1.blocked;
clanService.requestsEnabled = local1.incomingRequestEnabled;
clanService.maxCharactersDescription = local1.maxCharactersDescription;
this.description = local1.description;
clanService.addEventListener(ClanServiceEvent.CLAN_BLOCK,getFunctionWrapper(this.onBlockClan));
ClanInfoDelayed.getInstance().dispatchEvent(new Event(ClanInfoDelayed.EVENT_PREFIX + object.id.toString()));
}
private function onBlockClan(param1:ClanServiceEvent) : void {
putData(Boolean,true);
putData(String,param1.reasonBlock);
}
public function getDescription() : String {
var local1:Object = getData(Boolean);
if(Boolean(local1)) {
return String(getData(String));
}
if(this.description != null) {
return this.description;
}
return "";
}
public function getCreatorId() : Long {
return getInitParam().creatorId;
}
public function getCreateTime() : Long {
return getInitParam().createTime;
}
public function getUsersCount() : int {
return getInitParam().users.length;
}
private function onUpdateInfo(param1:ClanServiceUpdateEvent) : void {
this.description = param1.description;
server.updateDescription(param1.description);
server.changeFlag(param1.flag.id);
server.changeMinRankForAddClan(param1.rankIndex);
server.incomingRequestEnable(param1.incomingRequestsEnabled);
}
public function objectUnloaded() : void {
clanService.unloadMembers();
clanService.isSelf = false;
clanService.removeEventListener(ClanServiceUpdateEvent.UPDATE,getFunctionWrapper(this.onUpdateInfo));
clanService.removeEventListener(ClanServiceEvent.CLAN_BLOCK,getFunctionWrapper(this.onBlockClan));
}
public function getClanName() : String {
return getInitParam().name;
}
public function getClanTag() : String {
return getInitParam().tag;
}
public function getClanFlag() : ClanFlag {
var local2:ClanFlag = null;
var local1:int = 0;
while(local1 < createClanService.flags.length) {
local2 = createClanService.flags[local1];
if(getInitParam().flagId == local2.id) {
return local2;
}
local1++;
}
return createClanService.defaultFlag;
}
public function incomingRequestEnabled() : Boolean {
return getInitParam().incomingRequestEnabled;
}
public function getRankIndexForAddClan() : int {
return getInitParam().minRankForAddClan;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.blockuser {
public interface IBlockUserService {
function getBlockList() : Array;
function blockUser(param1:String) : void;
function unblockUser(param1:String) : void;
function unblockAll() : void;
function isBlocked(param1:String) : Boolean;
}
}
|
package _codec.projects.tanks.client.battlefield.models.ultimate.common {
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 projects.tanks.client.battlefield.models.ultimate.common.UltimateCC;
public class CodecUltimateCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_chargePercentPerSecond:ICodec;
private var codec_charged:ICodec;
private var codec_enabled:ICodec;
public function CodecUltimateCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_chargePercentPerSecond = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_charged = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_enabled = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:UltimateCC = new UltimateCC();
local2.chargePercentPerSecond = this.codec_chargePercentPerSecond.decode(param1) as Number;
local2.charged = this.codec_charged.decode(param1) as Boolean;
local2.enabled = this.codec_enabled.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:UltimateCC = UltimateCC(param2);
this.codec_chargePercentPerSecond.encode(param1,local3.chargePercentPerSecond);
this.codec_charged.encode(param1,local3.charged);
this.codec_enabled.encode(param1,local3.enabled);
}
}
}
|
package alternativa.tanks.view.mainview.groupinvite {
import alternativa.osgi.service.locale.ILocaleService;
import base.DiscreteSprite;
import controls.base.LabelBase;
import controls.statassets.StatLineHeader;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
import forms.ColorConstants;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class InviteHeader extends DiscreteSprite {
[Inject]
public static var localeService:ILocaleService;
private var bg:StatLineHeader = new StatLineHeader();
private var label:LabelBase = new LabelBase();
public function InviteHeader() {
super();
this.bg.width = width;
this.bg.height = 18;
addChild(this.bg);
addChild(this.label);
this.label.color = ColorConstants.HEADER_COLOR;
this.label.x = 2;
this.label.y = 0;
this.label.mouseEnabled = false;
this.label.autoSize = TextFieldAutoSize.NONE;
this.label.align = TextFormatAlign.LEFT;
this.label.height = 18;
this.label.text = localeService.getText(TanksLocale.TEXT_BATTLE_STAT_CALLSIGN);
}
override public function set width(param1:Number) : void {
super.width = width;
this.bg.width = param1;
this.label.width = width - 4;
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.sfx.shoot.ricochet
{
import scpacker.Base;
public class RicochetSFXModelBase extends Base
{
public function RicochetSFXModelBase()
{
super();
}
}
}
|
package alternativa.engine3d.materials
{
import alternativa.engine3d.core.ShadowMap;
import alternativa.gfx.agal.FragmentShader;
import alternativa.gfx.agal.SamplerDim;
import alternativa.gfx.agal.SamplerFilter;
import alternativa.gfx.agal.SamplerMipMap;
import alternativa.gfx.agal.SamplerRepeat;
import alternativa.gfx.agal.SamplerType;
public class TextureMaterialFragmentShader extends FragmentShader
{
public function TextureMaterialFragmentShader(param1:Boolean, param2:Boolean, param3:Boolean, param4:Boolean, param5:Boolean, param6:Boolean, param7:Boolean, param8:Boolean, param9:Boolean, param10:Boolean, param11:Boolean, param12:Boolean, param13:Boolean, param14:Boolean, param15:Boolean, param16:Boolean, param17:Boolean, param18:Boolean, param19:Boolean)
{
var _loc24_:int = 0;
super();
var _loc20_:SamplerRepeat = !!param1 ? SamplerRepeat.WRAP : SamplerRepeat.CLAMP;
var _loc21_:SamplerFilter = !!param2 ? SamplerFilter.LINEAR : SamplerFilter.NEAREST;
var _loc22_:SamplerMipMap = !!param3 ? (!!param2 ? SamplerMipMap.LINEAR : SamplerMipMap.NEAREST) : SamplerMipMap.NONE;
var _loc23_:SamplerType = !!param4 ? SamplerType.DXT1 : SamplerType.RGBA;
tex(ft0,v0,fs0.dim(SamplerDim.D2).repeat(_loc20_).filter(_loc21_).mipmap(_loc22_).type(_loc23_));
if(param6)
{
sub(ft1.w,ft0,fc[14]);
kil(ft1.w);
}
if(param7)
{
add(ft1.w,ft0,fc[18]);
div(ft0.xyz,ft0,ft1.w);
}
if(param8)
{
mul(ft0.xyz,ft0,fc[0]);
add(ft0.xyz,ft0,fc[1]);
}
if(param9)
{
mul(ft0.w,ft0,fc[0]);
}
if(param10)
{
abs(ft1,v0.z);
sat(ft1,ft1);
sub(ft1,fc[17],ft1);
mul(ft0.w,ft0,ft1);
}
if(param12 || param13 || param14 || param16)
{
div(ft4,v1,v1.z);
mul(ft4.xy,ft4,fc[18]);
add(ft4.xy,ft4,fc[18]);
}
if(param12 || param13 || param14)
{
mul(ft3,ft4,fc[4]);
}
if(param12 || param13)
{
tex(ft1,ft3,fs1.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
}
if(param14)
{
tex(ft6,ft3,fs5.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
}
if(param12)
{
dp3(ft2,ft1,fc[17]);
sub(ft2,ft2,v1);
abs(ft2,ft2);
div(ft2,ft2,fc[14]);
sat(ft2,ft2);
mul(ft0.w,ft0,ft2.z);
}
if(param13)
{
mul(ft2,fc[12],ft1.w);
sub(ft2,fc[17].w,ft2);
mul(ft0.xyz,ft0,ft2);
}
if(param16)
{
mov(ft5,fc[5]);
mul(ft5.z,ft5,v2);
mul(ft3,ft4,fc[7]);
tex(ft1,ft3,fs3.dim(SamplerDim.D2).repeat(SamplerRepeat.WRAP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
mul(ft1.z,ft1,fc[6]);
mul(ft2,ft1.z,ft1);
_loc24_ = 0;
while(_loc24_ < ShadowMap.numSamples)
{
if(_loc24_ == 0)
{
add(ft1,ft2,v2);
tex(ft1,ft1,fs2.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
dp3(ft1,ft1,ft5);
sat(ft1,ft1);
mov(ft4,ft1);
}
else
{
if(_loc24_ % 2 > 0)
{
dp3(ft3.x,ft2,fc[8]);
dp3(ft3.y,ft2,fc[9]);
add(ft1,ft3,v2);
}
else
{
dp3(ft2.x,ft3,fc[8]);
dp3(ft2.y,ft3,fc[9]);
add(ft1,ft2,v2);
}
tex(ft1,ft1,fs2.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
dp3(ft1,ft1,ft5);
sat(ft1,ft1);
add(ft4,ft4,ft1);
}
_loc24_++;
}
mul(ft2,ft4,fc[6]);
sat(ft1,v2);
mul(ft2,ft2,ft1);
mul(ft2.w,ft2,fc[7]);
}
if(param11)
{
if(param16)
{
sat(ft1,v1);
max(ft2,ft2,ft1);
}
else
{
sat(ft2,v1);
}
}
if(param16 || param11)
{
sub(ft2,fc[17],ft2);
mul(ft2,fc[10],ft2.w);
add(ft2,ft2,fc[11]);
if(param14)
{
add(ft6,ft6,ft6);
add(ft2,ft2,ft6);
}
else if(param15)
{
add(ft2,ft2,fc[13]);
}
mul(ft0.xyz,ft0,ft2);
}
else if(param14)
{
add(ft2,ft6,ft6);
mul(ft0.xyz,ft0,ft2);
}
else if(param15)
{
mul(ft0.xyz,ft0,fc[13]);
}
if(param17)
{
if(param18)
{
mul(ft0.xyz,ft0,fc[13].w);
add(ft0.xyz,ft0,fc[13]);
}
else
{
sat(ft1,v0);
mul(ft1,ft1,fc[2]);
if(param19)
{
sub(ft1,fc[17],ft1);
mul(ft0.w,ft0,ft1);
}
else
{
mul(ft1.xyz,fc[2],ft1.w);
sub(ft1.w,fc[17],ft1);
mul(ft0.xyz,ft0,ft1.w);
add(ft0.xyz,ft0,ft1);
}
}
}
mov(oc,ft0);
}
}
}
|
package alternativa.physics.collision.colliders {
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.physics.ShapeContact;
import alternativa.physics.collision.Collider;
import alternativa.physics.collision.CollisionShape;
import alternativa.physics.collision.primitives.CollisionBox;
import alternativa.physics.collision.primitives.CollisionSphere;
public class BoxSphereCollider implements Collider {
private var center:Vector3 = new Vector3();
private var closestPoint:Vector3 = new Vector3();
private var boxPosition:Vector3 = new Vector3();
private var spherePosition:Vector3 = new Vector3();
public function BoxSphereCollider() {
super();
}
public function getContacts(param1:CollisionShape, param2:CollisionShape, param3:Vector.<ShapeContact>) : void {
var local5:CollisionBox = null;
var local7:Matrix4 = null;
var local4:CollisionSphere = param1 as CollisionSphere;
if(local4 == null) {
local4 = param2 as CollisionSphere;
local5 = param1 as CollisionBox;
} else {
local5 = param2 as CollisionBox;
}
var local6:Matrix4 = local4.transform;
local6.getAxis(3,this.spherePosition);
local7 = local5.transform;
local7.getAxis(3,this.boxPosition);
local7.transformVectorInverse(this.spherePosition,this.center);
var local8:Vector3 = local5.hs;
var local9:Number = local8.x + local4.r;
var local10:Number = local8.y + local4.r;
var local11:Number = local8.z + local4.r;
if(this.center.x > local9 || this.center.x < -local9 || this.center.y > local10 || this.center.y < -local10 || this.center.z > local11 || this.center.z < -local11) {
return;
}
if(this.center.x > local8.x) {
this.closestPoint.x = local8.x;
} else if(this.center.x < -local8.x) {
this.closestPoint.x = -local8.x;
} else {
this.closestPoint.x = this.center.x;
}
if(this.center.y > local8.y) {
this.closestPoint.y = local8.y;
} else if(this.center.y < -local8.y) {
this.closestPoint.y = -local8.y;
} else {
this.closestPoint.y = this.center.y;
}
if(this.center.z > local8.z) {
this.closestPoint.z = local8.z;
} else if(this.center.z < -local8.z) {
this.closestPoint.z = -local8.z;
} else {
this.closestPoint.z = this.center.z;
}
var local12:Number = this.center.subtract(this.closestPoint).lengthSqr();
if(local12 > local4.r * local4.r) {
return;
}
var local13:ShapeContact = ShapeContact.create();
local13.shape1 = local4;
local13.shape2 = local5;
local13.normal.copy(this.closestPoint).transform4(local7).subtract(this.spherePosition).normalize().reverse();
local13.penetration = local4.r - Math.sqrt(local12);
local13.position.copy(local13.normal).scale(-local4.r).add(this.spherePosition);
param3[param3.length] = local13;
}
public function haveCollision(param1:CollisionShape, param2:CollisionShape) : Boolean {
var local4:CollisionBox = null;
var local3:CollisionSphere = param1 as CollisionSphere;
if(local3 == null) {
local3 = param2 as CollisionSphere;
local4 = param1 as CollisionBox;
} else {
local4 = param2 as CollisionBox;
}
var local5:Matrix4 = local3.transform;
local5.getAxis(3,this.spherePosition);
var local6:Matrix4 = local4.transform;
local6.getAxis(3,this.boxPosition);
local6.transformVectorInverse(this.spherePosition,this.center);
var local7:Vector3 = local4.hs;
var local8:Number = local7.x + local3.r;
var local9:Number = local7.y + local3.r;
var local10:Number = local7.z + local3.r;
if(this.center.x > local8 || this.center.x < -local8 || this.center.y > local9 || this.center.y < -local9 || this.center.z > local10 || this.center.z < -local10) {
return false;
}
if(this.center.x > local7.x) {
this.closestPoint.x = local7.x;
} else if(this.center.x < -local7.x) {
this.closestPoint.x = -local7.x;
} else {
this.closestPoint.x = this.center.x;
}
if(this.center.y > local7.y) {
this.closestPoint.y = local7.y;
} else if(this.center.y < -local7.y) {
this.closestPoint.y = -local7.y;
} else {
this.closestPoint.y = this.center.y;
}
if(this.center.z > local7.z) {
this.closestPoint.z = local7.z;
} else if(this.center.z < -local7.z) {
this.closestPoint.z = -local7.z;
} else {
this.closestPoint.z = this.center.z;
}
var local11:Number = this.center.subtract(this.closestPoint).lengthSqr();
return local11 <= local3.r * local3.r;
}
}
}
|
package alternativa.tanks.service.upgradingitems {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.alerts.UpgradedItemsAlert;
import alternativa.tanks.model.garage.upgradingitems.UpgradingItem;
import alternativa.types.Long;
import controls.timer.CountDownTimer;
import controls.timer.CountDownTimerOnCompleteAfter;
import flash.events.Event;
import flash.utils.getTimer;
import forms.events.PartsListEvent;
import platform.client.fp10.core.network.connection.ConnectionCloseStatus;
import platform.client.fp10.core.network.handler.OnConnectionClosedServiceListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.client.panel.model.garage.GarageItemInfo;
import projects.tanks.clients.flash.commons.models.runtime.DataOwner;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
public class UpgradingItemsServiceImpl implements UpgradingItemsService, CountDownTimerOnCompleteAfter, OnConnectionClosedServiceListener {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
private var upgradingItems:Vector.<ItemInfo> = new Vector.<ItemInfo>();
private var alert:UpgradedItemsAlert;
private var callback:UpgradingItem;
private var showUpgradeNotifications:Boolean = false;
public function UpgradingItemsServiceImpl() {
super();
}
public function init(param1:Vector.<GarageItemInfo>, param2:UpgradingItem) : void {
var local5:CountDownTimer = null;
this.callback = param2;
var local3:int = getTimer();
var local4:int = 0;
while(local4 < param1.length) {
local5 = new CountDownTimer();
local5.start(local3 + param1[local4].remaingTimeInMS);
this.add(param1[local4],local5);
local4++;
}
}
public function add(param1:GarageItemInfo, param2:CountDownTimer) : void {
var local3:ItemInfo = new ItemInfo(param1,param2);
this.addListener(param2);
this.upgradingItems.push(local3);
this.upgradingItems.sort(this.compare);
if(this.upgradingItems.length == 1) {
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.BEGIN_LAYOUT_SWITCH,this.onBeginLayoutSwitch);
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.onEndLayoutSwitch);
this.startShowUpgradeNotifications();
}
}
public function remove(param1:IGameObject) : void {
var local2:int = this.upgradingItemsIndexOf(param1);
if(local2 != -1) {
this.removeByIndex(local2);
}
}
private function removeByIndex(param1:int) : void {
this.removeListener(this.upgradingItems[param1].timer);
this.upgradingItems.splice(param1,1);
}
private function checkItems() : void {
var local2:ItemInfo = null;
if(this.alert != null) {
return;
}
var local1:Vector.<ItemInfo> = new Vector.<ItemInfo>();
while(this.upgradingItems.length > 0 && this.upgradingItems[this.upgradingItems.length - 1].timer.getRemainingSeconds() <= 0) {
local2 = this.upgradingItems.pop();
this.removeListener(local2.timer);
local1.push(local2);
}
this.showUpgradedItems(local1);
if(this.upgradingItems.length == 0) {
this.stopShowUpgradeNotifications();
}
}
private function showUpgradedItems(param1:Vector.<ItemInfo>) : void {
this.show(param1,TanksLocale.TEXT_HEADER_CONGRATULATION,localeService.getText(TanksLocale.TEXT_GARAGE_UPGRADE_COMPLETE_TEXT));
}
public function getCountDownTimer(param1:IGameObject) : CountDownTimer {
var local2:int = this.upgradingItemsIndexOf(param1);
if(local2 != -1) {
return this.upgradingItems[local2].timer;
}
return null;
}
public function onMount(param1:IGameObject, param2:IGameObject) : void {
var local3:int = this.upgradingItemsIndexOf(param1);
var local4:int = this.upgradingItemsIndexOf(param2);
if(local3 != -1) {
this.upgradingItems[local3].info.mounted = false;
}
if(local4 != -1) {
this.upgradingItems[local4].info.mounted = true;
}
}
private function show(param1:Vector.<ItemInfo>, param2:String, param3:String) : void {
if(param1.length > 0) {
this.alert = new UpgradedItemsAlert(param1,param2,param3);
this.alert.addEventListener(Event.CANCEL,this.onClose);
this.alert.addEventListener(PartsListEvent.ITEM_CLICK,this.onItemSelect);
}
}
private function onItemSelect(param1:PartsListEvent) : void {
this.callback.select(this.alert.partsList.selectedItem);
this.closeAlert();
}
private function onClose(param1:Event) : void {
this.closeAlert();
}
private function closeAlert() : void {
this.alert.removeEventListener(Event.CANCEL,this.onClose);
this.alert.removeEventListener(PartsListEvent.ITEM_CLICK,this.onItemSelect);
this.alert = null;
this.checkItems();
}
private function onBeginLayoutSwitch(param1:LobbyLayoutServiceEvent) : void {
this.stopShowUpgradeNotifications();
}
private function onEndLayoutSwitch(param1:LobbyLayoutServiceEvent) : void {
if(param1.state != LayoutState.BATTLE) {
this.startShowUpgradeNotifications();
this.checkItems();
}
}
private function startShowUpgradeNotifications() : void {
if(!this.showUpgradeNotifications) {
if(lobbyLayoutService.getCurrentState() != LayoutState.BATTLE) {
this.showUpgradeNotifications = true;
}
}
}
private function stopShowUpgradeNotifications() : void {
if(this.showUpgradeNotifications) {
this.showUpgradeNotifications = false;
if(this.upgradingItems.length == 0) {
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.BEGIN_LAYOUT_SWITCH,this.onBeginLayoutSwitch);
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.onEndLayoutSwitch);
}
}
}
public function onCompleteAfter(param1:CountDownTimer, param2:Boolean) : void {
var local3:int = this.indexOfByTimer(param1);
this.callback.itemUpgraded(this.upgradingItems[local3].info.item);
if(this.showUpgradeNotifications) {
if(param2) {
this.removeByIndex(local3);
} else {
this.checkItems();
}
}
}
public function reset() : void {
var local1:ItemInfo = null;
for each(local1 in this.upgradingItems) {
local1.timer.destroy();
}
this.upgradingItems.length = 0;
}
public function onConnectionClosed(param1:ConnectionCloseStatus) : void {
this.reset();
}
private function compare(param1:ItemInfo, param2:ItemInfo) : Number {
return param2.timer.getEndTime() - param1.timer.getEndTime();
}
private function upgradingItemsIndexOf(param1:IGameObject) : int {
var local4:ItemInfo = null;
var local2:Long = DataOwner(param1.adapt(DataOwner)).getDataOwnerId();
var local3:int = 0;
while(local3 < this.upgradingItems.length) {
local4 = this.upgradingItems[local3];
if(this.equalsLong(local4.ownerId,local2)) {
return local3;
}
local3++;
}
return -1;
}
private function indexOfByTimer(param1:CountDownTimer) : int {
var local3:ItemInfo = null;
var local2:int = 0;
while(local2 < this.upgradingItems.length) {
local3 = this.upgradingItems[local2];
if(local3.timer == param1) {
return local2;
}
local2++;
}
return -1;
}
private function addListener(param1:CountDownTimer) : void {
param1.addListener(CountDownTimerOnCompleteAfter,this);
}
private function removeListener(param1:CountDownTimer) : void {
param1.removeListener(CountDownTimerOnCompleteAfter,this);
}
public function informServerAboutUpgradedItem(param1:IGameObject) : void {
this.callback.itemUpgraded(param1);
}
public function equalsLong(param1:Long, param2:Long) : Boolean {
return param1.high == param2.high && param1.low == param2.low;
}
}
}
|
package alternativa.tanks.models.battle.ctf {
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleView;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.models.battle.commonflag.Flag;
import alternativa.tanks.models.battle.gui.markers.PointHudIndicator;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class CTFHudIndicators implements Renderer {
[Inject]
public static var battleService:BattleService;
private static var flagMovingBlue:Class = CTFHudIndicators_flagMovingBlue;
private static var flagMovingRed:Class = CTFHudIndicators_flagMovingRed;
private static var flagDownBlue:Class = CTFHudIndicators_flagDownBlue;
private static var flagDownRed:Class = CTFHudIndicators_flagDownRed;
private static var flagOnBaseBlue:Class = CTFHudIndicators_flagOnBaseBlue;
private static var flagOnBaseRed:Class = CTFHudIndicators_flagOnBaseRed;
private static var flagOutOfBaseBlue:Class = CTFHudIndicators_flagOutOfBaseBlue;
private static var flagOutOfBaseRed:Class = CTFHudIndicators_flagOutOfBaseRed;
private static const m:Matrix4 = new Matrix4();
private static const m1:Matrix4 = new Matrix4();
private static const v:Vector3 = new Vector3();
private static const pointPosition:Vector3 = new Vector3();
private static const cameraPosition:Vector3 = new Vector3();
private static const direction:Vector3 = new Vector3();
private static const NEAR_MARKER_DISTANCE:Number = 6600;
private static const FAR_MARKER_DISTANCE:Number = 7000;
private var redMarker:PointHudIndicator;
private var redBaseMarker:PointHudIndicator;
private var blueMarker:PointHudIndicator;
private var blueBaseMarker:PointHudIndicator;
private var camera:Camera3D;
private var markers:Array = [];
public function CTFHudIndicators(param1:Flag, param2:Object3D, param3:Flag, param4:Object3D) {
super();
this.redMarker = new PointHudIndicator(new flagOnBaseRed(),param1,new flagDownRed(),new flagMovingRed());
this.blueMarker = new PointHudIndicator(new flagOnBaseBlue(),param3,new flagDownBlue(),new flagMovingBlue());
this.redBaseMarker = new PointHudIndicator(new flagOutOfBaseRed(),new BaseIndicatorStateProvider(new Vector3(param2.x,param2.y,param2.z),this.redMarker));
this.blueBaseMarker = new PointHudIndicator(new flagOutOfBaseBlue(),new BaseIndicatorStateProvider(new Vector3(param4.x,param4.y,param4.z),this.blueMarker));
battleService.getBattleView().addOverlayObject(this.redMarker);
battleService.getBattleView().addOverlayObject(this.blueMarker);
battleService.getBattleView().addOverlayObject(this.redBaseMarker);
battleService.getBattleView().addOverlayObject(this.blueBaseMarker);
this.markers.push(this.redMarker,this.blueMarker,this.redBaseMarker,this.blueBaseMarker);
this.camera = battleService.getBattleScene3D().getCamera();
}
private static function getPerspectiveScale(param1:Camera3D, param2:Vector3) : Number {
var local3:Number = Math.cos(param1.rotationX);
var local4:Number = Math.sin(param1.rotationX);
var local5:Number = Math.cos(param1.rotationY);
var local6:Number = Math.sin(param1.rotationY);
var local7:Number = Math.cos(param1.rotationZ);
var local8:Number = Math.sin(param1.rotationZ);
var local9:Number = local7 * local6 * local3 + local8 * local4;
var local10:Number = -local7 * local4 + local6 * local8 * local3;
var local11:Number = local5 * local3;
var local12:Number = -local9 * param1.x - local10 * param1.y - local11 * param1.z;
var local13:Number = param1.view.width * 0.5;
var local14:Number = param1.view.height * 0.5;
var local15:Number = Math.sqrt(local13 * local13 + local14 * local14) / Math.tan(param1.fov * 0.5);
var local16:Number = local9 * param2.x + local10 * param2.y + local11 * param2.z + local12;
return local15 / local16;
}
private static function composeObject3DMatrix(param1:Object3D) : Matrix4 {
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local2:Number = Math.cos(param1.rotationX);
var local3:Number = Math.sin(param1.rotationX);
var local4:Number = Math.cos(param1.rotationY);
var local5:Number = Math.sin(param1.rotationY);
var local6:Number = Math.cos(param1.rotationZ);
var local7:Number = Math.sin(param1.rotationZ);
var local8:Number = local6 * local5;
local9 = local7 * local5;
local10 = local4 * param1.scaleX;
local11 = local3 * param1.scaleY;
local12 = local2 * param1.scaleY;
local13 = local2 * param1.scaleZ;
local14 = local3 * param1.scaleZ;
m1.m00 = local6 * local10;
m1.m01 = local8 * local11 - local7 * local12;
m1.m02 = local8 * local13 + local7 * local14;
m1.m03 = param1.x;
m1.m10 = local7 * local10;
m1.m11 = local9 * local11 + local6 * local12;
m1.m12 = local9 * local13 - local6 * local14;
m1.m13 = param1.y;
m1.m20 = -local5 * param1.scaleX;
m1.m21 = local4 * local11;
m1.m22 = local4 * local13;
m1.m23 = param1.z;
return m1;
}
public function setHudIndicatoresState(param1:int, param2:int) : void {
this.redMarker.setState(param1);
this.blueMarker.setState(param2);
}
public function setHudIndicatorState(param1:BattleTeam, param2:int) : void {
if(param1 == BattleTeam.RED) {
this.redMarker.setState(param2);
} else if(param1 == BattleTeam.BLUE) {
this.blueMarker.setState(param2);
}
}
public function render(param1:int, param2:int) : void {
var local3:Matrix4 = this.calculateProjectionMatrix();
this.updateMarker(local3,this.redBaseMarker);
this.updateMarker(local3,this.blueBaseMarker);
this.updateMarker(local3,this.redMarker);
this.updateMarker(local3,this.blueMarker);
this.sortChildren();
}
private function sortChildren() : void {
var local1:PointHudIndicator = null;
this.markers.sortOn("zindex",Array.DESCENDING | Array.NUMERIC);
for each(local1 in this.markers) {
battleService.getBattleView().addOverlayObject(local1);
}
}
private function updateMarker(param1:Matrix4, param2:PointHudIndicator) : void {
var local7:Number = NaN;
if(!param2.isActive(this.camera)) {
param2.visible = false;
return;
}
param2.readPosition3D(v);
v.transform4(param1);
this.projectToView(v);
var local3:Number = 15;
var local4:Number = this.getMarginY();
var local5:Boolean = this.isPointInsideViewport(v.x,v.y,local3,local4);
if(v.z > 0 && local5) {
local7 = this.getPointAlpha(param2);
if(local7 == 0) {
param2.visible = false;
param2.alpha = 0;
} else {
param2.visible = true;
param2.alpha = local7;
}
} else {
param2.alpha = 1;
param2.visible = false;
}
var local6:BattleView = battleService.getBattleView();
param2.x = int(v.x + local6.getWidth() / 2 - 12);
param2.y = int(v.y + local6.getHeight() / 2 - 12);
param2.zindex = this.getDistanceToCamera(param2);
}
private function getDistanceToCamera(param1:PointHudIndicator) : Number {
param1.readPosition3D(pointPosition);
cameraPosition.reset(this.camera.x,this.camera.y,this.camera.z);
direction.diff(pointPosition,cameraPosition);
return direction.length();
}
private function getPointAlpha(param1:PointHudIndicator) : Number {
var local2:Number = NaN;
param1.readPosition3D(pointPosition);
cameraPosition.reset(this.camera.x,this.camera.y,this.camera.z);
direction.diff(pointPosition,cameraPosition);
direction.normalize();
var local3:RayIntersectionData = battleService.getBattleScene3D().raycast(cameraPosition,direction,battleService.getExcludedObjects3D());
var local4:Number = pointPosition.distanceTo(cameraPosition);
if(local4 < NEAR_MARKER_DISTANCE) {
local2 = 0;
} else if(local4 > FAR_MARKER_DISTANCE) {
local2 = 1;
} else {
local2 = (local4 - NEAR_MARKER_DISTANCE) / (FAR_MARKER_DISTANCE - NEAR_MARKER_DISTANCE);
}
return local2;
}
private function getMarginY() : int {
switch(battleService.getBattleView().getScreenSize()) {
case BattleView.MAX_SCREEN_SIZE:
return 70;
case BattleView.MAX_SCREEN_SIZE - 1:
return 40;
default:
return 15;
}
}
private function isPointInsideViewport(param1:Number, param2:Number, param3:Number, param4:Number) : Boolean {
var local5:BattleView = battleService.getBattleView();
var local6:Number = local5.getWidth() / 2 - param3;
var local7:Number = local5.getHeight() / 2 - param4;
return param1 >= -local6 && param1 <= local6 && param2 >= -local7 && param2 <= local7;
}
private function projectToView(param1:Vector3) : void {
var local2:Number = NaN;
var local3:Number = NaN;
if(param1.z > 0.001) {
param1.x = param1.x * this.camera.viewSizeX / param1.z;
param1.y = param1.y * this.camera.viewSizeY / param1.z;
} else if(param1.z < -0.001) {
param1.x = -param1.x * this.camera.viewSizeX / param1.z;
param1.y = -param1.y * this.camera.viewSizeY / param1.z;
} else {
local2 = Number(battleService.getBattleView().getDiagonalSquared());
local3 = Math.sqrt(param1.x * param1.x + param1.y * param1.y);
param1.x *= local2 / local3;
param1.y *= local2 / local3;
}
}
private function calculateProjectionMatrix() : Matrix4 {
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Number = NaN;
var local10:Number = NaN;
var local12:Number = NaN;
var local14:Number = NaN;
var local1:Number = this.camera.viewSizeX / this.camera.focalLength;
var local2:Number = this.camera.viewSizeY / this.camera.focalLength;
var local3:Number = Math.cos(this.camera.rotationX);
var local4:Number = Math.sin(this.camera.rotationX);
local5 = Math.cos(this.camera.rotationY);
local6 = Math.sin(this.camera.rotationY);
local7 = Math.cos(this.camera.rotationZ);
local8 = Math.sin(this.camera.rotationZ);
var local9:Number = local7 * local6;
local10 = local8 * local6;
var local11:Number = local5 * this.camera.scaleX;
local12 = local4 * this.camera.scaleY;
var local13:Number = local3 * this.camera.scaleY;
local14 = local3 * this.camera.scaleZ;
var local15:Number = local4 * this.camera.scaleZ;
m.m00 = local7 * local11 * local1;
m.m01 = (local9 * local12 - local8 * local13) * local2;
m.m02 = local9 * local14 + local8 * local15;
m.m03 = this.camera.x;
m.m10 = local8 * local11 * local1;
m.m11 = (local10 * local12 + local7 * local13) * local2;
m.m12 = local10 * local14 - local7 * local15;
m.m13 = this.camera.y;
m.m20 = -local6 * this.camera.scaleX * local1;
m.m21 = local5 * local12 * local2;
m.m22 = local5 * local14;
m.m23 = this.camera.z;
var local16:Object3D = this.camera;
while(local16.parent != null) {
local16 = local16.parent;
m.append(composeObject3DMatrix(local16));
}
m.invert();
return m;
}
}
}
|
package alternativa.tanks.models.drones {
import alternativa.tanks.battle.scene3d.Renderer;
public interface DroneRenderer extends Renderer {
function stop() : void;
function start() : void;
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.base {
public class GreenShopItemSkin extends ButtonItemSkin {
private static const normalStateClass:Class = GreenShopItemSkin_normalStateClass;
private static const overStateClass:Class = GreenShopItemSkin_overStateClass;
public function GreenShopItemSkin() {
super();
normalState = new normalStateClass().bitmapData;
overState = new overStateClass().bitmapData;
}
}
}
|
package alternativa.tanks.battle.scene3d.scene3dcontainer {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Object3DContainer;
import flash.utils.Dictionary;
public class Object3DContainerProxy implements Scene3DContainer {
private var container:Object3DContainer = new Object3DContainer();
private const objects:Dictionary = new Dictionary();
public function Object3DContainerProxy(param1:Object3DContainer = null) {
super();
this.setContainer(param1);
}
public function addChild(param1:Object3D) : void {
if(param1 == null) {
throw new ArgumentError("Parameter is null");
}
if(!this.objects[param1]) {
this.objects[param1] = true;
this.container.addChild(param1);
}
}
public function addChildAt(param1:Object3D, param2:int) : void {
if(param1 == null) {
throw new ArgumentError("Parameter is null");
}
if(!this.objects[param1]) {
this.objects[param1] = true;
this.container.addChildAt(param1,param2);
}
}
public function addChildren(param1:Vector.<Object3D>) : void {
var local2:Object3D = null;
if(param1 == null) {
throw new ArgumentError("Parameter is null");
}
for each(local2 in param1) {
this.addChild(local2);
}
}
public function removeChild(param1:Object3D) : void {
if(param1 == null) {
throw new ArgumentError("Parameter is null");
}
if(Boolean(this.objects[param1])) {
delete this.objects[param1];
this.container.removeChild(param1);
}
}
public function setContainer(param1:Object3DContainer) : void {
var local2:Vector.<Object3D> = this.removeAllChildren();
this.container = param1 || new Object3DContainer();
this.addChildren(local2);
}
private function removeAllChildren() : Vector.<Object3D> {
var local2:* = undefined;
var local1:Vector.<Object3D> = new Vector.<Object3D>();
for(local2 in this.objects) {
delete this.objects[local2];
this.container.removeChild(local2);
local1.push(local2);
}
return local1;
}
}
}
|
package alternativa.tanks.models.battle.jgr {
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleView;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.models.battle.gui.markers.PointHudIndicator;
import alternativa.tanks.models.battle.gui.markers.PointIndicatorStateProvider;
import flash.display.Bitmap;
public class JuggernautHudIndicator implements Renderer {
[Inject]
public static var battleService:BattleService;
private static const m:Matrix4 = new Matrix4();
private static const m1:Matrix4 = new Matrix4();
private static const v:Vector3 = new Vector3();
private static const pointPosition:Vector3 = new Vector3();
private static const cameraPosition:Vector3 = new Vector3();
private static const direction:Vector3 = new Vector3();
private static const NEAR_MARKER_DISTANCE:Number = 6600;
private static const FAR_MARKER_DISTANCE:Number = 7000;
private var bossMarker:PointHudIndicator;
private var camera:Camera3D;
public function JuggernautHudIndicator(param1:Bitmap, param2:PointIndicatorStateProvider) {
super();
this.bossMarker = new PointHudIndicator(param1,param2);
battleService.getBattleView().addOverlayObject(this.bossMarker);
this.camera = battleService.getBattleScene3D().getCamera();
}
private static function getMarginY() : int {
switch(battleService.getBattleView().getScreenSize()) {
case BattleView.MAX_SCREEN_SIZE:
return 70;
case BattleView.MAX_SCREEN_SIZE - 1:
return 40;
default:
return 15;
}
}
private static function isPointInsideViewport(param1:Number, param2:Number, param3:Number, param4:Number) : Boolean {
var local5:BattleView = battleService.getBattleView();
var local6:Number = local5.getWidth() / 2 - param3;
var local7:Number = local5.getHeight() / 2 - param4;
return param1 >= -local6 && param1 <= local6 && param2 >= -local7 && param2 <= local7;
}
private static function composeObject3DMatrix(param1:Object3D) : Matrix4 {
var local4:Number = NaN;
var local5:Number = NaN;
var local7:Number = NaN;
var local9:Number = NaN;
var local11:Number = NaN;
var local13:Number = NaN;
var local2:Number = Math.cos(param1.rotationX);
var local3:Number = Math.sin(param1.rotationX);
local4 = Math.cos(param1.rotationY);
local5 = Math.sin(param1.rotationY);
var local6:Number = Math.cos(param1.rotationZ);
local7 = Math.sin(param1.rotationZ);
var local8:Number = local6 * local5;
local9 = local7 * local5;
var local10:Number = local4 * param1.scaleX;
local11 = local3 * param1.scaleY;
var local12:Number = local2 * param1.scaleY;
local13 = local2 * param1.scaleZ;
var local14:Number = local3 * param1.scaleZ;
m1.m00 = local6 * local10;
m1.m01 = local8 * local11 - local7 * local12;
m1.m02 = local8 * local13 + local7 * local14;
m1.m03 = param1.x;
m1.m10 = local7 * local10;
m1.m11 = local9 * local11 + local6 * local12;
m1.m12 = local9 * local13 - local6 * local14;
m1.m13 = param1.y;
m1.m20 = -local5 * param1.scaleX;
m1.m21 = local4 * local11;
m1.m22 = local4 * local13;
m1.m23 = param1.z;
return m1;
}
public function render(param1:int, param2:int) : void {
var local3:Matrix4 = this.calculateProjectionMatrix();
this.updateMarker(local3,this.bossMarker);
}
private function updateMarker(param1:Matrix4, param2:PointHudIndicator) : void {
var local7:Number = NaN;
if(!param2.isActive(this.camera)) {
param2.visible = false;
return;
}
param2.readPosition3D(v);
v.transform4(param1);
this.projectToView(v);
var local3:Number = 15;
var local4:Number = getMarginY();
var local5:Boolean = isPointInsideViewport(v.x,v.y,local3,local4);
if(v.z > 0 && local5) {
local7 = this.getPointAlpha(param2);
if(local7 == 0) {
param2.visible = false;
param2.alpha = 0;
} else {
param2.visible = true;
param2.alpha = local7;
}
} else {
param2.alpha = 1;
param2.visible = false;
}
var local6:BattleView = battleService.getBattleView();
param2.x = int(v.x + local6.getWidth() / 2 - 12);
param2.y = int(v.y + local6.getHeight() / 2 - 12);
param2.zindex = this.getDistanceToCamera(param2);
}
private function getDistanceToCamera(param1:PointHudIndicator) : Number {
param1.readPosition3D(pointPosition);
cameraPosition.reset(this.camera.x,this.camera.y,this.camera.z);
direction.diff(pointPosition,cameraPosition);
return direction.length();
}
private function getPointAlpha(param1:PointHudIndicator) : Number {
var local2:Number = NaN;
param1.readPosition3D(pointPosition);
cameraPosition.reset(this.camera.x,this.camera.y,this.camera.z);
direction.diff(pointPosition,cameraPosition);
direction.normalize();
var local3:Number = pointPosition.distanceTo(cameraPosition);
if(local3 < NEAR_MARKER_DISTANCE) {
local2 = 0;
} else if(local3 > FAR_MARKER_DISTANCE) {
local2 = 1;
} else {
local2 = (local3 - NEAR_MARKER_DISTANCE) / (FAR_MARKER_DISTANCE - NEAR_MARKER_DISTANCE);
}
return local2;
}
private function projectToView(param1:Vector3) : void {
var local2:Number = NaN;
var local3:Number = NaN;
if(param1.z > 0.001) {
param1.x = param1.x * this.camera.viewSizeX / param1.z;
param1.y = param1.y * this.camera.viewSizeY / param1.z;
} else if(param1.z < -0.001) {
param1.x = -param1.x * this.camera.viewSizeX / param1.z;
param1.y = -param1.y * this.camera.viewSizeY / param1.z;
} else {
local2 = Number(battleService.getBattleView().getDiagonalSquared());
local3 = Math.sqrt(param1.x * param1.x + param1.y * param1.y);
param1.x *= local2 / local3;
param1.y *= local2 / local3;
}
}
private function calculateProjectionMatrix() : Matrix4 {
var local1:Number = NaN;
var local2:Number = NaN;
var local5:Number = NaN;
local1 = this.camera.viewSizeX / this.camera.focalLength;
local2 = this.camera.viewSizeY / this.camera.focalLength;
var local3:Number = Math.cos(this.camera.rotationX);
var local4:Number = Math.sin(this.camera.rotationX);
local5 = Math.cos(this.camera.rotationY);
var local6:Number = Math.sin(this.camera.rotationY);
var local7:Number = Math.cos(this.camera.rotationZ);
var local8:Number = Math.sin(this.camera.rotationZ);
var local9:Number = local7 * local6;
var local10:Number = local8 * local6;
var local11:Number = local5 * this.camera.scaleX;
var local12:Number = local4 * this.camera.scaleY;
var local13:Number = local3 * this.camera.scaleY;
var local14:Number = local3 * this.camera.scaleZ;
var local15:Number = local4 * this.camera.scaleZ;
m.m00 = local7 * local11 * local1;
m.m01 = (local9 * local12 - local8 * local13) * local2;
m.m02 = local9 * local14 + local8 * local15;
m.m03 = this.camera.x;
m.m10 = local8 * local11 * local1;
m.m11 = (local10 * local12 + local7 * local13) * local2;
m.m12 = local10 * local14 - local7 * local15;
m.m13 = this.camera.y;
m.m20 = -local6 * this.camera.scaleX * local1;
m.m21 = local5 * local12 * local2;
m.m22 = local5 * local14;
m.m23 = this.camera.z;
var local16:Object3D = this.camera;
while(local16.parent != null) {
local16 = local16.parent;
m.append(composeObject3DMatrix(local16));
}
m.invert();
return m;
}
}
}
|
package forms
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
import controls.DefaultButton;
import controls.Label;
import controls.TankWindow;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.filters.BitmapFilter;
import flash.filters.BitmapFilterQuality;
import flash.filters.BlurFilter;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
import flash.ui.Keyboard;
import flash.utils.Timer;
import forms.events.AlertEvent;
public class Alert extends Sprite
{
public static const ALERT_QUIT:int = 0;
public static const ALERT_CONFIRM_EMAIL:int = 1;
public static const ERROR_CALLSIGN_FIRST_SYMBOL:int = 2;
public static const ERROR_CALLSIGN_DEVIDE:int = 3;
public static const ERROR_CALLSIGN_LAST_SYMBOL:int = 4;
public static const ERROR_CALLSIGN_LENGTH:int = 5;
public static const ERROR_CALLSIGN_UNIQUE:int = 6;
public static const ERROR_PASSWORD_LENGTH:int = 7;
public static const ERROR_PASSWORD_INCORRECT:int = 8;
public static const ERROR_PASSWORD_CHANGE:int = 9;
public static const ERROR_EMAIL_UNIQUE:int = 10;
public static const ERROR_EMAIL_INVALID:int = 11;
public static const ERROR_EMAIL_NOTFOUND:int = 12;
public static const ERROR_EMAIL_NOTSENDED:int = 13;
public static const ERROR_FATAL:int = 14;
public static const ERROR_FATAL_DEBUG:int = 15;
public static const ERROR_BAN:int = 19;
public static const GARAGE_AVAILABLE:int = 16;
public static const ALERT_RECOVERY_LINK_SENDED:int = 17;
public static const ALERT_CHAT_PROCEED:int = 18;
public static const WRONG_CAPTCHA:int = 20;
public static const ALERT_CONFIRM_BATTLE_EXIT:int = 21;
public static const ALERT_CONFIRM_REMOVE_FRIEND:int = 22;
protected var bgWindow:TankWindow;
private var output:Label;
public var _msg:String;
private var labeledButton:DefaultButton;
private var _labels:Array;
private var bg:Sprite;
private var bmp:Bitmap;
protected var alertWindow:Sprite;
public var closeButton:MainPanelCloseButton;
private var _closable:Boolean = false;
private var alerts:Array;
private var timer:Timer;
public function Alert(id:int = -1, closable:Boolean = false)
{
this.bgWindow = new TankWindow();
this.output = new Label();
this.bg = new Sprite();
this.bmp = new Bitmap();
this.alertWindow = new Sprite();
this.closeButton = new MainPanelCloseButton();
this.alerts = new Array();
super();
var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
this._closable = closable;
this.bgWindow.headerLang = localeService.getText(TextConst.GUI_LANG);
if(AlertAnswer.YES == null)
{
this.fillAlerts();
}
this.alerts[ALERT_QUIT] = [localeService.getText(TextConst.ALERT_QUIT_TEXT),[AlertAnswer.YES,AlertAnswer.NO]];
this.alerts[ALERT_CONFIRM_EMAIL] = [localeService.getText(TextConst.ALERT_EMAIL_CONFIRMED),[AlertAnswer.YES]];
this.alerts[ERROR_FATAL] = [localeService.getText(TextConst.ERROR_FATAL),[AlertAnswer.RETURN]];
this.alerts[ERROR_FATAL_DEBUG] = [localeService.getText(TextConst.ERROR_FATAL_DEBUG),[AlertAnswer.SEND]];
this.alerts[ERROR_CALLSIGN_FIRST_SYMBOL] = [localeService.getText(TextConst.ERROR_CALLSIGN_WRONG_FIRST_SYMBOL),[AlertAnswer.OK]];
this.alerts[ERROR_CALLSIGN_DEVIDE] = [localeService.getText(TextConst.ERROR_CALLSIGN_NOT_SINGLE_DEVIDERS),[AlertAnswer.OK]];
this.alerts[ERROR_CALLSIGN_LAST_SYMBOL] = [localeService.getText(TextConst.ERROR_CALLSIGN_WRONG_LAST_SYMBOL),[AlertAnswer.OK]];
this.alerts[ERROR_CALLSIGN_LENGTH] = [localeService.getText(TextConst.ERROR_CALLSIGN_LENGTH),[AlertAnswer.OK]];
this.alerts[ERROR_CALLSIGN_UNIQUE] = [localeService.getText(TextConst.ERROR_CALLSIGN_NOT_UNIQUE),[AlertAnswer.OK]];
this.alerts[ERROR_EMAIL_UNIQUE] = [localeService.getText(TextConst.ERROR_EMAIL_NOT_UNIQUE),[AlertAnswer.OK]];
this.alerts[ERROR_EMAIL_INVALID] = [localeService.getText(TextConst.ERROR_EMAIL_INVALID),[AlertAnswer.OK]];
this.alerts[ERROR_EMAIL_NOTFOUND] = [localeService.getText(TextConst.ERROR_EMAIL_NOT_FOUND),[AlertAnswer.OK]];
this.alerts[ERROR_EMAIL_NOTSENDED] = [localeService.getText(TextConst.ERROR_EMAIL_NOT_SENDED),[AlertAnswer.OK]];
this.alerts[ERROR_PASSWORD_INCORRECT] = [localeService.getText(TextConst.ERROR_PASSWORD_INCORRECT),[AlertAnswer.OK]];
this.alerts[ERROR_PASSWORD_LENGTH] = [localeService.getText(TextConst.ERROR_PASSWORD_LENGTH),[AlertAnswer.OK]];
this.alerts[ERROR_PASSWORD_CHANGE] = [localeService.getText(TextConst.ERROR_PASSWORD_CHANGE),[AlertAnswer.OK]];
this.alerts[GARAGE_AVAILABLE] = [localeService.getText(TextConst.ALERT_GARAGE_AVAILABLE),[AlertAnswer.GARAGE,AlertAnswer.CANCEL]];
this.alerts[ALERT_RECOVERY_LINK_SENDED] = [localeService.getText(TextConst.ALERT_RECOVERY_LINK_SENDED),[AlertAnswer.OK]];
this.alerts[ALERT_CHAT_PROCEED] = [localeService.getText(TextConst.ALERT_CHAT_PROCEED_EXTERNAL_LINK),[AlertAnswer.CANCEL]];
this.alerts[ERROR_BAN] = [localeService.getText(TextConst.ERROR_ACCOUNT_BAN),[AlertAnswer.OK]];
this.alerts[WRONG_CAPTCHA] = [localeService.getText(TextConst.ERROR_WRONG_CAPTCHA),[AlertAnswer.OK]];
this.alerts[ALERT_CONFIRM_BATTLE_EXIT] = [localeService.getText(TextConst.ALERT_CONFIRM_BATTLE_EXIT),[AlertAnswer.YES,AlertAnswer.NO]];
this.alerts[ALERT_CONFIRM_REMOVE_FRIEND] = [localeService.getText(TextConst.ALERT_CONFIRM_REMOVE_FRIEND),[AlertAnswer.YES,AlertAnswer.NO]];
if(id > -1)
{
this.showAlert(this.alerts[id][0],this.alerts[id][1]);
}
}
private function fillAlerts() : void
{
var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
AlertAnswer.YES = localeService.getText(TextConst.ALERT_ANSWER_YES);
AlertAnswer.NO = localeService.getText(TextConst.ALERT_ANSWER_NO);
AlertAnswer.OK = localeService.getText(TextConst.ALERT_ANSWER_OK);
AlertAnswer.CANCEL = localeService.getText(TextConst.ALERT_ANSWER_CANCEL);
AlertAnswer.SEND = localeService.getText(TextConst.ALERT_ANSWER_SEND_BUG_REPORT);
AlertAnswer.RETURN = localeService.getText(TextConst.ALERT_ANSWER_RETURN_TO_BATTLE);
AlertAnswer.GARAGE = localeService.getText(TextConst.ALERT_ANSWER_GO_TO_GARAGE);
AlertAnswer.PROCEED = localeService.getText(TextConst.ALERT_ANSWER_PROCEED);
}
public function showAlert(message:String, labels:Array) : void
{
this._msg = message;
this._labels = labels;
addEventListener(Event.ADDED_TO_STAGE,this.doLayout);
}
protected function doLayout(e:Event) : void
{
var i:int = 0;
var oneButtonWidth:int = this.calculateButtonsWidth();
var bwidth:int = oneButtonWidth * this._labels.length / 2;
removeEventListener(Event.ADDED_TO_STAGE,this.doLayout);
addChild(this.alertWindow);
this.alertWindow.addChild(this.bgWindow);
this.alertWindow.addChild(this.output);
this.output.autoSize = TextFieldAutoSize.CENTER;
this.output.align = TextFormatAlign.CENTER;
this.output.size = 13;
this.output.width = 10;
this.output.height = 10;
this.output.x = -5;
this.output.y = 30;
this.output.multiline = true;
this.output.htmlText = this._msg;
if(this._labels.length != 0)
{
for(i = 0; i < this._labels.length; i++)
{
this.labeledButton = new DefaultButton();
this.labeledButton.label = this._labels[i];
this.labeledButton.x = oneButtonWidth * i - bwidth;
this.labeledButton.y = this.output.y + this.output.height + 15;
this.labeledButton.width = oneButtonWidth - 6;
this.labeledButton.addEventListener(MouseEvent.CLICK,this.close);
this.alertWindow.addChild(this.labeledButton);
}
this.bgWindow.height = this.labeledButton.y + 60;
}
else
{
this.bgWindow.height = this.output.y + this.output.height + 30;
}
this.bgWindow.width = Math.max(int(this.output.width + 50),bwidth * 2 + 50);
this.bgWindow.x = -int(this.bgWindow.width / 2) - 3;
stage.addEventListener(Event.RESIZE,this.onResize);
stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp,false,-3);
if(this._closable)
{
this.alertWindow.addChild(this.closeButton);
this.closeButton.x = this.bgWindow.x + this.bgWindow.width - this.closeButton.width - 10;
this.closeButton.y = 10;
this.closeButton.addEventListener(MouseEvent.CLICK,this.close);
}
this.onResize(null);
}
private function onKeyUp(param1:KeyboardEvent) : void
{
var label:String = null;
var event:MouseEvent = null;
switch(this._labels.length)
{
case 1:
if(param1.keyCode == Keyboard.ENTER || param1.keyCode == Keyboard.ESCAPE)
{
label = this._labels[0];
}
break;
case 2:
if(param1.keyCode == Keyboard.ENTER)
{
label = this.getFirstExistingLabel(this.getConfirmationButtonNames());
}
else if(param1.keyCode == Keyboard.ESCAPE)
{
label = this.getFirstExistingLabel(this.getCancelButtonNames());
}
}
if(label != null)
{
param1.stopImmediatePropagation();
event = new MouseEvent(MouseEvent.CLICK,true,false,null,null,this.getButtonByLabel(label));
this.forceClose(this.getButtonByLabel(label));
}
}
private function getConfirmationButtonNames() : Vector.<String>
{
return Vector.<String>([AlertAnswer.OK,AlertAnswer.YES,AlertAnswer.GARAGE,AlertAnswer.PROCEED,AlertAnswer.SEND]);
}
private function getCancelButtonNames() : Vector.<String>
{
return Vector.<String>([AlertAnswer.NO,AlertAnswer.CANCEL,AlertAnswer.RETURN]);
}
private function getFirstExistingLabel(param1:Vector.<String>) : String
{
var _loc3_:int = 0;
var _loc2_:int = 0;
while(_loc2_ < this._labels.length)
{
_loc3_ = param1.indexOf(this._labels[_loc2_]);
if(_loc3_ > -1)
{
return param1[_loc3_];
}
_loc2_++;
}
return "";
}
private function calculateButtonsWidth() : int
{
var buttonWidth:int = 80;
var tempLabel:Label = new Label();
for(var i:int = 0; i < this._labels.length; i++)
{
tempLabel.text = this._labels[i];
if(tempLabel.width > buttonWidth)
{
buttonWidth = tempLabel.width;
}
}
return buttonWidth + 18;
}
private function drawBg() : void
{
var myFilters:Array = null;
var data:BitmapData = null;
var filter:BitmapFilter = new BlurFilter(5,5,BitmapFilterQuality.LOW);
myFilters = new Array();
myFilters.push(filter);
data = new BitmapData(stage.stageWidth,stage.stageHeight,true,0);
this.bmp.visible = false;
data.draw(stage);
this.bmp.visible = true;
this.bmp.filters = myFilters;
this.bmp.bitmapData = data;
}
private function onResize(e:Event) : void
{
this.alertWindow.x = int(stage.stageWidth / 2);
this.alertWindow.y = int(stage.stageHeight / 2 - this.alertWindow.height / 2);
}
private function getButtonByLabel(label:String) : DefaultButton
{
var trgt:DisplayObject = null;
for(var i:int = 0; i < this.alertWindow.numChildren; i++)
{
trgt = this.alertWindow.getChildAt(i);
if(trgt is DefaultButton || trgt == this.closeButton)
{
if((trgt as DefaultButton).label == label)
{
return trgt as DefaultButton;
}
}
}
return null;
}
private function forceClose(e:DefaultButton) : void
{
var trgt:DisplayObject = null;
var etarg:DefaultButton = e;
stage.removeEventListener(Event.RESIZE,this.onResize);
stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
for(var i:int = 0; i < this.alertWindow.numChildren; i++)
{
trgt = this.alertWindow.getChildAt(i);
if(trgt is DefaultButton || trgt == this.closeButton)
{
trgt.removeEventListener(MouseEvent.CLICK,this.close);
}
}
if(etarg != null)
{
dispatchEvent(new AlertEvent(etarg.label));
}
parent.removeChild(this);
}
private function close(e:MouseEvent) : void
{
var trgt:DisplayObject = null;
var etarg:DefaultButton = e.currentTarget as DefaultButton;
stage.removeEventListener(Event.RESIZE,this.onResize);
stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
for(var i:int = 0; i < this.alertWindow.numChildren; i++)
{
trgt = this.alertWindow.getChildAt(i);
if(trgt is DefaultButton || trgt == this.closeButton)
{
trgt.removeEventListener(MouseEvent.CLICK,this.close);
}
}
if(etarg != null)
{
dispatchEvent(new AlertEvent(etarg.label));
}
parent.removeChild(this);
}
}
}
|
package projects.tanks.client.partners.impl.china.chinamobilesdk.auth {
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 ChinaMobileSDKEntranceModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _loginId:Long = Long.getLong(538219146,1086364167);
private var _login_authDataCodec:ICodec;
private var _login_antiAddictionStateCodec:ICodec;
private var model:IModel;
public function ChinaMobileSDKEntranceModelServer(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._login_authDataCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._login_antiAddictionStateCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
}
public function login(param1:String, param2:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._login_authDataCodec.encode(this.protocolBuffer,param1);
this._login_antiAddictionStateCodec.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._loginId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.view.timeleftindicator {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.PixelSnapping;
public class GreenTimeLeftIndicator extends TimeLeftIndicator {
private static const emptyMarkerClass:Class = GreenTimeLeftIndicator_emptyMarkerClass;
private static const emptyMarkerBitmapData:BitmapData = new emptyMarkerClass().bitmapData;
private static const fullMarkerClass:Class = GreenTimeLeftIndicator_fullMarkerClass;
private static const fullMarkerBitmapData:BitmapData = new fullMarkerClass().bitmapData;
public function GreenTimeLeftIndicator() {
imageFull = new Bitmap(fullMarkerBitmapData,PixelSnapping.AUTO,true);
addChild(new Bitmap(emptyMarkerBitmapData,PixelSnapping.AUTO,true));
super();
}
}
}
|
package alternativa.tanks.battle {
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.ClientTankState;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.tankchassis.SuspensionRay;
import alternativa.tanks.battle.objects.tank.tankchassis.Track;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.sfx.*;
import alternativa.tanks.utils.GraphicsUtils;
import alternativa.utils.TextureMaterialRegistry;
import flash.display.BlendMode;
import flash.utils.Dictionary;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
public class Dust {
private static const CHANCE:Number = 0.2;
private static const SCALE_JITTER:Number = 1;
private static const bias:Vector3 = new Vector3(100,0,0);
private static const particleVelocity:Vector3 = new Vector3();
private static const particlePosition:Vector3 = new Vector3();
private var battleService:BattleService;
private var dustSize:Number = 0;
private var animation:TextureAnimation;
private var tanks:Dictionary = new Dictionary();
private var camera:GameCamera;
private var nearDistance:Number;
private var farDistance:Number;
public var enabled:Boolean = true;
private var intensity:Number;
private var density:Number;
public function Dust(param1:BattleService) {
super();
this.battleService = param1;
this.camera = param1.getBattleScene3D().getCamera();
}
private static function addJitter(param1:Vector3, param2:Number) : void {
param1.x += (Math.random() - 0.5) * 2 * param2;
param1.y += (Math.random() - 0.5) * 2 * param2;
param1.z += (Math.random() - 0.5) * 2 * param2;
}
public function init(param1:MultiframeTextureResource, param2:TextureMaterialRegistry, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number) : void {
this.animation = GraphicsUtils.getTextureAnimationFromResource(param2,param1);
this.farDistance = param3;
this.nearDistance = param4;
this.dustSize = param5;
this.intensity = param6;
this.density = param7;
}
public function addTank(param1:Tank) : void {
this.tanks[param1] = param1.getBoundSphereRadius() / 600;
}
public function removeTank(param1:Tank) : void {
delete this.tanks[param1];
}
public function update() : void {
var local1:* = undefined;
var local2:Tank = null;
if(this.enabled && Boolean(this.camera.softTransparency) && this.camera.softTransparencyStrength > 0) {
for(local1 in this.tanks) {
local2 = local1 as Tank;
if(Boolean(local2) && local2.state == ClientTankState.ACTIVE) {
this.addTankDust(local2,100,this.density);
}
}
}
}
public function addTankDust(param1:Tank, param2:Number = 100, param3:Number = 0.2) : void {
var local4:Number = Number(this.tanks[param1]);
var local5:Track = param1.getLeftTrack();
var local6:Track = param1.getRightTrack();
if(local5.animationSpeed * local6.animationSpeed < 0) {
param2 = 5;
}
var local7:Matrix3 = param1.getBody().baseMatrix;
bias.x *= -1;
local7.transformVector(bias,particleVelocity);
this.addTrackDust(local5,local4,particleVelocity,param2,param3);
bias.x *= -1;
local7.transformVector(bias,particleVelocity);
this.addTrackDust(local6,local4,particleVelocity,param2,param3);
}
private function addTrackDust(param1:Track, param2:Number, param3:Vector3, param4:Number, param5:Number) : void {
var local7:SuspensionRay = null;
var local8:Number = NaN;
var local9:Number = NaN;
var local6:int = 0;
while(local6 < param1.numRays) {
local7 = param1.rays[local6];
local8 = local7.speed;
if(local8 > param4 && Math.random() < param5) {
local9 = local8 > 500 ? 1 : 0.3 + local8 / 712;
particlePosition.copy(local7.getGlobalOrigin());
addJitter(particlePosition,50);
param3.z = 100;
addJitter(param3,20);
this.createDustParticle(param2,particlePosition,param3,local9);
}
local6++;
}
}
private function createDustParticle(param1:Number, param2:Vector3, param3:Vector3, param4:Number) : void {
var local5:ScalingObject3DPositionProvider = null;
var local6:LimitedDistanceAnimatedSpriteEffect = null;
var local7:Number = NaN;
if(this.enabled && Boolean(this.camera.softTransparency) && this.camera.softTransparencyStrength > 0) {
local5 = ScalingObject3DPositionProvider(this.battleService.getObjectPool().getObject(ScalingObject3DPositionProvider));
local5.init(param2,param3,0.01);
local6 = LimitedDistanceAnimatedSpriteEffect(this.battleService.getObjectPool().getObject(LimitedDistanceAnimatedSpriteEffect));
local7 = this.dustSize * param1 * (1 + SCALE_JITTER * Math.random());
local6.init(local7,local7,this.animation,Math.random() * 2 * Math.PI,local5,0.5,0.5,null,130,BlendMode.NORMAL,this.nearDistance,this.farDistance,this.intensity * param4 * this.camera.softTransparencyStrength,true);
this.battleService.addGraphicEffect(local6);
}
}
}
}
|
package alternativa.tanks.view.icons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.icons.BattleParamsBattleInfoIcons_devicesClass.png")]
public class BattleParamsBattleInfoIcons_devicesClass extends BitmapAsset {
public function BattleParamsBattleInfoIcons_devicesClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.common {
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.weapons.common.TargetPosition;
public class VectorCodecTargetPositionLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTargetPositionLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TargetPosition,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.<TargetPosition> = new Vector.<TargetPosition>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TargetPosition(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TargetPosition = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TargetPosition> = Vector.<TargetPosition>(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.service.payment.display {
import alternativa.tanks.loader.IModalLoaderService;
import alternativa.tanks.model.payment.PaymentUtils;
import alternativa.tanks.service.achievement.IAchievementService;
import alternativa.tanks.service.country.CountryService;
import alternativa.tanks.service.payment.IPaymentService;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.net.URLRequest;
import flash.net.navigateToURL;
import platform.client.fp10.core.type.IGameObject;
import platform.clients.fp10.libraries.alternativapartners.service.IPartnerService;
import projects.tanks.client.commons.types.ShopCategoryEnum;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.flash.commons.services.payment.event.PaymentDisplayServiceUnloadEvent;
import projects.tanks.clients.flash.commons.services.payment.event.PaymentLoadWithCategoryEvent;
import projects.tanks.clients.flash.commons.services.payment.event.PaymentLoadWithGarageItemEvent;
import projects.tanks.clients.flash.commons.services.payment.event.PaymentLoadWithShopItemEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.blur.IBlurService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.gamescreen.UserChangeGameScreenService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.paymentactions.UserPaymentActionsService;
public class PaymentDisplayServiceImpl extends EventDispatcher implements PaymentDisplayService {
[Inject]
public static var countryService:CountryService;
[Inject]
public static var modalLoaderService:IModalLoaderService;
[Inject]
public static var userPaymentActionsService:UserPaymentActionsService;
[Inject]
public static var blurService:IBlurService;
[Inject]
public static var paymentService:IPaymentService;
[Inject]
public static var achievementService:IAchievementService;
[Inject]
public static var partnerService:IPartnerService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var userChangeGameScreenService:UserChangeGameScreenService;
private var paymentDisplayed:Boolean = false;
private var reloadingState:Boolean = false;
private var loadEvent:Event;
public function PaymentDisplayServiceImpl() {
super();
}
public function openPaymentAt(param1:ShopCategoryEnum) : void {
this.openPaymentForAnyPurpose(new PaymentLoadWithCategoryEvent(param1));
}
public function openPaymentForGarageItem(param1:IGameObject) : void {
this.openPaymentForAnyPurpose(new PaymentLoadWithGarageItemEvent(param1));
}
public function openPayment() : void {
this.openPaymentForAnyPurpose(new PaymentLoadWithCategoryEvent(ShopCategoryEnum.NO_CATEGORY));
}
public function openPaymentForShopItem(param1:IGameObject) : void {
this.openPaymentForAnyPurpose(new PaymentLoadWithShopItemEvent(param1));
}
private function openPaymentForAnyPurpose(param1:Event) : void {
if(!paymentService.isEnabled()) {
return;
}
if(this.loadEvent != null) {
return;
}
userChangeGameScreenService.paymentWindowOpened();
userPaymentActionsService.openPayment(this.getCurrentStateName());
if(partnerService.hasPaymentAction()) {
partnerService.makePaymentAction();
return;
}
if(paymentService.isPaymentInLinkMode()) {
this.openPaymentLink();
return;
}
this.loadEvent = param1;
countryService.chooseCountryForPayment();
}
public function closePayment() : void {
userPaymentActionsService.closePayment(this.getCurrentStateName());
userChangeGameScreenService.paymentWindowClosed();
this.unloadPayment();
}
public function reloadPayment() : void {
this.reloadingState = true;
this.unloadPayment();
this.loadPayment();
}
private function unloadPayment() : void {
dispatchEvent(new PaymentDisplayServiceUnloadEvent());
this.paymentDisplayed = false;
}
public function loadPayment() : void {
blurService.blurGameContent();
modalLoaderService.show();
this.paymentDisplayed = true;
this.sendLoadEvent();
}
public function handlePaymentLoadingComplete() : void {
this.reloadingState = false;
modalLoaderService.hideForcibly();
}
public function handlePaymentUnloadingComplete() : void {
if(this.reloadingState) {
blurService.blurGameContent();
}
}
private function sendLoadEvent() : void {
dispatchEvent(this.loadEvent);
this.loadEvent = null;
}
public function isPaymentDisplayed() : Boolean {
return this.paymentDisplayed;
}
private function openPaymentLink() : void {
var local1:URLRequest = PaymentUtils.createUrlRequest(paymentService.getPaymentUrl());
navigateToURL(local1,"_blank");
}
private function getCurrentStateName() : String {
return lobbyLayoutService.getCurrentState().name;
}
}
}
|
package projects.tanks.client.battleservice.model.statistics {
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 StatisticsModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function StatisticsModelServer(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 projects.tanks.client.entrance.model.entrance.logging {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
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 RegistrationUXLoggerModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _initLoggerId:Long = Long.getLong(935931399,2106694434);
private var _initLogger_applicationStartTimeCodec:ICodec;
private var _initLogger_fromTutorialCodec:ICodec;
private var _initLogger_fromStandaloneTutorialCodec:ICodec;
private var _logFormActionId:Long = Long.getLong(1150797508,-1436727392);
private var _logFormAction_actionCodec:ICodec;
private var _logFormAction_additionalCountCodec:ICodec;
private var _logNavigationFinishId:Long = Long.getLong(255922434,49208013);
private var _logNavigationStartId:Long = Long.getLong(423897558,-955922712);
private var _logNavigationStart_destinationCodec:ICodec;
private var model:IModel;
public function RegistrationUXLoggerModelServer(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._initLogger_applicationStartTimeCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._initLogger_fromTutorialCodec = this.protocol.getCodec(new TypeCodecInfo(Boolean,false));
this._initLogger_fromStandaloneTutorialCodec = this.protocol.getCodec(new TypeCodecInfo(Boolean,false));
this._logFormAction_actionCodec = this.protocol.getCodec(new EnumCodecInfo(RegistrationUXFormAction,false));
this._logFormAction_additionalCountCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._logNavigationStart_destinationCodec = this.protocol.getCodec(new EnumCodecInfo(RegistrationUXScreen,false));
}
public function initLogger(param1:String, param2:Boolean, param3:Boolean) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._initLogger_applicationStartTimeCodec.encode(this.protocolBuffer,param1);
this._initLogger_fromTutorialCodec.encode(this.protocolBuffer,param2);
this._initLogger_fromStandaloneTutorialCodec.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._initLoggerId,this.protocolBuffer);
var local5:IGameObject = Model.object;
var local6:ISpace = local5.space;
local6.commandSender.sendCommand(local4);
this.protocolBuffer.optionalMap.clear();
}
public function logFormAction(param1:RegistrationUXFormAction, param2:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._logFormAction_actionCodec.encode(this.protocolBuffer,param1);
this._logFormAction_additionalCountCodec.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._logFormActionId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function logNavigationFinish() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._logNavigationFinishId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
public function logNavigationStart(param1:RegistrationUXScreen) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._logNavigationStart_destinationCodec.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._logNavigationStartId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
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;
public class DroneActivationRenderer extends AbstractDroneRenderer {
private const EFFECT_DURATION_MS:* = 2000;
private var localPosition:* = new Vector3();
public function DroneActivationRenderer(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:* = (param1 - startTime) / this.EFFECT_DURATION_MS;
if(local3 >= 1) {
drone.transitToActiveState();
return;
}
targetAlpha = -(local3 - 1) * (local3 - 1) + 1;
this.localPosition.copy(basePosition);
this.localPosition.x *= local3;
this.localPosition.y *= local3;
this.localPosition.z *= local3;
getTurretMatrix().transformVector(this.localPosition,drone.getPosition());
setPositionAndRotation(param1,param2);
updateVisibility();
}
override public function start() : void {
super.start();
drone.getObject3D().visible = true;
if(isLocal) {
drone.getObject3D().rotationZ = battleService.getBattleScene3D().getCamera().rotationZ;
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.sfx.shoot.shaft {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity.LightingSFXEntity;
import projects.tanks.client.battlefield.models.tankparts.sfx.shoot.shaft.ShaftShootSFXCC;
public class CodecShaftShootSFXCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_explosionSound:ICodec;
private var codec_explosionTexture:ICodec;
private var codec_hitMarkTexture:ICodec;
private var codec_lightingSFXEntity:ICodec;
private var codec_muzzleFlashTexture:ICodec;
private var codec_shotSound:ICodec;
private var codec_targetingSound:ICodec;
private var codec_trailTexture:ICodec;
private var codec_zoomModeSound:ICodec;
public function CodecShaftShootSFXCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_explosionSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_explosionTexture = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
this.codec_hitMarkTexture = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_lightingSFXEntity = param1.getCodec(new TypeCodecInfo(LightingSFXEntity,false));
this.codec_muzzleFlashTexture = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
this.codec_shotSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_targetingSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_trailTexture = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_zoomModeSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ShaftShootSFXCC = new ShaftShootSFXCC();
local2.explosionSound = this.codec_explosionSound.decode(param1) as SoundResource;
local2.explosionTexture = this.codec_explosionTexture.decode(param1) as MultiframeTextureResource;
local2.hitMarkTexture = this.codec_hitMarkTexture.decode(param1) as TextureResource;
local2.lightingSFXEntity = this.codec_lightingSFXEntity.decode(param1) as LightingSFXEntity;
local2.muzzleFlashTexture = this.codec_muzzleFlashTexture.decode(param1) as MultiframeTextureResource;
local2.shotSound = this.codec_shotSound.decode(param1) as SoundResource;
local2.targetingSound = this.codec_targetingSound.decode(param1) as SoundResource;
local2.trailTexture = this.codec_trailTexture.decode(param1) as TextureResource;
local2.zoomModeSound = this.codec_zoomModeSound.decode(param1) as SoundResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ShaftShootSFXCC = ShaftShootSFXCC(param2);
this.codec_explosionSound.encode(param1,local3.explosionSound);
this.codec_explosionTexture.encode(param1,local3.explosionTexture);
this.codec_hitMarkTexture.encode(param1,local3.hitMarkTexture);
this.codec_lightingSFXEntity.encode(param1,local3.lightingSFXEntity);
this.codec_muzzleFlashTexture.encode(param1,local3.muzzleFlashTexture);
this.codec_shotSound.encode(param1,local3.shotSound);
this.codec_targetingSound.encode(param1,local3.targetingSound);
this.codec_trailTexture.encode(param1,local3.trailTexture);
this.codec_zoomModeSound.encode(param1,local3.zoomModeSound);
}
}
}
|
package alternativa.tanks.model.item.container.gui.opening {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.loader.ILoaderWindowService;
import controls.TankWindow;
import controls.TankWindowInner;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.PixelSnapping;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.ColorTransform;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.utils.getTimer;
import platform.client.fp10.core.resource.BatchResourceLoader;
import platform.client.fp10.core.resource.Resource;
import projects.tanks.client.garage.models.item.container.ContainerGivenItem;
import projects.tanks.client.garage.models.item.container.resources.ContainerResourceCC;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
public class ContainerOpenDialog extends DialogWindow {
[Inject]
public static var loaderService:ILoaderWindowService;
[Inject]
public static var localeService:ILocaleService;
private static const Shine:Class = ContainerOpenDialog_Shine;
private static const shine:BitmapData = new Shine().bitmapData;
private static const Mote:Class = ContainerOpenDialog_Mote;
private static const mote:BitmapData = new Mote().bitmapData;
private static const Star:Class = ContainerOpenDialog_Star;
private static const star:BitmapData = new Star().bitmapData;
private static const Highlight:Class = ContainerOpenDialog_Highlight;
private static const highlight:BitmapData = new Highlight().bitmapData;
private static const STATE_SELECT:int = 0;
private static const STATE_OPEN:int = 1;
private static const STATE_DELAY:int = 2;
private static const STATE_PRESENT:int = 3;
private static const STATE_SWITCH:int = 4;
private static const STATE_COMPLETE:int = 5;
private static const STATE_MULTIPLIER:int = 6;
private static const STATE_LIGHT_UP:int = 7;
private static const OPEN_BUTTON_WIDTH:Number = 135;
private static const OPEN_TIME:Number = 35 / 60;
private static const LIGHT_UP_TIME:Number = 35 / 60;
private static const PRESENT_MIDDLE_TIME:Number = 15 / 60;
private static const PRESENT_APPEAR_TIME:Number = 20 / 60;
private static const PRESENT_TIME:Number = PRESENT_APPEAR_TIME + 40 / 60;
private static const PRESENT_DISAPPEAR_TIME:Number = PRESENT_TIME + 10 / 60;
private static const SWITCH_TIME:Number = 30 / 60;
private static const MULTIPLIER_MIDDLE_TIME:Number = 10 / 60;
private static const MULTIPLIER_APPEAR_TIME:Number = 15 / 60;
private static const MULTIPLIER_TIME:Number = MULTIPLIER_APPEAR_TIME + 40 / 60;
private static const MULTIPLIER_DISAPPEAR_TIME:Number = MULTIPLIER_TIME + 5 / 60;
private static const WINDOW_WIDTH:int = 625;
private static const WINDOW_HEIGHT:int = 591;
private static const BUTTON_PANEL_HEIGHT:int = 54;
private static const MARGIN:int = 11;
private var boxesCount:int = 0;
private var closeButton:DefaultButtonBase = new DefaultButtonBase();
private var openButtonsPanel:Sprite = new Sprite();
private var params:ContainerResourceCC;
private var window:TankWindow = new TankWindow(WINDOW_WIDTH,WINDOW_HEIGHT);
private var inner:TankWindowInner;
private var rewards:Vector.<ContainerGivenItem> = new Vector.<ContainerGivenItem>();
private var presents:Array = [];
private var index:int = 0;
private var color:ColorTransform = new ColorTransform();
private var bgClosed:Sprite = new Sprite();
private var bgOpen:Sprite = new Sprite();
private var bgLight:Sprite = new Sprite();
private var shine1:Sprite = new Sprite();
private var shine2:Sprite = new Sprite();
private var dust:Dust = new Dust(mote,16,WINDOW_WIDTH - 100,WINDOW_HEIGHT - 40);
private var stars:Stars = new Stars(star,highlight,16,WINDOW_WIDTH / 2 - 80);
private var present:Sprite = new Sprite();
private var label:LabelBase = new LabelBase();
private var multiplier:LabelBase = new LabelBase();
private var timer:int = 0;
private var state:int = 0;
private var hasOpenAllButton:Boolean = false;
private var batchLoader:BatchResourceLoader;
public function ContainerOpenDialog(param1:ContainerResourceCC, param2:int, param3:Boolean = false) {
this.batchLoader = new BatchResourceLoader(this.onBoxResourcesLoaded);
super();
this.params = param1;
this.boxesCount = param2;
this.hasOpenAllButton = param3;
addChild(this.window);
this.addResourcesToLoad();
}
private function addResourcesToLoad() : void {
var local1:Vector.<Resource> = new Vector.<Resource>();
local1.push(this.params.oneBoxImage);
local1.push(this.params.oneBoxOpenedImage);
local1.push(this.params.oneBoxLightImage);
if(this.params.threeBoxImage != null) {
local1.push(this.params.threeBoxImage);
}
if(this.params.threeBoxOpenedImage != null) {
local1.push(this.params.threeBoxOpenedImage);
}
if(this.params.threeBoxLightImage != null) {
local1.push(this.params.threeBoxLightImage);
}
if(this.params.fiveBoxImage != null) {
local1.push(this.params.fiveBoxImage);
}
if(this.params.fiveBoxOpenedImage != null) {
local1.push(this.params.fiveBoxOpenedImage);
}
if(this.params.fiveBoxLightImage != null) {
local1.push(this.params.fiveBoxLightImage);
}
this.batchLoader.load(local1);
}
public function openLoots(param1:Vector.<ContainerGivenItem>) : void {
var resources:Vector.<Resource>;
var reward:ContainerGivenItem = null;
var rewards:Vector.<ContainerGivenItem> = param1;
this.rewards = rewards.concat();
resources = new Vector.<Resource>();
for each(reward in rewards) {
if(!reward.image.isLoaded && resources.indexOf(reward.image) < 0) {
resources.push(reward.image);
}
}
if(resources.length > 0) {
new BatchResourceLoader(function():void {
startOpeningBox();
}).load(resources);
} else {
this.startOpeningBox();
}
}
public function select(param1:int) : void {
if(param1 == 0) {
this.bgClosed.getChildAt(0).visible = true;
this.bgClosed.getChildAt(1).visible = false;
this.bgClosed.getChildAt(2).visible = false;
this.bgOpen.getChildAt(0).visible = true;
this.bgOpen.getChildAt(1).visible = false;
this.bgOpen.getChildAt(2).visible = false;
this.bgLight.getChildAt(0).visible = true;
this.bgLight.getChildAt(1).visible = false;
this.bgLight.getChildAt(2).visible = false;
} else if(param1 == 1) {
this.bgClosed.getChildAt(0).visible = false;
this.bgClosed.getChildAt(1).visible = true;
this.bgClosed.getChildAt(2).visible = false;
this.bgOpen.getChildAt(0).visible = false;
this.bgOpen.getChildAt(1).visible = true;
this.bgOpen.getChildAt(2).visible = false;
this.bgLight.getChildAt(0).visible = false;
this.bgLight.getChildAt(1).visible = true;
this.bgLight.getChildAt(2).visible = false;
} else if(param1 == 2) {
this.bgClosed.getChildAt(0).visible = false;
this.bgClosed.getChildAt(1).visible = false;
this.bgClosed.getChildAt(2).visible = true;
this.bgOpen.getChildAt(0).visible = false;
this.bgOpen.getChildAt(1).visible = false;
this.bgOpen.getChildAt(2).visible = true;
this.bgLight.getChildAt(0).visible = false;
this.bgLight.getChildAt(1).visible = false;
this.bgLight.getChildAt(2).visible = true;
}
}
private function startOpeningBox() : void {
var local1:ContainerGivenItem = null;
var local2:Present = null;
for each(local1 in this.rewards) {
local2 = new Present(local1.image.data,local1.name,local1.category);
this.presents.push(local2);
}
this.colorize((this.presents[0] as Present).color);
this.state = STATE_OPEN;
this.inner.addChild(this.bgOpen);
this.inner.addChild(this.bgLight);
this.inner.addChild(this.dust);
this.inner.addChild(this.stars);
this.inner.addChild(this.present);
this.timer = getTimer();
this.dust.alpha = 0;
this.bgLight.alpha = 0;
addEventListener(Event.ENTER_FRAME,this.onEnterFrame,false,0,true);
}
private function onEnterFrame(param1:Event) : void {
var local2:Number = NaN;
var local3:Number = NaN;
var local9:Present = null;
var local4:Number = (getTimer() - this.timer) / 1000;
var local5:Present = this.presents[this.index];
var local6:Present = this.presents[this.index + 1] as Present;
var local7:int = 1;
var local8:int = this.index - 1;
while(local8 >= 0) {
local9 = this.presents[local8];
if(local9.bitmap.bitmapData != local5.bitmap.bitmapData) {
break;
}
local7++;
local8--;
}
this.multiplier.alpha = local7 > 1 && this.state == STATE_COMPLETE ? 1 : 0;
this.multiplier.text = "x" + local7.toString();
this.multiplier.x = -this.multiplier.width / 2;
if(this.state == STATE_MULTIPLIER) {
if(local4 < MULTIPLIER_MIDDLE_TIME) {
local2 = local4 / MULTIPLIER_MIDDLE_TIME;
local2 = Math.pow(local2,1 / 3);
local3 = 0.35 + (0.65 + 0.1) * local2;
this.multiplier.alpha = local2;
this.multiplier.scaleX = local3;
this.multiplier.scaleY = local3;
} else if(local4 < MULTIPLIER_APPEAR_TIME) {
local2 = 1 - (local4 - MULTIPLIER_MIDDLE_TIME) / (MULTIPLIER_APPEAR_TIME - MULTIPLIER_MIDDLE_TIME);
local3 = 1 + 0.1 * local2;
this.multiplier.alpha = 1;
this.multiplier.scaleX = local3;
this.multiplier.scaleY = local3;
} else if(local4 < MULTIPLIER_TIME) {
this.multiplier.alpha = 1;
this.multiplier.scaleX = 1;
this.multiplier.scaleY = 1;
} else if(local4 < MULTIPLIER_DISAPPEAR_TIME) {
if(this.index < this.presents.length - 1) {
local2 = 1 - (local4 - MULTIPLIER_TIME) / (MULTIPLIER_DISAPPEAR_TIME - MULTIPLIER_TIME);
this.multiplier.alpha = local2;
} else {
this.timer = getTimer();
this.state = STATE_COMPLETE;
}
} else {
this.multiplier.alpha = 0;
if(local6 != null && local5.bitmap.bitmapData != local6.bitmap.bitmapData) {
this.present.removeChildren();
this.state = STATE_SWITCH;
} else if(local6 == null) {
this.state = STATE_COMPLETE;
} else {
++this.index;
}
this.timer = getTimer();
}
} else if(this.state == STATE_OPEN) {
local2 = local4 / OPEN_TIME;
if(local2 < 1) {
this.bgOpen.alpha = local2;
} else {
this.bgOpen.alpha = 1;
this.inner.removeChild(this.bgClosed);
this.timer = getTimer();
this.state = STATE_LIGHT_UP;
}
} else if(this.state == STATE_LIGHT_UP) {
local2 = local4 / LIGHT_UP_TIME;
if(local2 < 1) {
this.bgLight.alpha = local2;
this.dust.alpha = local2;
} else {
this.bgLight.alpha = 1;
this.dust.alpha = 1;
this.timer = getTimer();
this.state = STATE_DELAY;
}
} else if(this.state == STATE_DELAY) {
if(local4 > local5.delay) {
this.present.addChild(local5.bitmap);
this.present.addChild(this.label);
this.present.addChild(this.multiplier);
this.label.text = local5.name;
this.label.x = -this.label.width / 2;
local5.bitmap.x = -local5.bitmap.width / 2;
local5.bitmap.y = -local5.bitmap.height / 2;
this.present.alpha = 0;
this.timer = getTimer();
this.state = STATE_PRESENT;
}
} else if(this.state == STATE_PRESENT) {
if(local4 < PRESENT_MIDDLE_TIME) {
local2 = local4 / PRESENT_MIDDLE_TIME;
local2 = Math.pow(local2,1 / 3);
local3 = 0.35 + (0.65 + 0.1) * local2;
this.present.alpha = local2;
this.present.scaleX = local3;
this.present.scaleY = local3;
} else if(local4 < PRESENT_APPEAR_TIME) {
this.inner.addChild(this.shine1);
this.inner.addChild(this.shine2);
this.inner.addChild(this.dust);
this.inner.addChild(this.stars);
this.inner.addChild(this.present);
this.dust.alpha = 1;
this.stars.alpha = 1;
local2 = 1 - (local4 - PRESENT_MIDDLE_TIME) / (PRESENT_APPEAR_TIME - PRESENT_MIDDLE_TIME);
local3 = 1 + 0.1 * local2;
this.present.alpha = 1;
this.present.scaleX = local3;
this.present.scaleY = local3;
} else if(local4 < PRESENT_TIME) {
this.present.alpha = 1;
this.present.scaleX = 1;
this.present.scaleY = 1;
} else if(local4 < PRESENT_DISAPPEAR_TIME) {
if(this.index < this.presents.length - 1) {
if(local5.bitmap.bitmapData != local6.bitmap.bitmapData) {
local2 = 1 - (local4 - PRESENT_TIME) / (PRESENT_DISAPPEAR_TIME - PRESENT_TIME);
this.present.alpha = local2;
}
} else {
this.timer = getTimer();
this.state = STATE_COMPLETE;
}
} else {
if(local6 != null && local6.bitmap.bitmapData == local5.bitmap.bitmapData) {
this.state = STATE_MULTIPLIER;
++this.index;
} else {
this.state = STATE_SWITCH;
this.present.alpha = 0;
this.present.removeChild(local5.bitmap);
}
this.timer = getTimer();
}
} else if(this.state == STATE_SWITCH) {
if(local4 < SWITCH_TIME) {
local2 = local4 / SWITCH_TIME;
this.interpolate(local5.color,local6.color,local2);
this.colorize(this.color);
} else {
this.colorize(local6.color);
++this.index;
this.timer = getTimer();
this.state = STATE_DELAY;
}
} else if(this.state == STATE_COMPLETE) {
this.window.addChild(this.closeButton);
}
this.shine1.rotation += 0.3;
this.shine2.rotation -= 0.3;
this.dust.update();
this.stars.update();
}
private function onBoxResourcesLoaded() : void {
var local1:int = WINDOW_WIDTH - 2 * MARGIN;
var local2:int = WINDOW_HEIGHT - 2 * MARGIN - BUTTON_PANEL_HEIGHT - 5;
this.inner = new TankWindowInner(local1,local2,TankWindowInner.GREEN);
this.inner.x = MARGIN;
this.inner.y = MARGIN;
this.window.addChild(this.inner);
this.closeButton.label = localeService.getText(TanksLocale.TEXT_CLOSE_LABEL);
this.closeButton.addEventListener(MouseEvent.CLICK,this.onCloseDialog,false,0,true);
this.closeButton.x = WINDOW_WIDTH - this.closeButton.width - MARGIN;
this.closeButton.y = WINDOW_HEIGHT - this.closeButton.height - MARGIN;
this.addOpenButtons();
this.bgClosed.addChild(new Bitmap(this.params.oneBoxImage.data));
this.bgClosed.addChild(new Bitmap(this.params.threeBoxImage != null ? this.params.threeBoxImage.data : this.params.oneBoxImage.data));
this.bgClosed.addChild(new Bitmap(this.params.fiveBoxImage != null ? this.params.fiveBoxImage.data : this.params.oneBoxImage.data));
this.inner.addChild(this.bgClosed);
this.bgOpen.addChild(new Bitmap(this.params.oneBoxOpenedImage.data));
this.bgOpen.addChild(new Bitmap(this.params.threeBoxOpenedImage != null ? this.params.threeBoxOpenedImage.data : this.params.oneBoxOpenedImage.data));
this.bgOpen.addChild(new Bitmap(this.params.fiveBoxOpenedImage != null ? this.params.fiveBoxOpenedImage.data : this.params.oneBoxOpenedImage.data));
this.bgOpen.alpha = 0;
this.bgLight.addChild(new Bitmap(this.params.oneBoxLightImage.data));
this.bgLight.addChild(new Bitmap(this.params.threeBoxLightImage != null ? this.params.threeBoxLightImage.data : this.params.oneBoxOpenedImage.data));
this.bgLight.addChild(new Bitmap(this.params.fiveBoxLightImage != null ? this.params.fiveBoxLightImage.data : this.params.oneBoxOpenedImage.data));
this.bgLight.blendMode = BlendMode.ADD;
this.bgLight.alpha = 0;
this.bgClosed.width = local1;
this.bgClosed.height = local2;
this.bgOpen.width = local1;
this.bgOpen.height = local2;
this.bgLight.width = local1;
this.bgLight.height = local2;
this.shine1.addChild(new Bitmap(shine,PixelSnapping.NEVER,true));
this.shine1.getChildAt(0).x = -this.shine1.getChildAt(0).width / 2;
this.shine1.getChildAt(0).y = -this.shine1.getChildAt(0).height / 2;
this.shine1.x = WINDOW_WIDTH / 2;
this.shine1.y = WINDOW_HEIGHT / 2;
this.shine1.width = 410;
this.shine1.height = 410;
this.shine1.blendMode = BlendMode.ADD;
this.shine2.addChild(new Bitmap(shine,PixelSnapping.NEVER,true));
this.shine2.getChildAt(0).x = -this.shine1.getChildAt(0).width / 2;
this.shine2.getChildAt(0).y = -this.shine1.getChildAt(0).height / 2;
this.shine2.x = WINDOW_WIDTH / 2;
this.shine2.y = WINDOW_HEIGHT / 2;
this.shine2.width = 410;
this.shine2.height = 410;
this.shine2.blendMode = BlendMode.ADD;
this.dust.x = 50;
this.dust.y = 20;
this.dust.alpha = 0;
this.stars.x = WINDOW_WIDTH / 2;
this.stars.y = WINDOW_HEIGHT / 2;
this.stars.alpha = 0;
this.present.x = WINDOW_WIDTH / 2;
this.present.y = WINDOW_HEIGHT / 2;
this.present.alpha = 0;
var local3:TextFormat = new TextFormat();
local3.align = "center";
this.label.autoSize = TextFieldAutoSize.CENTER;
this.label.defaultTextFormat = local3;
this.label.size = 40;
this.label.x = -(local1 - 100) / 2;
this.label.y = WINDOW_HEIGHT / 6;
this.multiplier.autoSize = TextFieldAutoSize.CENTER;
this.multiplier.defaultTextFormat = local3;
this.multiplier.size = 40;
this.multiplier.y = WINDOW_HEIGHT / 6 + 40;
this.multiplier.alpha = 0;
this.select(0);
}
private function addOpenButtons() : void {
var local2:OpenBoxButton = null;
var local3:Array = null;
var local4:Array = null;
var local5:int = 0;
var local6:int = 0;
var local7:OpenBoxButton = null;
this.openButtonsPanel.y = WINDOW_HEIGHT - 2 * MARGIN - BUTTON_PANEL_HEIGHT + 15;
this.window.addChild(this.closeButton);
this.window.addChild(this.openButtonsPanel);
var local1:int = 0;
if(this.hasOpenAllButton) {
local2 = this.createButton(localeService.getText(TanksLocale.TEXT_OPEN_ALL_CONTAINERS),this.boxesCount,0);
this.openButtonsPanel.addChild(local2);
local1 += OPEN_BUTTON_WIDTH;
} else {
local3 = [1,5,15];
local4 = [localeService.getText(TanksLocale.TEXT_LOOT_1_OPEN_BUTTON),localeService.getText(TanksLocale.TEXT_LOOT_2_OPEN_BUTTON),localeService.getText(TanksLocale.TEXT_LOOT_3_OPEN_BUTTON)];
local5 = 0;
while(local5 < local3.length) {
local6 = int(local3[local5]);
local7 = this.createButton(local4[local5],local6,local5);
local7.x = local1;
this.openButtonsPanel.addChild(local7);
local1 += OPEN_BUTTON_WIDTH;
local7.enabled = local6 <= this.boxesCount;
local5++;
}
}
this.openButtonsPanel.x = (WINDOW_WIDTH - local1) / 2;
}
private function createButton(param1:String, param2:int, param3:int) : OpenBoxButton {
var local4:OpenBoxButton = new OpenBoxButton(param1,param2,param3);
local4.addEventListener(MouseEvent.ROLL_OVER,this.onRollOver,false,0,true);
local4.addEventListener(MouseEvent.CLICK,this.onBoxSelected,false,0,true);
return local4;
}
private function interpolate(param1:ColorTransform, param2:ColorTransform, param3:Number) : void {
this.color.redMultiplier = param1.redMultiplier + (param2.redMultiplier - param1.redMultiplier) * param3;
this.color.greenMultiplier = param1.greenMultiplier + (param2.greenMultiplier - param1.greenMultiplier) * param3;
this.color.blueMultiplier = param1.blueMultiplier + (param2.blueMultiplier - param1.blueMultiplier) * param3;
}
private function colorize(param1:ColorTransform) : void {
this.bgLight.transform.colorTransform = param1;
this.shine1.transform.colorTransform = param1;
this.shine2.transform.colorTransform = param1;
this.dust.transform.colorTransform = param1;
this.stars.colorize(param1);
}
private function onRollOver(param1:MouseEvent) : void {
var local2:OpenBoxButton = param1.target as OpenBoxButton;
this.select(local2.mode);
}
private function onBoxSelected(param1:MouseEvent) : void {
var local2:OpenBoxButton = param1.target as OpenBoxButton;
this.window.removeChild(this.openButtonsPanel);
this.window.removeChild(this.closeButton);
this.boxesCount -= local2.count;
dispatchEvent(new ContainerEvent(local2.count));
}
private function close() : void {
dialogService.removeDialog(this);
}
private function onCloseDialog(param1:MouseEvent) : void {
this.close();
}
override protected function cancelKeyPressed() : void {
if(this.window.contains(this.closeButton)) {
this.close();
}
}
override protected function confirmationKeyPressed() : void {
if(this.window.contains(this.closeButton)) {
this.close();
}
}
}
}
|
package projects.tanks.client.battlefield.gui.models.statistics
{
public interface IStatisticsModelBase
{
}
}
|
package projects.tanks.clients.flash.commons.services.nameutils {
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class SocialNetworkNameUtils {
[Inject]
public static var localeService:ILocaleService;
public function SocialNetworkNameUtils() {
super();
}
public static function makeSocialNetworkNameFromId(param1:String) : String {
switch(param1) {
case "vkontakte":
return localeService.getText(TanksLocale.TEXT_VKONTAKTE_NAME);
case "facebook":
return localeService.getText(TanksLocale.TEXT_FACEBOOK_NAME);
default:
return param1.substr(0,1).toUpperCase() + param1.substr(1);
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes.android {
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.payment.modes.android.PurchaseData;
public class CodecPurchaseData implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_currency:ICodec;
private var codec_itemId:ICodec;
private var codec_token:ICodec;
public function CodecPurchaseData() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_currency = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_itemId = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_token = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:PurchaseData = new PurchaseData();
local2.currency = this.codec_currency.decode(param1) as String;
local2.itemId = this.codec_itemId.decode(param1) as String;
local2.token = this.codec_token.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:PurchaseData = PurchaseData(param2);
this.codec_currency.encode(param1,local3.currency);
this.codec_itemId.encode(param1,local3.itemId);
this.codec_token.encode(param1,local3.token);
}
}
}
|
package platform.client.fp10.core.type {
import platform.client.fp10.core.model.impl.Model;
public interface IGameObjectInternal extends IGameObject {
function putData(param1:Model, param2:Class, param3:Object) : void;
function getData(param1:Model, param2:Class) : Object;
function clearData(param1:Model, param2:Class) : Object;
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.healing {
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 alternativa.types.Short;
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;
import projects.tanks.client.battlefield.types.Vector3d;
public class IsisModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _resetTargetId:Long = Long.getLong(315477850,74416950);
private var _resetTarget_timeCodec:ICodec;
private var _setTargetId:Long = Long.getLong(724350021,-1874612855);
private var _setTarget_timeCodec:ICodec;
private var _setTarget_targetCodec:ICodec;
private var _setTarget_targetIncarnationCodec:ICodec;
private var _setTarget_localHitPointCodec:ICodec;
private var _stopWeaponCommandId:Long = Long.getLong(2132283949,89958307);
private var _stopWeaponCommand_timeCodec:ICodec;
private var _tickCommandId:Long = Long.getLong(315880994,956762724);
private var _tickCommand_timeCodec:ICodec;
private var _tickCommand_targetIncarnationCodec:ICodec;
private var _tickCommand_targetPositionCodec:ICodec;
private var _tickCommand_localHitPointCodec:ICodec;
private var model:IModel;
public function IsisModelServer(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._resetTarget_timeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._setTarget_timeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._setTarget_targetCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._setTarget_targetIncarnationCodec = this.protocol.getCodec(new TypeCodecInfo(Short,false));
this._setTarget_localHitPointCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._stopWeaponCommand_timeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._tickCommand_timeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._tickCommand_targetIncarnationCodec = this.protocol.getCodec(new TypeCodecInfo(Short,false));
this._tickCommand_targetPositionCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._tickCommand_localHitPointCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,false));
}
public function resetTarget(param1:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._resetTarget_timeCodec.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._resetTargetId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function setTarget(param1:int, param2:IGameObject, param3:int, param4:Vector3d) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._setTarget_timeCodec.encode(this.protocolBuffer,param1);
this._setTarget_targetCodec.encode(this.protocolBuffer,param2);
this._setTarget_targetIncarnationCodec.encode(this.protocolBuffer,param3);
this._setTarget_localHitPointCodec.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._setTargetId,this.protocolBuffer);
var local6:IGameObject = Model.object;
var local7:ISpace = local6.space;
local7.commandSender.sendCommand(local5);
this.protocolBuffer.optionalMap.clear();
}
public function stopWeaponCommand(param1:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._stopWeaponCommand_timeCodec.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._stopWeaponCommandId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function tickCommand(param1:int, param2:int, param3:Vector3d, param4:Vector3d) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._tickCommand_timeCodec.encode(this.protocolBuffer,param1);
this._tickCommand_targetIncarnationCodec.encode(this.protocolBuffer,param2);
this._tickCommand_targetPositionCodec.encode(this.protocolBuffer,param3);
this._tickCommand_localHitPointCodec.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._tickCommandId,this.protocolBuffer);
var local6:IGameObject = Model.object;
var local7:ISpace = local6.space;
local7.commandSender.sendCommand(local5);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package base {
import flash.display.Sprite;
public class DiscreteSprite extends Sprite {
public function DiscreteSprite() {
super();
}
override public function set x(param1:Number) : void {
super.x = int(param1);
}
override public function set y(param1:Number) : void {
super.y = int(param1);
}
override public function set width(param1:Number) : void {
super.width = Math.ceil(param1);
}
override public function set height(param1:Number) : void {
super.height = Math.ceil(param1);
}
}
}
|
package alternativa.tanks.model.referals
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import alternativa.tanks.model.panel.IPanel;
import projects.tanks.client.panel.model.referals.IReferalsModelBase;
import projects.tanks.client.panel.model.referals.ReferalsModelBase;
import projects.tanks.client.panel.model.referals.RefererIncomeData;
public class ReferalsModel extends ReferalsModelBase implements IReferalsModelBase, IObjectLoadListener, IReferals
{
private var clientObject:ClientObject;
private var referals:Array;
private var modelRegister:IModelService;
public function ReferalsModel()
{
super();
_interfaces.push(IModel);
_interfaces.push(IReferalsModelBase);
_interfaces.push(IObjectLoadListener);
_interfaces.push(IReferals);
this.modelRegister = Main.osgi.getService(IModelService) as IModelService;
}
public function initObject(object:ClientObject, magicString:String) : void
{
this.clientObject = object;
Main.writeVarsToConsoleChannel("REFERALS MODEL","initObject magicString: %1",magicString);
}
public function objectLoaded(object:ClientObject) : void
{
Main.writeVarsToConsoleChannel("REFERALS MODEL","objectLoaded");
this.clientObject = object;
Main.writeVarsToConsoleChannel("REFERALS MODEL"," clientObject: %1",this.clientObject);
}
public function objectUnloaded(object:ClientObject) : void
{
Main.writeVarsToConsoleChannel("REFERALS MODEL","objectUnloaded");
this.clientObject = null;
}
public function inviteSentSuccessfuly(clientObject:ClientObject, sentSuccessfuly:Boolean, errorMessage:String) : void
{
var panelModel:IPanel = (this.modelRegister.getModelsByInterface(IPanel) as Vector.<IModel>)[0] as IPanel;
panelModel.setInviteSendResult(sentSuccessfuly,errorMessage);
}
public function setRefererIncomeData(clientObject:ClientObject, data:Array) : void
{
var incomeData:RefererIncomeData = null;
var listeners:Vector.<IModel> = null;
var i:int = 0;
this.referals = data;
for each(incomeData in data)
{
Main.writeVarsToConsoleChannel("REFERALS MODEL","rank: " + incomeData.rank + " callsign: " + incomeData.callsign + " income: " + incomeData.income);
}
listeners = this.modelRegister.getModelsByInterface(IReferalsListener) as Vector.<IModel>;
if(listeners != null)
{
for(i = 0; i < listeners.length; i++)
{
(listeners[i] as IReferalsListener).updateReferalsData(data);
}
}
}
public function getReferalsData() : void
{
Main.writeVarsToConsoleChannel("REFERALS MODEL","getReferalsData clientObject: %1",this.clientObject);
}
}
}
|
package alternativa.tanks.service.matchmaking {
import alternativa.types.Long;
import flash.events.IEventDispatcher;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.MatchmakingUserData;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.MountItemsUserData;
public interface MatchmakingGroupFormService extends IEventDispatcher {
function showGroupView(param1:Vector.<MatchmakingUserData>, param2:Boolean) : void;
function hideGroupView() : void;
function addUserToGroup(param1:MatchmakingUserData) : void;
function removeUserFromGroup(param1:Long) : void;
function showUserReady(param1:Long) : void;
function showUserNotReady(param1:Long) : void;
function updateMountedItem(param1:MountItemsUserData) : void;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.