code
stringlengths 57
237k
|
|---|
package alternativa.tanks.engine3d {
import alternativa.engine3d.materials.TextureMaterial;
import flash.display.BitmapData;
public interface TextureMaterialFactory {
function createTextureMaterial(param1:BitmapData, param2:Boolean) : TextureMaterial;
}
}
|
package alternativa.tanks.models.weapon.healing {
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
internal class HealingGunShaft extends Mesh {
private var verts:Vector.<Vertex>;
private var vertsLen:int = 0;
private var direction:int = 1;
private var width:Number;
private var segment:Number = 1;
private var offset:Number = 0;
private var wave1Offset:Number = 0;
private var wave2Offset:Number = 0;
public function HealingGunShaft() {
var local4:Vertex = null;
var local5:Vertex = null;
this.verts = new Vector.<Vertex>();
super();
var local1:Vertex = addVertex(-1,0,0);
var local2:Vertex = addVertex(1,0,0);
this.verts[this.vertsLen] = local1;
++this.vertsLen;
this.verts[this.vertsLen] = local2;
++this.vertsLen;
var local3:int = 0;
while(local3 < HealingGunEffectsParams.SHAFT_NUM_SEGMENTS) {
local4 = addVertex(-1,-local3 - 1,0);
local5 = addVertex(1,-local3 - 1,0);
this.verts[this.vertsLen] = local4;
++this.vertsLen;
this.verts[this.vertsLen] = local5;
++this.vertsLen;
addQuadFace(local1,local4,local5,local2);
local1 = local4;
local2 = local5;
local3++;
}
calculateFacesNormals();
sorting = Sorting.DYNAMIC_BSP;
shadowMapAlphaThreshold = 2;
depthMapAlphaThreshold = 2;
useShadowMap = false;
useLight = false;
}
public function init(param1:Number, param2:Number) : void {
var local5:Vertex = null;
var local6:Vertex = null;
this.width = param1;
var local3:Number = param1 * 0.5;
var local4:int = 0;
while(local4 < this.vertsLen) {
local5 = this.verts[local4];
local4++;
local6 = this.verts[local4];
local5.x = -local3;
local5.u = 0;
local6.x = local3;
local6.u = 1;
local4++;
}
boundMinX = -local3;
boundMaxX = local3;
boundMinY = 0;
boundMinZ = 0;
boundMaxZ = 0;
}
public function setMaterial(param1:Material, param2:int) : void {
this.direction = param2;
setMaterialToAllFaces(param1);
var local3:TextureMaterial = param1 as TextureMaterial;
if(local3 != null && local3.texture != null) {
this.segment = this.width * local3.texture.height / local3.texture.width;
} else {
this.segment = this.width;
}
this.offset = 0;
this.wave1Offset = 0;
this.wave2Offset = 0;
}
public function update(param1:int, param2:Number) : void {
var local11:Vertex = null;
var local12:Vertex = null;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local3:Number = HealingGunEffectsParams.SHAFT_WAVE_AMPLITUDE / this.width;
var local4:Number = this.direction * HealingGunEffectsParams.SHAFT_WAVE1_SPEED;
var local5:Number = this.direction * HealingGunEffectsParams.SHAFT_WAVE2_SPEED;
var local6:Number = this.direction * HealingGunEffectsParams.SHAFT_STREAM_SPEED / this.segment;
this.wave1Offset += local4 * param1 / 1000;
this.wave2Offset += local5 * param1 / 1000;
this.offset += local6 * param1 / 1000;
var local7:Number = param2 / HealingGunEffectsParams.SHAFT_NUM_SEGMENTS;
var local8:Number = param2 / 2;
var local9:Number = 1;
var local10:int = 0;
while(local10 < this.vertsLen) {
local11 = this.verts[local10];
local10++;
local12 = this.verts[local10];
local11.y = param2 - (local10 >> 1) * local7;
local12.y = local11.y;
local13 = local8 - local11.y;
local11.v = local13 / this.segment + this.offset;
local12.v = local11.v;
if(local11.y < local8) {
local9 = local11.y / HealingGunEffectsParams.SHAFT_AMPLITUDE_FADE;
} else {
local9 = (param2 - local11.y) / HealingGunEffectsParams.SHAFT_AMPLITUDE_FADE;
}
if(local9 > 1) {
local9 = 1;
}
local14 = Math.sin(Math.PI * 2 * (local13 + this.wave1Offset) / HealingGunEffectsParams.SHAFT_WAVE1_LENGTH);
local15 = Math.sin(Math.PI * 2 * (local13 + this.wave2Offset) / HealingGunEffectsParams.SHAFT_WAVE2_LENGTH);
local11.u = (local14 + local15) * 0.5 * local3 * local9;
local12.u = 1 + local11.u;
local10++;
}
boundMaxY = param2;
}
public function clear() : void {
setMaterialToAllFaces(null);
}
}
}
|
package forms.friends
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class FriendsWindowStateBigButton_ButtonDownCenter extends BitmapAsset
{
public function FriendsWindowStateBigButton_ButtonDownCenter()
{
super();
}
}
}
|
package alternativa.tanks.view.forms {
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.osgi.service.logging.LogService;
import alternativa.tanks.controller.events.LoginButtonPressed;
import alternativa.tanks.controller.events.PartnersEvent;
import alternativa.tanks.loader.ILoaderWindowService;
import alternativa.tanks.service.IRegistrationUXService;
import alternativa.tanks.view.bubbles.Bubble;
import alternativa.tanks.view.bubbles.EntranceBubbleFactory;
import alternativa.tanks.view.forms.commons.RegistrationCommonElementsSection;
import alternativa.tanks.view.forms.primivites.ValidationIcon;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.base.TankInputBase;
import flash.display.Bitmap;
import flash.display.InteractiveObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.ui.Keyboard;
import flash.utils.Timer;
import forms.TankWindowWithHeader;
import forms.events.LoginFormEvent;
import org.robotlegs.core.IInjector;
import projects.tanks.clients.flash.commons.models.captcha.CaptchaSection;
import projects.tanks.clients.flash.commons.models.captcha.RefreshCaptchaClickedEvent;
import projects.tanks.clients.flash.commons.services.validate.IValidateService;
import projects.tanks.clients.flash.commons.services.validate.ValidateService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import services.alertservice.Alert;
public class LinkPartnerLoginForm extends Sprite {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var log:LogService;
[Inject]
public static var validateService:IValidateService;
[Inject]
public static var clientLog:IClientLog;
[Inject]
public static var registrationUXService:IRegistrationUXService;
[Inject]
public static var loaderWindowService:ILoaderWindowService;
[Inject]
public var injector:IInjector;
private var _callSignOrEmail:TankInputBase;
private var _password:TankInputBase;
private var _playButton:DefaultButtonBase;
private var _backButton:DefaultButtonBase;
private var _informLabel:LabelBase;
private var _window:TankWindowWithHeader;
private var _captchaSection:CaptchaSection;
private var _backgroundContainer:Sprite;
private var _backgroundImage:Bitmap;
private var _margin:int = 25;
private var _windowWidth:int = 372;
private var _windowHeight:int = 208;
private var _inputsLeftMargin:int = 72;
private var _symbolIsNotAllowedBubble:Bubble;
private var _callSignCheckIcon:ValidationIcon;
private var _notAllowedDelayTimerTimer:Timer;
public function LinkPartnerLoginForm(param1:Bitmap) {
super();
this._backgroundImage = param1;
}
[PostConstruct]
public function postConstruct() : void {
this._backgroundContainer = new Sprite();
addChild(this._backgroundContainer);
this._window = TankWindowWithHeader.createWindow(TanksLocale.TEXT_HEADER_LINK,this._windowWidth,this._windowHeight);
addChild(this._window);
var local1:int = 115;
this._callSignOrEmail = new TankInputBase();
this._callSignOrEmail.label = localeService.getText(TanksLocale.TEXT_CHECK_PASSWORD_FORM_CALLSIGN);
this._callSignOrEmail.maxChars = RegistrationCommonElementsSection.MAX_CHARS_EMAIL;
this._password = new TankInputBase();
this._password.label = localeService.getText(TanksLocale.TEXT_CHECK_PASSWORD_FORM_PASSWORD);
this._inputsLeftMargin = this._margin - 3 + (Math.abs(this._callSignOrEmail._label.x) > Math.abs(this._password._label.x) ? Math.abs(this._callSignOrEmail._label.x) : Math.abs(this._password._label.x));
this._callSignOrEmail.width = this._windowWidth - this._inputsLeftMargin - this._margin;
this._callSignOrEmail.x = this._inputsLeftMargin;
this._callSignOrEmail.y = this._margin;
this._callSignOrEmail.tabIndex = 0;
this._callSignOrEmail.restrict = "@А-Яа-я.0-9a-zA-z_\\-";
this._window.addChild(this._callSignOrEmail);
display.stage.focus = this._callSignOrEmail;
this._password.width = this._windowWidth - this._inputsLeftMargin - this._margin;
this._password.x = this._inputsLeftMargin;
this._password.y = this._callSignOrEmail.y + this._callSignOrEmail.height + this._margin / 3;
this._password.hidden = true;
this._password.tabIndex = 1;
this._window.addChild(this._password);
this._callSignCheckIcon = new ValidationIcon();
this._callSignCheckIcon.x = this._windowWidth - this._margin - this._callSignCheckIcon.width - 10;
this._callSignCheckIcon.y = this._callSignOrEmail.y + 7;
this._window.addChild(this._callSignCheckIcon);
this._informLabel = new LabelBase();
this._informLabel.text = localeService.getText(TanksLocale.TEXT_PARTNER_LOGIN_FORM_ENTER_USERNAME_TEXT);
this._informLabel.x = this._margin;
this._informLabel.y = this._password.y + this._password.height + this._margin - 10;
this._informLabel.multiline = true;
this._informLabel.wordWrap = true;
this._informLabel.width = this._windowWidth - this._informLabel.x - this._margin;
this._window.addChild(this._informLabel);
this._backButton = new DefaultButtonBase();
this._backButton.label = localeService.getText(TanksLocale.TEXT_BACK_BUTTON);
this._playButton = new DefaultButtonBase();
this._playButton.label = localeService.getText(TanksLocale.TEXT_COMPLETE_BUTTON);
this._playButton.width = this._backButton.width = Math.max(this._playButton.width,this._backButton.width,local1);
this._playButton.x = this._windowWidth - this._margin - this._playButton.width;
this._playButton.y = this._windowHeight - this._playButton.height - this._margin;
this._window.addChild(this._playButton);
this._backButton.x = this._margin;
this._backButton.y = this._playButton.y;
this._window.addChild(this._backButton);
this._notAllowedDelayTimerTimer = new Timer(1000,1);
this._captchaSection = this.injector.instantiate(CaptchaSection);
this._symbolIsNotAllowedBubble = EntranceBubbleFactory.symbolIsNotAllowedBubble();
this.setEvents();
this.alignYourself();
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
registrationUXService.logNavigationFinish();
}
private function onAddedToStage(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemovedFromStage);
stage.addEventListener(Event.RESIZE,this.alignYourself);
this.alignYourself(null);
if(Boolean(this._backgroundImage)) {
this.setBackground(this._backgroundImage);
}
loaderWindowService.hide();
}
private function onRemovedFromStage(param1:Event) : void {
stage.removeEventListener(Event.RESIZE,this.alignYourself);
}
public function setBackground(param1:Bitmap) : void {
if(this._backgroundContainer.numChildren == 0) {
this._backgroundImage = param1;
this._backgroundContainer.addChild(param1);
this.alignYourself();
}
}
private function onPlayClicked(param1:MouseEvent = null) : void {
this._playButton.enable = false;
dispatchEvent(new LoginButtonPressed());
}
private function onBackClicked(param1:MouseEvent) : void {
dispatchEvent(new PartnersEvent(PartnersEvent.START_REGISTRATION));
}
private function onKeyDownPasswordInput(param1:KeyboardEvent) : void {
if(param1.keyCode == Keyboard.ENTER && this._playButton.enable) {
this.onPlayClicked();
}
}
public function get captchaAnswer() : String {
return this._captchaSection.captchaAnswer.value;
}
public function get mainPassword() : String {
return this._password.value;
}
public function set password(param1:String) : void {
this._password.value = param1;
}
public function get callsign() : String {
return this._callSignOrEmail.value;
}
public function set callsign(param1:String) : void {
if(param1 != null) {
this._callSignOrEmail.value = param1;
display.stage.focus = this._callSignOrEmail.textField.length == 0 ? this._callSignOrEmail.textField : this._password.textField;
}
}
public function get password() : String {
return this._password.value;
}
private function setEvents() : void {
display.stage.addEventListener(Event.RESIZE,this.alignYourself);
this._playButton.addEventListener(MouseEvent.CLICK,this.onPlayClicked);
this._backButton.addEventListener(MouseEvent.CLICK,this.onBackClicked);
this._password.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDownPasswordInput);
this._callSignOrEmail.addEventListener(LoginFormEvent.TEXT_CHANGED,this.onCallsignChanged);
this._captchaSection.captchaAnswer.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDownPasswordInput);
this._captchaSection.refreshButton.addEventListener(MouseEvent.CLICK,this.onCaptchaRefresh);
this._notAllowedDelayTimerTimer.addEventListener(TimerEvent.TIMER_COMPLETE,this.onCallsignCheckTimerComplete);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
}
private function onCaptchaRefresh(param1:MouseEvent = null) : void {
this._captchaSection.captchaAnswer.clear();
dispatchEvent(new RefreshCaptchaClickedEvent());
}
private function onRemoveFromStage(param1:Event) : void {
this._notAllowedDelayTimerTimer.stop();
this.removeEvents();
}
private function removeEvents() : void {
removeEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
display.stage.removeEventListener(Event.RESIZE,this.alignYourself);
this._playButton.removeEventListener(MouseEvent.CLICK,this.onPlayClicked);
this._backButton.removeEventListener(MouseEvent.CLICK,this.onBackClicked);
this._password.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDownPasswordInput);
this._callSignOrEmail.removeEventListener(LoginFormEvent.TEXT_CHANGED,this.onCallsignChanged);
this._captchaSection.captchaAnswer.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDownPasswordInput);
this._captchaSection.refreshButton.removeEventListener(MouseEvent.CLICK,this.onCaptchaRefresh);
this._notAllowedDelayTimerTimer.removeEventListener(TimerEvent.TIMER_COMPLETE,this.onCallsignCheckTimerComplete);
}
private function onCallsignCheckTimerComplete(param1:TimerEvent) : void {
this.hideBubbles();
}
private function onCallsignChanged(param1:LoginFormEvent) : void {
this.hideBubbles();
this._notAllowedDelayTimerTimer.reset();
this._notAllowedDelayTimerTimer.start();
if(!validateService.isValidIdentificationStringForLogin(this._callSignOrEmail.value)) {
this._callSignOrEmail.value = this._callSignOrEmail.value.replace(ValidateService.NOT_ALLOWED_PATTERN_FOR_LOGIN,"");
this._callSignOrEmail.validValue = false;
this._callSignCheckIcon.markAsInvalid();
this._callSignCheckIcon.addChild(this._symbolIsNotAllowedBubble);
}
}
private function hideBubbles() : void {
this._callSignOrEmail.validValue = true;
this._symbolIsNotAllowedBubble.hide();
this._callSignCheckIcon.turnOff();
}
public function showAlertAboutWrongPassword() : void {
this._playButton.enable = true;
this.showErrorWindow(Alert.ERROR_PASSWORD_INCORRECT);
this._password.clear();
if(this._window.contains(this._captchaSection)) {
this.onCaptchaRefresh();
}
}
private function showErrorWindow(param1:int) : void {
var local2:Alert = new Alert(param1);
display.contentUILayer.addChild(local2);
}
private function alignYourself(param1:Event = null) : void {
this.x = int((display.stage.stageWidth - this._windowWidth) / 2);
this.y = int((display.stage.stageHeight - this._windowHeight) / 2);
if(Boolean(this._backgroundImage)) {
graphics.clear();
graphics.beginFill(0);
graphics.drawRect(-this.x,-this.y,display.stage.width,display.stage.height);
graphics.endFill();
this._backgroundImage.x = int(this._windowWidth - this._backgroundImage.width >> 1);
this._backgroundImage.y = -int(display.stage.stageHeight - this._window.height >> 1);
}
}
public function set captchaImage(param1:Bitmap) : void {
if(Boolean(this._captchaSection)) {
this._captchaSection.captcha = param1;
}
}
public function captchaFailed() : void {
this._playButton.enable = true;
}
public function showCaptchaSection() : void {
if(!this._window.contains(this._captchaSection)) {
this._window.addChild(this._captchaSection);
this._captchaSection.y = this._password.y + this._password.height + this._margin - 5;
this._captchaSection.x = this._inputsLeftMargin;
this._captchaSection.width = this._windowWidth - this._inputsLeftMargin - this._margin;
this._captchaSection.visible = true;
this._informLabel.y = this._captchaSection.y + this._captchaSection.height + this._margin - 10;
this._playButton.y = this._informLabel.y + this._informLabel.height + this._margin - 5;
this._backButton.y = this._playButton.y;
this._windowHeight = this._windowHeight + this._captchaSection.height + this._margin - 5;
this._window.height = this._windowHeight;
this.alignYourself();
this.onCaptchaRefresh();
this._playButton.enable = true;
}
}
public function linkAlreadyExists() : void {
this._playButton.enable = true;
this.showErrorWindow(Alert.ERROR_PARTNER_LINK_ALREADY_EXISTS);
}
}
}
|
package platform.client.fp10.core.type.impl {
import alternativa.types.Long;
import flash.utils.Dictionary;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
import platform.client.fp10.core.type.*;
public class GameObject implements IGameObject, IGameObjectInternal {
[Inject]
public static var modelRegistry:ModelRegistry;
private var _name:String;
private var _id:Long;
private var _gameClass:IGameClass;
private var _space:ISpace;
private var data:Dictionary = new Dictionary();
private var adapts:Dictionary;
private var events:Dictionary;
private var interfaceToComponentsList:*;
private var components:Vector.<Component>;
public function GameObject(param1:Long, param2:IGameClass, param3:String, param4:ISpace) {
super();
this._id = param1;
this._gameClass = param2;
this._name = param3;
this._space = param4;
}
public function get id() : Long {
return this._id;
}
public function get name() : String {
return this._name;
}
public function get gameClass() : IGameClass {
return this._gameClass;
}
public function get space() : ISpace {
return this._space;
}
public function addComponent(param1:Component) : void {
this.resetInterfaceCache();
if(param1.gameObject != null) {
throw new Error("Component has already added to gameObject " + param1.gameObject);
}
if(this.components == null) {
this.components = new Vector.<Component>();
}
this.components.push(param1);
}
public function event(param1:Class) : Object {
var local3:Vector.<Object> = null;
var local4:Class = null;
if(this.events == null) {
this.events = new Dictionary();
}
var local2:Object = this.events[param1];
if(local2 == null) {
local3 = this.getComponents(param1);
local4 = modelRegistry.getEventsClass(param1);
local2 = new local4(this,local3);
this.events[param1] = local2;
}
return local2;
}
public function hasModel(param1:Class) : Boolean {
return this.getComponents(param1).length > 0;
}
public function adapt(param1:Class) : Object {
var local3:Vector.<Object> = null;
var local4:Class = null;
if(this.adapts == null) {
this.adapts = new Dictionary();
}
var local2:Object = this.adapts[param1];
if(local2 == null) {
local3 = this.getComponents(param1);
if(local3.length > 1) {
throw new Error("GameObject::_adapt() Multiple models have been found. Object: " + this + ", interface: " + param1);
}
if(local3.length == 0) {
throw new Error("GameObject::adapt() No models have been found. Object: " + this + ", interface: " + param1);
}
local4 = modelRegistry.getAdaptClass(param1);
local2 = new local4(this,local3[0]);
this.adapts[param1] = local2;
}
return local2;
}
public function putData(param1:Model, param2:Class, param3:Object) : void {
var local4:Dictionary = this.data[param1];
if(local4 == null) {
local4 = new Dictionary();
this.data[param1] = local4;
}
local4[param2] = param3;
}
public function getData(param1:Model, param2:Class) : Object {
var local3:Dictionary = this.data[param1];
return local3 == null ? null : local3[param2];
}
public function clearData(param1:Model, param2:Class) : Object {
var local3:Dictionary = this.data[param1];
if(local3 == null) {
return null;
}
var local4:Object = local3[param2];
delete local3[param2];
return local4;
}
public function toString() : String {
return "[GameObject id=" + this._id + "]";
}
private function getComponents(param1:Class) : Vector.<Object> {
var local3:Long = null;
var local4:Object = null;
var local5:Component = null;
if(this.interfaceToComponentsList == null) {
this.interfaceToComponentsList = new Dictionary();
}
if(param1 in this.interfaceToComponentsList) {
return this.interfaceToComponentsList[param1];
}
var local2:Vector.<Object> = new Vector.<Object>();
if(this.gameClass != null) {
for each(local3 in this.gameClass.models) {
local4 = modelRegistry.getModel(local3);
if(local4 is param1) {
local2.push(local4);
}
}
}
if(this.components != null) {
for each(local5 in this.components) {
if(local5 is param1) {
local2.push(local5);
}
}
}
this.interfaceToComponentsList[param1] = local2;
return local2;
}
public function clear() : void {
this.clearModelsInitParams();
this._gameClass = null;
this._space = null;
this.clearModelData();
this.resetInterfaceCache();
}
private function clearModelData() : void {
var local1:* = undefined;
var local2:Dictionary = null;
var local3:* = undefined;
var local4:* = undefined;
for(local1 in this.data) {
local2 = this.data[local1];
for(local3 in local2) {
local4 = local2[local3];
if(local4 is AutoClosable) {
AutoClosable(local4).close();
}
delete local2[local3];
}
delete this.data[local1];
}
}
private function clearModelsInitParams() : void {
var local1:Long = null;
var local2:IModel = null;
Model.object = this;
for each(local1 in this.gameClass.models) {
local2 = modelRegistry.getModel(local1);
if(local2 != null) {
local2.clearInitParams();
}
}
Model.popObject();
}
private function resetInterfaceCache() : void {
this.clearDictionary(this.interfaceToComponentsList);
this.clearDictionary(this.adapts);
this.clearDictionary(this.events);
this.interfaceToComponentsList = null;
this.adapts = null;
this.events = null;
}
private function clearDictionary(param1:Dictionary) : void {
var local2:* = undefined;
if(param1 == null) {
return;
}
for(local2 in param1) {
delete param1[local2];
}
}
}
}
|
package alternativa.tanks.models.weapon.flamethrower {
import alternativa.tanks.models.weapon.shared.streamweapon.StreamWeaponEffects;
[ModelInterface]
public interface IFlamethrowerSFXModel {
function getFlamethrowerEffects(param1:Number, param2:Number) : StreamWeaponEffects;
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.partners.kongregate {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.launcherparams.ILauncherParams;
import flash.display.Loader;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLRequest;
import flash.utils.Dictionary;
import platform.client.core.general.socialnetwork.types.LoginParameters;
import platform.clients.fp10.libraries.alternativapartners.type.IParametersListener;
import platform.clients.fp10.libraries.alternativapartners.type.IPartner;
import projects.tanks.client.partners.impl.kongregate.IKongregateLoginModelBase;
import projects.tanks.client.partners.impl.kongregate.KongregateLoginModelBase;
import projects.tanks.clients.fp10.models.tankspartnersmodel.guestform.GuestForm;
[ModelInfo]
public class KongregateLoginModel extends KongregateLoginModelBase implements IKongregateLoginModelBase, IPartner {
[Inject]
public static var launcherParams:ILauncherParams;
[Inject]
public static var displayService:IDisplay;
private var _kongregate:*;
private var listener:IParametersListener;
public var kongregateGuestWindow:GuestForm;
public function KongregateLoginModel() {
super();
}
public function getLoginParameters(param1:IParametersListener) : void {
this.listener = param1;
this.initKongregateApi();
}
private function initKongregateApi() : void {
var local1:String = null;
var local2:Loader = null;
if(!this._kongregate) {
local1 = launcherParams.getParameter("kongregate_api_path") || "http://www.kongregate.com/flash/API_AS3_Local.swf";
local2 = new Loader();
local2.contentLoaderInfo.addEventListener(Event.COMPLETE,this.onComplete);
local2.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.onError);
local2.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onError);
local2.load(new URLRequest(local1));
displayService.stage.addChild(local2);
} else {
this.loginClient();
}
}
private function onComplete(param1:Event) : void {
KongregateInstanceWrapper.kongregate = param1.target.content;
this._kongregate = KongregateInstanceWrapper.kongregate;
this._kongregate.services.connect();
this.loginClient();
}
private function onError(param1:Event) : void {
this.listener.onFailSetParameters();
}
private function generateParameters() : LoginParameters {
this._kongregate.stats.submit("initialized",1);
var local1:Dictionary = new Dictionary();
local1["user_id"] = this._kongregate.services.getUserId();
local1["game_auth_token"] = this._kongregate.services.getGameAuthToken();
return new LoginParameters(local1);
}
private function loginClient() : void {
if(Boolean(this._kongregate.services.isGuest())) {
this.kongregateGuestWindow = new GuestForm(this._kongregate.services.showSignInBox);
displayService.stage.addChild(this.kongregateGuestWindow);
this._kongregate.services.addEventListener("login",this.onLogin);
} else {
this.listener.onSetParameters(this.generateParameters());
}
}
private function onLogin(param1:Event) : void {
displayService.stage.removeChild(this.kongregateGuestWindow);
this.listener.onSetParameters(this.generateParameters());
}
public function getFailRedirectUrl() : String {
return "http://www.kongregate.com/";
}
public function isExternalLoginAllowed() : Boolean {
return false;
}
public function hasPaymentAction() : Boolean {
return false;
}
public function paymentAction() : void {
}
public function hasRatings() : Boolean {
return true;
}
}
}
|
package forms.userlabel {
import alternativa.types.Long;
import flash.display.Bitmap;
import flash.utils.Dictionary;
import projects.tanks.client.users.services.chatmoderator.ChatModeratorLevel;
public class ChatUserLabel extends UserLabel {
public static const CHAT_MODERATOR_STATUS_ICON_CONT_WIDTH:int = 16;
private static const cmStatusIconClass:Class = ChatUserLabel_cmStatusIconClass;
private static const goldBattleStatusIconClass:Class = ChatUserLabel_goldBattleStatusIconClass;
private static const silverBattleStatusIconClass:Class = ChatUserLabel_silverBattleStatusIconClass;
private static const bronzeBattleStatusIconClass:Class = ChatUserLabel_bronzeBattleStatusIconClass;
private static const goldStatusIconClass:Class = ChatUserLabel_goldStatusIconClass;
private static const silverStatusIconClass:Class = ChatUserLabel_silverStatusIconClass;
private static const bronzeStatusIconClass:Class = ChatUserLabel_bronzeStatusIconClass;
private static const eventGoldStatusIconClass:Class = ChatUserLabel_eventGoldStatusIconClass;
private static const eventSilverStatusIconClass:Class = ChatUserLabel_eventSilverStatusIconClass;
private static const eventBronzeStatusIconClass:Class = ChatUserLabel_eventBronzeStatusIconClass;
private static const bitmapDatas:Dictionary = new Dictionary();
bitmapDatas[ChatModeratorLevel.COMMUNITY_MANAGER] = new cmStatusIconClass().bitmapData;
bitmapDatas[ChatModeratorLevel.BATTLE_ADMINISTRATOR] = new goldBattleStatusIconClass().bitmapData;
bitmapDatas[ChatModeratorLevel.BATTLE_MODERATOR] = new silverBattleStatusIconClass().bitmapData;
bitmapDatas[ChatModeratorLevel.BATTLE_CANDIDATE] = new bronzeBattleStatusIconClass().bitmapData;
bitmapDatas[ChatModeratorLevel.ADMINISTRATOR] = new goldStatusIconClass().bitmapData;
bitmapDatas[ChatModeratorLevel.MODERATOR] = new silverStatusIconClass().bitmapData;
bitmapDatas[ChatModeratorLevel.CANDIDATE] = new bronzeStatusIconClass().bitmapData;
bitmapDatas[ChatModeratorLevel.EVENT_CHAT_ADMIN] = new eventGoldStatusIconClass().bitmapData;
bitmapDatas[ChatModeratorLevel.EVENT_CHAT_MODERATOR] = new eventSilverStatusIconClass().bitmapData;
bitmapDatas[ChatModeratorLevel.EVENT_CHAT_CANDIDATE] = new eventBronzeStatusIconClass().bitmapData;
protected var _chatModeratorLevel:ChatModeratorLevel;
protected var _needDrawAdditionalIcons:Boolean = this._chatModeratorLevel != ChatModeratorLevel.NONE;
public function ChatUserLabel(param1:Long, param2:Boolean = true) {
super(param1,param2);
}
override protected function createAdditionalIcons() : void {
var local1:Bitmap = null;
if(this._needDrawAdditionalIcons) {
local1 = new Bitmap(bitmapDatas[this._chatModeratorLevel]);
local1.x = RANK_ICON_CONT_WIDTH + 1;
local1.y = 3;
shadowContainer.addChild(local1);
}
}
override protected function getAdditionalIconsWidth() : Number {
return this._needDrawAdditionalIcons ? CHAT_MODERATOR_STATUS_ICON_CONT_WIDTH : 0;
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.UpgradeIndicator_m1Class.png")]
public class UpgradeIndicator_m1Class extends BitmapAsset {
public function UpgradeIndicator_m1Class() {
super();
}
}
}
|
package alternativa.tanks.display.usertitle {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.display.usertitle.EffectIndicator_iconPowerCls.png")]
public class EffectIndicator_iconPowerCls extends BitmapAsset {
public function EffectIndicator_iconPowerCls() {
super();
}
}
}
|
package alternativa.tanks.model.item.properties {
import alternativa.tanks.model.item.upgradable.UpgradableItemPropertyValue;
import projects.tanks.client.commons.types.ItemGarageProperty;
import projects.tanks.client.garage.models.item.properties.ItemGaragePropertyData;
public class ItemGaragePropertyValue implements ItemPropertyValue {
private var garageProperty:ItemGaragePropertyData;
public function ItemGaragePropertyValue(param1:ItemGaragePropertyData) {
super();
this.garageProperty = param1;
}
public function getValue(param1:int = 0) : String {
return this.garageProperty.value;
}
public function getProperty() : ItemGarageProperty {
return this.garageProperty.property;
}
public function isUpgradable() : Boolean {
return false;
}
public function getUpgradableValue() : UpgradableItemPropertyValue {
return null;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.machinegun {
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 MachineGunModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function MachineGunModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package controls.buttons.h30px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h30px.OrangeMediumButtonSkin_rightOverClass.png")]
public class OrangeMediumButtonSkin_rightOverClass extends BitmapAsset {
public function OrangeMediumButtonSkin_rightOverClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.antiaddictionalert
{
public interface IAntiAddictionAlertModelBase
{
}
}
|
package alternativa.tanks.service.paymentcomplete {
import flash.events.Event;
public class PaymentCompleteEvent extends Event {
public static const COMPLETED:String = "PaymentCompleteEvent.COMPLETED";
public function PaymentCompleteEvent() {
super(COMPLETED);
}
}
}
|
package alternativa.tanks.gui.friends {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.FriendsWindowStateSmallButton_sentClass.png")]
public class FriendsWindowStateSmallButton_sentClass extends BitmapAsset {
public function FriendsWindowStateSmallButton_sentClass() {
super();
}
}
}
|
package alternativa.tanks.servermodels.loginwithoutregistration {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ILoginWithoutRegistrationAdapt implements ILoginWithoutRegistration {
private var object:IGameObject;
private var impl:ILoginWithoutRegistration;
public function ILoginWithoutRegistrationAdapt(param1:IGameObject, param2:ILoginWithoutRegistration) {
super();
this.object = param1;
this.impl = param2;
}
public function passToFirstBattle() : void {
try {
Model.object = this.object;
this.impl.passToFirstBattle();
}
finally {
Model.popObject();
}
}
}
}
|
package forms.battlelist
{
import assets.cellrenderer.battlelist.CellRenderer_disabledDownSkin;
import assets.cellrenderer.battlelist.CellRenderer_disabledOverSkin;
import assets.cellrenderer.battlelist.CellRenderer_disabledSelectedDownSkin;
import assets.cellrenderer.battlelist.CellRenderer_disabledSelectedOverSkin;
import assets.cellrenderer.battlelist.CellRenderer_disabledSelectedUpSkin;
import assets.cellrenderer.battlelist.CellRenderer_disabledUpSkin;
import assets.cellrenderer.battlelist.CellRenderer_downSkin;
import assets.cellrenderer.battlelist.CellRenderer_overSkin;
import assets.cellrenderer.battlelist.CellRenderer_selectedDownSkin;
import assets.cellrenderer.battlelist.CellRenderer_selectedOverSkin;
import assets.cellrenderer.battlelist.CellRenderer_selectedUpSkin;
import assets.cellrenderer.battlelist.CellRenderer_upSkin;
import fl.controls.listClasses.CellRenderer;
import fl.controls.listClasses.ListData;
import flash.display.DisplayObject;
public class BattleListRenderer extends CellRenderer
{
private static var defaultStyles:Object = {
"upSkin":"CellRenderer_upSkin",
"downSkin":"CellRenderer_downSkin",
"overSkin":"CellRenderer_overSkin",
"disabledSkin":"CellRenderer_disabledSkin",
"selectedDisabledSkin":"CellRenderer_selectedDisabledSkin",
"selectedUpSkin":"CellRenderer_selectedUpSkin",
"selectedDownSkin":"CellRenderer_selectedUpSkin",
"selectedOverSkin":"CellRenderer_selectedUpSkin",
"textFormat":null,
"disabledTextFormat":null,
"embedFonts":null,
"textPadding":5
};
private var access:Boolean = true;
private var nicon:DisplayObject;
private var sicon:DisplayObject;
public function BattleListRenderer()
{
super();
}
override public function set data(value:Object) : void
{
_data = value;
this.access = value.accessible;
this.nicon = value.iconNormal;
this.sicon = value.iconSelected;
if(!this.access)
{
setStyle("upSkin",CellRenderer_disabledUpSkin);
setStyle("downSkin",CellRenderer_disabledDownSkin);
setStyle("overSkin",CellRenderer_disabledOverSkin);
setStyle("selectedUpSkin",CellRenderer_disabledSelectedUpSkin);
setStyle("selectedOverSkin",CellRenderer_disabledSelectedOverSkin);
setStyle("selectedDownSkin",CellRenderer_disabledSelectedDownSkin);
}
else
{
setStyle("upSkin",CellRenderer_upSkin);
setStyle("downSkin",CellRenderer_downSkin);
setStyle("overSkin",CellRenderer_overSkin);
setStyle("selectedUpSkin",CellRenderer_selectedUpSkin);
setStyle("selectedOverSkin",CellRenderer_selectedOverSkin);
setStyle("selectedDownSkin",CellRenderer_selectedDownSkin);
}
}
override public function set listData(value:ListData) : void
{
_listData = value;
label = _listData.label;
if(this.nicon != null && this.sicon != null)
{
setStyle("icon",this.nicon);
setStyle("selectedUpIcon",this.sicon);
setStyle("selectedOverIcon",this.sicon);
setStyle("selectedDownIcon",this.sicon);
}
}
override protected function drawBackground() : void
{
var styleName:String = !!enabled ? mouseState : "disabled";
if(selected)
{
styleName = "selected" + styleName.substr(0,1).toUpperCase() + styleName.substr(1);
}
styleName += "Skin";
var bg:DisplayObject = background;
background = getDisplayObjectInstance(getStyleValue(styleName));
addChildAt(background,0);
if(bg != null && bg != background)
{
removeChild(bg);
}
}
override protected function drawLayout() : void
{
super.drawLayout();
background.width = width - 4;
background.height = height;
}
override protected function drawIcon() : void
{
var oldIcon:DisplayObject = icon;
var styleName:String = !!enabled ? mouseState : "disabled";
if(selected)
{
styleName = "selected" + styleName.substr(0,1).toUpperCase() + styleName.substr(1);
}
styleName += "Icon";
var iconStyle:Object = getStyleValue(styleName);
if(iconStyle == null)
{
iconStyle = getStyleValue("icon");
}
if(iconStyle != null)
{
icon = getDisplayObjectInstance(iconStyle);
}
if(icon != null)
{
addChildAt(icon,1);
}
if(oldIcon != null && oldIcon != icon && oldIcon.parent == this)
{
removeChild(oldIcon);
}
}
}
}
|
package alternativa.tanks.gui.device {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.shop.components.itemscategory.ItemsCategoryViewGrid;
import alternativa.tanks.gui.skins.ItemSkinsWindow;
import alternativa.tanks.gui.skins.ShotSkinsWindow;
import alternativa.tanks.loader.IModalLoaderService;
import alternativa.tanks.model.item.availabledevices.AvailableDevices;
import alternativa.tanks.model.item.device.ItemDevicesGarage;
import alternativa.tanks.model.item.skins.AvailableShotSkins;
import alternativa.tanks.model.item.skins.AvailableSkins;
import alternativa.tanks.model.item.skins.MountShotSkin;
import alternativa.tanks.model.item.skins.MountSkin;
import alternativa.tanks.service.device.DeviceService;
import alternativa.tanks.service.device.UpdateDevicesEvent;
import alternativa.tanks.service.item.ItemService;
import controls.base.LabelBase;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import forms.ColorConstants;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.blur.IBlurService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import utils.preview.IImageResource;
import utils.preview.ImageResourceLoadingWrapper;
public class ItemInfoDevicesPanel extends Sprite implements IImageResource {
[Inject]
public static var deviceService:DeviceService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var modalLoaderService:IModalLoaderService;
[Inject]
public static var blurService:IBlurService;
[Inject]
public static var itemService:ItemService;
[Inject]
public static var localeService:ILocaleService;
private static const NUMBER_OF_DEVICES:int = 3;
private static const SLOT_SKIN:int = 0;
private static const SLOT_DEVICE:int = 1;
private static const SLOT_SHOT_COLOR:int = 2;
private var deviceButtons:Vector.<DeviceButton>;
private var imageResources:Vector.<ImageResource>;
private var loadListeners:Vector.<ImageResourceLoadingWrapper>;
private var targetItem:IGameObject;
private var panel:ItemsCategoryViewGrid;
private var skinsWindow:DialogWindow = null;
public function ItemInfoDevicesPanel() {
var local3:DeviceButton = null;
this.deviceButtons = new Vector.<DeviceButton>(NUMBER_OF_DEVICES,true);
this.imageResources = new Vector.<ImageResource>(NUMBER_OF_DEVICES,true);
this.loadListeners = new Vector.<ImageResourceLoadingWrapper>(NUMBER_OF_DEVICES,true);
this.panel = new ItemsCategoryViewGrid();
super();
var local1:LabelBase = new LabelBase();
local1.text = localeService.getText(TanksLocale.TEXT_DEVICES);
local1.size = 18;
local1.color = ColorConstants.GREEN_TEXT;
local1.x = -3;
addChild(local1);
this.panel.y = local1.y + local1.height + 4;
this.panel.columnCount = NUMBER_OF_DEVICES;
this.panel.horizontalSpacing = 8;
var local2:int = 0;
while(local2 < this.deviceButtons.length) {
local3 = new DeviceButton(local2);
this.deviceButtons[local2] = local3;
this.panel.addItem(local3);
local2++;
}
addChild(this.panel);
this.panel.render();
deviceService.addEventListener(UpdateDevicesEvent.EVENT,this.onDeviceChanged);
}
public function init(param1:IGameObject) : void {
this.targetItem = param1;
this.updateButtons();
}
private function updateButtons() : void {
this.removeListeners();
var local1:int = 0;
while(local1 < this.deviceButtons.length) {
this.updateGradeButton(local1);
local1++;
}
}
private function updateGradeButton(param1:int) : void {
this.removeLazyListener(param1);
var local2:DeviceButton = this.deviceButtons[param1];
local2.visible = false;
local2.setUnclickable();
switch(param1) {
case SLOT_SKIN:
local2.visible = true;
if(AvailableSkins(this.targetItem.adapt(AvailableSkins)).getSkins().length > 0) {
local2.setClickable();
local2.addEventListener(MouseEvent.CLICK,this.onDeviceButtonClick);
this.setDeviceButtonImage(SLOT_SKIN);
}
break;
case SLOT_SHOT_COLOR:
if(this.targetItem.hasModel(AvailableShotSkins)) {
local2.visible = true;
if(AvailableShotSkins(this.targetItem.adapt(AvailableShotSkins)).getSkins().length > 0) {
local2.setClickable();
local2.addEventListener(MouseEvent.CLICK,this.onDeviceButtonClick);
this.setDeviceButtonImage(SLOT_SHOT_COLOR);
}
}
break;
default:
if(this.targetItem.hasModel(ItemDevicesGarage)) {
local2.visible = true;
if(deviceService.isDevicesAvailable(this.targetItem)) {
if(!lobbyLayoutService.inBattle() || Boolean(battleInfoService.reArmorEnabled) || !itemService.isMounted(this.targetItem)) {
local2.addEventListener(MouseEvent.CLICK,this.onDeviceButtonClick);
local2.setClickable();
}
this.setDeviceButtonImage(SLOT_DEVICE);
if(deviceService.isSale(this.targetItem)) {
local2.setSale(true);
}
}
}
}
}
private function setDeviceButtonImage(param1:int) : void {
var local2:ImageResource = null;
var local3:IGameObject = null;
if(param1 == SLOT_SKIN) {
local3 = MountSkin(this.targetItem.adapt(MountSkin)).getMountedSkin();
local2 = this.targetItem == local3 ? null : itemService.getPreviewResource(local3);
} else if(param1 == SLOT_SHOT_COLOR) {
local3 = MountShotSkin(this.targetItem.adapt(MountShotSkin)).getMountedSkin();
local2 = this.targetItem == local3 ? null : itemService.getPreviewResource(local3);
} else {
local2 = deviceService.getInsertedDevicePreview(this.targetItem);
}
if(local2 == null) {
this.deviceButtons[param1].setDevicesAvailableIcon();
return;
}
if(Boolean(local2.isLazy) && !local2.isLoaded) {
this.imageResources[param1] = local2;
this.loadListeners[param1] = new ImageResourceLoadingWrapper(this);
if(!local2.isLoading) {
local2.loadLazyResource(this.loadListeners[param1]);
} else {
local2.addLazyListener(this.loadListeners[param1]);
}
} else {
this.deviceButtons[param1].setDeviceImage(local2.data);
}
}
private function onDeviceButtonClick(param1:MouseEvent) : void {
var event:MouseEvent = param1;
var grade:int = int(this.deviceButtons.indexOf(event.target));
if(grade == SLOT_SKIN) {
this.skinsWindow = new ItemSkinsWindow(this.targetItem,function():void {
skinsWindow.removeEventListener(Event.CHANGE,onDeviceChanged);
skinsWindow = null;
});
this.skinsWindow.addEventListener(Event.CHANGE,this.onDeviceChanged);
return;
}
if(grade == SLOT_SHOT_COLOR) {
this.skinsWindow = new ShotSkinsWindow(this.targetItem,function():void {
skinsWindow.removeEventListener(Event.CHANGE,onDeviceChanged);
skinsWindow = null;
});
this.skinsWindow.addEventListener(Event.CHANGE,this.onDeviceChanged);
return;
}
if(deviceService.getAvailableDevices(this.targetItem) != null) {
new DevicesWindow(this.targetItem);
} else {
blurService.blurGameContent();
modalLoaderService.show();
deviceService.addEventListener(DevicesLoadedEvent.DEVICES_LOADED,this.devicesLoaded);
AvailableDevices(this.targetItem.adapt(AvailableDevices)).loadDevices();
}
}
private function devicesLoaded(param1:DevicesLoadedEvent) : void {
deviceService.removeEventListener(DevicesLoadedEvent.DEVICES_LOADED,this.devicesLoaded);
modalLoaderService.hideForcibly();
blurService.unblurGameContent();
new DevicesWindow(this.targetItem);
}
public function destroy() : void {
this.removeListeners();
deviceService.removeEventListener(UpdateDevicesEvent.EVENT,this.onDeviceChanged);
this.deviceButtons = null;
this.imageResources = null;
this.loadListeners = null;
this.targetItem = null;
if(this.skinsWindow is ItemSkinsWindow) {
(this.skinsWindow as ItemSkinsWindow).close();
}
if(this.skinsWindow is ShotSkinsWindow) {
(this.skinsWindow as ShotSkinsWindow).close();
}
}
private function removeListeners() : void {
var local1:DeviceButton = null;
for each(local1 in this.deviceButtons) {
local1.removeEventListener(MouseEvent.CLICK,this.onDeviceButtonClick);
}
this.removeLazyListeners();
}
private function removeLazyListeners() : void {
var local1:int = 0;
while(local1 < this.deviceButtons.length) {
this.removeLazyListener(local1);
local1++;
}
}
private function removeLazyListener(param1:int) : void {
if(this.imageResources[param1] != null && this.loadListeners[param1] != null) {
this.imageResources[param1].removeLazyListener(this.loadListeners[param1]);
}
}
private function onDeviceChanged(param1:Event) : void {
this.updateButtons();
}
public function setPreviewResource(param1:ImageResource) : void {
var local2:int = int(this.imageResources.indexOf(param1));
this.deviceButtons[local2].setDeviceImage(param1.data);
}
}
}
|
package _codec.projects.tanks.client.battleservice.model.statistics {
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.battleservice.model.statistics.UserInfo;
public class VectorCodecUserInfoLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecUserInfoLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(UserInfo,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.<UserInfo> = new Vector.<UserInfo>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = UserInfo(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:UserInfo = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<UserInfo> = Vector.<UserInfo>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p4 extends BitmapAsset
{
public function RangsIcon_p4()
{
super();
}
}
}
|
package alternativa.tanks.gui.settings.tabs.game {
import alternativa.tanks.gui.settings.SettingsWindow;
import alternativa.tanks.gui.settings.tabs.SettingsTabView;
import alternativa.tanks.gui.settings.tabs.SoundSettingsTab;
import alternativa.tanks.service.settings.SettingEnum;
import controls.Label;
import controls.TankWindowInner;
import controls.checkbox.CheckBoxBase;
import controls.containers.StackPanel;
import controls.containers.VerticalStackPanel;
import flash.events.MouseEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.battleinvite.IBattleInviteService;
public class GameSettingsTab extends SettingsTabView {
[Inject]
public static var battleInviteService:IBattleInviteService;
private var cbReceivePersonalMessagesOnlyFromFriends:CheckBoxBase;
private var cbReceiveBattleInvite:CheckBoxBase;
private var soundTab:SoundSettingsTab;
public function GameSettingsTab(param1:Boolean) {
super();
var local2:VerticalStackPanel = new VerticalStackPanel();
local2.x = MARGIN;
local2.y = MARGIN;
local2.setMargin(MARGIN);
local2.addItem(createCheckBox(SettingEnum.SHOW_DAMAGE,localeService.getText(TanksLocale.TEXT_SHOW_DAMAGE),settingsService.showDamage));
local2.addItem(createCheckBox(SettingEnum.SHOW_DROP_ZONES,localeService.getText(TanksLocale.TEXT_SETTINGS_SHOW_DROP_ZONES_LABEL_TEXT),settingsService.showDropZones));
local2.addItem(createCheckBox(SettingEnum.ALTERNATE_CAMERA,localeService.getText(TanksLocale.TEXT_SETTINGS_ALTERNATE_CAMERA_LABEL_TEXT),settingsService.alternateCamera));
local2.addItem(createCheckBox(SettingEnum.SHOW_LOCAL_DRONE,localeService.getText(TanksLocale.TEXT_SETTINGS_SHOW_LOCAL_DRONE),settingsService.showLocalDrone));
local2.addItem(createCheckBox(SettingEnum.RECEIVE_PRESENTS,localeService.getText(TanksLocale.TEXT_SETTINGS_RECEIVE_PRESENTS),settingsService.receivePresents));
var local3:VerticalStackPanel = new VerticalStackPanel();
local3.setMargin(MARGIN);
local3.y = MARGIN;
local3.x = SettingsWindow.TAB_VIEW_MAX_WIDTH * 0.5;
this.cbReceivePersonalMessagesOnlyFromFriends = this.createCheckBoxWithoutAutoSave(localeService.getText(TanksLocale.TEXT_SETTINGS_MESSAGE_ONLY_FROM_FRIENDS),param1);
this.cbReceivePersonalMessagesOnlyFromFriends.addEventListener(MouseEvent.CLICK,this.onReceivePersonalMessagesOnlyFromFriendsClick);
local3.addItem(this.cbReceivePersonalMessagesOnlyFromFriends);
local3.addItem(createCheckBox(SettingEnum.SHOW_CHAT,localeService.getText(TanksLocale.TEXT_SETTINGS_SHOW_CHAT_CHECKBOX_LABEL_TEXT),settingsService.showChat));
this.cbReceiveBattleInvite = this.createCheckBoxWithoutAutoSave(localeService.getText(TanksLocale.TEXT_SHOW_NOTIFICATIONS_LABEL),battleInviteService.receiveBattleInvite);
this.cbReceiveBattleInvite.addEventListener(MouseEvent.CLICK,this.onReceiveBattleInviteClick);
local3.addItem(this.cbReceiveBattleInvite);
local3.addItem(createCheckBox(SettingEnum.SHOW_REMOTE_DRONES,localeService.getText(TanksLocale.TEXT_SETTINGS_SHOW_REMOTE_DRONES),settingsService.showRemoteDrones));
var local4:TankWindowInner = new TankWindowInner(SettingsWindow.TAB_VIEW_MAX_WIDTH,local2.height + 2 * MARGIN,TankWindowInner.TRANSPARENT);
local4.addChild(local2);
local4.addChild(local3);
addChild(local4);
var local5:StackPanel = this.createSoundPanel();
local5.y = local4.y + local4.height + MARGIN_BEFORE_PARTITION_LABEL;
addChild(local5);
}
private function createSoundPanel() : StackPanel {
var local1:VerticalStackPanel = new VerticalStackPanel();
local1.setMargin(MARGIN_AFTER_PARTITION_LABEL);
var local2:Label = new Label();
local2.text = localeService.getText(TanksLocale.TEXT_SETTINGS_SOUND_VOLUME_LABEL_TEXT);
local1.addItem(local2);
this.soundTab = new SoundSettingsTab();
local1.addItem(this.soundTab);
return local1;
}
private function onReceiveBattleInviteClick(param1:MouseEvent) : void {
battleInviteService.receiveBattleInvite = this.cbReceiveBattleInvite.checked;
}
private function onReceivePersonalMessagesOnlyFromFriendsClick(param1:MouseEvent) : void {
dispatchEvent(new ReceivePersonalMessagesSettingEvent(ReceivePersonalMessagesSettingEvent.RECEIVE_PERSONAL_MESSAGES_CHANGE,this.cbReceivePersonalMessagesOnlyFromFriends.checked));
}
protected function createCheckBoxWithoutAutoSave(param1:String, param2:Boolean, param3:int = 0, param4:int = 0) : CheckBoxBase {
var local5:CheckBoxBase = new CheckBoxBase();
local5.checked = param2;
local5.x = param3;
local5.y = param4;
local5.label = param1;
return local5;
}
override public function destroy() : void {
this.cbReceiveBattleInvite.removeEventListener(MouseEvent.CLICK,this.onReceiveBattleInviteClick);
this.cbReceivePersonalMessagesOnlyFromFriends.removeEventListener(MouseEvent.CLICK,this.onReceivePersonalMessagesOnlyFromFriendsClick);
this.soundTab.destroy();
super.destroy();
}
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased.assault {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class AssaultModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:AssaultModelServer;
private var client:IAssaultModelBase = IAssaultModelBase(this);
private var modelId:Long = Long.getLong(1436393696,1464967608);
public function AssaultModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new AssaultModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(AssaultCC,false)));
}
protected function getInitParam() : AssaultCC {
return AssaultCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.dom.cp
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ControlPointSprite_noneC extends BitmapAsset
{
public function ControlPointSprite_noneC()
{
super();
}
}
}
|
package alternativa.tanks.model.info.team {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class BattleTeamInfoAdapt implements BattleTeamInfo {
private var object:IGameObject;
private var impl:BattleTeamInfo;
public function BattleTeamInfoAdapt(param1:IGameObject, param2:BattleTeamInfo) {
super();
this.object = param1;
this.impl = param2;
}
public function getUsersCountBlue() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getUsersCountBlue());
}
finally {
Model.popObject();
}
return result;
}
public function getUsersCountRed() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getUsersCountRed());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.user.damageindicator {
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.user.damageindicator.TargetTankDamage;
public class VectorCodecTargetTankDamageLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTargetTankDamageLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TargetTankDamage,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.<TargetTankDamage> = new Vector.<TargetTankDamage>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TargetTankDamage(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TargetTankDamage = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TargetTankDamage> = Vector.<TargetTankDamage>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.view.battleinfo.renderer {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battleinfo.renderer.CellRed_cellRedLeft.png")]
public class CellRed_cellRedLeft extends BitmapAsset {
public function CellRed_cellRedLeft() {
super();
}
}
}
|
package projects.tanks.clients.fp10.models.tanksusermodelflash {
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.launcherparams.ILauncherParams;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.osgi.service.logging.LogService;
import alternativa.tanks.controller.commands.goto_.GoToPartnerRegistrationCommand;
import alternativa.tanks.loader.ILoaderWindowService;
import alternativa.tanks.loader.IModalLoaderService;
import alternativa.tanks.newbieservice.NewbieUserService;
import alternativa.tanks.servermodels.EntranceModel;
import alternativa.tanks.servermodels.GoogleEntranceModel;
import alternativa.tanks.servermodels.IEntrance;
import alternativa.tanks.servermodels.IEntranceAdapt;
import alternativa.tanks.servermodels.IEntranceEvents;
import alternativa.tanks.servermodels.IGoogleEntranceModel;
import alternativa.tanks.servermodels.IGoogleEntranceModelAdapt;
import alternativa.tanks.servermodels.IGoogleEntranceModelEvents;
import alternativa.tanks.servermodels.ILeavableEntranceState;
import alternativa.tanks.servermodels.ILeavableEntranceStateAdapt;
import alternativa.tanks.servermodels.ILeavableEntranceStateEvents;
import alternativa.tanks.servermodels.TrackingPixelShowing;
import alternativa.tanks.servermodels.blockvalidator.BlockValidatorModel;
import alternativa.tanks.servermodels.changeuid.ChangeUidModel;
import alternativa.tanks.servermodels.changeuid.IChangeUid;
import alternativa.tanks.servermodels.changeuid.IChangeUidAdapt;
import alternativa.tanks.servermodels.changeuid.IChangeUidEvents;
import alternativa.tanks.servermodels.emailandpasswordchanger.IPasswordRecovery;
import alternativa.tanks.servermodels.emailandpasswordchanger.IPasswordRecoveryAdapt;
import alternativa.tanks.servermodels.emailandpasswordchanger.IPasswordRecoveryEvents;
import alternativa.tanks.servermodels.emailandpasswordchanger.PasswordRestoreModel;
import alternativa.tanks.servermodels.emailconfirm.EmailConfirmModel;
import alternativa.tanks.servermodels.emailconfirm.IEmailConfirm;
import alternativa.tanks.servermodels.emailconfirm.IEmailConfirmAdapt;
import alternativa.tanks.servermodels.emailconfirm.IEmailConfirmEvents;
import alternativa.tanks.servermodels.invite.IInvite;
import alternativa.tanks.servermodels.invite.IInviteAdapt;
import alternativa.tanks.servermodels.invite.IInviteEvents;
import alternativa.tanks.servermodels.invite.InviteModel;
import alternativa.tanks.servermodels.logging.RegistrationUXLoggerModel;
import alternativa.tanks.servermodels.login.ILogin;
import alternativa.tanks.servermodels.login.ILoginAdapt;
import alternativa.tanks.servermodels.login.ILoginEvents;
import alternativa.tanks.servermodels.login.LoginModel;
import alternativa.tanks.servermodels.loginbyhash.ILoginByHash;
import alternativa.tanks.servermodels.loginbyhash.ILoginByHashAdapt;
import alternativa.tanks.servermodels.loginbyhash.ILoginByHashEvents;
import alternativa.tanks.servermodels.loginbyhash.LoginByHashModel;
import alternativa.tanks.servermodels.loginwithoutregistration.ILoginWithoutRegistration;
import alternativa.tanks.servermodels.loginwithoutregistration.ILoginWithoutRegistrationAdapt;
import alternativa.tanks.servermodels.loginwithoutregistration.ILoginWithoutRegistrationEvents;
import alternativa.tanks.servermodels.loginwithoutregistration.LoginWithoutRegistrationModel;
import alternativa.tanks.servermodels.newbie.NewbieRegistrationModel;
import alternativa.tanks.servermodels.objectdetach.EntranceObjectDetachModel;
import alternativa.tanks.servermodels.partners.CompositePartnerModel;
import alternativa.tanks.servermodels.partners.ICompositePartnerModel;
import alternativa.tanks.servermodels.partners.ICompositePartnerModelAdapt;
import alternativa.tanks.servermodels.partners.ICompositePartnerModelEvents;
import alternativa.tanks.servermodels.pushnotification.NotificationTokenModel;
import alternativa.tanks.servermodels.redirect.WarRedirectModel;
import alternativa.tanks.servermodels.registartion.email.EmailRegistrationModel;
import alternativa.tanks.servermodels.registartion.email.IEmailRegistration;
import alternativa.tanks.servermodels.registartion.email.IEmailRegistrationAdapt;
import alternativa.tanks.servermodels.registartion.email.IEmailRegistrationEvents;
import alternativa.tanks.servermodels.registartion.password.IPasswordRegistration;
import alternativa.tanks.servermodels.registartion.password.IPasswordRegistrationAdapt;
import alternativa.tanks.servermodels.registartion.password.IPasswordRegistrationEvents;
import alternativa.tanks.servermodels.registartion.password.PasswordRegistrationModel;
import alternativa.tanks.servermodels.serverhalt.ServerHaltEntranceModel;
import alternativa.tanks.servermodels.socialnetwork.ExternalEntranceModel;
import alternativa.tanks.servermodels.socialnetwork.IExternalEntranceModel;
import alternativa.tanks.servermodels.socialnetwork.IExternalEntranceModelAdapt;
import alternativa.tanks.servermodels.socialnetwork.IExternalEntranceModelEvents;
import alternativa.tanks.servermodels.telegram.TelegramEntranceModel;
import alternativa.tanks.servermodels.timezoneoffset.TimeZoneOffsetModel;
import alternativa.tanks.service.IEntranceClientFacade;
import alternativa.tanks.service.IEntranceServerFacade;
import alternativa.tanks.service.IExternalEntranceService;
import alternativa.tanks.service.IPasswordParamsService;
import alternativa.tanks.service.IRegistrationUXService;
import alternativa.tanks.tracker.ITrackerService;
import alternativa.tanks.view.EntranceViewMediator;
import alternativa.tanks.view.LinkPartnerLoginFormMediator;
import alternativa.tanks.view.LoginFormMediator;
import alternativa.tanks.view.bubbles.EntranceBubbleFactory;
import alternativa.tanks.view.forms.ChangeEmailAndPasswordForm;
import alternativa.tanks.view.forms.ChangeUidForm;
import alternativa.tanks.view.forms.ExternalRegistrationForm;
import alternativa.tanks.view.forms.InviteForm;
import alternativa.tanks.view.forms.LinkExternalLoginForm;
import alternativa.tanks.view.forms.LinkPartnerLoginForm;
import alternativa.tanks.view.forms.LoginForm;
import alternativa.tanks.view.forms.PartnersRegistrationForm;
import alternativa.tanks.view.forms.PasswordRestoreForm;
import alternativa.tanks.view.forms.RegistrationForm;
import alternativa.tanks.view.forms.commons.AntiAddictionSection;
import alternativa.tanks.view.forms.commons.ChangeUidInputField;
import alternativa.tanks.view.forms.commons.RegistrationCommonElementsSection;
import alternativa.tanks.view.forms.freeuids.FreeUidsForm;
import alternativa.tanks.view.layers.EntranceView;
import alternativa.tanks.view.registration.ExternalEntranceForm;
import alternativa.tanks.ymservice.YandexMetricaService;
import platform.client.fp10.core.registry.ModelRegistry;
import platform.clients.fp10.libraries.alternativapartners.service.IPartnerService;
import projects.tanks.clients.flash.commons.services.externalauth.ExternalAuthParamsService;
import projects.tanks.clients.flash.commons.services.timeunit.ITimeUnitService;
import projects.tanks.clients.flash.commons.services.validate.IValidateService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.IHelpService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
public class Activator implements IBundleActivator {
public static var osgi:OSGi;
public function Activator() {
super();
}
public function start(param1:OSGi) : void {
var modelRegister:ModelRegistry;
var modelRegisterAdapt:ModelRegistry;
var _osgi:OSGi = param1;
osgi = _osgi;
osgi.injectService(IPartnerService,function(param1:Object):void {
GoToPartnerRegistrationCommand.partnerService = IPartnerService(param1);
},function():IPartnerService {
return GoToPartnerRegistrationCommand.partnerService;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
EntranceModel.clientFacade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return EntranceModel.clientFacade;
});
osgi.injectService(IDisplay,function(param1:Object):void {
EntranceModel.display = IDisplay(param1);
},function():IDisplay {
return EntranceModel.display;
});
osgi.injectService(ILoaderWindowService,function(param1:Object):void {
EntranceModel.loaderWindow = ILoaderWindowService(param1);
},function():ILoaderWindowService {
return EntranceModel.loaderWindow;
});
osgi.injectService(IEntranceServerFacade,function(param1:Object):void {
EntranceModel.serverFacade = IEntranceServerFacade(param1);
},function():IEntranceServerFacade {
return EntranceModel.serverFacade;
});
osgi.injectService(IClientLog,function(param1:Object):void {
TrackingPixelShowing.clientLog = IClientLog(param1);
},function():IClientLog {
return TrackingPixelShowing.clientLog;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
BlockValidatorModel.clientFacade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return BlockValidatorModel.clientFacade;
});
osgi.injectService(IStorageService,function(param1:Object):void {
BlockValidatorModel.storageService = IStorageService(param1);
},function():IStorageService {
return BlockValidatorModel.storageService;
});
osgi.injectService(ITrackerService,function(param1:Object):void {
BlockValidatorModel.trackerService = ITrackerService(param1);
},function():ITrackerService {
return BlockValidatorModel.trackerService;
});
osgi.injectService(IAlertService,function(param1:Object):void {
ChangeUidModel.alertService = IAlertService(param1);
},function():IAlertService {
return ChangeUidModel.alertService;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
ChangeUidModel.clientFacade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return ChangeUidModel.clientFacade;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
ChangeUidModel.localeService = ILocaleService(param1);
},function():ILocaleService {
return ChangeUidModel.localeService;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
PasswordRestoreModel.entranceClientFacade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return PasswordRestoreModel.entranceClientFacade;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
EmailConfirmModel.clientFacade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return EmailConfirmModel.clientFacade;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
InviteModel.clientFacade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return InviteModel.clientFacade;
});
osgi.injectService(IRegistrationUXService,function(param1:Object):void {
RegistrationUXLoggerModel.registrationUXService = IRegistrationUXService(param1);
},function():IRegistrationUXService {
return RegistrationUXLoggerModel.registrationUXService;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
LoginModel.entranceClientFacade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return LoginModel.entranceClientFacade;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
LoginByHashModel.clientFacade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return LoginByHashModel.clientFacade;
});
osgi.injectService(ILauncherParams,function(param1:Object):void {
LoginByHashModel.launcherParams = ILauncherParams(param1);
},function():ILauncherParams {
return LoginByHashModel.launcherParams;
});
osgi.injectService(IStorageService,function(param1:Object):void {
LoginByHashModel.storageService = IStorageService(param1);
},function():IStorageService {
return LoginByHashModel.storageService;
});
osgi.injectService(IStorageService,function(param1:Object):void {
NewbieRegistrationModel.storageService = IStorageService(param1);
},function():IStorageService {
return NewbieRegistrationModel.storageService;
});
osgi.injectService(ILoaderWindowService,function(param1:Object):void {
EntranceObjectDetachModel.loaderWindowService = ILoaderWindowService(param1);
},function():ILoaderWindowService {
return EntranceObjectDetachModel.loaderWindowService;
});
osgi.injectService(IAlertService,function(param1:Object):void {
CompositePartnerModel.alertService = IAlertService(param1);
},function():IAlertService {
return CompositePartnerModel.alertService;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
CompositePartnerModel.clientFacade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return CompositePartnerModel.clientFacade;
});
osgi.injectService(ILauncherParams,function(param1:Object):void {
CompositePartnerModel.launcherParams = ILauncherParams(param1);
},function():ILauncherParams {
return CompositePartnerModel.launcherParams;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
CompositePartnerModel.localeService = ILocaleService(param1);
},function():ILocaleService {
return CompositePartnerModel.localeService;
});
osgi.injectService(IPartnerService,function(param1:Object):void {
CompositePartnerModel.partnerService = IPartnerService(param1);
},function():IPartnerService {
return CompositePartnerModel.partnerService;
});
osgi.injectService(IAlertService,function(param1:Object):void {
EmailRegistrationModel.alertService = IAlertService(param1);
},function():IAlertService {
return EmailRegistrationModel.alertService;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
EmailRegistrationModel.facade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return EmailRegistrationModel.facade;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
EmailRegistrationModel.localeService = ILocaleService(param1);
},function():ILocaleService {
return EmailRegistrationModel.localeService;
});
osgi.injectService(IAlertService,function(param1:Object):void {
PasswordRegistrationModel.alertService = IAlertService(param1);
},function():IAlertService {
return PasswordRegistrationModel.alertService;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
PasswordRegistrationModel.facade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return PasswordRegistrationModel.facade;
});
osgi.injectService(ILauncherParams,function(param1:Object):void {
PasswordRegistrationModel.launcherParams = ILauncherParams(param1);
},function():ILauncherParams {
return PasswordRegistrationModel.launcherParams;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
PasswordRegistrationModel.localeService = ILocaleService(param1);
},function():ILocaleService {
return PasswordRegistrationModel.localeService;
});
osgi.injectService(NewbieUserService,function(param1:Object):void {
PasswordRegistrationModel.newbieUserService = NewbieUserService(param1);
},function():NewbieUserService {
return PasswordRegistrationModel.newbieUserService;
});
osgi.injectService(IPasswordParamsService,function(param1:Object):void {
PasswordRegistrationModel.passwordParamsService = IPasswordParamsService(param1);
},function():IPasswordParamsService {
return PasswordRegistrationModel.passwordParamsService;
});
osgi.injectService(IStorageService,function(param1:Object):void {
PasswordRegistrationModel.storageService = IStorageService(param1);
},function():IStorageService {
return PasswordRegistrationModel.storageService;
});
osgi.injectService(ITrackerService,function(param1:Object):void {
PasswordRegistrationModel.trackerService = ITrackerService(param1);
},function():ITrackerService {
return PasswordRegistrationModel.trackerService;
});
osgi.injectService(YandexMetricaService,function(param1:Object):void {
PasswordRegistrationModel.ymService = YandexMetricaService(param1);
},function():YandexMetricaService {
return PasswordRegistrationModel.ymService;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
ServerHaltEntranceModel.facade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return ServerHaltEntranceModel.facade;
});
osgi.injectService(IAlertService,function(param1:Object):void {
ExternalEntranceModel.alertService = IAlertService(param1);
},function():IAlertService {
return ExternalEntranceModel.alertService;
});
osgi.injectService(IEntranceClientFacade,function(param1:Object):void {
ExternalEntranceModel.clientFacade = IEntranceClientFacade(param1);
},function():IEntranceClientFacade {
return ExternalEntranceModel.clientFacade;
});
osgi.injectService(ExternalAuthParamsService,function(param1:Object):void {
ExternalEntranceModel.externalAuthParamsService = ExternalAuthParamsService(param1);
},function():ExternalAuthParamsService {
return ExternalEntranceModel.externalAuthParamsService;
});
osgi.injectService(IExternalEntranceService,function(param1:Object):void {
ExternalEntranceModel.externalEntranceService = IExternalEntranceService(param1);
},function():IExternalEntranceService {
return ExternalEntranceModel.externalEntranceService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
ExternalEntranceModel.localeService = ILocaleService(param1);
},function():ILocaleService {
return ExternalEntranceModel.localeService;
});
osgi.injectService(YandexMetricaService,function(param1:Object):void {
ExternalEntranceModel.ymService = YandexMetricaService(param1);
},function():YandexMetricaService {
return ExternalEntranceModel.ymService;
});
osgi.injectService(IClientLog,function(param1:Object):void {
EntranceViewMediator.clientLog = IClientLog(param1);
},function():IClientLog {
return EntranceViewMediator.clientLog;
});
osgi.injectService(YandexMetricaService,function(param1:Object):void {
EntranceViewMediator.ymService = YandexMetricaService(param1);
},function():YandexMetricaService {
return EntranceViewMediator.ymService;
});
osgi.injectService(IClientLog,function(param1:Object):void {
LinkPartnerLoginFormMediator.clientLog = IClientLog(param1);
},function():IClientLog {
return LinkPartnerLoginFormMediator.clientLog;
});
osgi.injectService(LogService,function(param1:Object):void {
LinkPartnerLoginFormMediator.log = LogService(param1);
},function():LogService {
return LinkPartnerLoginFormMediator.log;
});
osgi.injectService(IClientLog,function(param1:Object):void {
LoginFormMediator.clientLog = IClientLog(param1);
},function():IClientLog {
return LoginFormMediator.clientLog;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
EntranceBubbleFactory.LocaleService = ILocaleService(param1);
},function():ILocaleService {
return EntranceBubbleFactory.LocaleService;
});
osgi.injectService(ILoaderWindowService,function(param1:Object):void {
ChangeEmailAndPasswordForm.loaderWindowService = ILoaderWindowService(param1);
},function():ILoaderWindowService {
return ChangeEmailAndPasswordForm.loaderWindowService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
ChangeEmailAndPasswordForm.localeService = ILocaleService(param1);
},function():ILocaleService {
return ChangeEmailAndPasswordForm.localeService;
});
osgi.injectService(IPasswordParamsService,function(param1:Object):void {
ChangeEmailAndPasswordForm.passwordParamsService = IPasswordParamsService(param1);
},function():IPasswordParamsService {
return ChangeEmailAndPasswordForm.passwordParamsService;
});
osgi.injectService(IValidateService,function(param1:Object):void {
ChangeEmailAndPasswordForm.validateService = IValidateService(param1);
},function():IValidateService {
return ChangeEmailAndPasswordForm.validateService;
});
osgi.injectService(IDisplay,function(param1:Object):void {
ChangeUidForm.display = IDisplay(param1);
},function():IDisplay {
return ChangeUidForm.display;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
ChangeUidForm.localeService = ILocaleService(param1);
},function():ILocaleService {
return ChangeUidForm.localeService;
});
osgi.injectService(IPasswordParamsService,function(param1:Object):void {
ChangeUidForm.passwordParamsService = IPasswordParamsService(param1);
},function():IPasswordParamsService {
return ChangeUidForm.passwordParamsService;
});
osgi.injectService(IDisplay,function(param1:Object):void {
ExternalRegistrationForm.display = IDisplay(param1);
},function():IDisplay {
return ExternalRegistrationForm.display;
});
osgi.injectService(IHelpService,function(param1:Object):void {
ExternalRegistrationForm.helperService = IHelpService(param1);
},function():IHelpService {
return ExternalRegistrationForm.helperService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
ExternalRegistrationForm.localeService = ILocaleService(param1);
},function():ILocaleService {
return ExternalRegistrationForm.localeService;
});
osgi.injectService(IRegistrationUXService,function(param1:Object):void {
ExternalRegistrationForm.registrationUXService = IRegistrationUXService(param1);
},function():IRegistrationUXService {
return ExternalRegistrationForm.registrationUXService;
});
osgi.injectService(IValidateService,function(param1:Object):void {
ExternalRegistrationForm.validateService = IValidateService(param1);
},function():IValidateService {
return ExternalRegistrationForm.validateService;
});
osgi.injectService(ILoaderWindowService,function(param1:Object):void {
InviteForm.loaderWindowService = ILoaderWindowService(param1);
},function():ILoaderWindowService {
return InviteForm.loaderWindowService;
});
osgi.injectService(IModalLoaderService,function(param1:Object):void {
InviteForm.modalLoaderService = IModalLoaderService(param1);
},function():IModalLoaderService {
return InviteForm.modalLoaderService;
});
osgi.injectService(IDisplay,function(param1:Object):void {
LinkExternalLoginForm.display = IDisplay(param1);
},function():IDisplay {
return LinkExternalLoginForm.display;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
LinkExternalLoginForm.localeService = ILocaleService(param1);
},function():ILocaleService {
return LinkExternalLoginForm.localeService;
});
osgi.injectService(IValidateService,function(param1:Object):void {
LinkExternalLoginForm.validateService = IValidateService(param1);
},function():IValidateService {
return LinkExternalLoginForm.validateService;
});
osgi.injectService(IClientLog,function(param1:Object):void {
LinkPartnerLoginForm.clientLog = IClientLog(param1);
},function():IClientLog {
return LinkPartnerLoginForm.clientLog;
});
osgi.injectService(IDisplay,function(param1:Object):void {
LinkPartnerLoginForm.display = IDisplay(param1);
},function():IDisplay {
return LinkPartnerLoginForm.display;
});
osgi.injectService(ILoaderWindowService,function(param1:Object):void {
LinkPartnerLoginForm.loaderWindowService = ILoaderWindowService(param1);
},function():ILoaderWindowService {
return LinkPartnerLoginForm.loaderWindowService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
LinkPartnerLoginForm.localeService = ILocaleService(param1);
},function():ILocaleService {
return LinkPartnerLoginForm.localeService;
});
osgi.injectService(LogService,function(param1:Object):void {
LinkPartnerLoginForm.log = LogService(param1);
},function():LogService {
return LinkPartnerLoginForm.log;
});
osgi.injectService(IRegistrationUXService,function(param1:Object):void {
LinkPartnerLoginForm.registrationUXService = IRegistrationUXService(param1);
},function():IRegistrationUXService {
return LinkPartnerLoginForm.registrationUXService;
});
osgi.injectService(IValidateService,function(param1:Object):void {
LinkPartnerLoginForm.validateService = IValidateService(param1);
},function():IValidateService {
return LinkPartnerLoginForm.validateService;
});
osgi.injectService(IDisplay,function(param1:Object):void {
LoginForm.display = IDisplay(param1);
},function():IDisplay {
return LoginForm.display;
});
osgi.injectService(IExternalEntranceService,function(param1:Object):void {
LoginForm.externalEntranceService = IExternalEntranceService(param1);
},function():IExternalEntranceService {
return LoginForm.externalEntranceService;
});
osgi.injectService(ILoaderWindowService,function(param1:Object):void {
LoginForm.loaderWindowService = ILoaderWindowService(param1);
},function():ILoaderWindowService {
return LoginForm.loaderWindowService;
});
osgi.injectService(IRegistrationUXService,function(param1:Object):void {
LoginForm.registrationUXService = IRegistrationUXService(param1);
},function():IRegistrationUXService {
return LoginForm.registrationUXService;
});
osgi.injectService(IStorageService,function(param1:Object):void {
LoginForm.storageService = IStorageService(param1);
},function():IStorageService {
return LoginForm.storageService;
});
osgi.injectService(IValidateService,function(param1:Object):void {
LoginForm.validateService = IValidateService(param1);
},function():IValidateService {
return LoginForm.validateService;
});
osgi.injectService(IDisplay,function(param1:Object):void {
PartnersRegistrationForm.display = IDisplay(param1);
},function():IDisplay {
return PartnersRegistrationForm.display;
});
osgi.injectService(IHelpService,function(param1:Object):void {
PartnersRegistrationForm.helperService = IHelpService(param1);
},function():IHelpService {
return PartnersRegistrationForm.helperService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
PartnersRegistrationForm.localeService = ILocaleService(param1);
},function():ILocaleService {
return PartnersRegistrationForm.localeService;
});
osgi.injectService(IRegistrationUXService,function(param1:Object):void {
PartnersRegistrationForm.registrationUXService = IRegistrationUXService(param1);
},function():IRegistrationUXService {
return PartnersRegistrationForm.registrationUXService;
});
osgi.injectService(IValidateService,function(param1:Object):void {
PartnersRegistrationForm.validateService = IValidateService(param1);
},function():IValidateService {
return PartnersRegistrationForm.validateService;
});
osgi.injectService(ILoaderWindowService,function(param1:Object):void {
PasswordRestoreForm.loaderWindowService = ILoaderWindowService(param1);
},function():ILoaderWindowService {
return PasswordRestoreForm.loaderWindowService;
});
osgi.injectService(IValidateService,function(param1:Object):void {
PasswordRestoreForm.validateService = IValidateService(param1);
},function():IValidateService {
return PasswordRestoreForm.validateService;
});
osgi.injectService(IExternalEntranceService,function(param1:Object):void {
RegistrationForm.externalEntranceService = IExternalEntranceService(param1);
},function():IExternalEntranceService {
return RegistrationForm.externalEntranceService;
});
osgi.injectService(ILoaderWindowService,function(param1:Object):void {
RegistrationForm.loaderWindowService = ILoaderWindowService(param1);
},function():ILoaderWindowService {
return RegistrationForm.loaderWindowService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
RegistrationForm.localeService = ILocaleService(param1);
},function():ILocaleService {
return RegistrationForm.localeService;
});
osgi.injectService(IRegistrationUXService,function(param1:Object):void {
RegistrationForm.registrationUXService = IRegistrationUXService(param1);
},function():IRegistrationUXService {
return RegistrationForm.registrationUXService;
});
osgi.injectService(YandexMetricaService,function(param1:Object):void {
RegistrationForm.ymService = YandexMetricaService(param1);
},function():YandexMetricaService {
return RegistrationForm.ymService;
});
osgi.injectService(IValidateService,function(param1:Object):void {
AntiAddictionSection.validateService = IValidateService(param1);
},function():IValidateService {
return AntiAddictionSection.validateService;
});
osgi.injectService(IDisplay,function(param1:Object):void {
ChangeUidInputField.display = IDisplay(param1);
},function():IDisplay {
return ChangeUidInputField.display;
});
osgi.injectService(IValidateService,function(param1:Object):void {
ChangeUidInputField.validateService = IValidateService(param1);
},function():IValidateService {
return ChangeUidInputField.validateService;
});
osgi.injectService(IDisplay,function(param1:Object):void {
RegistrationCommonElementsSection.display = IDisplay(param1);
},function():IDisplay {
return RegistrationCommonElementsSection.display;
});
osgi.injectService(ILauncherParams,function(param1:Object):void {
RegistrationCommonElementsSection.launcherParams = ILauncherParams(param1);
},function():ILauncherParams {
return RegistrationCommonElementsSection.launcherParams;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
RegistrationCommonElementsSection.localeService = ILocaleService(param1);
},function():ILocaleService {
return RegistrationCommonElementsSection.localeService;
});
osgi.injectService(IPasswordParamsService,function(param1:Object):void {
RegistrationCommonElementsSection.passwordParamsService = IPasswordParamsService(param1);
},function():IPasswordParamsService {
return RegistrationCommonElementsSection.passwordParamsService;
});
osgi.injectService(IRegistrationUXService,function(param1:Object):void {
RegistrationCommonElementsSection.registrationUXService = IRegistrationUXService(param1);
},function():IRegistrationUXService {
return RegistrationCommonElementsSection.registrationUXService;
});
osgi.injectService(IValidateService,function(param1:Object):void {
RegistrationCommonElementsSection.validateService = IValidateService(param1);
},function():IValidateService {
return RegistrationCommonElementsSection.validateService;
});
osgi.injectService(YandexMetricaService,function(param1:Object):void {
RegistrationCommonElementsSection.ymService = YandexMetricaService(param1);
},function():YandexMetricaService {
return RegistrationCommonElementsSection.ymService;
});
osgi.injectService(IDisplay,function(param1:Object):void {
FreeUidsForm.display = IDisplay(param1);
},function():IDisplay {
return FreeUidsForm.display;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
FreeUidsForm.localeService = ILocaleService(param1);
},function():ILocaleService {
return FreeUidsForm.localeService;
});
osgi.injectService(IAlertService,function(param1:Object):void {
EntranceView.alertService = IAlertService(param1);
},function():IAlertService {
return EntranceView.alertService;
});
osgi.injectService(ILoaderWindowService,function(param1:Object):void {
EntranceView.loaderWindowService = ILoaderWindowService(param1);
},function():ILoaderWindowService {
return EntranceView.loaderWindowService;
});
osgi.injectService(ILocaleService,function(param1:Object):void {
EntranceView.localeService = ILocaleService(param1);
},function():ILocaleService {
return EntranceView.localeService;
});
osgi.injectService(IPartnerService,function(param1:Object):void {
EntranceView.partnerService = IPartnerService(param1);
},function():IPartnerService {
return EntranceView.partnerService;
});
osgi.injectService(IRegistrationUXService,function(param1:Object):void {
EntranceView.registrationUXService = IRegistrationUXService(param1);
},function():IRegistrationUXService {
return EntranceView.registrationUXService;
});
osgi.injectService(ITimeUnitService,function(param1:Object):void {
EntranceView.timeUnitService = ITimeUnitService(param1);
},function():ITimeUnitService {
return EntranceView.timeUnitService;
});
osgi.injectService(IExternalEntranceService,function(param1:Object):void {
ExternalEntranceForm.externalEntranceService = IExternalEntranceService(param1);
},function():IExternalEntranceService {
return ExternalEntranceForm.externalEntranceService;
});
modelRegister = osgi.getService(ModelRegistry) as ModelRegistry;
modelRegister.add(new EntranceModel());
modelRegister.add(new GoogleEntranceModel());
modelRegisterAdapt = osgi.getService(ModelRegistry) as ModelRegistry;
modelRegisterAdapt.registerAdapt(IEntrance,IEntranceAdapt);
modelRegisterAdapt.registerEvents(IEntrance,IEntranceEvents);
modelRegisterAdapt.registerAdapt(IGoogleEntranceModel,IGoogleEntranceModelAdapt);
modelRegisterAdapt.registerEvents(IGoogleEntranceModel,IGoogleEntranceModelEvents);
modelRegisterAdapt.registerAdapt(ILeavableEntranceState,ILeavableEntranceStateAdapt);
modelRegisterAdapt.registerEvents(ILeavableEntranceState,ILeavableEntranceStateEvents);
modelRegister.add(new TrackingPixelShowing());
modelRegister.add(new BlockValidatorModel());
modelRegister.add(new ChangeUidModel());
modelRegisterAdapt.registerAdapt(IChangeUid,IChangeUidAdapt);
modelRegisterAdapt.registerEvents(IChangeUid,IChangeUidEvents);
modelRegisterAdapt.registerAdapt(IPasswordRecovery,IPasswordRecoveryAdapt);
modelRegisterAdapt.registerEvents(IPasswordRecovery,IPasswordRecoveryEvents);
modelRegister.add(new PasswordRestoreModel());
modelRegister.add(new EmailConfirmModel());
modelRegisterAdapt.registerAdapt(IEmailConfirm,IEmailConfirmAdapt);
modelRegisterAdapt.registerEvents(IEmailConfirm,IEmailConfirmEvents);
modelRegisterAdapt.registerAdapt(IInvite,IInviteAdapt);
modelRegisterAdapt.registerEvents(IInvite,IInviteEvents);
modelRegister.add(new InviteModel());
modelRegister.add(new RegistrationUXLoggerModel());
modelRegisterAdapt.registerAdapt(ILogin,ILoginAdapt);
modelRegisterAdapt.registerEvents(ILogin,ILoginEvents);
modelRegister.add(new LoginModel());
modelRegisterAdapt.registerAdapt(ILoginByHash,ILoginByHashAdapt);
modelRegisterAdapt.registerEvents(ILoginByHash,ILoginByHashEvents);
modelRegister.add(new LoginByHashModel());
modelRegisterAdapt.registerAdapt(ILoginWithoutRegistration,ILoginWithoutRegistrationAdapt);
modelRegisterAdapt.registerEvents(ILoginWithoutRegistration,ILoginWithoutRegistrationEvents);
modelRegister.add(new LoginWithoutRegistrationModel());
modelRegister.add(new NewbieRegistrationModel());
modelRegister.add(new EntranceObjectDetachModel());
modelRegister.add(new CompositePartnerModel());
modelRegisterAdapt.registerAdapt(ICompositePartnerModel,ICompositePartnerModelAdapt);
modelRegisterAdapt.registerEvents(ICompositePartnerModel,ICompositePartnerModelEvents);
modelRegister.add(new NotificationTokenModel());
modelRegister.add(new WarRedirectModel());
modelRegister.add(new EmailRegistrationModel());
modelRegisterAdapt.registerAdapt(IEmailRegistration,IEmailRegistrationAdapt);
modelRegisterAdapt.registerEvents(IEmailRegistration,IEmailRegistrationEvents);
modelRegisterAdapt.registerAdapt(IPasswordRegistration,IPasswordRegistrationAdapt);
modelRegisterAdapt.registerEvents(IPasswordRegistration,IPasswordRegistrationEvents);
modelRegister.add(new PasswordRegistrationModel());
modelRegister.add(new ServerHaltEntranceModel());
modelRegister.add(new ExternalEntranceModel());
modelRegisterAdapt.registerAdapt(IExternalEntranceModel,IExternalEntranceModelAdapt);
modelRegisterAdapt.registerEvents(IExternalEntranceModel,IExternalEntranceModelEvents);
modelRegister.add(new TelegramEntranceModel());
modelRegister.add(new TimeZoneOffsetModel());
}
public function stop(param1:OSGi) : void {
}
}
}
|
package alternativa.tanks.services.bonusregion {
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Decal;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.bonus.region.BonusRegion;
import alternativa.tanks.models.bonus.region.GoldBonusRegion;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.service.settings.SettingsServiceEvent;
import alternativa.utils.TextureMaterialRegistry;
import alternativa.utils.clearDictionary;
import flash.display.BitmapData;
import flash.utils.Dictionary;
import platform.client.fp10.core.resource.types.StubBitmapData;
import projects.tanks.client.battlefield.models.bonus.battle.bonusregions.BonusRegionData;
import projects.tanks.client.battlefield.models.bonus.battle.bonusregions.BonusRegionResource;
import projects.tanks.client.battlefield.models.bonus.bonus.BonusesType;
public class BonusRegionService implements IBonusRegionService {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var materialRegistry:TextureMaterialRegistry;
[Inject]
public static var settings:ISettingsService;
private static var stubBitmapData:BitmapData;
private static const REGION_SIZE:int = 500;
private static const REGION_DECAL_ACSENSION:Number = 5;
private var _battleEventSupport:BattleEventSupport;
private var _textures:Dictionary;
private var _bonusRegions:Dictionary;
private var _forceShow:Boolean;
private var _forceHide:Boolean;
private var _tank:Tank;
public function BonusRegionService(param1:BattleEventDispatcher) {
super();
this._battleEventSupport = new BattleEventSupport(param1);
this._battleEventSupport.addEventHandler(BattleFinishEvent,this.onBattleFinished);
}
private static function createRegion(param1:Vector3, param2:Vector3, param3:TextureMaterial) : Mesh {
var local4:Decal = new Decal();
var local5:Number = REGION_SIZE / 2;
var local6:Number = 0.5;
var local7:Vertex = local4.addVertex(-local5,local5,local6,0,0);
var local8:Vertex = local4.addVertex(-local5,-local5,local6,0,1);
var local9:Vertex = local4.addVertex(local5,-local5,local6,1,1);
var local10:Vertex = local4.addVertex(local5,local5,local6,1,0);
local4.addQuadFace(local7,local8,local9,local10,param3);
local4.calculateFacesNormals();
local4.calculateVerticesNormals();
local4.x = param1.x;
local4.y = param1.y;
local4.z = param1.z + REGION_DECAL_ACSENSION;
local4.rotationX = param2.x;
local4.rotationY = param2.y;
local4.rotationZ = param2.z;
return local4;
}
private static function getStubBitmapData() : BitmapData {
if(stubBitmapData == null) {
stubBitmapData = new StubBitmapData(65280);
}
return stubBitmapData;
}
private function onBattleFinished(param1:BattleFinishEvent) : void {
this.hideAndRemoveGoldRegions();
}
private function hideAndRemoveGoldRegions() : void {
var local1:BonusRegion = null;
for each(local1 in this._bonusRegions) {
if(local1 is GoldBonusRegion) {
local1.hideAndRemoveFromGame();
delete this._bonusRegions[local1.getPosition().toString()];
}
}
}
public function showAll() : void {
var local1:BonusRegion = null;
if(this._forceShow) {
for each(local1 in this._bonusRegions) {
local1.showForce();
}
}
}
private function hasTank() : Boolean {
return this._tank != null;
}
public function prepare(param1:Vector.<BonusRegionResource>) : void {
this._forceShow = settings.showDropZones;
this._forceHide = !this._forceShow;
settings.addEventListener(SettingsServiceEvent.SETTINGS_CHANGED,this.onSettingsAccept);
this._battleEventSupport.activateHandlers();
this._bonusRegions = new Dictionary();
this.initMaterials(param1);
}
private function onSettingsAccept(param1:SettingsServiceEvent) : void {
if(this._forceShow != settings.showDropZones) {
this.toggleRegionsVisible();
}
}
private function initMaterials(param1:Vector.<BonusRegionResource>) : void {
var local4:BonusRegionResource = null;
this._textures = new Dictionary();
var local2:int = int(param1.length);
var local3:int = 0;
while(local3 < local2) {
local4 = param1[local3];
this._textures[local4.regionType] = local4.dropZoneResource.data;
local3++;
}
}
public function destroy() : void {
settings.removeEventListener(SettingsServiceEvent.SETTINGS_CHANGED,this.onSettingsAccept);
this._battleEventSupport.deactivateHandlers();
this.destroyBonusRegions();
this.destroyTextures();
this._tank = null;
}
private function destroyBonusRegions() : void {
var local1:BonusRegion = null;
for each(local1 in this._bonusRegions) {
local1.removeFromGame();
}
clearDictionary(this._bonusRegions);
this._bonusRegions = null;
}
private function destroyTextures() : void {
clearDictionary(this._textures);
this._textures = null;
}
public function addOneRegion(param1:BonusRegionData) : void {
var local2:Vector3 = null;
var local3:Mesh = null;
var local4:BonusRegion = null;
if(!this.hasRegion(param1)) {
local2 = BattleUtils.getVector3(param1.position);
local3 = createRegion(local2,BattleUtils.getVector3(param1.rotation),this.getMaterial(param1.regionType));
if(param1.regionType == BonusesType.GOLD) {
local4 = new GoldBonusRegion(local3,local2);
} else {
local4 = new BonusRegion(local3,local2,this._forceShow);
}
local4.addToGame();
this._bonusRegions[local2.toString()] = local4;
}
}
public function addFewRegions(param1:Vector.<BonusRegionData>) : void {
var local2:int = int(param1.length);
var local3:int = 0;
while(local3 < local2) {
this.addOneRegion(param1[local3]);
local3++;
}
}
private function getMaterial(param1:BonusesType) : TextureMaterial {
var local2:BitmapData = this._textures[param1];
if(local2 == null) {
local2 = getStubBitmapData();
}
var local3:TextureMaterial = materialRegistry.getMaterial(local2);
local3.resolution = 2;
return local3;
}
public function setTank(param1:Tank) : void {
this._tank = param1;
}
public function changeTank(param1:Tank) : void {
if(!this.hasTank() || this.hasTank() && this._tank.getUser() != param1.getUser()) {
this._tank = param1;
}
}
public function resetTank() : void {
this._tank = null;
if(this._forceShow) {
this.showAll();
}
}
public function enableForceShow() : void {
var local1:BonusRegion = null;
this._forceShow = true;
this._forceHide = false;
settings.showDropZones = true;
for each(local1 in this._bonusRegions) {
if(!(local1 is GoldBonusRegion)) {
local1.showForce();
}
}
}
public function enableForceHide() : void {
var local1:BonusRegion = null;
this._forceHide = true;
this._forceShow = false;
settings.showDropZones = false;
for each(local1 in this._bonusRegions) {
if(!(local1 is GoldBonusRegion)) {
local1.hideForce();
}
}
}
public function addAndShowRegion(param1:BonusRegionData) : void {
var local2:Vector3 = null;
var local3:BonusRegion = null;
if(!this.hasRegion(param1)) {
this.addOneRegion(param1);
local2 = BattleUtils.getVector3(param1.position);
local3 = this._bonusRegions[local2.toString()];
local3.show();
}
}
public function hideAndRemoveRegion(param1:BonusRegionData) : void {
var local2:Vector3 = null;
var local3:BonusRegion = null;
if(this.hasRegion(param1)) {
local2 = BattleUtils.getVector3(param1.position);
local3 = this._bonusRegions[local2.toString()];
local3.hideAndRemoveFromGame();
delete this._bonusRegions[local2.toString()];
}
}
public function hasRegion(param1:BonusRegionData) : Boolean {
var local2:Vector3 = BattleUtils.getVector3(param1.position);
return this._bonusRegions[local2.toString()] != undefined;
}
public function toggleRegionsVisible() : void {
if(this._forceShow) {
this.enableForceHide();
} else if(this._forceHide) {
this.enableForceShow();
}
}
}
}
|
package alternativa.engine3d.objects
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.engine3d.core.VG;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.gfx.core.IndexBufferResource;
import alternativa.gfx.core.VertexBufferResource;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
use namespace alternativa3d;
public class Mesh extends Object3D
{
public var clipping:int = 2;
public var sorting:int = 1;
public var threshold:Number = 0.01;
alternativa3d var vertexList:Vertex;
alternativa3d var faceList:Face;
alternativa3d var vertexBuffer:VertexBufferResource;
alternativa3d var indexBuffer:IndexBufferResource;
alternativa3d var numOpaqueTriangles:int;
alternativa3d var numTriangles:int;
protected var opaqueMaterials:Vector.<Material>;
protected var opaqueBegins:Vector.<int>;
protected var opaqueNums:Vector.<int>;
protected var opaqueLength:int = 0;
private var transparentList:Face;
private var material:Material;
public function Mesh()
{
this.opaqueMaterials = new Vector.<Material>();
this.opaqueBegins = new Vector.<int>();
this.opaqueNums = new Vector.<int>();
super();
}
public static function calculateVerticesNormalsBySmoothingGroupsForMeshList(param1:Vector.<Object3D>, param2:Number = 0) : void
{
var _loc3_:int = 0;
var _loc4_:Number = NaN;
var _loc5_:Number = NaN;
var _loc6_:Number = NaN;
var _loc7_:* = undefined;
var _loc8_:Mesh = null;
var _loc9_:Face = null;
var _loc10_:Vertex = null;
var _loc11_:Wrapper = null;
var _loc16_:Object3D = null;
var _loc17_:Vertex = null;
var _loc18_:Number = NaN;
var _loc19_:* = null;
var _loc12_:Dictionary = new Dictionary();
var _loc13_:int = param1.length;
_loc3_ = 0;
while(_loc3_ < _loc13_)
{
_loc8_ = param1[_loc3_] as Mesh;
if(_loc8_ != null)
{
_loc8_.deleteResources();
_loc8_.composeMatrix();
_loc16_ = _loc8_;
while(_loc16_._parent != null)
{
_loc16_ = _loc16_._parent;
_loc16_.composeMatrix();
_loc8_.appendMatrix(_loc16_);
}
_loc10_ = _loc8_.vertexList;
while(_loc10_ != null)
{
_loc4_ = _loc10_.x;
_loc5_ = _loc10_.y;
_loc6_ = _loc10_.z;
_loc10_.x = _loc8_.ma * _loc4_ + _loc8_.mb * _loc5_ + _loc8_.mc * _loc6_ + _loc8_.md;
_loc10_.y = _loc8_.me * _loc4_ + _loc8_.mf * _loc5_ + _loc8_.mg * _loc6_ + _loc8_.mh;
_loc10_.z = _loc8_.mi * _loc4_ + _loc8_.mj * _loc5_ + _loc8_.mk * _loc6_ + _loc8_.ml;
_loc10_ = _loc10_.next;
}
_loc8_.calculateNormalsAndRemoveDegenerateFaces();
_loc9_ = _loc8_.faceList;
while(_loc9_ != null)
{
if(_loc9_.smoothingGroups > 0)
{
_loc11_ = _loc9_.wrapper;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(!_loc12_[_loc10_])
{
_loc12_[_loc10_] = new Dictionary();
}
_loc12_[_loc10_][_loc9_] = true;
_loc11_ = _loc11_.next;
}
}
_loc9_ = _loc9_.next;
}
}
_loc3_++;
}
var _loc14_:Vector.<Vertex> = new Vector.<Vertex>();
var _loc15_:int = 0;
for each(_loc14_[_loc15_] in _loc12_)
{
_loc15_++;
}
if(_loc15_ > 0)
{
shareFaces(_loc14_,0,_loc15_,0,param2,new Vector.<int>(),_loc12_);
}
_loc3_ = 0;
while(_loc3_ < _loc13_)
{
_loc8_ = param1[_loc3_] as Mesh;
if(_loc8_ != null)
{
_loc8_.vertexList = null;
_loc9_ = _loc8_.faceList;
while(_loc9_ != null)
{
_loc11_ = _loc9_.wrapper;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
_loc17_ = new Vertex();
_loc17_.x = _loc10_.x;
_loc17_.y = _loc10_.y;
_loc17_.z = _loc10_.z;
_loc17_.u = _loc10_.u;
_loc17_.v = _loc10_.v;
_loc17_.id = _loc10_.id;
_loc17_.normalX = _loc9_.normalX;
_loc17_.normalY = _loc9_.normalY;
_loc17_.normalZ = _loc9_.normalZ;
if(_loc9_.smoothingGroups > 0)
{
for(_loc19_ in _loc12_[_loc10_])
{
if(_loc9_ != _loc19_ && (_loc9_.smoothingGroups & _loc19_.smoothingGroups) > 0)
{
_loc17_.normalX += _loc19_.normalX;
_loc17_.normalY += _loc19_.normalY;
_loc17_.normalZ += _loc19_.normalZ;
}
}
_loc18_ = _loc17_.normalX * _loc17_.normalX + _loc17_.normalY * _loc17_.normalY + _loc17_.normalZ * _loc17_.normalZ;
if(_loc18_ > 0.001)
{
_loc18_ = 1 / Math.sqrt(_loc18_);
_loc17_.normalX *= _loc18_;
_loc17_.normalY *= _loc18_;
_loc17_.normalZ *= _loc18_;
}
}
_loc11_.vertex = _loc17_;
_loc17_.next = _loc8_.vertexList;
_loc8_.vertexList = _loc17_;
_loc11_ = _loc11_.next;
}
_loc9_ = _loc9_.next;
}
}
_loc3_++;
}
_loc3_ = 0;
while(_loc3_ < _loc13_)
{
_loc8_ = param1[_loc3_] as Mesh;
if(_loc8_ != null)
{
_loc8_.invertMatrix();
_loc10_ = _loc8_.vertexList;
while(_loc10_ != null)
{
_loc4_ = _loc10_.x;
_loc5_ = _loc10_.y;
_loc6_ = _loc10_.z;
_loc10_.x = _loc8_.ma * _loc4_ + _loc8_.mb * _loc5_ + _loc8_.mc * _loc6_ + _loc8_.md;
_loc10_.y = _loc8_.me * _loc4_ + _loc8_.mf * _loc5_ + _loc8_.mg * _loc6_ + _loc8_.mh;
_loc10_.z = _loc8_.mi * _loc4_ + _loc8_.mj * _loc5_ + _loc8_.mk * _loc6_ + _loc8_.ml;
_loc4_ = _loc10_.normalX;
_loc5_ = _loc10_.normalY;
_loc6_ = _loc10_.normalZ;
_loc10_.normalX = _loc8_.ma * _loc4_ + _loc8_.mb * _loc5_ + _loc8_.mc * _loc6_;
_loc10_.normalY = _loc8_.me * _loc4_ + _loc8_.mf * _loc5_ + _loc8_.mg * _loc6_;
_loc10_.normalZ = _loc8_.mi * _loc4_ + _loc8_.mj * _loc5_ + _loc8_.mk * _loc6_;
_loc10_ = _loc10_.next;
}
_loc9_ = _loc8_.faceList;
while(_loc9_ != null)
{
_loc4_ = _loc9_.normalX;
_loc5_ = _loc9_.normalY;
_loc6_ = _loc9_.normalZ;
_loc9_.normalX = _loc8_.ma * _loc4_ + _loc8_.mb * _loc5_ + _loc8_.mc * _loc6_;
_loc9_.normalY = _loc8_.me * _loc4_ + _loc8_.mf * _loc5_ + _loc8_.mg * _loc6_;
_loc9_.normalZ = _loc8_.mi * _loc4_ + _loc8_.mj * _loc5_ + _loc8_.mk * _loc6_;
_loc9_.offset = _loc9_.wrapper.vertex.x * _loc9_.normalX + _loc9_.wrapper.vertex.y * _loc9_.normalY + _loc9_.wrapper.vertex.z * _loc9_.normalZ;
_loc9_ = _loc9_.next;
}
}
_loc3_++;
}
}
private static function shareFaces(param1:Vector.<Vertex>, param2:int, param3:int, param4:int, param5:Number, param6:Vector.<int>, param7:Dictionary) : void
{
var _loc8_:int = 0;
var _loc9_:int = 0;
var _loc10_:int = 0;
var _loc11_:Vertex = null;
var _loc13_:Vertex = null;
var _loc14_:int = 0;
var _loc15_:int = 0;
var _loc16_:Number = NaN;
var _loc17_:Vertex = null;
var _loc18_:Vertex = null;
var _loc19_:* = undefined;
switch(param4)
{
case 0:
_loc8_ = param2;
while(_loc8_ < param3)
{
_loc11_ = param1[_loc8_];
_loc11_.offset = _loc11_.x;
_loc8_++;
}
break;
case 1:
_loc8_ = param2;
while(_loc8_ < param3)
{
_loc11_ = param1[_loc8_];
_loc11_.offset = _loc11_.y;
_loc8_++;
}
break;
case 2:
_loc8_ = param2;
while(_loc8_ < param3)
{
_loc11_ = param1[_loc8_];
_loc11_.offset = _loc11_.z;
_loc8_++;
}
}
param6[0] = param2;
param6[1] = param3 - 1;
var _loc12_:int = 2;
while(_loc12_ > 0)
{
_loc12_--;
_loc14_ = param6[_loc12_];
_loc9_ = _loc14_;
_loc12_--;
_loc15_ = param6[_loc12_];
_loc8_ = _loc15_;
_loc11_ = param1[_loc14_ + _loc15_ >> 1];
_loc16_ = _loc11_.offset;
while(_loc8_ <= _loc9_)
{
_loc17_ = param1[_loc8_];
while(_loc17_.offset > _loc16_)
{
_loc8_++;
_loc17_ = param1[_loc8_];
}
_loc18_ = param1[_loc9_];
while(_loc18_.offset < _loc16_)
{
_loc9_--;
_loc18_ = param1[_loc9_];
}
if(_loc8_ <= _loc9_)
{
param1[_loc8_] = _loc18_;
param1[_loc9_] = _loc17_;
_loc8_++;
_loc9_--;
}
}
if(_loc15_ < _loc9_)
{
param6[_loc12_] = _loc15_;
_loc12_++;
param6[_loc12_] = _loc9_;
_loc12_++;
}
if(_loc8_ < _loc14_)
{
param6[_loc12_] = _loc8_;
_loc12_++;
param6[_loc12_] = _loc14_;
_loc12_++;
}
}
_loc8_ = param2;
_loc11_ = param1[_loc8_];
_loc9_ = _loc8_ + 1;
while(_loc9_ <= param3)
{
if(_loc9_ < param3)
{
_loc13_ = param1[_loc9_];
}
if(_loc9_ == param3 || _loc11_.offset - _loc13_.offset > param5)
{
if(_loc9_ - _loc8_ > 1)
{
if(param4 < 2)
{
shareFaces(param1,_loc8_,_loc9_,param4 + 1,param5,param6,param7);
}
else
{
_loc10_ = _loc8_ + 1;
while(_loc10_ < _loc9_)
{
_loc13_ = param1[_loc10_];
for(_loc19_ in param7[_loc13_])
{
param7[_loc11_][_loc19_] = true;
}
_loc10_++;
}
_loc10_ = _loc8_ + 1;
while(_loc10_ < _loc9_)
{
_loc13_ = param1[_loc10_];
for(_loc19_ in param7[_loc11_])
{
param7[_loc13_][_loc19_] = true;
}
_loc10_++;
}
}
}
if(_loc9_ < param3)
{
_loc8_ = _loc9_;
_loc11_ = param1[_loc8_];
}
}
_loc9_++;
}
}
public function addVertex(param1:Number, param2:Number, param3:Number, param4:Number = 0, param5:Number = 0, param6:Object = null) : Vertex
{
var _loc8_:Vertex = null;
this.deleteResources();
var _loc7_:Vertex = new Vertex();
_loc7_.x = param1;
_loc7_.y = param2;
_loc7_.z = param3;
_loc7_.u = param4;
_loc7_.v = param5;
_loc7_.id = param6;
if(this.vertexList != null)
{
_loc8_ = this.vertexList;
while(_loc8_.next != null)
{
_loc8_ = _loc8_.next;
}
_loc8_.next = _loc7_;
}
else
{
this.vertexList = _loc7_;
}
return _loc7_;
}
public function removeVertex(param1:Vertex) : Vertex
{
var _loc3_:Vertex = null;
var _loc5_:Face = null;
var _loc6_:Face = null;
var _loc7_:Wrapper = null;
this.deleteResources();
if(param1 == null)
{
throw new TypeError("Parameter vertex must be non-null.");
}
var _loc2_:Vertex = this.vertexList;
while(_loc2_ != null)
{
if(_loc2_ == param1)
{
if(_loc3_ != null)
{
_loc3_.next = _loc2_.next;
}
else
{
this.vertexList = _loc2_.next;
}
_loc2_.next = null;
break;
}
_loc3_ = _loc2_;
_loc2_ = _loc2_.next;
}
if(_loc2_ == null)
{
throw new ArgumentError("Vertex not found.");
}
var _loc4_:Face = this.faceList;
while(_loc4_ != null)
{
_loc6_ = _loc4_.next;
_loc7_ = _loc4_.wrapper;
while(_loc7_ != null)
{
if(_loc7_.vertex == _loc2_)
{
break;
}
_loc7_ = _loc7_.next;
}
if(_loc7_ != null)
{
if(_loc5_ != null)
{
_loc5_.next = _loc6_;
}
else
{
this.faceList = _loc6_;
}
_loc4_.next = null;
}
else
{
_loc5_ = _loc4_;
}
_loc4_ = _loc6_;
}
return _loc2_;
}
public function removeVertexById(param1:Object) : Vertex
{
var _loc3_:Vertex = null;
var _loc5_:Face = null;
var _loc6_:Face = null;
var _loc7_:Wrapper = null;
this.deleteResources();
if(param1 == null)
{
throw new TypeError("Parameter id must be non-null.");
}
var _loc2_:Vertex = this.vertexList;
while(_loc2_ != null)
{
if(_loc2_.id == param1)
{
if(_loc3_ != null)
{
_loc3_.next = _loc2_.next;
}
else
{
this.vertexList = _loc2_.next;
}
_loc2_.next = null;
break;
}
_loc3_ = _loc2_;
_loc2_ = _loc2_.next;
}
if(_loc2_ == null)
{
throw new ArgumentError("Vertex not found.");
}
var _loc4_:Face = this.faceList;
while(_loc4_ != null)
{
_loc6_ = _loc4_.next;
_loc7_ = _loc4_.wrapper;
while(_loc7_ != null)
{
if(_loc7_.vertex == _loc2_)
{
break;
}
_loc7_ = _loc7_.next;
}
if(_loc7_ != null)
{
if(_loc5_ != null)
{
_loc5_.next = _loc6_;
}
else
{
this.faceList = _loc6_;
}
_loc4_.next = null;
}
else
{
_loc5_ = _loc4_;
}
_loc4_ = _loc6_;
}
return _loc2_;
}
public function containsVertex(param1:Vertex) : Boolean
{
if(param1 == null)
{
throw new TypeError("Parameter vertex must be non-null.");
}
var _loc2_:Vertex = this.vertexList;
while(_loc2_ != null)
{
if(_loc2_ == param1)
{
return true;
}
_loc2_ = _loc2_.next;
}
return false;
}
public function containsVertexWithId(param1:Object) : Boolean
{
if(param1 == null)
{
throw new TypeError("Parameter id must be non-null.");
}
var _loc2_:Vertex = this.vertexList;
while(_loc2_ != null)
{
if(_loc2_.id == param1)
{
return true;
}
_loc2_ = _loc2_.next;
}
return false;
}
public function getVertexById(param1:Object) : Vertex
{
if(param1 == null)
{
throw new TypeError("Parameter id must be non-null.");
}
var _loc2_:Vertex = this.vertexList;
while(_loc2_ != null)
{
if(_loc2_.id == param1)
{
return _loc2_;
}
_loc2_ = _loc2_.next;
}
return null;
}
public function addFace(param1:Vector.<Vertex>, param2:Material = null, param3:Object = null) : Face
{
var _loc8_:Wrapper = null;
var _loc9_:Vertex = null;
var _loc10_:Face = null;
this.deleteResources();
if(param1 == null)
{
throw new TypeError("Parameter vertices must be non-null.");
}
var _loc4_:int = param1.length;
if(_loc4_ < 3)
{
throw new ArgumentError(_loc4_ + " vertices not enough.");
}
var _loc5_:Face = new Face();
_loc5_.material = param2;
_loc5_.id = param3;
var _loc6_:Wrapper = null;
var _loc7_:int = 0;
while(_loc7_ < _loc4_)
{
_loc8_ = new Wrapper();
_loc9_ = param1[_loc7_];
if(_loc9_ == null)
{
throw new ArgumentError("Null vertex in vector.");
}
if(!this.containsVertex(_loc9_))
{
throw new ArgumentError("Vertex not found.");
}
_loc8_.vertex = _loc9_;
if(_loc6_ != null)
{
_loc6_.next = _loc8_;
}
else
{
_loc5_.wrapper = _loc8_;
}
_loc6_ = _loc8_;
_loc7_++;
}
if(this.faceList != null)
{
_loc10_ = this.faceList;
while(_loc10_.next != null)
{
_loc10_ = _loc10_.next;
}
_loc10_.next = _loc5_;
}
else
{
this.faceList = _loc5_;
}
return _loc5_;
}
public function addFaceByIds(param1:Array, param2:Material = null, param3:Object = null) : Face
{
var _loc8_:Wrapper = null;
var _loc9_:Vertex = null;
var _loc10_:Face = null;
this.deleteResources();
if(param1 == null)
{
throw new TypeError("Parameter vertices must be non-null.");
}
var _loc4_:int = param1.length;
if(_loc4_ < 3)
{
throw new ArgumentError(_loc4_ + " vertices not enough.");
}
var _loc5_:Face = new Face();
_loc5_.material = param2;
_loc5_.id = param3;
var _loc6_:Wrapper = null;
var _loc7_:int = 0;
while(_loc7_ < _loc4_)
{
_loc8_ = new Wrapper();
_loc9_ = this.getVertexById(param1[_loc7_]);
if(_loc9_ == null)
{
throw new ArgumentError("Vertex not found.");
}
_loc8_.vertex = _loc9_;
if(_loc6_ != null)
{
_loc6_.next = _loc8_;
}
else
{
_loc5_.wrapper = _loc8_;
}
_loc6_ = _loc8_;
_loc7_++;
}
if(this.faceList != null)
{
_loc10_ = this.faceList;
while(_loc10_.next != null)
{
_loc10_ = _loc10_.next;
}
_loc10_.next = _loc5_;
}
else
{
this.faceList = _loc5_;
}
return _loc5_;
}
public function addTriFace(param1:Vertex, param2:Vertex, param3:Vertex, param4:Material = null, param5:Object = null) : Face
{
var _loc7_:Face = null;
this.deleteResources();
if(param1 == null)
{
throw new TypeError("Parameter v1 must be non-null.");
}
if(param2 == null)
{
throw new TypeError("Parameter v2 must be non-null.");
}
if(param3 == null)
{
throw new TypeError("Parameter v3 must be non-null.");
}
if(!this.containsVertex(param1))
{
throw new ArgumentError("Vertex not found.");
}
if(!this.containsVertex(param2))
{
throw new ArgumentError("Vertex not found.");
}
if(!this.containsVertex(param3))
{
throw new ArgumentError("Vertex not found.");
}
var _loc6_:Face = new Face();
_loc6_.material = param4;
_loc6_.id = param5;
_loc6_.wrapper = new Wrapper();
_loc6_.wrapper.vertex = param1;
_loc6_.wrapper.next = new Wrapper();
_loc6_.wrapper.next.vertex = param2;
_loc6_.wrapper.next.next = new Wrapper();
_loc6_.wrapper.next.next.vertex = param3;
if(this.faceList != null)
{
_loc7_ = this.faceList;
while(_loc7_.next != null)
{
_loc7_ = _loc7_.next;
}
_loc7_.next = _loc6_;
}
else
{
this.faceList = _loc6_;
}
return _loc6_;
}
public function addQuadFace(param1:Vertex, param2:Vertex, param3:Vertex, param4:Vertex, param5:Material = null, param6:Object = null) : Face
{
var _loc8_:Face = null;
this.deleteResources();
if(param1 == null)
{
throw new TypeError("Parameter v1 must be non-null.");
}
if(param2 == null)
{
throw new TypeError("Parameter v2 must be non-null.");
}
if(param3 == null)
{
throw new TypeError("Parameter v3 must be non-null.");
}
if(param4 == null)
{
throw new TypeError("Parameter v4 must be non-null.");
}
if(!this.containsVertex(param1))
{
throw new ArgumentError("Vertex not found.");
}
if(!this.containsVertex(param2))
{
throw new ArgumentError("Vertex not found.");
}
if(!this.containsVertex(param3))
{
throw new ArgumentError("Vertex not found.");
}
if(!this.containsVertex(param4))
{
throw new ArgumentError("Vertex not found.");
}
var _loc7_:Face = new Face();
_loc7_.material = param5;
_loc7_.id = param6;
_loc7_.wrapper = new Wrapper();
_loc7_.wrapper.vertex = param1;
_loc7_.wrapper.next = new Wrapper();
_loc7_.wrapper.next.vertex = param2;
_loc7_.wrapper.next.next = new Wrapper();
_loc7_.wrapper.next.next.vertex = param3;
_loc7_.wrapper.next.next.next = new Wrapper();
_loc7_.wrapper.next.next.next.vertex = param4;
if(this.faceList != null)
{
_loc8_ = this.faceList;
while(_loc8_.next != null)
{
_loc8_ = _loc8_.next;
}
_loc8_.next = _loc7_;
}
else
{
this.faceList = _loc7_;
}
return _loc7_;
}
public function removeFace(param1:Face) : Face
{
var _loc3_:Face = null;
this.deleteResources();
if(param1 == null)
{
throw new TypeError("Parameter face must be non-null.");
}
var _loc2_:Face = this.faceList;
while(_loc2_ != null)
{
if(_loc2_ == param1)
{
if(_loc3_ != null)
{
_loc3_.next = _loc2_.next;
}
else
{
this.faceList = _loc2_.next;
}
_loc2_.next = null;
break;
}
_loc3_ = _loc2_;
_loc2_ = _loc2_.next;
}
if(_loc2_ == null)
{
throw new ArgumentError("Face not found.");
}
return _loc2_;
}
public function removeFaceById(param1:Object) : Face
{
var _loc3_:Face = null;
this.deleteResources();
if(param1 == null)
{
throw new TypeError("Parameter id must be non-null.");
}
var _loc2_:Face = this.faceList;
while(_loc2_ != null)
{
if(_loc2_.id == param1)
{
if(_loc3_ != null)
{
_loc3_.next = _loc2_.next;
}
else
{
this.faceList = _loc2_.next;
}
_loc2_.next = null;
break;
}
_loc3_ = _loc2_;
_loc2_ = _loc2_.next;
}
if(_loc2_ == null)
{
throw new ArgumentError("Face not found.");
}
return _loc2_;
}
public function containsFace(param1:Face) : Boolean
{
if(param1 == null)
{
throw new TypeError("Parameter face must be non-null.");
}
var _loc2_:Face = this.faceList;
while(_loc2_ != null)
{
if(_loc2_ == param1)
{
return true;
}
_loc2_ = _loc2_.next;
}
return false;
}
public function containsFaceWithId(param1:Object) : Boolean
{
if(param1 == null)
{
throw new TypeError("Parameter id must be non-null.");
}
var _loc2_:Face = this.faceList;
while(_loc2_ != null)
{
if(_loc2_.id == param1)
{
return true;
}
_loc2_ = _loc2_.next;
}
return false;
}
public function getFaceById(param1:Object) : Face
{
if(param1 == null)
{
throw new TypeError("Parameter id must be non-null.");
}
var _loc2_:Face = this.faceList;
while(_loc2_ != null)
{
if(_loc2_.id == param1)
{
return _loc2_;
}
_loc2_ = _loc2_.next;
}
return null;
}
public function addVerticesAndFaces(param1:Vector.<Number>, param2:Vector.<Number>, param3:Vector.<int>, param4:Boolean = false, param5:Material = null) : void
{
var _loc6_:int = 0;
var _loc7_:int = 0;
var _loc8_:int = 0;
var _loc11_:Vertex = null;
var _loc13_:Face = null;
var _loc14_:Face = null;
var _loc15_:Wrapper = null;
var _loc16_:int = 0;
var _loc17_:int = 0;
var _loc18_:Vertex = null;
var _loc19_:Wrapper = null;
this.deleteResources();
if(param1 == null)
{
throw new TypeError("Parameter vertices must be non-null.");
}
if(param2 == null)
{
throw new TypeError("Parameter uvs must be non-null.");
}
if(param3 == null)
{
throw new TypeError("Parameter indices must be non-null.");
}
var _loc9_:int = param1.length / 3;
if(_loc9_ != param2.length / 2)
{
throw new ArgumentError("Vertices count and uvs count doesn\'t match.");
}
var _loc10_:int = param3.length;
if(!param4 && _loc10_ % 3)
{
throw new ArgumentError("Incorrect indices.");
}
_loc6_ = 0;
_loc8_ = 0;
while(_loc6_ < _loc10_)
{
if(_loc6_ == _loc8_)
{
_loc17_ = !!param4 ? int(int(param3[_loc6_])) : int(int(3));
if(_loc17_ < 3)
{
throw new ArgumentError(_loc17_ + " vertices not enough.");
}
_loc8_ = !!param4 ? int(int(_loc17_ + ++_loc6_)) : int(int(_loc6_ + _loc17_));
if(_loc8_ > _loc10_)
{
throw new ArgumentError("Incorrect indices.");
}
}
_loc16_ = param3[_loc6_];
if(_loc16_ < 0 || _loc16_ >= _loc9_)
{
throw new RangeError("Index is out of bounds.");
}
_loc6_++;
}
if(this.vertexList != null)
{
_loc11_ = this.vertexList;
while(_loc11_.next != null)
{
_loc11_ = _loc11_.next;
}
}
var _loc12_:Vector.<Vertex> = new Vector.<Vertex>(_loc9_);
_loc6_ = 0;
_loc7_ = 0;
_loc8_ = 0;
while(_loc6_ < _loc9_)
{
_loc18_ = new Vertex();
_loc18_.x = param1[_loc7_];
_loc7_++;
_loc18_.y = param1[_loc7_];
_loc7_++;
_loc18_.z = param1[_loc7_];
_loc7_++;
_loc18_.u = param2[_loc8_];
_loc8_++;
_loc18_.v = param2[_loc8_];
_loc8_++;
_loc12_[_loc6_] = _loc18_;
if(_loc11_ != null)
{
_loc11_.next = _loc18_;
}
else
{
this.vertexList = _loc18_;
}
_loc11_ = _loc18_;
_loc6_++;
}
if(this.faceList != null)
{
_loc13_ = this.faceList;
while(_loc13_.next != null)
{
_loc13_ = _loc13_.next;
}
}
_loc6_ = 0;
_loc8_ = 0;
while(_loc6_ < _loc10_)
{
if(_loc6_ == _loc8_)
{
_loc8_ = !!param4 ? int(int(param3[_loc6_] + ++_loc6_)) : int(int(_loc6_ + 3));
_loc15_ = null;
_loc14_ = new Face();
_loc14_.material = param5;
if(_loc13_ != null)
{
_loc13_.next = _loc14_;
}
else
{
this.faceList = _loc14_;
}
_loc13_ = _loc14_;
}
_loc19_ = new Wrapper();
_loc19_.vertex = _loc12_[param3[_loc6_]];
if(_loc15_ != null)
{
_loc15_.next = _loc19_;
}
else
{
_loc14_.wrapper = _loc19_;
}
_loc15_ = _loc19_;
_loc6_++;
}
}
public function get vertices() : Vector.<Vertex>
{
var _loc1_:Vector.<Vertex> = new Vector.<Vertex>();
var _loc2_:int = 0;
var _loc3_:Vertex = this.vertexList;
while(_loc3_ != null)
{
_loc1_[_loc2_] = _loc3_;
_loc2_++;
_loc3_ = _loc3_.next;
}
return _loc1_;
}
public function get faces() : Vector.<Face>
{
var _loc1_:Vector.<Face> = new Vector.<Face>();
var _loc2_:int = 0;
var _loc3_:Face = this.faceList;
while(_loc3_ != null)
{
_loc1_[_loc2_] = _loc3_;
_loc2_++;
_loc3_ = _loc3_.next;
}
return _loc1_;
}
public function weldVertices(param1:Number = 0, param2:Number = 0) : void
{
var _loc3_:Vertex = null;
var _loc4_:Vertex = null;
var _loc9_:Wrapper = null;
this.deleteResources();
var _loc5_:Vector.<Vertex> = new Vector.<Vertex>();
var _loc6_:int = 0;
_loc3_ = this.vertexList;
while(_loc3_ != null)
{
_loc4_ = _loc3_.next;
_loc3_.next = null;
_loc5_[_loc6_] = _loc3_;
_loc6_++;
_loc3_ = _loc4_;
}
this.vertexList = null;
this.group(_loc5_,0,_loc6_,0,param1,param2,new Vector.<int>());
var _loc7_:Face = this.faceList;
while(_loc7_ != null)
{
_loc9_ = _loc7_.wrapper;
while(_loc9_ != null)
{
if(_loc9_.vertex.value != null)
{
_loc9_.vertex = _loc9_.vertex.value;
}
_loc9_ = _loc9_.next;
}
_loc7_ = _loc7_.next;
}
var _loc8_:int = 0;
while(_loc8_ < _loc6_)
{
_loc3_ = _loc5_[_loc8_];
if(_loc3_.value == null)
{
_loc3_.next = this.vertexList;
this.vertexList = _loc3_;
}
_loc8_++;
}
}
public function weldFaces(angleThreshold:Number = 0, uvThreshold:Number = 0, convexThreshold:Number = 0, pairWeld:Boolean = false) : void
{
var i:int = 0;
var j:int = 0;
var key:* = undefined;
var sibling:* = null;
var face:* = null;
var wp:Wrapper = null;
var sp:Wrapper = null;
var w:Wrapper = null;
var s:Wrapper = null;
var wn:Wrapper = null;
var sn:Wrapper = null;
var wm:Wrapper = null;
var sm:Wrapper = null;
var vertex:Vertex = null;
var a:Vertex = null;
var b:Vertex = null;
var c:Vertex = null;
var abx:Number = NaN;
var aby:Number = NaN;
var abz:Number = NaN;
var abu:Number = NaN;
var abv:Number = NaN;
var acx:Number = NaN;
var acy:Number = NaN;
var acz:Number = NaN;
var acu:Number = NaN;
var acv:Number = NaN;
var nx:Number = NaN;
var ny:Number = NaN;
var nz:Number = NaN;
var nl:Number = NaN;
var faceIdCounter:Number = NaN;
var dictionary:Dictionary = null;
var island:Vector.<Face> = null;
var siblings:Dictionary = null;
var unfit:Dictionary = null;
var num:int = 0;
var det:Number = NaN;
var ima:Number = NaN;
var imb:Number = NaN;
var imc:Number = NaN;
var imd:Number = NaN;
var ime:Number = NaN;
var imf:Number = NaN;
var img:Number = NaN;
var imh:Number = NaN;
var ma:Number = NaN;
var mb:Number = NaN;
var mc:Number = NaN;
var md:Number = NaN;
var me:Number = NaN;
var mf:Number = NaN;
var mg:Number = NaN;
var mh:Number = NaN;
var du:Number = NaN;
var dv:Number = NaN;
var weld:Boolean = false;
var newFace:Face = null;
angleThreshold = Math.cos(angleThreshold) - 0.001;
uvThreshold += 0.001;
convexThreshold = Math.cos(Math.PI - convexThreshold) - 0.001;
var faceSet:Dictionary = new Dictionary();
var map:Dictionary = new Dictionary();
for each(face in this.faces)
{
a = face.wrapper.vertex;
b = face.wrapper.next.vertex;
c = face.wrapper.next.next.vertex;
abx = b.x - a.x;
aby = b.y - a.y;
abz = b.z - a.z;
acx = c.x - a.x;
acy = c.y - a.y;
acz = c.z - a.z;
nx = acz * aby - acy * abz;
ny = acx * abz - acz * abx;
nz = acy * abx - acx * aby;
nl = nx * nx + ny * ny + nz * nz;
if(nl > 0.001)
{
nl = 1 / Math.sqrt(nl);
nx *= nl;
ny *= nl;
nz *= nl;
face.normalX = nx;
face.normalY = ny;
face.normalZ = nz;
face.offset = a.x * nx + a.y * ny + a.z * nz;
faceSet[face] = true;
for(wn = face.wrapper; wn != null; wn = wn.next)
{
vertex = wn.vertex;
dictionary = map[vertex];
if(dictionary == null)
{
dictionary = new Dictionary();
map[vertex] = dictionary;
}
dictionary[face] = true;
}
}
}
faceSet = new Dictionary();
faceIdCounter = 0;
island = new Vector.<Face>();
siblings = new Dictionary();
unfit = new Dictionary();
while(true)
{
face = null;
var _loc66_:int = 0;
var _loc67_:* = faceSet;
for(face in _loc67_)
{
delete faceSet[key];
}
if(face == null)
{
break;
}
num = 0;
island[num] = face;
num++;
a = face.wrapper.vertex;
b = face.wrapper.next.vertex;
c = face.wrapper.next.next.vertex;
abx = b.x - a.x;
aby = b.y - a.y;
abz = b.z - a.z;
abu = b.u - a.u;
abv = b.v - a.v;
acx = c.x - a.x;
acy = c.y - a.y;
acz = c.z - a.z;
acu = c.u - a.u;
acv = c.v - a.v;
nx = face.normalX;
ny = face.normalY;
nz = face.normalZ;
det = -nx * acy * abz + acx * ny * abz + nx * aby * acz - abx * ny * acz - acx * aby * nz + abx * acy * nz;
ima = (-ny * acz + acy * nz) / det;
imb = (nx * acz - acx * nz) / det;
imc = (-nx * acy + acx * ny) / det;
imd = (a.x * ny * acz - nx * a.y * acz - a.x * acy * nz + acx * a.y * nz + nx * acy * a.z - acx * ny * a.z) / det;
ime = (ny * abz - aby * nz) / det;
imf = (-nx * abz + abx * nz) / det;
img = (nx * aby - abx * ny) / det;
imh = (nx * a.y * abz - a.x * ny * abz + a.x * aby * nz - abx * a.y * nz - nx * aby * a.z + abx * ny * a.z) / det;
ma = abu * ima + acu * ime;
mb = abu * imb + acu * imf;
mc = abu * imc + acu * img;
md = abu * imd + acu * imh + a.u;
me = abv * ima + acv * ime;
mf = abv * imb + acv * imf;
mg = abv * imc + acv * img;
mh = abv * imd + acv * imh + a.v;
for(key in unfit)
{
delete unfit[key];
}
for(i = 0; i < num; i++)
{
face = island[i];
for(key in siblings)
{
delete siblings[key];
}
for(w = face.wrapper; w != null; w = w.next)
{
for(key in map[w.vertex])
{
if(faceSet[key] && !unfit[key])
{
siblings[key] = true;
}
}
}
for(sibling in siblings)
{
if(nx * sibling.normalX + ny * sibling.normalY + nz * sibling.normalZ >= angleThreshold)
{
for(s = sibling.wrapper; s != null; s = s.next)
{
vertex = s.vertex;
du = ma * vertex.x + mb * vertex.y + mc * vertex.z + md - vertex.u;
dv = me * vertex.x + mf * vertex.y + mg * vertex.z + mh - vertex.v;
if(du > uvThreshold || du < -uvThreshold || dv > uvThreshold || dv < -uvThreshold)
{
break;
}
}
if(s == null)
{
for(w = face.wrapper; w != null; w = w.next)
{
wn = w.next != null ? w.next : face.wrapper;
for(s = sibling.wrapper; s != null; s = s.next)
{
sn = s.next != null ? s.next : sibling.wrapper;
if(w.vertex == sn.vertex && wn.vertex == s.vertex)
{
break;
}
}
if(s != null)
{
break;
}
}
if(w != null)
{
island[num] = sibling;
num++;
delete faceSet[sibling];
}
}
else
{
unfit[sibling] = true;
}
}
else
{
unfit[sibling] = true;
}
}
}
if(num == 1)
{
faceSet[faceIdCounter] = island[0];
faceIdCounter++;
}
else
{
do
{
weld = false;
for(i = 0; i < num - 1; i++)
{
face = island[i];
if(face != null)
{
for(j = 1; j < num; j++)
{
sibling = island[j];
if(sibling != null)
{
for(w = face.wrapper; w != null; w = w.next)
{
wn = w.next != null ? w.next : face.wrapper;
for(s = sibling.wrapper; s != null; s = s.next)
{
sn = s.next != null ? s.next : sibling.wrapper;
if(w.vertex == sn.vertex && wn.vertex == s.vertex)
{
break;
}
}
if(s != null)
{
break;
}
}
if(w != null)
{
while(true)
{
wm = wn.next != null ? wn.next : face.wrapper;
sp = sibling.wrapper;
while(sp.next != s && sp.next != null)
{
sp = sp.next;
}
if(wm.vertex != sp.vertex)
{
break;
}
wn = wm;
s = sp;
}
while(true)
{
wp = face.wrapper;
while(wp.next != w && wp.next != null)
{
wp = wp.next;
}
sm = sn.next != null ? sn.next : sibling.wrapper;
if(wp.vertex != sm.vertex)
{
break;
}
w = wp;
sn = sm;
}
a = w.vertex;
b = sm.vertex;
c = wp.vertex;
abx = b.x - a.x;
aby = b.y - a.y;
abz = b.z - a.z;
acx = c.x - a.x;
acy = c.y - a.y;
acz = c.z - a.z;
nx = acz * aby - acy * abz;
ny = acx * abz - acz * abx;
nz = acy * abx - acx * aby;
if(nx < 0.001 && nx > -0.001 && ny < 0.001 && ny > -0.001 && nz < 0.001 && nz > -0.001)
{
if(abx * acx + aby * acy + abz * acz > 0)
{
continue;
}
}
else if(face.normalX * nx + face.normalY * ny + face.normalZ * nz < 0)
{
continue;
}
nl = 1 / Math.sqrt(abx * abx + aby * aby + abz * abz);
abx *= nl;
aby *= nl;
abz *= nl;
nl = 1 / Math.sqrt(acx * acx + acy * acy + acz * acz);
acx *= nl;
acy *= nl;
acz *= nl;
if(abx * acx + aby * acy + abz * acz >= convexThreshold)
{
a = s.vertex;
b = wm.vertex;
c = sp.vertex;
abx = b.x - a.x;
aby = b.y - a.y;
abz = b.z - a.z;
acx = c.x - a.x;
acy = c.y - a.y;
acz = c.z - a.z;
nx = acz * aby - acy * abz;
ny = acx * abz - acz * abx;
nz = acy * abx - acx * aby;
if(nx < 0.001 && nx > -0.001 && ny < 0.001 && ny > -0.001 && nz < 0.001 && nz > -0.001)
{
if(abx * acx + aby * acy + abz * acz > 0)
{
continue;
}
}
else if(face.normalX * nx + face.normalY * ny + face.normalZ * nz < 0)
{
continue;
}
nl = 1 / Math.sqrt(abx * abx + aby * aby + abz * abz);
abx *= nl;
aby *= nl;
abz *= nl;
nl = 1 / Math.sqrt(acx * acx + acy * acy + acz * acz);
acx *= nl;
acy *= nl;
acz *= nl;
if(abx * acx + aby * acy + abz * acz >= convexThreshold)
{
weld = true;
newFace = new Face();
newFace.material = face.material;
newFace.normalX = face.normalX;
newFace.normalY = face.normalY;
newFace.normalZ = face.normalZ;
newFace.offset = face.offset;
for(wm = null; wn != w; )
{
sm = new Wrapper();
sm.vertex = wn.vertex;
if(wm != null)
{
wm.next = sm;
}
else
{
newFace.wrapper = sm;
}
wm = sm;
wn = wn.next != null ? wn.next : face.wrapper;
}
while(sn != s)
{
sm = new Wrapper();
sm.vertex = sn.vertex;
if(wm != null)
{
wm.next = sm;
}
else
{
newFace.wrapper = sm;
}
wm = sm;
sn = sn.next != null ? sn.next : sibling.wrapper;
}
island[i] = newFace;
island[j] = null;
face = newFace;
if(pairWeld)
{
break;
}
}
}
}
}
}
}
}
}
while(weld);
for(i = 0; i < num; i++)
{
face = island[i];
if(face != null)
{
face.calculateBestSequenceAndNormal();
faceSet[faceIdCounter] = face;
faceIdCounter++;
}
}
}
}
}
private function group(param1:Vector.<Vertex>, param2:int, param3:int, param4:int, param5:Number, param6:Number, param7:Vector.<int>) : void
{
var _loc8_:int = 0;
var _loc9_:int = 0;
var _loc10_:Vertex = null;
var _loc11_:Number = NaN;
var _loc13_:Vertex = null;
var _loc14_:int = 0;
var _loc15_:int = 0;
var _loc16_:Number = NaN;
var _loc17_:Vertex = null;
var _loc18_:Vertex = null;
switch(param4)
{
case 0:
_loc8_ = param2;
while(_loc8_ < param3)
{
_loc10_ = param1[_loc8_];
_loc10_.offset = _loc10_.x;
_loc8_++;
}
_loc11_ = param5;
break;
case 1:
_loc8_ = param2;
while(_loc8_ < param3)
{
_loc10_ = param1[_loc8_];
_loc10_.offset = _loc10_.y;
_loc8_++;
}
_loc11_ = param5;
break;
case 2:
_loc8_ = param2;
while(_loc8_ < param3)
{
_loc10_ = param1[_loc8_];
_loc10_.offset = _loc10_.z;
_loc8_++;
}
_loc11_ = param5;
break;
case 3:
_loc8_ = param2;
while(_loc8_ < param3)
{
_loc10_ = param1[_loc8_];
_loc10_.offset = _loc10_.u;
_loc8_++;
}
_loc11_ = param6;
break;
case 4:
_loc8_ = param2;
while(_loc8_ < param3)
{
_loc10_ = param1[_loc8_];
_loc10_.offset = _loc10_.v;
_loc8_++;
}
_loc11_ = param6;
}
param7[0] = param2;
param7[1] = param3 - 1;
var _loc12_:int = 2;
while(_loc12_ > 0)
{
_loc12_--;
_loc14_ = param7[_loc12_];
_loc9_ = _loc14_;
_loc12_--;
_loc15_ = param7[_loc12_];
_loc8_ = _loc15_;
_loc10_ = param1[_loc14_ + _loc15_ >> 1];
_loc16_ = _loc10_.offset;
while(_loc8_ <= _loc9_)
{
_loc17_ = param1[_loc8_];
while(_loc17_.offset > _loc16_)
{
_loc8_++;
_loc17_ = param1[_loc8_];
}
_loc18_ = param1[_loc9_];
while(_loc18_.offset < _loc16_)
{
_loc9_--;
_loc18_ = param1[_loc9_];
}
if(_loc8_ <= _loc9_)
{
param1[_loc8_] = _loc18_;
param1[_loc9_] = _loc17_;
_loc8_++;
_loc9_--;
}
}
if(_loc15_ < _loc9_)
{
param7[_loc12_] = _loc15_;
_loc12_++;
param7[_loc12_] = _loc9_;
_loc12_++;
}
if(_loc8_ < _loc14_)
{
param7[_loc12_] = _loc8_;
_loc12_++;
param7[_loc12_] = _loc14_;
_loc12_++;
}
}
_loc8_ = param2;
_loc10_ = param1[_loc8_];
_loc9_ = _loc8_ + 1;
while(_loc9_ <= param3)
{
if(_loc9_ < param3)
{
_loc13_ = param1[_loc9_];
}
if(_loc9_ == param3 || _loc10_.offset - _loc13_.offset > _loc11_)
{
if(param4 < 4 && _loc9_ - _loc8_ > 1)
{
this.group(param1,_loc8_,_loc9_,param4 + 1,param5,param6,param7);
}
if(_loc9_ < param3)
{
_loc8_ = _loc9_;
_loc10_ = param1[_loc8_];
}
}
else if(param4 == 4)
{
_loc13_.value = _loc10_;
}
_loc9_++;
}
}
public function setMaterialToAllFaces(param1:Material) : void
{
this.deleteResources();
this.material = param1;
var _loc2_:Face = this.faceList;
while(_loc2_ != null)
{
if(!(param1 != null && _loc2_.material != null && _loc2_.material.name == "track"))
{
_loc2_.material = param1;
}
_loc2_ = _loc2_.next;
}
}
public function calculateFacesNormals(param1:Boolean = true) : void
{
var _loc3_:Wrapper = null;
var _loc4_:Vertex = null;
var _loc5_:Vertex = null;
var _loc6_:Vertex = null;
var _loc7_:Number = NaN;
var _loc8_:Number = NaN;
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc13_:Number = NaN;
var _loc14_:Number = NaN;
var _loc15_:Number = NaN;
var _loc16_:Number = NaN;
this.deleteResources();
var _loc2_:Face = this.faceList;
while(_loc2_ != null)
{
_loc3_ = _loc2_.wrapper;
_loc4_ = _loc3_.vertex;
_loc3_ = _loc3_.next;
_loc5_ = _loc3_.vertex;
_loc3_ = _loc3_.next;
_loc6_ = _loc3_.vertex;
_loc7_ = _loc5_.x - _loc4_.x;
_loc8_ = _loc5_.y - _loc4_.y;
_loc9_ = _loc5_.z - _loc4_.z;
_loc10_ = _loc6_.x - _loc4_.x;
_loc11_ = _loc6_.y - _loc4_.y;
_loc12_ = _loc6_.z - _loc4_.z;
_loc13_ = _loc12_ * _loc8_ - _loc11_ * _loc9_;
_loc14_ = _loc10_ * _loc9_ - _loc12_ * _loc7_;
_loc15_ = _loc11_ * _loc7_ - _loc10_ * _loc8_;
if(param1)
{
_loc16_ = _loc13_ * _loc13_ + _loc14_ * _loc14_ + _loc15_ * _loc15_;
if(_loc16_ > 0.001)
{
_loc16_ = 1 / Math.sqrt(_loc16_);
_loc13_ *= _loc16_;
_loc14_ *= _loc16_;
_loc15_ *= _loc16_;
}
}
_loc2_.normalX = _loc13_;
_loc2_.normalY = _loc14_;
_loc2_.normalZ = _loc15_;
_loc2_.offset = _loc4_.x * _loc13_ + _loc4_.y * _loc14_ + _loc4_.z * _loc15_;
_loc2_ = _loc2_.next;
}
}
public function calculateVerticesNormals(param1:Boolean = false, param2:Number = 0) : void
{
var _loc3_:Vertex = null;
var _loc4_:Number = NaN;
var _loc6_:Wrapper = null;
var _loc7_:Vertex = null;
var _loc8_:Vertex = null;
var _loc9_:Vertex = null;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc13_:Number = NaN;
var _loc14_:Number = NaN;
var _loc15_:Number = NaN;
var _loc16_:Number = NaN;
var _loc17_:Number = NaN;
var _loc18_:Number = NaN;
var _loc19_:Vector.<Vertex> = null;
this.deleteResources();
_loc3_ = this.vertexList;
while(_loc3_ != null)
{
_loc3_.normalX = 0;
_loc3_.normalY = 0;
_loc3_.normalZ = 0;
_loc3_ = _loc3_.next;
}
var _loc5_:Face = this.faceList;
while(_loc5_ != null)
{
_loc6_ = _loc5_.wrapper;
_loc7_ = _loc6_.vertex;
_loc6_ = _loc6_.next;
_loc8_ = _loc6_.vertex;
_loc6_ = _loc6_.next;
_loc9_ = _loc6_.vertex;
_loc10_ = _loc8_.x - _loc7_.x;
_loc11_ = _loc8_.y - _loc7_.y;
_loc12_ = _loc8_.z - _loc7_.z;
_loc13_ = _loc9_.x - _loc7_.x;
_loc14_ = _loc9_.y - _loc7_.y;
_loc15_ = _loc9_.z - _loc7_.z;
_loc16_ = _loc15_ * _loc11_ - _loc14_ * _loc12_;
_loc17_ = _loc13_ * _loc12_ - _loc15_ * _loc10_;
_loc18_ = _loc14_ * _loc10_ - _loc13_ * _loc11_;
_loc4_ = _loc16_ * _loc16_ + _loc17_ * _loc17_ + _loc18_ * _loc18_;
if(_loc4_ > 0.001)
{
_loc4_ = 1 / Math.sqrt(_loc4_);
_loc16_ *= _loc4_;
_loc17_ *= _loc4_;
_loc18_ *= _loc4_;
}
_loc6_ = _loc5_.wrapper;
while(_loc6_ != null)
{
_loc3_ = _loc6_.vertex;
_loc3_.normalX += _loc16_;
_loc3_.normalY += _loc17_;
_loc3_.normalZ += _loc18_;
_loc6_ = _loc6_.next;
}
_loc5_ = _loc5_.next;
}
if(param1)
{
_loc19_ = this.vertices;
this.weldNormals(_loc19_,0,_loc19_.length,0,param2,new Vector.<int>());
}
_loc3_ = this.vertexList;
while(_loc3_ != null)
{
_loc4_ = _loc3_.normalX * _loc3_.normalX + _loc3_.normalY * _loc3_.normalY + _loc3_.normalZ * _loc3_.normalZ;
if(_loc4_ > 0.001)
{
_loc4_ = 1 / Math.sqrt(_loc4_);
_loc3_.normalX *= _loc4_;
_loc3_.normalY *= _loc4_;
_loc3_.normalZ *= _loc4_;
}
_loc3_ = _loc3_.next;
}
}
alternativa3d function weldNormals(param1:Vector.<Vertex>, param2:int, param3:int, param4:int, param5:Number, param6:Vector.<int>) : void
{
var _loc7_:int = 0;
var _loc8_:int = 0;
var _loc9_:int = 0;
var _loc10_:Vertex = null;
var _loc12_:Vertex = null;
var _loc13_:int = 0;
var _loc14_:int = 0;
var _loc15_:Number = NaN;
var _loc16_:Vertex = null;
var _loc17_:Vertex = null;
switch(param4)
{
case 0:
_loc7_ = param2;
while(_loc7_ < param3)
{
_loc10_ = param1[_loc7_];
_loc10_.offset = _loc10_.x;
_loc7_++;
}
break;
case 1:
_loc7_ = param2;
while(_loc7_ < param3)
{
_loc10_ = param1[_loc7_];
_loc10_.offset = _loc10_.y;
_loc7_++;
}
break;
case 2:
_loc7_ = param2;
while(_loc7_ < param3)
{
_loc10_ = param1[_loc7_];
_loc10_.offset = _loc10_.z;
_loc7_++;
}
}
param6[0] = param2;
param6[1] = param3 - 1;
var _loc11_:int = 2;
while(_loc11_ > 0)
{
_loc11_--;
_loc13_ = param6[_loc11_];
_loc8_ = _loc13_;
_loc11_--;
_loc14_ = param6[_loc11_];
_loc7_ = _loc14_;
_loc10_ = param1[_loc13_ + _loc14_ >> 1];
_loc15_ = _loc10_.offset;
while(_loc7_ <= _loc8_)
{
_loc16_ = param1[_loc7_];
while(_loc16_.offset > _loc15_)
{
_loc7_++;
_loc16_ = param1[_loc7_];
}
_loc17_ = param1[_loc8_];
while(_loc17_.offset < _loc15_)
{
_loc8_--;
_loc17_ = param1[_loc8_];
}
if(_loc7_ <= _loc8_)
{
param1[_loc7_] = _loc17_;
param1[_loc8_] = _loc16_;
_loc7_++;
_loc8_--;
}
}
if(_loc14_ < _loc8_)
{
param6[_loc11_] = _loc14_;
_loc11_++;
param6[_loc11_] = _loc8_;
_loc11_++;
}
if(_loc7_ < _loc13_)
{
param6[_loc11_] = _loc7_;
_loc11_++;
param6[_loc11_] = _loc13_;
_loc11_++;
}
}
_loc7_ = param2;
_loc10_ = param1[_loc7_];
_loc8_ = _loc7_ + 1;
while(_loc8_ <= param3)
{
if(_loc8_ < param3)
{
_loc12_ = param1[_loc8_];
}
if(_loc8_ == param3 || _loc10_.offset - _loc12_.offset > param5)
{
if(_loc8_ - _loc7_ > 1)
{
if(param4 < 2)
{
this.weldNormals(param1,_loc7_,_loc8_,param4 + 1,param5,param6);
}
else
{
_loc9_ = _loc7_ + 1;
while(_loc9_ < _loc8_)
{
_loc12_ = param1[_loc9_];
_loc10_.normalX += _loc12_.normalX;
_loc10_.normalY += _loc12_.normalY;
_loc10_.normalZ += _loc12_.normalZ;
_loc9_++;
}
_loc9_ = _loc7_ + 1;
while(_loc9_ < _loc8_)
{
_loc12_ = param1[_loc9_];
_loc12_.normalX = _loc10_.normalX;
_loc12_.normalY = _loc10_.normalY;
_loc12_.normalZ = _loc10_.normalZ;
_loc9_++;
}
}
}
if(_loc8_ < param3)
{
_loc7_ = _loc8_;
_loc10_ = param1[_loc7_];
}
}
_loc8_++;
}
}
public function calculateVerticesNormalsByAngle(param1:Number, param2:Number = 0) : void
{
var _loc3_:Face = null;
var _loc4_:Wrapper = null;
var _loc5_:Vertex = null;
var _loc8_:Vertex = null;
var _loc9_:* = undefined;
var _loc10_:Number = NaN;
var _loc11_:* = null;
this.deleteResources();
this.calculateNormalsAndRemoveDegenerateFaces();
var _loc6_:Dictionary = new Dictionary();
_loc5_ = this.vertexList;
while(_loc5_ != null)
{
_loc6_[_loc5_] = new Dictionary();
_loc5_ = _loc5_.next;
}
_loc3_ = this.faceList;
while(_loc3_ != null)
{
_loc4_ = _loc3_.wrapper;
while(_loc4_ != null)
{
_loc5_ = _loc4_.vertex;
_loc6_[_loc5_][_loc3_] = true;
_loc4_ = _loc4_.next;
}
_loc3_ = _loc3_.next;
}
var _loc7_:Vector.<Vertex> = this.vertices;
shareFaces(_loc7_,0,_loc7_.length,0,param2,new Vector.<int>(),_loc6_);
this.vertexList = null;
param1 = Math.cos(param1);
_loc3_ = this.faceList;
while(_loc3_ != null)
{
_loc4_ = _loc3_.wrapper;
while(_loc4_ != null)
{
_loc5_ = _loc4_.vertex;
_loc8_ = new Vertex();
_loc8_.x = _loc5_.x;
_loc8_.y = _loc5_.y;
_loc8_.z = _loc5_.z;
_loc8_.u = _loc5_.u;
_loc8_.v = _loc5_.v;
_loc8_.id = _loc5_.id;
_loc8_.normalX = _loc3_.normalX;
_loc8_.normalY = _loc3_.normalY;
_loc8_.normalZ = _loc3_.normalZ;
for(_loc11_ in _loc6_[_loc5_])
{
if(_loc3_ != _loc11_ && _loc3_.normalX * _loc11_.normalX + _loc3_.normalY * _loc11_.normalY + _loc3_.normalZ * _loc11_.normalZ >= param1)
{
_loc8_.normalX += _loc11_.normalX;
_loc8_.normalY += _loc11_.normalY;
_loc8_.normalZ += _loc11_.normalZ;
}
}
_loc10_ = _loc8_.normalX * _loc8_.normalX + _loc8_.normalY * _loc8_.normalY + _loc8_.normalZ * _loc8_.normalZ;
if(_loc10_ > 0.001)
{
_loc10_ = 1 / Math.sqrt(_loc10_);
_loc8_.normalX *= _loc10_;
_loc8_.normalY *= _loc10_;
_loc8_.normalZ *= _loc10_;
}
_loc4_.vertex = _loc8_;
_loc8_.next = this.vertexList;
this.vertexList = _loc8_;
_loc4_ = _loc4_.next;
}
_loc3_ = _loc3_.next;
}
}
public function calculateVerticesNormalsBySmoothingGroups(param1:Number = 0) : void
{
var _loc2_:* = undefined;
var _loc3_:Face = null;
var _loc4_:Vertex = null;
var _loc5_:Wrapper = null;
var _loc9_:Vertex = null;
var _loc10_:Number = NaN;
var _loc11_:* = null;
this.deleteResources();
this.calculateNormalsAndRemoveDegenerateFaces();
var _loc6_:Dictionary = new Dictionary();
_loc3_ = this.faceList;
while(_loc3_ != null)
{
if(_loc3_.smoothingGroups > 0)
{
_loc5_ = _loc3_.wrapper;
while(_loc5_ != null)
{
_loc4_ = _loc5_.vertex;
if(!_loc6_[_loc4_])
{
_loc6_[_loc4_] = new Dictionary();
}
_loc6_[_loc4_][_loc3_] = true;
_loc5_ = _loc5_.next;
}
}
_loc3_ = _loc3_.next;
}
var _loc7_:Vector.<Vertex> = new Vector.<Vertex>();
var _loc8_:int = 0;
for each(_loc7_[_loc8_] in _loc6_)
{
_loc8_++;
}
if(_loc8_ > 0)
{
shareFaces(_loc7_,0,_loc8_,0,param1,new Vector.<int>(),_loc6_);
}
this.vertexList = null;
_loc3_ = this.faceList;
while(_loc3_ != null)
{
_loc5_ = _loc3_.wrapper;
while(_loc5_ != null)
{
_loc4_ = _loc5_.vertex;
_loc9_ = new Vertex();
_loc9_.x = _loc4_.x;
_loc9_.y = _loc4_.y;
_loc9_.z = _loc4_.z;
_loc9_.u = _loc4_.u;
_loc9_.v = _loc4_.v;
_loc9_.id = _loc4_.id;
_loc9_.normalX = _loc3_.normalX;
_loc9_.normalY = _loc3_.normalY;
_loc9_.normalZ = _loc3_.normalZ;
if(_loc3_.smoothingGroups > 0)
{
for each(_loc11_ in _loc6_[_loc4_])
{
if(_loc3_ != _loc11_ && (_loc3_.smoothingGroups & _loc11_.smoothingGroups) > 0)
{
_loc9_.normalX += _loc11_.normalX;
_loc9_.normalY += _loc11_.normalY;
_loc9_.normalZ += _loc11_.normalZ;
}
}
_loc10_ = _loc9_.normalX * _loc9_.normalX + _loc9_.normalY * _loc9_.normalY + _loc9_.normalZ * _loc9_.normalZ;
if(_loc10_ > 0.001)
{
_loc10_ = 1 / Math.sqrt(_loc10_);
_loc9_.normalX *= _loc10_;
_loc9_.normalY *= _loc10_;
_loc9_.normalZ *= _loc10_;
}
}
_loc5_.vertex = _loc9_;
_loc9_.next = this.vertexList;
this.vertexList = _loc9_;
_loc5_ = _loc5_.next;
}
_loc3_ = _loc3_.next;
}
}
private function calculateNormalsAndRemoveDegenerateFaces() : void
{
var _loc2_:Face = null;
var _loc3_:Wrapper = null;
var _loc4_:Vertex = null;
var _loc5_:Vertex = null;
var _loc6_:Vertex = null;
var _loc7_:Number = NaN;
var _loc8_:Number = NaN;
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc13_:Number = NaN;
var _loc1_:Face = this.faceList;
this.faceList = null;
while(_loc1_ != null)
{
_loc2_ = _loc1_.next;
_loc3_ = _loc1_.wrapper;
_loc4_ = _loc3_.vertex;
_loc3_ = _loc3_.next;
_loc5_ = _loc3_.vertex;
_loc3_ = _loc3_.next;
_loc6_ = _loc3_.vertex;
_loc7_ = _loc5_.x - _loc4_.x;
_loc8_ = _loc5_.y - _loc4_.y;
_loc9_ = _loc5_.z - _loc4_.z;
_loc10_ = _loc6_.x - _loc4_.x;
_loc11_ = _loc6_.y - _loc4_.y;
_loc12_ = _loc6_.z - _loc4_.z;
_loc1_.normalX = _loc12_ * _loc8_ - _loc11_ * _loc9_;
_loc1_.normalY = _loc10_ * _loc9_ - _loc12_ * _loc7_;
_loc1_.normalZ = _loc11_ * _loc7_ - _loc10_ * _loc8_;
_loc13_ = _loc1_.normalX * _loc1_.normalX + _loc1_.normalY * _loc1_.normalY + _loc1_.normalZ * _loc1_.normalZ;
if(_loc13_ > 0.001)
{
_loc13_ = 1 / Math.sqrt(_loc13_);
_loc1_.normalX *= _loc13_;
_loc1_.normalY *= _loc13_;
_loc1_.normalZ *= _loc13_;
_loc1_.offset = _loc4_.x * _loc1_.normalX + _loc4_.y * _loc1_.normalY + _loc4_.z * _loc1_.normalZ;
_loc1_.next = this.faceList;
this.faceList = _loc1_;
}
else
{
_loc1_.next = null;
}
_loc1_ = _loc2_;
}
}
public function optimizeForDynamicBSP(param1:int = 1) : void
{
var _loc3_:Face = null;
var _loc5_:Face = null;
var _loc6_:Face = null;
var _loc7_:Number = NaN;
var _loc8_:Number = NaN;
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc13_:int = 0;
var _loc14_:Face = null;
var _loc15_:Wrapper = null;
var _loc16_:Vertex = null;
var _loc17_:Vertex = null;
var _loc18_:Vertex = null;
var _loc19_:Number = NaN;
var _loc20_:Number = NaN;
var _loc21_:Number = NaN;
var _loc22_:Boolean = false;
var _loc23_:Boolean = false;
var _loc24_:Vertex = null;
var _loc25_:Number = NaN;
this.deleteResources();
var _loc2_:Face = this.faceList;
var _loc4_:int = 0;
while(_loc4_ < param1)
{
_loc5_ = null;
_loc6_ = _loc2_;
while(_loc6_ != null)
{
_loc7_ = _loc6_.normalX;
_loc8_ = _loc6_.normalY;
_loc9_ = _loc6_.normalZ;
_loc10_ = _loc6_.offset;
_loc11_ = _loc10_ - this.threshold;
_loc12_ = _loc10_ + this.threshold;
_loc13_ = 0;
_loc14_ = _loc2_;
while(_loc14_ != null)
{
if(_loc14_ != _loc6_)
{
_loc15_ = _loc14_.wrapper;
_loc16_ = _loc15_.vertex;
_loc15_ = _loc15_.next;
_loc17_ = _loc15_.vertex;
_loc15_ = _loc15_.next;
_loc18_ = _loc15_.vertex;
_loc15_ = _loc15_.next;
_loc19_ = _loc16_.x * _loc7_ + _loc16_.y * _loc8_ + _loc16_.z * _loc9_;
_loc20_ = _loc17_.x * _loc7_ + _loc17_.y * _loc8_ + _loc17_.z * _loc9_;
_loc21_ = _loc18_.x * _loc7_ + _loc18_.y * _loc8_ + _loc18_.z * _loc9_;
_loc22_ = _loc19_ < _loc11_ || _loc20_ < _loc11_ || _loc21_ < _loc11_;
_loc23_ = _loc19_ > _loc12_ || _loc20_ > _loc12_ || _loc21_ > _loc12_;
while(_loc15_ != null)
{
_loc24_ = _loc15_.vertex;
_loc25_ = _loc24_.x * _loc7_ + _loc24_.y * _loc8_ + _loc24_.z * _loc9_;
if(_loc25_ < _loc11_)
{
_loc22_ = true;
if(_loc23_)
{
break;
}
}
else if(_loc25_ > _loc12_)
{
_loc23_ = true;
if(_loc22_)
{
break;
}
}
_loc15_ = _loc15_.next;
}
if(_loc23_ && _loc22_)
{
_loc13_++;
if(_loc13_ > _loc4_)
{
break;
}
}
}
_loc14_ = _loc14_.next;
}
if(_loc14_ == null)
{
if(_loc5_ != null)
{
_loc5_.next = _loc6_.next;
}
else
{
_loc2_ = _loc6_.next;
}
if(_loc3_ != null)
{
_loc3_.next = _loc6_;
}
else
{
this.faceList = _loc6_;
}
_loc3_ = _loc6_;
}
else
{
_loc5_ = _loc6_;
}
_loc6_ = _loc6_.next;
}
if(_loc2_ == null)
{
break;
}
_loc4_++;
}
if(_loc3_ != null)
{
_loc3_.next = _loc2_;
}
}
override public function intersectRay(param1:Vector3D, param2:Vector3D, param3:Dictionary = null, param4:Camera3D = null) : RayIntersectionData
{
var _loc11_:Vector3D = null;
var _loc12_:Face = null;
var _loc15_:Number = NaN;
var _loc16_:Number = NaN;
var _loc17_:Number = NaN;
var _loc18_:Number = NaN;
var _loc19_:Number = NaN;
var _loc20_:Number = NaN;
var _loc21_:Number = NaN;
var _loc22_:Number = NaN;
var _loc23_:Number = NaN;
var _loc24_:Wrapper = null;
var _loc25_:Vertex = null;
var _loc26_:Vertex = null;
var _loc27_:Number = NaN;
var _loc28_:Number = NaN;
var _loc29_:Number = NaN;
var _loc30_:Number = NaN;
var _loc31_:Number = NaN;
var _loc32_:Number = NaN;
var _loc33_:RayIntersectionData = null;
if(param3 != null && param3[this])
{
return null;
}
if(!boundIntersectRay(param1,param2,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ))
{
return null;
}
var _loc5_:Number = param1.x;
var _loc6_:Number = param1.y;
var _loc7_:Number = param1.z;
var _loc8_:Number = param2.x;
var _loc9_:Number = param2.y;
var _loc10_:Number = param2.z;
var _loc13_:Number = 1e+22;
var _loc14_:Face = this.faceList;
while(_loc14_ != null)
{
_loc15_ = _loc14_.normalX;
_loc16_ = _loc14_.normalY;
_loc17_ = _loc14_.normalZ;
_loc18_ = _loc8_ * _loc15_ + _loc9_ * _loc16_ + _loc10_ * _loc17_;
if(_loc18_ < 0)
{
_loc19_ = _loc5_ * _loc15_ + _loc6_ * _loc16_ + _loc7_ * _loc17_ - _loc14_.offset;
if(_loc19_ > 0)
{
_loc20_ = -_loc19_ / _loc18_;
if(_loc11_ == null || _loc20_ < _loc13_)
{
_loc21_ = _loc5_ + _loc8_ * _loc20_;
_loc22_ = _loc6_ + _loc9_ * _loc20_;
_loc23_ = _loc7_ + _loc10_ * _loc20_;
_loc24_ = _loc14_.wrapper;
while(_loc24_ != null)
{
_loc25_ = _loc24_.vertex;
_loc26_ = _loc24_.next != null ? _loc24_.next.vertex : _loc14_.wrapper.vertex;
_loc27_ = _loc26_.x - _loc25_.x;
_loc28_ = _loc26_.y - _loc25_.y;
_loc29_ = _loc26_.z - _loc25_.z;
_loc30_ = _loc21_ - _loc25_.x;
_loc31_ = _loc22_ - _loc25_.y;
_loc32_ = _loc23_ - _loc25_.z;
if((_loc32_ * _loc28_ - _loc31_ * _loc29_) * _loc15_ + (_loc30_ * _loc29_ - _loc32_ * _loc27_) * _loc16_ + (_loc31_ * _loc27_ - _loc30_ * _loc28_) * _loc17_ < 0)
{
break;
}
_loc24_ = _loc24_.next;
}
if(_loc24_ == null)
{
if(_loc20_ < _loc13_)
{
_loc13_ = _loc20_;
if(_loc11_ == null)
{
_loc11_ = new Vector3D();
}
_loc11_.x = _loc21_;
_loc11_.y = _loc22_;
_loc11_.z = _loc23_;
_loc12_ = _loc14_;
}
}
}
}
}
_loc14_ = _loc14_.next;
}
if(_loc11_ != null)
{
_loc33_ = new RayIntersectionData();
_loc33_.object = this;
_loc33_.face = _loc12_;
_loc33_.point = _loc11_;
_loc33_.uv = _loc12_.getUV(_loc11_);
_loc33_.time = _loc13_;
return _loc33_;
}
return null;
}
override alternativa3d function checkIntersection(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Dictionary) : Boolean
{
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc13_:Number = NaN;
var _loc14_:Number = NaN;
var _loc15_:Number = NaN;
var _loc16_:Number = NaN;
var _loc17_:Number = NaN;
var _loc18_:Number = NaN;
var _loc19_:Wrapper = null;
var _loc20_:Vertex = null;
var _loc21_:Vertex = null;
var _loc22_:Number = NaN;
var _loc23_:Number = NaN;
var _loc24_:Number = NaN;
var _loc25_:Number = NaN;
var _loc26_:Number = NaN;
var _loc27_:Number = NaN;
var _loc9_:Face = null;
_loc10_ = NaN;
_loc11_ = NaN;
_loc12_ = NaN;
_loc13_ = NaN;
_loc14_ = NaN;
_loc15_ = NaN;
_loc16_ = NaN;
_loc17_ = NaN;
_loc18_ = NaN;
_loc19_ = null;
_loc20_ = null;
_loc21_ = null;
_loc22_ = NaN;
_loc23_ = NaN;
_loc24_ = NaN;
_loc25_ = NaN;
_loc26_ = NaN;
_loc27_ = NaN;
_loc9_ = this.faceList;
while(true)
{
if(_loc9_ == null)
{
return false;
}
_loc10_ = _loc9_.normalX;
_loc11_ = _loc9_.normalY;
_loc12_ = _loc9_.normalZ;
_loc13_ = param4 * _loc10_ + param5 * _loc11_ + param6 * _loc12_;
if(_loc13_ < 0)
{
_loc14_ = param1 * _loc10_ + param2 * _loc11_ + param3 * _loc12_ - _loc9_.offset;
if(_loc14_ > 0)
{
_loc15_ = -_loc14_ / _loc13_;
if(_loc15_ < param7)
{
_loc16_ = param1 + param4 * _loc15_;
_loc17_ = param2 + param5 * _loc15_;
_loc18_ = param3 + param6 * _loc15_;
_loc19_ = _loc9_.wrapper;
while(_loc19_ != null)
{
_loc20_ = _loc19_.vertex;
_loc21_ = _loc19_.next != null ? _loc19_.next.vertex : _loc9_.wrapper.vertex;
_loc22_ = _loc21_.x - _loc20_.x;
_loc23_ = _loc21_.y - _loc20_.y;
_loc24_ = _loc21_.z - _loc20_.z;
_loc25_ = _loc16_ - _loc20_.x;
_loc26_ = _loc17_ - _loc20_.y;
_loc27_ = _loc18_ - _loc20_.z;
if((_loc27_ * _loc23_ - _loc26_ * _loc24_) * _loc10_ + (_loc25_ * _loc24_ - _loc27_ * _loc22_) * _loc11_ + (_loc26_ * _loc22_ - _loc25_ * _loc23_) * _loc12_ < 0)
{
break;
}
_loc19_ = _loc19_.next;
}
if(_loc19_ == null)
{
break;
}
}
}
}
_loc9_ = _loc9_.next;
}
return true;
}
override alternativa3d function collectPlanes(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Vector3D, param5:Vector3D, param6:Vector.<Face>, param7:Dictionary = null) : void
{
var _loc9_:Vertex = null;
var _loc11_:Number = NaN;
var _loc12_:Wrapper = null;
var _loc8_:Vector3D = null;
var _loc10_:Face = null;
_loc9_ = null;
_loc11_ = NaN;
_loc12_ = null;
if(param7 != null && param7[this])
{
return;
}
_loc8_ = calculateSphere(param1,param2,param3,param4,param5);
if(!boundIntersectSphere(_loc8_,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ))
{
return;
}
if(transformId > 500000000)
{
transformId = 0;
_loc9_ = this.vertexList;
while(_loc9_ != null)
{
_loc9_.transformId = 0;
_loc9_ = _loc9_.next;
}
}
++transformId;
_loc10_ = this.faceList;
while(_loc10_ != null)
{
_loc11_ = _loc8_.x * _loc10_.normalX + _loc8_.y * _loc10_.normalY + _loc8_.z * _loc10_.normalZ - _loc10_.offset;
if(_loc11_ < _loc8_.w && _loc11_ > -_loc8_.w)
{
_loc12_ = _loc10_.wrapper;
while(_loc12_ != null)
{
_loc9_ = _loc12_.vertex;
if(_loc9_.transformId != transformId)
{
_loc9_.cameraX = ma * _loc9_.x + mb * _loc9_.y + mc * _loc9_.z + md;
_loc9_.cameraY = me * _loc9_.x + mf * _loc9_.y + mg * _loc9_.z + mh;
_loc9_.cameraZ = mi * _loc9_.x + mj * _loc9_.y + mk * _loc9_.z + ml;
_loc9_.transformId = transformId;
}
_loc12_ = _loc12_.next;
}
param6.push(_loc10_);
}
_loc10_ = _loc10_.next;
}
}
override public function clone() : Object3D
{
var _loc1_:Mesh = null;
_loc1_ = new Mesh();
_loc1_.clonePropertiesFrom(this);
return _loc1_;
}
override protected function clonePropertiesFrom(param1:Object3D) : void
{
var _loc3_:Vertex = null;
var _loc4_:Vertex = null;
var _loc5_:Face = null;
var _loc7_:Vertex = null;
var _loc8_:Face = null;
var _loc9_:Wrapper = null;
var _loc10_:Wrapper = null;
var _loc11_:Wrapper = null;
var _loc2_:Mesh = null;
var _loc6_:Face = null;
_loc3_ = null;
_loc4_ = null;
_loc5_ = null;
_loc7_ = null;
_loc8_ = null;
_loc9_ = null;
_loc10_ = null;
_loc11_ = null;
super.clonePropertiesFrom(param1);
_loc2_ = param1 as Mesh;
this.clipping = _loc2_.clipping;
this.sorting = _loc2_.sorting;
this.threshold = _loc2_.threshold;
_loc3_ = _loc2_.vertexList;
while(_loc3_ != null)
{
_loc7_ = new Vertex();
_loc7_.x = _loc3_.x;
_loc7_.y = _loc3_.y;
_loc7_.z = _loc3_.z;
_loc7_.u = _loc3_.u;
_loc7_.v = _loc3_.v;
_loc7_.normalX = _loc3_.normalX;
_loc7_.normalY = _loc3_.normalY;
_loc7_.normalZ = _loc3_.normalZ;
_loc7_.offset = _loc3_.offset;
_loc7_.id = _loc3_.id;
_loc3_.value = _loc7_;
if(_loc4_ != null)
{
_loc4_.next = _loc7_;
}
else
{
this.vertexList = _loc7_;
}
_loc4_ = _loc7_;
_loc3_ = _loc3_.next;
}
_loc6_ = _loc2_.faceList;
while(_loc6_ != null)
{
_loc8_ = new Face();
_loc8_.material = _loc6_.material;
_loc8_.smoothingGroups = _loc6_.smoothingGroups;
_loc8_.id = _loc6_.id;
_loc8_.normalX = _loc6_.normalX;
_loc8_.normalY = _loc6_.normalY;
_loc8_.normalZ = _loc6_.normalZ;
_loc8_.offset = _loc6_.offset;
_loc9_ = null;
_loc10_ = _loc6_.wrapper;
while(_loc10_ != null)
{
_loc11_ = new Wrapper();
_loc11_.vertex = _loc10_.vertex.value;
if(_loc9_ != null)
{
_loc9_.next = _loc11_;
}
else
{
_loc8_.wrapper = _loc11_;
}
_loc9_ = _loc11_;
_loc10_ = _loc10_.next;
}
if(_loc5_ != null)
{
_loc5_.next = _loc8_;
}
else
{
this.faceList = _loc8_;
}
_loc5_ = _loc8_;
_loc6_ = _loc6_.next;
}
_loc3_ = _loc2_.vertexList;
while(_loc3_ != null)
{
_loc3_.value = null;
_loc3_ = _loc3_.next;
}
}
override alternativa3d function draw(param1:Camera3D) : void
{
var _loc2_:Face = null;
var _loc4_:Vertex = null;
var _loc3_:int = 0;
_loc2_ = null;
_loc4_ = null;
if(this.faceList == null)
{
return;
}
if(this.clipping == 0)
{
if(culling & 1)
{
return;
}
culling = 0;
}
this.prepareResources();
if(useDepth = !param1.view.constrained && (param1.softTransparency && param1.softTransparencyStrength > 0 || param1.ssao && param1.ssaoStrength > 0 || param1.deferredLighting && param1.deferredLightingStrength > 0) && concatenatedAlpha >= depthMapAlphaThreshold)
{
param1.depthObjects[param1.depthCount] = this;
++param1.depthCount;
}
if(concatenatedAlpha >= 1 && concatenatedBlendMode == "normal")
{
this.addOpaque(param1);
_loc2_ = this.transparentList;
}
else
{
_loc2_ = this.faceList;
}
transformConst[0] = ma;
transformConst[1] = mb;
transformConst[2] = mc;
transformConst[3] = md;
transformConst[4] = me;
transformConst[5] = mf;
transformConst[6] = mg;
transformConst[7] = mh;
transformConst[8] = mi;
transformConst[9] = mj;
transformConst[10] = mk;
transformConst[11] = ml;
_loc3_ = !!param1.debug ? int(int(param1.checkInDebug(this))) : int(int(0));
if(_loc3_ & Debug.BOUNDS)
{
Debug.drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ);
}
if(_loc2_ == null)
{
return;
}
if(transformId > 500000000)
{
transformId = 0;
_loc4_ = this.vertexList;
while(_loc4_ != null)
{
_loc4_.transformId = 0;
_loc4_ = _loc4_.next;
}
}
++transformId;
calculateInverseMatrix();
_loc2_ = this.prepareFaces(param1,_loc2_);
if(_loc2_ == null)
{
return;
}
if(culling > 0)
{
if(this.clipping == 1)
{
_loc2_ = param1.cull(_loc2_,culling);
}
else
{
_loc2_ = param1.clip(_loc2_,culling);
}
if(_loc2_ == null)
{
return;
}
}
if(_loc2_.processNext != null)
{
if(this.sorting == 1)
{
_loc2_ = param1.sortByAverageZ(_loc2_);
}
else if(this.sorting == 2)
{
_loc2_ = param1.sortByDynamicBSP(_loc2_,this.threshold);
}
}
if(_loc3_ & Debug.EDGES)
{
Debug.drawEdges(param1,_loc2_,16777215);
}
this.drawFaces(param1,_loc2_);
}
override alternativa3d function getVG(param1:Camera3D) : VG
{
var _loc2_:Face = null;
var _loc4_:Vertex = null;
var _loc3_:int = 0;
_loc2_ = null;
_loc4_ = null;
if(this.faceList == null)
{
return null;
}
if(this.clipping == 0)
{
if(culling & 1)
{
return null;
}
culling = 0;
}
this.prepareResources();
if(useDepth = !param1.view.constrained && (param1.softTransparency && param1.softTransparencyStrength > 0 || param1.ssao && param1.ssaoStrength > 0 || param1.deferredLighting && param1.deferredLightingStrength > 0) && concatenatedAlpha >= depthMapAlphaThreshold)
{
param1.depthObjects[param1.depthCount] = this;
++param1.depthCount;
}
if(concatenatedAlpha >= 1 && concatenatedBlendMode == "normal")
{
this.addOpaque(param1);
_loc2_ = this.transparentList;
}
else
{
_loc2_ = this.faceList;
}
transformConst[0] = ma;
transformConst[1] = mb;
transformConst[2] = mc;
transformConst[3] = md;
transformConst[4] = me;
transformConst[5] = mf;
transformConst[6] = mg;
transformConst[7] = mh;
transformConst[8] = mi;
transformConst[9] = mj;
transformConst[10] = mk;
transformConst[11] = ml;
_loc3_ = !!param1.debug ? int(int(param1.checkInDebug(this))) : int(int(0));
if(_loc3_ & Debug.BOUNDS)
{
Debug.drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ);
}
if(_loc2_ == null)
{
return null;
}
if(transformId > 500000000)
{
transformId = 0;
_loc4_ = this.vertexList;
while(_loc4_ != null)
{
_loc4_.transformId = 0;
_loc4_ = _loc4_.next;
}
}
++transformId;
calculateInverseMatrix();
_loc2_ = this.prepareFaces(param1,_loc2_);
if(_loc2_ == null)
{
return null;
}
if(culling > 0)
{
if(this.clipping == 1)
{
_loc2_ = param1.cull(_loc2_,culling);
}
else
{
_loc2_ = param1.clip(_loc2_,culling);
}
if(_loc2_ == null)
{
return null;
}
}
return VG.create(this,_loc2_,this.sorting,_loc3_,false);
}
alternativa3d function prepareResources() : void
{
var _loc1_:Vector.<Number> = null;
var _loc2_:int = 0;
var _loc3_:int = 0;
var _loc4_:Vertex = null;
var _loc5_:int = 0;
var _loc6_:int = 0;
var _loc7_:int = 0;
var _loc8_:Face = null;
var _loc9_:Face = null;
var _loc10_:Face = null;
var _loc11_:Wrapper = null;
var _loc12_:Dictionary = null;
var _loc13_:Vector.<uint> = null;
var _loc14_:int = 0;
var _loc15_:* = undefined;
var _loc16_:Face = null;
_loc1_ = null;
_loc2_ = 0;
_loc3_ = 0;
_loc4_ = null;
_loc5_ = 0;
_loc6_ = 0;
_loc7_ = 0;
_loc8_ = null;
_loc9_ = null;
_loc10_ = null;
_loc11_ = null;
_loc12_ = null;
_loc13_ = null;
_loc14_ = 0;
_loc15_ = undefined;
_loc16_ = null;
if(this.vertexBuffer == null)
{
_loc1_ = new Vector.<Number>();
_loc2_ = 0;
_loc3_ = 0;
_loc4_ = this.vertexList;
while(_loc4_ != null)
{
_loc1_[_loc2_] = _loc4_.x;
_loc2_++;
_loc1_[_loc2_] = _loc4_.y;
_loc2_++;
_loc1_[_loc2_] = _loc4_.z;
_loc2_++;
_loc1_[_loc2_] = _loc4_.u;
_loc2_++;
_loc1_[_loc2_] = _loc4_.v;
_loc2_++;
_loc1_[_loc2_] = _loc4_.normalX;
_loc2_++;
_loc1_[_loc2_] = _loc4_.normalY;
_loc2_++;
_loc1_[_loc2_] = _loc4_.normalZ;
_loc2_++;
_loc4_.index = _loc3_;
_loc3_++;
_loc4_ = _loc4_.next;
}
if(_loc3_ > 0)
{
this.vertexBuffer = new VertexBufferResource(_loc1_,8);
}
_loc12_ = new Dictionary();
_loc8_ = this.faceList;
while(_loc8_ != null)
{
_loc9_ = _loc8_.next;
_loc8_.next = null;
if(_loc8_.material != null && (!_loc8_.material.transparent || _loc8_.material.alphaTestThreshold > 0))
{
_loc8_.next = _loc12_[_loc8_.material];
_loc12_[_loc8_.material] = _loc8_;
}
else
{
if(_loc10_ != null)
{
_loc10_.next = _loc8_;
}
else
{
this.transparentList = _loc8_;
}
_loc10_ = _loc8_;
}
_loc8_ = _loc9_;
}
this.faceList = this.transparentList;
_loc13_ = new Vector.<uint>();
_loc14_ = 0;
for(_loc15_ in _loc12_)
{
_loc16_ = _loc12_[_loc15_];
this.opaqueMaterials[this.opaqueLength] = _loc16_.material;
this.opaqueBegins[this.opaqueLength] = this.numTriangles * 3;
_loc8_ = _loc16_;
while(_loc8_ != null)
{
_loc11_ = _loc8_.wrapper;
_loc5_ = _loc11_.vertex.index;
_loc11_ = _loc11_.next;
_loc6_ = _loc11_.vertex.index;
_loc11_ = _loc11_.next;
while(_loc11_ != null)
{
_loc7_ = _loc11_.vertex.index;
_loc13_[_loc14_] = _loc5_;
_loc14_++;
_loc13_[_loc14_] = _loc6_;
_loc14_++;
_loc13_[_loc14_] = _loc7_;
_loc14_++;
_loc6_ = _loc7_;
++this.numTriangles;
_loc11_ = _loc11_.next;
}
if(_loc8_.next == null)
{
_loc10_ = _loc8_;
}
_loc8_ = _loc8_.next;
}
this.opaqueNums[this.opaqueLength] = this.numTriangles - this.opaqueBegins[this.opaqueLength] / 3;
++this.opaqueLength;
_loc10_.next = this.faceList;
this.faceList = _loc16_;
}
this.numOpaqueTriangles = this.numTriangles;
_loc8_ = this.transparentList;
while(_loc8_ != null)
{
_loc11_ = _loc8_.wrapper;
_loc5_ = _loc11_.vertex.index;
_loc11_ = _loc11_.next;
_loc6_ = _loc11_.vertex.index;
_loc11_ = _loc11_.next;
while(_loc11_ != null)
{
_loc7_ = _loc11_.vertex.index;
_loc13_[_loc14_] = _loc5_;
_loc14_++;
_loc13_[_loc14_] = _loc6_;
_loc14_++;
_loc13_[_loc14_] = _loc7_;
_loc14_++;
_loc6_ = _loc7_;
++this.numTriangles;
_loc11_ = _loc11_.next;
}
_loc8_ = _loc8_.next;
}
if(_loc14_ > 0)
{
this.indexBuffer = new IndexBufferResource(_loc13_);
}
}
}
alternativa3d function deleteResources() : void
{
if(this.vertexBuffer != null)
{
this.vertexBuffer.dispose();
this.vertexBuffer = null;
this.indexBuffer.dispose();
this.indexBuffer = null;
this.numTriangles = 0;
this.numOpaqueTriangles = 0;
this.opaqueMaterials.length = 0;
this.opaqueBegins.length = 0;
this.opaqueNums.length = 0;
this.opaqueLength = 0;
this.transparentList = null;
}
}
alternativa3d function addOpaque(param1:Camera3D) : void
{
var _loc2_:int = 0;
_loc2_ = 0;
while(_loc2_ < this.opaqueLength)
{
param1.addOpaque(this.opaqueMaterials[_loc2_],this.vertexBuffer,this.indexBuffer,this.opaqueBegins[_loc2_],this.opaqueNums[_loc2_],this);
_loc2_++;
}
}
alternativa3d function prepareFaces(param1:Camera3D, param2:Face) : Face
{
var _loc3_:Face = null;
var _loc4_:Face = null;
var _loc5_:Face = null;
var _loc6_:Wrapper = null;
var _loc7_:Vertex = null;
var _loc8_:Number = NaN;
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
_loc3_ = null;
_loc4_ = null;
_loc5_ = null;
_loc6_ = null;
_loc7_ = null;
_loc8_ = NaN;
_loc9_ = NaN;
_loc10_ = NaN;
_loc5_ = param2;
while(_loc5_ != null)
{
if(_loc5_.normalX * imd + _loc5_.normalY * imh + _loc5_.normalZ * iml > _loc5_.offset)
{
_loc6_ = _loc5_.wrapper;
while(_loc6_ != null)
{
_loc7_ = _loc6_.vertex;
if(_loc7_.transformId != transformId)
{
_loc8_ = _loc7_.x;
_loc9_ = _loc7_.y;
_loc10_ = _loc7_.z;
_loc7_.cameraX = ma * _loc8_ + mb * _loc9_ + mc * _loc10_ + md;
_loc7_.cameraY = me * _loc8_ + mf * _loc9_ + mg * _loc10_ + mh;
_loc7_.cameraZ = mi * _loc8_ + mj * _loc9_ + mk * _loc10_ + ml;
_loc7_.transformId = transformId;
_loc7_.drawId = 0;
}
_loc6_ = _loc6_.next;
}
if(_loc3_ != null)
{
_loc4_.processNext = _loc5_;
}
else
{
_loc3_ = _loc5_;
}
_loc4_ = _loc5_;
}
_loc5_ = _loc5_.next;
}
if(_loc4_ != null)
{
_loc4_.processNext = null;
}
return _loc3_;
}
alternativa3d function drawFaces(param1:Camera3D, param2:Face) : void
{
var _loc3_:Face = null;
var _loc4_:Face = null;
var _loc5_:Face = null;
_loc3_ = null;
_loc4_ = null;
_loc5_ = null;
_loc5_ = param2;
while(_loc5_ != null)
{
_loc3_ = _loc5_.processNext;
if(_loc3_ == null || _loc3_.material != param2.material)
{
_loc5_.processNext = null;
if(param2.material != null)
{
param2.processNegative = _loc4_;
_loc4_ = param2;
}
else
{
while(param2 != null)
{
_loc5_ = param2.processNext;
param2.processNext = null;
param2 = _loc5_;
}
}
param2 = _loc3_;
}
_loc5_ = _loc3_;
}
param2 = _loc4_;
while(param2 != null)
{
_loc3_ = param2.processNegative;
param2.processNegative = null;
param1.addTransparent(param2,this);
param2 = _loc3_;
}
}
override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void
{
var _loc3_:Vertex = null;
_loc3_ = null;
_loc3_ = this.vertexList;
while(_loc3_ != null)
{
if(param2 != null)
{
_loc3_.cameraX = param2.ma * _loc3_.x + param2.mb * _loc3_.y + param2.mc * _loc3_.z + param2.md;
_loc3_.cameraY = param2.me * _loc3_.x + param2.mf * _loc3_.y + param2.mg * _loc3_.z + param2.mh;
_loc3_.cameraZ = param2.mi * _loc3_.x + param2.mj * _loc3_.y + param2.mk * _loc3_.z + param2.ml;
}
else
{
_loc3_.cameraX = _loc3_.x;
_loc3_.cameraY = _loc3_.y;
_loc3_.cameraZ = _loc3_.z;
}
if(_loc3_.cameraX < param1.boundMinX)
{
param1.boundMinX = _loc3_.cameraX;
}
if(_loc3_.cameraX > param1.boundMaxX)
{
param1.boundMaxX = _loc3_.cameraX;
}
if(_loc3_.cameraY < param1.boundMinY)
{
param1.boundMinY = _loc3_.cameraY;
}
if(_loc3_.cameraY > param1.boundMaxY)
{
param1.boundMaxY = _loc3_.cameraY;
}
if(_loc3_.cameraZ < param1.boundMinZ)
{
param1.boundMinZ = _loc3_.cameraZ;
}
if(_loc3_.cameraZ > param1.boundMaxZ)
{
param1.boundMaxZ = _loc3_.cameraZ;
}
_loc3_ = _loc3_.next;
}
}
override alternativa3d function split(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Number) : Vector.<Object3D>
{
var _loc5_:Vector.<Object3D> = null;
var _loc6_:Vector3D = null;
var _loc7_:Number = NaN;
var _loc8_:Number = NaN;
var _loc9_:Vertex = null;
var _loc10_:Vertex = null;
var _loc11_:Face = null;
var _loc12_:Mesh = null;
var _loc13_:Mesh = null;
var _loc14_:Face = null;
var _loc15_:Face = null;
var _loc16_:Face = null;
var _loc17_:Face = null;
var _loc18_:Wrapper = null;
var _loc19_:Vertex = null;
var _loc20_:Vertex = null;
var _loc21_:Vertex = null;
var _loc22_:Boolean = false;
var _loc23_:Boolean = false;
var _loc24_:Face = null;
var _loc25_:Face = null;
var _loc26_:Wrapper = null;
var _loc27_:Wrapper = null;
var _loc28_:Wrapper = null;
var _loc29_:Number = NaN;
var _loc30_:Vertex = null;
_loc5_ = null;
_loc6_ = null;
_loc7_ = NaN;
_loc8_ = NaN;
_loc9_ = null;
_loc10_ = null;
_loc11_ = null;
_loc12_ = null;
_loc13_ = null;
_loc14_ = null;
_loc15_ = null;
_loc16_ = null;
_loc17_ = null;
_loc18_ = null;
_loc19_ = null;
_loc20_ = null;
_loc21_ = null;
_loc22_ = false;
_loc23_ = false;
_loc24_ = null;
_loc25_ = null;
_loc26_ = null;
_loc27_ = null;
_loc28_ = null;
_loc29_ = NaN;
_loc30_ = null;
this.deleteResources();
_loc5_ = new Vector.<Object3D>(2);
_loc6_ = calculatePlane(param1,param2,param3);
_loc7_ = _loc6_.w - param4;
_loc8_ = _loc6_.w + param4;
_loc9_ = this.vertexList;
while(_loc9_ != null)
{
_loc10_ = _loc9_.next;
_loc9_.next = null;
_loc9_.offset = _loc9_.x * _loc6_.x + _loc9_.y * _loc6_.y + _loc9_.z * _loc6_.z;
if(_loc9_.offset >= _loc7_ && _loc9_.offset <= _loc8_)
{
_loc9_.value = new Vertex();
_loc9_.value.x = _loc9_.x;
_loc9_.value.y = _loc9_.y;
_loc9_.value.z = _loc9_.z;
_loc9_.value.u = _loc9_.u;
_loc9_.value.v = _loc9_.v;
_loc9_.value.normalX = _loc9_.normalX;
_loc9_.value.normalY = _loc9_.normalY;
_loc9_.value.normalZ = _loc9_.normalZ;
}
_loc9_.transformId = 0;
_loc9_ = _loc10_;
}
this.vertexList = null;
_loc11_ = this.faceList;
this.faceList = null;
_loc12_ = this.clone() as Mesh;
_loc13_ = this.clone() as Mesh;
_loc16_ = _loc11_;
while(_loc16_ != null)
{
_loc17_ = _loc16_.next;
_loc18_ = _loc16_.wrapper;
_loc19_ = _loc18_.vertex;
_loc18_ = _loc18_.next;
_loc20_ = _loc18_.vertex;
_loc18_ = _loc18_.next;
_loc21_ = _loc18_.vertex;
_loc22_ = _loc19_.offset < _loc7_ || _loc20_.offset < _loc7_ || _loc21_.offset < _loc7_;
_loc23_ = _loc19_.offset > _loc8_ || _loc20_.offset > _loc8_ || _loc21_.offset > _loc8_;
_loc18_ = _loc18_.next;
while(_loc18_ != null)
{
_loc9_ = _loc18_.vertex;
if(_loc9_.offset < _loc7_)
{
_loc22_ = true;
}
else if(_loc9_.offset > _loc8_)
{
_loc23_ = true;
}
_loc18_ = _loc18_.next;
}
if(!_loc22_)
{
if(_loc15_ != null)
{
_loc15_.next = _loc16_;
}
else
{
_loc13_.faceList = _loc16_;
}
_loc15_ = _loc16_;
}
else if(!_loc23_)
{
if(_loc14_ != null)
{
_loc14_.next = _loc16_;
}
else
{
_loc12_.faceList = _loc16_;
}
_loc14_ = _loc16_;
_loc18_ = _loc16_.wrapper;
while(_loc18_ != null)
{
if(_loc18_.vertex.value != null)
{
_loc18_.vertex = _loc18_.vertex.value;
}
_loc18_ = _loc18_.next;
}
}
else
{
_loc24_ = new Face();
_loc25_ = new Face();
_loc26_ = null;
_loc27_ = null;
_loc18_ = _loc16_.wrapper.next.next;
while(_loc18_.next != null)
{
_loc18_ = _loc18_.next;
}
_loc19_ = _loc18_.vertex;
_loc18_ = _loc16_.wrapper;
while(_loc18_ != null)
{
_loc20_ = _loc18_.vertex;
if(_loc19_.offset < _loc7_ && _loc20_.offset > _loc8_ || _loc19_.offset > _loc8_ && _loc20_.offset < _loc7_)
{
_loc29_ = (_loc6_.w - _loc19_.offset) / (_loc20_.offset - _loc19_.offset);
_loc9_ = new Vertex();
_loc9_.x = _loc19_.x + (_loc20_.x - _loc19_.x) * _loc29_;
_loc9_.y = _loc19_.y + (_loc20_.y - _loc19_.y) * _loc29_;
_loc9_.z = _loc19_.z + (_loc20_.z - _loc19_.z) * _loc29_;
_loc9_.u = _loc19_.u + (_loc20_.u - _loc19_.u) * _loc29_;
_loc9_.v = _loc19_.v + (_loc20_.v - _loc19_.v) * _loc29_;
_loc9_.normalX = _loc19_.normalX + (_loc20_.normalX - _loc19_.normalX) * _loc29_;
_loc9_.normalY = _loc19_.normalY + (_loc20_.normalY - _loc19_.normalY) * _loc29_;
_loc9_.normalZ = _loc19_.normalZ + (_loc20_.normalZ - _loc19_.normalZ) * _loc29_;
_loc28_ = new Wrapper();
_loc28_.vertex = _loc9_;
if(_loc26_ != null)
{
_loc26_.next = _loc28_;
}
else
{
_loc24_.wrapper = _loc28_;
}
_loc26_ = _loc28_;
_loc30_ = new Vertex();
_loc30_.x = _loc9_.x;
_loc30_.y = _loc9_.y;
_loc30_.z = _loc9_.z;
_loc30_.u = _loc9_.u;
_loc30_.v = _loc9_.v;
_loc30_.normalX = _loc9_.normalX;
_loc30_.normalY = _loc9_.normalY;
_loc30_.normalZ = _loc9_.normalZ;
_loc28_ = new Wrapper();
_loc28_.vertex = _loc30_;
if(_loc27_ != null)
{
_loc27_.next = _loc28_;
}
else
{
_loc25_.wrapper = _loc28_;
}
_loc27_ = _loc28_;
}
if(_loc20_.offset < _loc7_)
{
_loc28_ = _loc18_.create();
_loc28_.vertex = _loc20_;
if(_loc26_ != null)
{
_loc26_.next = _loc28_;
}
else
{
_loc24_.wrapper = _loc28_;
}
_loc26_ = _loc28_;
}
else if(_loc20_.offset > _loc8_)
{
_loc28_ = _loc18_.create();
_loc28_.vertex = _loc20_;
if(_loc27_ != null)
{
_loc27_.next = _loc28_;
}
else
{
_loc25_.wrapper = _loc28_;
}
_loc27_ = _loc28_;
}
else
{
_loc28_ = _loc18_.create();
_loc28_.vertex = _loc20_.value;
if(_loc26_ != null)
{
_loc26_.next = _loc28_;
}
else
{
_loc24_.wrapper = _loc28_;
}
_loc26_ = _loc28_;
_loc28_ = _loc18_.create();
_loc28_.vertex = _loc20_;
if(_loc27_ != null)
{
_loc27_.next = _loc28_;
}
else
{
_loc25_.wrapper = _loc28_;
}
_loc27_ = _loc28_;
}
_loc19_ = _loc20_;
_loc18_ = _loc18_.next;
}
_loc24_.material = _loc16_.material;
_loc24_.calculateBestSequenceAndNormal();
if(_loc14_ != null)
{
_loc14_.next = _loc24_;
}
else
{
_loc12_.faceList = _loc24_;
}
_loc14_ = _loc24_;
_loc25_.material = _loc16_.material;
_loc25_.calculateBestSequenceAndNormal();
if(_loc15_ != null)
{
_loc15_.next = _loc25_;
}
else
{
_loc13_.faceList = _loc25_;
}
_loc15_ = _loc25_;
}
_loc16_ = _loc17_;
}
if(_loc14_ != null)
{
_loc14_.next = null;
++_loc12_.transformId;
_loc12_.collectVertices();
_loc12_.calculateBounds();
_loc5_[0] = _loc12_;
}
if(_loc15_ != null)
{
_loc15_.next = null;
++_loc13_.transformId;
_loc13_.collectVertices();
_loc13_.calculateBounds();
_loc5_[1] = _loc13_;
}
return _loc5_;
}
private function collectVertices() : void
{
var _loc1_:Face = null;
var _loc2_:Wrapper = null;
var _loc3_:Vertex = null;
_loc1_ = null;
_loc2_ = null;
_loc3_ = null;
_loc1_ = this.faceList;
while(_loc1_ != null)
{
_loc2_ = _loc1_.wrapper;
while(_loc2_ != null)
{
_loc3_ = _loc2_.vertex;
if(_loc3_.transformId != transformId)
{
_loc3_.next = this.vertexList;
this.vertexList = _loc3_;
_loc3_.transformId = transformId;
_loc3_.value = null;
}
_loc2_ = _loc2_.next;
}
_loc1_ = _loc1_.next;
}
}
override public function destroy() : void
{
var textMat:TextureMaterial = null;
var buf:Vertex = null;
var buf1:Face = null;
this.deleteResources();
textMat = this.material as TextureMaterial;
if(textMat != null)
{
textMat.dispose();
textMat = null;
}
if(this.vertexList != null)
{
while(this.vertexList.next != null)
{
buf = this.vertexList;
this.vertexList = null;
this.vertexList = buf.next;
}
this.vertexList = null;
}
if(this.faceList != null)
{
while(this.faceList.next != null)
{
buf1 = this.faceList;
this.faceList.destroy();
this.faceList = null;
this.faceList = buf1.next;
}
this.faceList = null;
}
captureListeners = null;
bubbleListeners = null;
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _4d9401e592a2288fb86b8f55f39cf6aaecc1ea0b91f7d0259511f2924613b1cd_flash_display_Sprite extends Sprite {
public function _4d9401e592a2288fb86b8f55f39cf6aaecc1ea0b91f7d0259511f2924613b1cd_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package projects.tanks.client.tanksservices.model.notifier.battle {
import alternativa.types.Long;
public interface IBattleNotifierModelBase {
function leaveBattle(param1:Long) : void;
function leaveGroup(param1:Long) : void;
function setBattle(param1:Vector.<BattleNotifierData>) : void;
}
}
|
package projects.tanks.client.garage.models.item.countable {
public interface ICountableItemModelBase {
}
}
|
package resources.windowheaders.background {
import flash.display.BitmapData;
public class BackgroundHeader {
private static const shortBackgroundHeaderClass:Class = BackgroundHeader_shortBackgroundHeaderClass;
public static const shortBackgroundHeader:BitmapData = new shortBackgroundHeaderClass().bitmapData;
private static const longBackgroundHeaderClass:Class = BackgroundHeader_longBackgroundHeaderClass;
public static const longBackgroundHeader:BitmapData = new longBackgroundHeaderClass().bitmapData;
private static const verticalBackgroundHeaderClass:Class = BackgroundHeader_verticalBackgroundHeaderClass;
public static const verticalBackgroundHeader:BitmapData = new verticalBackgroundHeaderClass().bitmapData;
public function BackgroundHeader() {
super();
}
}
}
|
package alternativa.tanks.model.payment.modes {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
public class PayModeEvents implements PayMode {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function PayModeEvents(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:PayMode = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayMode(this.impl[i]);
result = m.getName();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getDescription() : String {
var result:String = null;
var i:int = 0;
var m:PayMode = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayMode(this.impl[i]);
result = m.getDescription();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function hasCustomManualDescription() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:PayMode = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayMode(this.impl[i]);
result = Boolean(m.hasCustomManualDescription());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getCustomManualDescription() : String {
var result:String = null;
var i:int = 0;
var m:PayMode = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayMode(this.impl[i]);
result = m.getCustomManualDescription();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getOrderIndex() : int {
var result:int = 0;
var i:int = 0;
var m:PayMode = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayMode(this.impl[i]);
result = int(m.getOrderIndex());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getImage() : ImageResource {
var result:ImageResource = null;
var i:int = 0;
var m:PayMode = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayMode(this.impl[i]);
result = m.getImage();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function isDiscount() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:PayMode = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayMode(this.impl[i]);
result = Boolean(m.isDiscount());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function setDiscount(param1:Boolean) : void {
var i:int = 0;
var m:PayMode = null;
var value:Boolean = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayMode(this.impl[i]);
m.setDiscount(value);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.services.lightingeffects {
import alternativa.tanks.models.teamlight.ModeLight;
import alternativa.tanks.models.teamlight.TeamLightColor;
import flash.geom.ColorTransform;
import projects.tanks.client.battleservice.BattleMode;
import projects.tanks.clients.flash.commons.models.gpu.GPUCapabilities;
public class LightingEffectsService implements ILightingEffectsService {
private var modes:Vector.<ModeLight> = new Vector.<ModeLight>(BattleMode.values.length,true);
private var bonusLightIntensity:Number;
private var bonusColorAdjust:ColorTransform;
public function LightingEffectsService() {
super();
var local1:int = 0;
while(local1 < this.modes.length) {
this.modes[local1] = new ModeLight(new TeamLightColor(0,0),new TeamLightColor(0,0),new TeamLightColor(0,0),0,0);
local1++;
}
}
public function setLightForMode(param1:BattleMode, param2:ModeLight) : void {
this.modes[param1.value] = param2;
}
public function getLightForMode(param1:BattleMode) : ModeLight {
return this.modes[param1.value];
}
public function setBonusLighting(param1:Number, param2:ColorTransform, param3:ColorTransform) : void {
this.bonusLightIntensity = param1;
if(GPUCapabilities.gpuEnabled) {
this.bonusColorAdjust = param2;
} else {
this.bonusColorAdjust = param3;
}
}
public function getBonusLightIntensity() : Number {
return this.bonusLightIntensity;
}
public function getBonusColorAdjust() : ColorTransform {
return this.bonusColorAdjust;
}
}
}
|
package alternativa.osgi.service.logging {
public interface LogTarget {
function log(param1:Object, param2:LogLevel, param3:String, param4:Array = null) : void;
}
}
|
package projects.tanks.client.garage.models.garage.passtoshop {
public class PassToShopCC {
private var _passToShopEnabled:Boolean;
public function PassToShopCC(param1:Boolean = false) {
super();
this._passToShopEnabled = param1;
}
public function get passToShopEnabled() : Boolean {
return this._passToShopEnabled;
}
public function set passToShopEnabled(param1:Boolean) : void {
this._passToShopEnabled = param1;
}
public function toString() : String {
var local1:String = "PassToShopCC [";
local1 += "passToShopEnabled = " + this.passToShopEnabled + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.tanksservices.model.formatbattle {
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 EquipmentConstraintsNamingModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function EquipmentConstraintsNamingModelServer(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.item.itemforpartners {
import platform.clients.fp10.libraries.alternativapartners.service.IPartnerService;
import projects.tanks.client.commons.socialnetwork.SocialNetworkEnum;
import projects.tanks.client.garage.models.item.itemforpartners.IItemEnabledForPartnerModelBase;
import projects.tanks.client.garage.models.item.itemforpartners.ItemEnabledForPartnerModelBase;
[ModelInfo]
public class ItemEnabledForPartnerModel extends ItemEnabledForPartnerModelBase implements IItemEnabledForPartnerModelBase, ItemEnabledForPartner {
[Inject]
public static var partnerService:IPartnerService;
public function ItemEnabledForPartnerModel() {
super();
}
public function isAvailable() : Boolean {
var local1:String = getInitParam().partnerId;
if(local1 == SocialNetworkEnum.MAIN.name.toLowerCase()) {
return true;
}
return !partnerService.isRunningInsidePartnerEnvironment() && getInitParam().availableForNonPartnerUsers || Boolean(partnerService.isRunningInsidePartnerEnvironment()) && partnerService.getEnvironmentPartnerId() == local1;
}
}
}
|
package controls.scroller.green
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ScrollSkinGreen_trackTop extends BitmapAsset
{
public function ScrollSkinGreen_trackTop()
{
super();
}
}
}
|
package alternativa.tanks.gui.components.button {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.components.button.RequestCountIndicator_leftIconClass.png")]
public class RequestCountIndicator_leftIconClass extends BitmapAsset {
public function RequestCountIndicator_leftIconClass() {
super();
}
}
}
|
package
{
import alternativa.init.BattleSelectModelActivator;
import alternativa.init.ChatModelActivator;
import alternativa.init.GarageModelActivator;
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.osgi.service.storage.IStorageService;
import alternativa.service.IModelService;
import alternativa.tanks.gui.shopitems.item.kits.description.KitsInfoData;
import alternativa.tanks.model.Friend;
import alternativa.tanks.model.GarageModel;
import alternativa.tanks.model.IGarage;
import alternativa.tanks.model.IItemEffect;
import alternativa.tanks.model.ItemEffectModel;
import alternativa.tanks.model.ItemParams;
import alternativa.tanks.model.achievement.Achievement;
import alternativa.tanks.model.achievement.AchievementModel;
import alternativa.tanks.model.achievement.IAchievementModel;
import alternativa.tanks.model.challenge.ChallengeModel;
import alternativa.tanks.model.challenge.ChallengePrizeInfo;
import alternativa.tanks.model.challenge.IChallenge;
import alternativa.tanks.model.challenge.server.ChallengeServerData;
import alternativa.tanks.model.challenge.server.UserProgressServerData;
import alternativa.tanks.model.gift.server.GiftServerItem;
import alternativa.tanks.model.gift.server.GiftServerModel;
import alternativa.tanks.model.gift.server.IGiftServerModel;
import alternativa.tanks.model.news.INewsModel;
import alternativa.tanks.model.news.NewsItemServer;
import alternativa.tanks.model.news.NewsModel;
import alternativa.tanks.model.panel.IPanel;
import alternativa.tanks.model.panel.PanelModel;
import alternativa.tanks.model.profile.server.UserGiftServerItem;
import alternativa.tanks.model.user.IUserData;
import alternativa.tanks.model.user.UserData;
import alternativa.types.Long;
import com.alternativaplatform.client.models.core.community.chat.types.ChatMessage;
import com.alternativaplatform.client.models.core.community.chat.types.UserChat;
import com.alternativaplatform.projects.tanks.client.commons.models.itemtype.ItemTypeEnum;
import com.alternativaplatform.projects.tanks.client.commons.types.ItemProperty;
import com.alternativaplatform.projects.tanks.client.garage.garage.ItemInfo;
import com.alternativaplatform.projects.tanks.client.garage.item.ItemPropertyValue;
import com.alternativaplatform.projects.tanks.client.garage.item.ModificationInfo;
import flash.net.SharedObject;
import flash.net.URLRequest;
import flash.net.navigateToURL;
import forms.Alert;
import forms.AlertAnswer;
import projects.tanks.client.battlefield.gui.models.chat.IChatModelBase;
import projects.tanks.client.battleselect.IBattleSelectModelBase;
import projects.tanks.client.battleselect.types.BattleClient;
import projects.tanks.client.battleselect.types.MapClient;
import projects.tanks.client.battleselect.types.UserInfoClient;
import projects.tanks.client.battleservice.model.BattleType;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
import projects.tanks.client.panel.model.shop.kitpackage.KitPackageItemInfo;
import scpacker.networking.INetworkListener;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
import scpacker.networking.commands.Command;
import scpacker.networking.commands.Type;
import scpacker.resource.ResourceType;
import scpacker.resource.ResourceUtil;
import scpacker.server.models.bonus.ServerBonusModel;
public class Lobby implements INetworkListener
{
public static var firstInit:Boolean = true;
public var chat:ChatModelActivator;
public var battleSelect:BattleSelectModelActivator;
public var garage:GarageModelActivator;
private var networker:Network;
private var nullCommand:String;
private var chatInited:Boolean = false;
private const greenColor:uint = 8454016;
private const yellowColor:uint = 15335168;
private var bonusModel:ServerBonusModel;
private var modelRegister:IModelService;
private var itemEffectModel:ItemEffectModel;
private var waitForLoad = false;
private var listInited:Boolean = false;
public function Lobby()
{
this.bonusModel = new ServerBonusModel();
super();
this.chat = new ChatModelActivator();
this.battleSelect = new BattleSelectModelActivator();
this.garage = new GarageModelActivator();
this.garage.start(Main.osgi);
this.modelRegister = Main.osgi.getService(IModelService) as IModelService;
this.itemEffectModel = (this.modelRegister.getModelsByInterface(IItemEffect) as Vector.<IModel>)[0] as IItemEffect as ItemEffectModel;
}
public function onData(data:Command) : void
{
var parser:Object = null;
var questsModel:ChallengeModel = null;
var quest:ChallengeServerData = null;
var prizes:Array = null;
var p:String = null;
var idOldItem:String = null;
var special:Object = null;
var specQuest:ChallengeServerData = null;
var specialPrizes:Array = null;
var _prize:Object = null;
var prize:ChallengePrizeInfo = null;
var alert:Alert = null;
var parserGifts:Object = null;
var itemsGift:Array = null;
var parserInfo:Object = null;
var storage:SharedObject = null;
parser = null;
var info:UserInfoClient = null;
var achievementModel:AchievementModel = null;
var temp:BattleController = null;
var effect:* = undefined;
var id:String = null;
var time:Number = NaN;
var newsModel:NewsModel = null;
var news:Vector.<NewsItemServer> = null;
var news_item:* = undefined;
questsModel = null;
var progress:UserProgressServerData = null;
var quests:Array = null;
var q:Object = null;
quest = null;
prizes = null;
p = null;
var achievements:Vector.<Achievement> = null;
var achievementId:Object = null;
var achievement:Achievement = null;
var giftsModel:GiftServerModel = null;
var items:Array = null;
var _item:* = undefined;
var j:Array = null;
var oldItem:ItemParams = null;
idOldItem = null;
var item:ItemParams = null;
var item_info:ItemInfo = null;
var parser1:Object = null;
switch(data.type)
{
case Type.LOBBY_CHAT:
if(data.args[0] == "system")
{
if(!this.chatInited)
{
this.chatInited = true;
}
this.chat.chatModel.chatPanel.addMessage("",0,0,data.args[1],0,0,"",true,data.args[2] == "yellow" ? uint(this.yellowColor) : uint(this.greenColor));
}
else if(data.args[0] == "init_chat")
{
storage = IStorageService(Main.osgi.getService(IStorageService)).getStorage();
if(storage.data.showNewRules)
{
return;
}
this.bonusModel.showRulesUpdate();
storage.data.showNewRules = true;
}
else if(data.args[0] == "clear_all")
{
if(!this.chatInited)
{
this.chatInited = true;
}
this.chat.chatModel.cleanUsersMessages(null,"");
}
else if(data.args[0] == "init_messages")
{
Main.osgi.registerService(IChatModelBase,this.chat.chatModel);
this.chat.chatModel.initObject(Game.getInstance.classObject,["vk.com/scpacker"],(Main.osgi.getService(IUserData) as UserData).name);
this.chat.chatModel.objectLoaded(Game.getInstance.classObject);
this.parseChatMessages(data.args[1]);
}
else if(data.args[0] == "clean_by")
{
this.chat.chatModel.cleanUsersMessages(null,data.args[1]);
}
else if(data.args[0] == "clean_by_text")
{
this.chat.chatModel.cleanMessages(data.args[1]);
}
else
{
if(!this.chatInited)
{
this.chatInited = true;
}
this.parseAndAddMessageToChat(data.args[0]);
}
break;
case Type.LOBBY:
if(data.args[0] == "init_panel")
{
this.parseAndInitPanelInfo(data.args[1]);
}
else if(data.args[0] == "add_crystall")
{
PanelModel(Main.osgi.getService(IPanel)).updateCrystal(null,int(data.args[1]));
}
else if(data.args[0] == "add_score")
{
PanelModel(Main.osgi.getService(IPanel)).updateScore(null,int(data.args[1]));
}
else if(data.args[0] == "update_rang_progress")
{
PanelModel(Main.osgi.getService(IPanel)).updateRankProgress(null,int(data.args[1]));
}
else if(data.args[0] == "update_rang")
{
PanelModel(Main.osgi.getService(IPanel)).updateRang(null,int(data.args[1]),int(data.args[2]));
}
else if(data.args[0] == "init_battle_select")
{
this.parseAndInitBattlesList(data.args[1]);
}
else if(data.args[0] == "create_battle")
{
this.parseBattle(data.args[1]);
}
else if(data.args[0] == "start_battle")
{
this.battleSelect.battleSelectModel.startLoadBattle();
}
else if(data.args[0] == "check_battle_name")
{
this.battleSelect.battleSelectModel.setFilteredBattleName(null,data.args[1]);
}
else if(data.args[0] == "show_battle_info")
{
this.parseBattleInfo(data.args[1]);
}
else if(data.args[0] == "navigate_url")
{
navigateToURL(new URLRequest(data.args[1]),"_self");
PanelModel(Main.osgi.getService(IPanel)).unlock();
}
else if(data.args[0] == "show_discount_window")
{
PanelModel(Main.osgi.getService(IPanel)).openDiscountWindow(data.args[1],data.args[2],data.args[3]);
}
else if(data.args[0] == "show_quests")
{
trace(data.args[1]);
parser = JSON.parse(data.args[1]);
questsModel = Main.osgi.getService(IChallenge) as ChallengeModel;
quest = new ChallengeServerData();
quest.description = parser.description;
quest.id = parser.id;
quest.target_progress = parser.target_progress;
quest.progress = parser.progress;
prizes = new Array();
for each(p in parser.prizes)
{
prizes.push(p);
}
quest.prizes = prizes;
quest.completed = parser.completed;
quest.changeCost = parser.changeCost;
if(parser.special != null)
{
special = parser.special;
specQuest = new ChallengeServerData();
specQuest.description = special.description;
specQuest.id = special.id;
specQuest.target_progress = special.target_progress;
specQuest.progress = special.progress;
specialPrizes = new Array();
for each(p in special.prizes)
{
specialPrizes.push(p);
}
specQuest.prizes = specialPrizes;
quest.specialChallenge = specQuest;
}
questsModel.show(quest);
PanelModel(Main.osgi.getService(IPanel)).unlock();
}
else if(data.args[0] == "show_new_quests")
{
trace(data.args[1]);
parser = JSON.parse(data.args[1]);
questsModel = Main.osgi.getService(IChallenge) as ChallengeModel;
quest = new ChallengeServerData();
quest.description = parser.description;
quest.id = parser.id;
quest.target_progress = parser.target_progress;
quest.progress = parser.progress;
prizes = new Array();
for each(p in parser.prizes)
{
prizes.push(p);
}
quest.prizes = prizes;
quest.completed = parser.completed;
quest.changeCost = parser.changeCost;
if(parser.special != null)
{
special = parser.special;
specQuest = new ChallengeServerData();
specQuest.description = special.description;
specQuest.id = special.id;
specQuest.target_progress = special.target_progress;
specQuest.progress = special.progress;
specialPrizes = new Array();
for each(p in special.prizes)
{
specialPrizes.push(p);
}
specQuest.prizes = specialPrizes;
quest.specialChallenge = specQuest;
}
questsModel.updateQuest(quest);
}
else if(data.args[0] == "show_quests_bonus")
{
trace(data.args[1]);
parser = JSON.parse(data.args[1]);
prizes = new Array();
for each(_prize in parser.prizes)
{
prize = new ChallengePrizeInfo();
prize.count = _prize.count;
prize.nameId = _prize.nameId;
prizes.push(prize);
}
PanelModel(Main.osgi.getService(IPanel)).openChallegneCongratsWindow(prizes);
}
else if(data.args[0] == "show_alert_info")
{
alert = new Alert();
alert.showAlert(data.args[1],[AlertAnswer.OK]);
Main.contentUILayer.addChild(alert);
PanelModel(Main.osgi.getService(IPanel)).unlock();
}
else if(data.args[0] == "init_friends_list")
{
Friend.friends = data.args[1];
PanelModel(Main.osgi.getService(IPanel)).openFriends();
}
else if(data.args[0] == "update_friends_list")
{
Friend.friends = data.args[1];
PanelModel(Main.osgi.getService(IPanel)).updateFriendsList();
}
else if(data.args[0] == "update_count_users_in_dm_battle")
{
this.battleSelect.battleSelectModel.updateUsersCountForDM(null,data.args[1],data.args[2]);
}
else if(data.args[0] == "update_count_users_in_team_battle")
{
parser = JSON.parse(data.args[1]);
this.battleSelect.battleSelectModel.updateUsersCountForTeam(null,parser.battleId,parser.redPeople,parser.bluePeople);
}
else if(data.args[0] == "remove_battle")
{
this.battleSelect.battleSelectModel.removeBattle(null,data.args[1]);
}
else if(data.args[0] == "add_player_to_battle")
{
parser = JSON.parse(data.args[1]);
if(parser.battleId != this.battleSelect.battleSelectModel.selectedBattleId)
{
return;
}
info = new UserInfoClient();
info.id = parser.id;
info.kills = parser.kills;
info.name = parser.name;
info.rank = parser.rank;
info.type = BattleTeamType.getType(parser.type);
info.isBot = parser.isBot;
this.battleSelect.battleSelectModel.currentBattleAddUser(null,info);
}
else if(data.args[0] == "remove_player_from_battle")
{
parser = JSON.parse(data.args[1]);
if(parser.battleId != this.battleSelect.battleSelectModel.selectedBattleId)
{
return;
}
this.battleSelect.battleSelectModel.currentBattleRemoveUser(null,parser.id);
}
else if(data.args[0] == "server_message")
{
Main.debug.showServerMessageWindow(data.args[1]);
}
else if(data.args[0] == "show_bonuses")
{
this.bonusModel.showBonuses(data.args[1]);
}
else if(data.args[0] == "show_no_supplies")
{
this.bonusModel.showNoSupplies();
}
else if(data.args[0] == "show_double_crystalls")
{
this.bonusModel.showDoubleCrystalls();
}
else if(data.args[0] == "show_crystalls")
{
this.bonusModel.showCrystalls(int(data.args[1]));
}
else if(data.args[0] == "show_nube_up_score")
{
this.bonusModel.showNewbiesUpScore();
}
else if(data.args[0] == "show_nube_new_rank")
{
achievementModel = Main.osgi.getService(IAchievementModel) as AchievementModel;
achievementModel.showNewRankCongratulationsWindow();
}
else if(data.args[0] == "init_battlecontroller")
{
PanelModel(Main.osgi.getService(IPanel)).startBattle(null);
if(BattleController(Main.osgi.getService(IBattleController)) == null)
{
temp = new BattleController();
Main.osgi.registerService(IBattleController,temp);
}
Network(Main.osgi.getService(INetworker)).addEventListener(Main.osgi.getService(IBattleController) as BattleController);
}
else if(data.args[0] == "server_halt")
{
PanelModel(Main.osgi.getService(IPanel)).serverHalt(null,50,0,0,null);
}
else if(data.args[0] == "show_profile")
{
parser = JSON.parse(data.args[1]);
PanelModel(Main.osgi.getService(IPanel)).openProfile(null,parser.emailNotice,parser.isComfirmEmail,false,"","");
}
else if(data.args[0] == "open_profile")
{
trace(data.args[1]);
trace(data.args[2]);
parserGifts = JSON.parse(data.args[1]).incoming;
itemsGift = new Array();
for each(_item in parserGifts)
{
itemsGift.push(new UserGiftServerItem(_item.userid,_item.giftid,_item.image,_item.name,_item.status,_item.message,_item.date));
}
parserInfo = JSON.parse(data.args[2]);
PanelModel(Main.osgi.getService(IPanel)).showGiftWindow(itemsGift,parserInfo);
}
else if(data.args[0] == "open_shop")
{
PanelModel(Main.osgi.getService(IPanel)).onShopWindow(JSON.parse(data.args[1]));
}
else if(data.args[0] == "open_url")
{
navigateToURL(new URLRequest(data.args[1]),"_self");
}
else if(data.args[0] == "donate_successfully")
{
PanelModel(Main.osgi.getService(IPanel)).showPurchaseWindow(data.args[1],data.args[2],data.args[3]);
}
else if(data.args[0] == "open_recovery_window")
{
PanelModel(Main.osgi.getService(IPanel)).openRecoveryWindow(data.args[1]);
}
else if(data.args[0] == "effect_stopped")
{
this.itemEffectModel.effectStopped(data.args[1]);
}
else if(data.args[0] == "init_effect_model")
{
parser = JSON.parse(data.args[1]);
for each(effect in parser.effects)
{
id = effect.id;
time = effect.time;
this.itemEffectModel.setRemaining(id,time);
}
}
else if(data.args[0] == "set_reamining_time")
{
this.itemEffectModel.setRemaining(data.args[1],data.args[2]);
}
else if(data.args[0] == "show_news")
{
parser = JSON.parse(data.args[1]);
newsModel = Main.osgi.getService(INewsModel) as NewsModel;
news = new Vector.<NewsItemServer>();
for each(news_item in parser)
{
news.push(new NewsItemServer(news_item.date,news_item.text,news_item.icon_id));
}
newsModel.showNews(news);
}
else if(data.args[0] == "show_achievements")
{
achievementModel = Main.osgi.getService(IAchievementModel) as AchievementModel;
parser = JSON.parse(data.args[1]);
achievements = new Vector.<Achievement>();
for each(achievementId in parser.ids)
{
achievements.push(Achievement.getById(achievementId as int));
}
achievementModel.objectLoaded(achievements);
}
else if(data.args[0] == "complete_achievement")
{
achievementModel = Main.osgi.getService(IAchievementModel) as AchievementModel;
achievement = Achievement.getById(parseInt(data.args[1]));
achievementModel.completeAchievement(achievement);
}
else if(data.args[0] == "update_rating_data")
{
PanelModel(Main.osgi.getService(IPanel)).updateRating(null,parseInt(data.args[1]));
PanelModel(Main.osgi.getService(IPanel)).updatePlace(null,parseInt(data.args[2]));
}
else if(data.args[0] == "show_gifts_window")
{
parser = JSON.parse(data.args[1]);
giftsModel = Main.osgi.getService(IGiftServerModel) as GiftServerModel;
items = new Array();
for each(_item in parser)
{
items.push(new GiftServerItem(_item.item_id,_item.rarity,_item.count));
}
giftsModel.openGiftWindow(items,parseInt(data.args[2]));
}
else if(data.args[0] == "item_rolled")
{
giftsModel = Main.osgi.getService(IGiftServerModel) as GiftServerModel;
giftsModel.doRoll(data.args[1],JSON.parse(data.args[2]) as Array,data.args[3],data.args[4],parseInt(data.args[5]));
}
else if(data.args[0] == "items_rolled")
{
giftsModel = Main.osgi.getService(IGiftServerModel) as GiftServerModel;
j = JSON.parse(data.args[1]) as Array;
giftsModel.doRolls(j);
}
break;
case Type.GARAGE:
if(data.args[0] == "init_garage_items")
{
this.parseGarageItems(data.args[1],data.src);
}
else if(data.args[0] == "init_market")
{
this.parseMarket(data.args[1]);
}
else if(data.args[0] == "mount_item")
{
oldItem = GarageModel.getItemParams(data.args[1]);
if(oldItem.itemType == ItemTypeEnum.ARMOR)
{
idOldItem = this.garage.garageModel.mountedArmorId;
}
else if(oldItem.itemType == ItemTypeEnum.WEAPON)
{
idOldItem = this.garage.garageModel.mountedWeaponId;
}
else if(oldItem.itemType == ItemTypeEnum.COLOR)
{
idOldItem = this.garage.garageModel.mountedEngineId;
}
if(ResourceUtil.getResource(ResourceType.IMAGE,"garage_box_img") == null)
{
ResourceUtil.addEventListener(function():void
{
garage.garageModel.mountItem(null,idOldItem,data.args[1]);
});
}
else
{
this.garage.garageModel.mountItem(null,idOldItem,data.args[1]);
}
}
else if(data.args[0] == "update_item")
{
GarageModel.replaceItemInfo(data.args[1],this.getNextId(data.args[1]));
GarageModel.replaceItemParams(data.args[1],this.getNextId(data.args[1]));
this.garage.garageModel.upgradeItem(null,data.args[2] == "" ? this.garage.garageModel.currentItemForUpdate : data.args[2],GarageModel.getItemInfo(this.getNextId(data.args[1])));
}
else if(data.args[0] == "init_mounted_item")
{
item = GarageModel.getItemParams(data.args[1]);
this.garage.garageModel.mountItem(null,null,data.args[1]);
}
else if(data.args[0] == "buy_item")
{
item_info = new ItemInfo();
parser1 = JSON.parse(data.args[2]);
item_info.count = parser1.count;
item_info.itemId = data.args[1];
item_info.addable = parser1.addable;
item_info.multicounted = parser1.multicounted;
this.garage.garageModel.buyItem(null,item_info);
}
else if(data.args[0] == "remove_item_from_market")
{
this.garage.garageModel.removeItemFromStore(data.args[1]);
}
}
}
private function parseChatMessages(json:String) : void
{
var obj:Object = null;
var user:UserChat = null;
var msg:ChatMessage = null;
var parser:Object = JSON.parse(json);
var msgs:Array = new Array();
var userTo:UserChat = null;
for each(obj in parser.messages)
{
user = new UserChat();
user.rankIndex = obj.rang;
user.chatPermissions = obj.chatPermissions;
user.uid = obj.name;
if(obj.addressed)
{
userTo = new UserChat();
userTo.uid = obj.nameTo;
userTo.chatPermissions = obj.chatPermissionsTo;
userTo.rankIndex = obj.rangTo;
}
msg = new ChatMessage();
msg.sourceUser = user;
msg.system = obj.system;
msg.targetUser = userTo;
msg.text = obj.message;
msg.sysCollor = !!Boolean(obj.yellow) ? uint(uint(this.yellowColor)) : uint(uint(this.greenColor));
msgs.push(msg);
userTo = null;
}
this.chat.chatModel.showMessages(null,msgs);
}
private function parseBattleInfo(json:String) : void
{
var user_obj:Object = null;
var usr:UserInfoClient = null;
var obj:Object = JSON.parse(json);
if(obj.null_battle)
{
return;
}
var users:Array = new Array();
for each(user_obj in obj.users_in_battle)
{
usr = new UserInfoClient();
usr.id = String(user_obj.nickname);
usr.kills = int(user_obj.kills);
usr.name = String(user_obj.nickname);
usr.rank = int(user_obj.rank);
usr.type = BattleTeamType.getType(user_obj.team_type);
usr.isBot = user_obj.isBot;
users.push(usr);
}
this.battleSelect.battleSelectModel.showBattleInfo(null,obj.name,obj.maxPeople,BattleType.getType(obj.type),obj.battleId,obj.previewId,obj.minRank,obj.maxRank,obj.timeLimit,obj.timeCurrent,obj.killsLimit,obj.scoreRed,obj.scoreBlue,obj.autobalance,obj.frielndyFie,users,obj.paidBattle,obj.withoutBonuses,obj.userAlreadyPaid,obj.fullCash,obj.clanName != null ? obj.clanName : "",obj.spectator);
this.battleSelect.battleSelectModel.selectedBattleId = obj.battleId;
}
private function parseBattle(json:String) : void
{
var parser:Object = JSON.parse(json);
var battle:BattleClient = new BattleClient();
battle.battleId = parser.battleId;
battle.mapId = parser.mapId;
battle.name = parser.name;
battle.team = parser.team;
battle.countRedPeople = parser.redPeople;
battle.countBluePeople = parser.bluePeople;
battle.countPeople = parser.countPeople;
battle.maxPeople = parser.maxPeople;
battle.minRank = parser.minRank;
battle.maxRank = parser.maxRank;
battle.paid = parser.isPaid;
this.battleSelect.battleSelectModel.addBattle(null,battle);
}
private function initMarket(json:String) : void
{
var obj:Object = null;
var modifications:Array = null;
var obj2:Object = null;
var id:int = 0;
var item:ItemParams = null;
var infoItem:ItemInfo = null;
var props:Array = null;
var prop:Object = null;
var info:ModificationInfo = null;
var pid:String = null;
var p:ItemPropertyValue = null;
var parser:Object = JSON.parse(json);
var items:Array = new Array();
for each(obj in parser.items)
{
modifications = new Array();
for each(obj2 in obj.modification)
{
props = new Array();
for each(prop in obj2.properts)
{
p = new ItemPropertyValue();
p.property = this.getItemProperty(prop.property);
p.value = prop.value;
props.push(p);
}
info = new ModificationInfo();
info.crystalPrice = obj2.price;
info.rankId = obj2.rank;
info.previewId = obj2.previewId;
pid = obj2.previewId;
info.itemProperties = props;
modifications.push(info);
}
if(obj.json_kit_info != null)
{
this.parseKitInfo(obj.id + "_m" + obj.modificationID,JSON.parse(obj.json_kit_info),obj.discount);
}
id = obj.modificationID;
item = new ItemParams(obj.id + "_m" + id,obj.description,obj.isInventory,obj.index,props,this.getTypeItem(obj.type),obj.modificationID,obj.name,obj.next_price,null,obj.next_rank,modifications[id].previewId,obj.price,obj.rank,modifications);
infoItem = new ItemInfo();
infoItem.count = item.price;
infoItem.itemId = item.baseItemId;
infoItem.discount = obj.discount;
infoItem.multicounted = obj.multicounted;
this.garage.garageModel.initItem(item.baseItemId,item);
this.garage.garageModel.initMarket(null,[infoItem]);
}
this.garage.garageModel.objectLoaded(Game.getInstance.classObject);
}
private function parseKitInfo(key:String, kitInfos:Object, discount:int) : void
{
var infoObj:Object = null;
var lang:String = (Main.osgi.getService(ILocaleService) as ILocaleService).language;
if(lang == null)
{
lang = "EN";
}
else
{
lang = lang.toUpperCase();
}
var kitPackage:Vector.<KitPackageItemInfo> = new Vector.<KitPackageItemInfo>();
for each(infoObj in kitInfos)
{
kitPackage.push(new KitPackageItemInfo(1,infoObj.price,lang == "RU" ? infoObj.name_ru : infoObj.name_en));
}
KitsInfoData.setData(key,kitPackage,discount);
}
private function parseMarket(json:String) : void
{
if(!ResourceUtil.resourceLoaded || ResourceUtil.getResource(ResourceType.IMAGE,"garage_box_img") == null || ResourceUtil.getResource(ResourceType.IMAGE,"zeus_m0_preview") == null)
{
ResourceUtil.addEventListener(function():void
{
parseMarket(json);
});
}
else
{
this.initMarket(json);
}
}
private function getNextId(oldId:String) : String
{
var temp:String = oldId.substring(0,oldId.length - 1);
var mod:int = int(oldId.substring(oldId.length - 1,oldId.length));
return temp + (mod + 1);
}
public function parseGarageItems(json:String, src:String = null) : void
{
if(!ResourceUtil.resourceLoaded || ResourceUtil.getResource(ResourceType.IMAGE,"garage_box_img") == null || ResourceUtil.getResource(ResourceType.IMAGE,"zeus_m0_preview") == null)
{
ResourceUtil.addEventListener(function():void
{
parseGarageItems(json,src);
});
}
else
{
this.initGarageItems(json,src);
}
}
private function initGarageItems(json:String, src:String = null) : void
{
var parser:Object = null;
var items:Array = null;
var obj:Object = null;
var modifications:Array = null;
var obj2:Object = null;
var id:int = 0;
var item:ItemParams = null;
var infoItem:ItemInfo = null;
var props:Array = null;
var prop:Object = null;
var info:ModificationInfo = null;
var pid:String = null;
var p:ItemPropertyValue = null;
this.garage.garageModel.initObject(Game.getInstance.classObject,"russia",1000000,new Long(100,100),this.networker);
try
{
parser = JSON.parse(json);
items = new Array();
for each(obj in parser.items)
{
modifications = new Array();
for each(obj2 in obj.modification)
{
props = new Array();
for each(prop in obj2.properts)
{
p = new ItemPropertyValue();
p.property = this.getItemProperty(prop.property);
p.value = prop.value;
props.push(p);
}
info = new ModificationInfo();
info.crystalPrice = obj2.price;
info.rankId = obj2.rank;
info.previewId = obj2.previewId;
pid = obj2.previewId;
info.itemProperties = props;
modifications.push(info);
}
id = obj.modificationID;
item = new ItemParams(obj.id + "_m" + id,obj.description,obj.isInventory,obj.index,props,this.getTypeItem(obj.type),obj.modificationID,obj.name,obj.next_price,null,obj.next_rank,modifications[id].previewId,obj.price,obj.rank,modifications);
if(item.baseItemId == "smoky_xt_m0")
{
trace(item.baseItemId);
}
infoItem = new ItemInfo();
if(this.getTypeItem(obj.type) != ItemTypeEnum.ARMOR)
{
if(this.getTypeItem(obj.type) != ItemTypeEnum.WEAPON)
{
if(this.getTypeItem(obj.type) == ItemTypeEnum.COLOR)
{
}
}
}
infoItem.count = obj.count;
infoItem.itemId = item.baseItemId;
infoItem.discount = obj.discount;
infoItem.multicounted = obj.multicounted;
this.garage.garageModel.initItem(item.baseItemId,item);
this.garage.garageModel.initDepot(null,[infoItem]);
}
Network(Main.osgi.getService(INetworker)).send("garage;get_garage_data");
PanelModel(Main.osgi.getService(IPanel)).addListener(this.garage.garageModel);
Main.osgi.registerService(IGarage,this.garage.garageModel);
PanelModel(Main.osgi.getService(IPanel)).isGarageSelect = true;
}
catch(e:Error)
{
throw new Error("Ошибка " + e.getStackTrace());
}
}
public function parseAndInitBattlesList(json:String) : void
{
var obj1:Object = null;
var btl:Object = null;
var map:MapClient = null;
var battle:BattleClient = null;
Main.osgi.registerService(IBattleSelectModelBase,this.battleSelect.battleSelectModel);
var maps:Array = new Array();
var battles:Array = new Array();
var js:Object = JSON.parse(json);
for each(obj1 in js.items)
{
map = new MapClient();
map.ctf = obj1.ctf;
map.gameName = obj1.gameName;
map.id = obj1.id;
map.maxPeople = obj1.maxPeople;
map.maxRank = obj1.maxRank;
map.minRank = obj1.minRank;
map.name = obj1.name;
map.previewId = obj1.id + "_preview";
map.tdm = obj1.tdm;
map.dom = obj1.dom;
map.hr = obj1.hr;
map.themeName = obj1.themeName;
maps.push(map);
}
for each(btl in js.battles)
{
battle = new BattleClient();
battle.battleId = btl.battleId;
battle.mapId = btl.mapId;
battle.name = btl.name;
battle.type = btl.type;
battle.team = btl.team;
battle.countRedPeople = btl.redPeople;
battle.countBluePeople = btl.bluePeople;
battle.countPeople = btl.countPeople;
battle.maxPeople = btl.maxPeople;
battle.minRank = btl.minRank;
battle.maxRank = btl.maxRank;
battle.paid = btl.isPaid;
battles.push(battle);
}
this.battleSelect.battleSelectModel.initObject(null,10,js.haveSubscribe,maps);
this.battleSelect.battleSelectModel.initBattleList(null,battles,js.recommendedBattle,false);
if(!this.listInited)
{
this.listInited = true;
}
}
public function parseAndAddMessageToChat(json:String) : void
{
var parser:Object = JSON.parse(json);
this.chat.chatModel.chatPanel.addMessage(parser.name,parser.rang,parser.chatPermissions,parser.message,parser.rangTo,parser.chatPermissionsTo,parser.nameTo == "NULL" ? "" : parser.nameTo,parser.system);
}
public function parseAndInitPanelInfo(json:String) : void
{
var obj:Object = JSON.parse(json);
this.initPanel(obj.crystall,obj.email,obj.tester,obj.name,obj.next_score,obj.place,obj.rang,obj.rating,obj.score,obj.have_double_crystalls);
}
public function initPanel(crystall:int, email:String, tester:Boolean, name:String, nextScore:int, place:int, rang:int, rating:int, score:int, haveDoubleCrystalls:Boolean) : void
{
var modelPanel:PanelModel = PanelModel(Main.osgi.getService(IPanel));
modelPanel.initObject(Game.getInstance.classObject,crystall,email,tester,name,nextScore,place,rang,rating,score,haveDoubleCrystalls);
modelPanel.lock();
var user1:UserData = new UserData(name,name,rang);
Main.osgi.registerService(IUserData,user1);
this.init();
}
public function beforeAuth() : void
{
this.networker = Main.osgi.getService(INetworker) as Network;
this.networker.addEventListener(this);
}
private function init() : void
{
this.chat.start(Game.getInstance.osgi);
this.battleSelect.start(Game.getInstance.osgi);
}
public function getItemProperty(src:String) : ItemProperty
{
switch(src)
{
case "damage":
return ItemProperty.DAMAGE;
case "damage_per_second":
return ItemProperty.DAMAGE_PER_SECOND;
case "critical_chance":
return ItemProperty.CRITICAL_CHANCE;
case "heating_time":
return ItemProperty.HEATING_TIME;
case "aiming_error":
return ItemProperty.AIMING_ERROR;
case "cone_angle":
return ItemProperty.CONE_ANGLE;
case "shot_area":
return ItemProperty.SHOT_AREA;
case "shot_frequency":
return ItemProperty.SHOT_FREQUENCY;
case "shot_range":
return ItemProperty.SHOT_RANGE;
case "turn_speed":
return ItemProperty.TURN_SPEED;
case "mech_resistance":
return ItemProperty.MECH_RESISTANCE;
case "plasma_resistance":
return ItemProperty.PLASMA_RESISTANCE;
case "rail_resistance":
return ItemProperty.RAIL_RESISTANCE;
case "terminator_resistance":
return ItemProperty.TERMINATOR_RESISTANCE;
case "mine_resistance":
return ItemProperty.MINE_RESISTANCE;
case "vampire_resistance":
return ItemProperty.VAMPIRE_RESISTANCE;
case "armor":
return ItemProperty.ARMOR;
case "turret_turn_speed":
return ItemProperty.TURRET_TURN_SPEED;
case "fire_resistance":
return ItemProperty.FIRE_RESISTANCE;
case "thunder_resistance":
return ItemProperty.THUNDER_RESISTANCE;
case "freeze_resistance":
return ItemProperty.FREEZE_RESISTANCE;
case "ricochet_resistance":
return ItemProperty.RICOCHET_RESISTANCE;
case "healing_radius":
return ItemProperty.HEALING_RADUIS;
case "heal_rate":
return ItemProperty.HEAL_RATE;
case "vampire_rate":
return ItemProperty.VAMPIRE_RATE;
case "speed":
return ItemProperty.SPEED;
case "shaft_damage":
return ItemProperty.SHAFT_DAMAGE;
case "shaft_shot_frequency":
return ItemProperty.SHAFT_FIRE_RATE;
case "shaft_resistance":
return ItemProperty.SHAFT_RESISTANCE;
default:
return null;
}
}
public function getTypeItem(sct:int) : ItemTypeEnum
{
switch(sct)
{
case 2:
return ItemTypeEnum.ARMOR;
case 1:
return ItemTypeEnum.WEAPON;
case 3:
return ItemTypeEnum.COLOR;
case 4:
return ItemTypeEnum.INVENTORY;
case 5:
return ItemTypeEnum.PLUGIN;
case 6:
return ItemTypeEnum.KIT;
default:
return null;
}
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.railgun {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.types.Vector3d;
public interface IRailgunModelBase {
function fire(param1:IGameObject, param2:Vector3d, param3:Vector.<IGameObject>, param4:Vector.<Vector3d>) : void;
function fireDummy(param1:IGameObject) : void;
function immediateReload() : void;
function reconfigureWeapon(param1:int) : void;
function startCharging(param1:IGameObject) : void;
}
}
|
package alternativa.tanks.models.tank {
import alternativa.tanks.battle.objects.tank.tankskin.TankHullSkinCacheItem;
import flash.utils.Dictionary;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
internal class HullsRegistry {
private var hulls:Dictionary = new Dictionary();
public function HullsRegistry() {
super();
}
public function getHull(param1:Tanks3DSResource) : TankHullSkinCacheItem {
var local2:TankHullSkinCacheItem = this.hulls[param1.id];
if(local2 == null) {
local2 = new TankHullSkinCacheItem(param1);
this.hulls[param1.id] = local2;
}
return local2;
}
}
}
|
package alternativa.tanks.models.weapon.common {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class WeaponBuffListenerAdapt implements WeaponBuffListener {
private var object:IGameObject;
private var impl:WeaponBuffListener;
public function WeaponBuffListenerAdapt(param1:IGameObject, param2:WeaponBuffListener) {
super();
this.object = param1;
this.impl = param2;
}
public function weaponBuffStateChanged(param1:IGameObject, param2:Boolean, param3:Number) : void {
var user:IGameObject = param1;
var buffed:Boolean = param2;
var recoilForce:Number = param3;
try {
Model.object = this.object;
this.impl.weaponBuffStateChanged(user,buffed,recoilForce);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.weapon.shaft {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.sfx.LightAnimation;
import flash.media.Sound;
internal class ShaftSFXData {
public var shotSound:Sound;
public var explosionSound:Sound;
public var zoomModeSound:Sound;
public var targetingSound:Sound;
public var muzzleFlashAnimation:TextureAnimation;
public var explosionAnimation:TextureAnimation;
public var trailMaterial:TextureMaterial;
public var hitMarkMaterial:TextureMaterial;
public var trailLength:Number;
public var shotLightAnimation:LightAnimation;
public var hitLightAnimation:LightAnimation;
public function ShaftSFXData(param1:Sound, param2:Sound, param3:Sound, param4:Sound, param5:TextureAnimation, param6:TextureMaterial, param7:TextureAnimation, param8:TextureMaterial, param9:Number) {
super();
this.shotSound = param1;
this.explosionSound = param2;
this.zoomModeSound = param3;
this.targetingSound = param4;
this.muzzleFlashAnimation = param5;
this.trailMaterial = param6;
this.explosionAnimation = param7;
this.hitMarkMaterial = param8;
this.trailLength = param9;
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapSmallRank16.png")]
public class DefaultRanksBitmaps_bitmapSmallRank16 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapSmallRank16() {
super();
}
}
}
|
package alternativa.tanks.model.payment
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.osgi.service.storage.IStorageService;
import alternativa.service.IModelService;
import flash.net.SharedObject;
import projects.tanks.client.panel.model.payment.IPaymentModelBase;
import projects.tanks.client.panel.model.payment.PaymentModelBase;
public class PaymentModel extends PaymentModelBase implements IPaymentModelBase, IObjectLoadListener, IPayment
{
private var clientObject:ClientObject;
private var _accountId:String;
private var _projectId:int;
private var _formId:String;
private var _currentLocaleCurrency:String;
public function PaymentModel()
{
super();
_interfaces.push(IModel);
_interfaces.push(IPayment);
_interfaces.push(IPaymentModelBase);
_interfaces.push(IObjectLoadListener);
}
public function objectLoaded(object:ClientObject) : void
{
this.clientObject = object;
}
public function objectUnloaded(object:ClientObject) : void
{
this.clientObject = null;
}
public function setInitData(clientObject:ClientObject, counries:Array, rates:Array, accountId:String, projectId:int, formId:String, currentLocaleCurrency:String) : void
{
var i:int = 0;
this._accountId = accountId;
this._projectId = projectId;
this._formId = formId;
this._currentLocaleCurrency = currentLocaleCurrency;
var modelRegister:IModelService = Main.osgi.getService(IModelService) as IModelService;
var listeners:Vector.<IModel> = modelRegister.getModelsByInterface(IPaymentListener);
if(listeners != null)
{
for(i = 0; i < listeners.length; i++)
{
(listeners[i] as IPaymentListener).setInitData(counries,rates,accountId,projectId,formId);
}
}
}
public function setOperators(clientObject:ClientObject, countryId:String, operators:Array) : void
{
var i:int = 0;
var modelRegister:IModelService = Main.osgi.getService(IModelService) as IModelService;
var listeners:Vector.<IModel> = modelRegister.getModelsByInterface(IPaymentListener);
if(listeners != null)
{
for(i = 0; i < listeners.length; i++)
{
(listeners[i] as IPaymentListener).setOperators(countryId,operators);
}
}
}
public function setNumbers(clientObject:ClientObject, operatorId:int, smsNumbers:Array) : void
{
var i:int = 0;
var modelRegister:IModelService = Main.osgi.getService(IModelService) as IModelService;
var listeners:Vector.<IModel> = modelRegister.getModelsByInterface(IPaymentListener);
if(listeners != null)
{
for(i = 0; i < listeners.length; i++)
{
(listeners[i] as IPaymentListener).setNumbers(operatorId,smsNumbers);
}
}
}
public function getData() : void
{
}
public function getOperatorsList(countryId:String) : void
{
}
public function getNumbersList(operatorId:int) : void
{
var storage:SharedObject = IStorageService(Main.osgi.getService(IStorageService)).getStorage();
storage.data.userOperator = operatorId;
}
public function get currentLocaleCurrency() : String
{
return this._currentLocaleCurrency;
}
public function get accountId() : String
{
return this._accountId;
}
public function get projectId() : int
{
return this._projectId;
}
public function get formId() : String
{
return this._formId;
}
}
}
|
package projects.tanks.client.panel.model.bonus.showing.image {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class BonusImageShowingModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BonusImageShowingModelServer;
private var client:IBonusImageShowingModelBase = IBonusImageShowingModelBase(this);
private var modelId:Long = Long.getLong(641472381,-160466740);
public function BonusImageShowingModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BonusImageShowingModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(BonusImageCC,false)));
}
protected function getInitParam() : BonusImageCC {
return BonusImageCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package controls.buttons.h71px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h71px.GreyHugeButtonSkin_leftOffClass.png")]
public class GreyHugeButtonSkin_leftOffClass extends BitmapAsset {
public function GreyHugeButtonSkin_leftOffClass() {
super();
}
}
}
|
package alternativa.tanks.model.item.resistance {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class MountedResistancesEvents implements MountedResistances {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function MountedResistancesEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function mount(param1:int, param2:IGameObject) : void {
var i:int = 0;
var m:MountedResistances = null;
var index:int = param1;
var item:IGameObject = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = MountedResistances(this.impl[i]);
m.mount(index,item);
i++;
}
}
finally {
Model.popObject();
}
}
public function unmount(param1:IGameObject) : void {
var i:int = 0;
var m:MountedResistances = null;
var item:IGameObject = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = MountedResistances(this.impl[i]);
m.unmount(item);
i++;
}
}
finally {
Model.popObject();
}
}
public function getMounted() : Vector.<IGameObject> {
var result:Vector.<IGameObject> = null;
var i:int = 0;
var m:MountedResistances = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = MountedResistances(this.impl[i]);
result = m.getMounted();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.battlefield.models.coloradjust {
public interface IColorAdjustModelBase {
}
}
|
package alternativa.tanks.sfx
{
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.events.Event;
import flash.media.SoundChannel;
public class Sound3DEffect extends PooledObject implements ISound3DEffect
{
public static var wrongSoundsCount:int;
private var _owner:ClientObject;
private var position:Vector3;
private var sound:Sound3D;
private var playbackDelay:int;
private var startTime:int;
private var loops:int = 0;
private var channel:SoundChannel;
private var _enabled:Boolean = false;
private var _playing:Boolean = false;
public function Sound3DEffect(objectPool:ObjectPool)
{
this.position = new Vector3();
super(objectPool);
}
public static function create(objectPool:ObjectPool, owner:ClientObject, position:Vector3, sound:Sound3D, playbackDelay:int = 0, startTime:int = 0, loops:int = 0) : Sound3DEffect
{
var effect:Sound3DEffect = Sound3DEffect(objectPool.getObject(Sound3DEffect));
effect.init(owner,position,sound,playbackDelay,startTime,loops);
return effect;
}
public function init(owner:ClientObject, position:Vector3, sound:Sound3D, playbackDelay:int = 0, startTime:int = 0, loops:int = 0) : void
{
this._owner = owner;
this.position.vCopy(position);
this.sound = sound;
this.playbackDelay = playbackDelay;
this.startTime = startTime;
this.loops = loops;
this._enabled = false;
this._playing = false;
}
public function get owner() : ClientObject
{
return this._owner;
}
public function play(millis:int, camera:GameCamera) : Boolean
{
this.playbackDelay -= millis;
if(this.playbackDelay > 0)
{
return this._enabled;
}
if(!this._playing)
{
this._playing = true;
this.channel = this.sound.play(this.startTime,this.loops);
if(this.channel == null)
{
this._enabled = false;
return false;
}
this.channel.addEventListener(Event.SOUND_COMPLETE,this.onSoundComplete);
}
this.sound.checkVolume(camera.pos,this.position,camera.xAxis);
return this._enabled;
}
public function destroy() : void
{
this._owner = null;
Sound3D.destroy(this.sound);
this.sound = null;
this.onSoundComplete(null);
storeInPool();
}
public function kill() : void
{
this._enabled = false;
}
public function set enabled(value:Boolean) : void
{
if(this._enabled == value)
{
return;
}
if(!(this._enabled = value))
{
this.onSoundComplete(null);
}
}
public function readPosition(result:Vector3) : void
{
result.x = this.position.x;
result.y = this.position.y;
result.z = this.position.z;
}
public function get numSounds() : int
{
return !!this._enabled ? int(int(1)) : int(int(0));
}
private function onSoundComplete(e:Event) : void
{
if(this.channel != null)
{
this.channel.removeEventListener(Event.SOUND_COMPLETE,this.onSoundComplete);
}
this._enabled = false;
this.channel = null;
}
override protected function getClass() : Class
{
return Sound3DEffect;
}
}
}
|
package projects.tanks.client.battleselect.model.matchmaking.group.notify {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class MatchmakingGroupNotifyModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:MatchmakingGroupNotifyModelServer;
private var client:IMatchmakingGroupNotifyModelBase = IMatchmakingGroupNotifyModelBase(this);
private var modelId:Long = Long.getLong(24345264,-1141305498);
private var _addUserId:Long = Long.getLong(457644934,1356384143);
private var _addUser_userDataCodec:ICodec;
private var _removeUserId:Long = Long.getLong(1473935785,1650079766);
private var _removeUser_userIdCodec:ICodec;
private var _userMountedItemId:Long = Long.getLong(796961862,-1942684603);
private var _userMountedItem_userDataCodec:ICodec;
private var _userNotReadyId:Long = Long.getLong(907288320,709901878);
private var _userNotReady_userIdCodec:ICodec;
private var _userReadyId:Long = Long.getLong(1710113617,1839810627);
private var _userReady_userIdCodec:ICodec;
public function MatchmakingGroupNotifyModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new MatchmakingGroupNotifyModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(MatchmakingGroupCC,false)));
this._addUser_userDataCodec = this._protocol.getCodec(new TypeCodecInfo(MatchmakingUserData,false));
this._removeUser_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._userMountedItem_userDataCodec = this._protocol.getCodec(new TypeCodecInfo(MountItemsUserData,false));
this._userNotReady_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._userReady_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
}
protected function getInitParam() : MatchmakingGroupCC {
return MatchmakingGroupCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._addUserId:
this.client.addUser(MatchmakingUserData(this._addUser_userDataCodec.decode(param2)));
break;
case this._removeUserId:
this.client.removeUser(Long(this._removeUser_userIdCodec.decode(param2)));
break;
case this._userMountedItemId:
this.client.userMountedItem(MountItemsUserData(this._userMountedItem_userDataCodec.decode(param2)));
break;
case this._userNotReadyId:
this.client.userNotReady(Long(this._userNotReady_userIdCodec.decode(param2)));
break;
case this._userReadyId:
this.client.userReady(Long(this._userReady_userIdCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.weapon.ricochet {
import alternativa.math.Vector3;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.BattleRunnerProvider;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapon.angles.verticals.autoaiming.VerticalAutoAiming;
import alternativa.tanks.models.weapon.shared.SimpleWeaponController;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import alternativa.tanks.utils.MathUtils;
import flash.utils.getTimer;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapon.ricochet.RicochetCC;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class RicochetWeapon extends BattleRunnerProvider implements IRicochetWeapon, LogicUnit {
[Inject]
public static var battleService:BattleService;
private static var shotId:int;
private static const shotDirection:Vector3 = new Vector3();
private static const rayHit:RayHit = new RayHit();
private static const _gunParams:AllGlobalGunParams = new AllGlobalGunParams();
private var recoilForce:Number;
private var energyRechargeRate:Number;
private var nextShotTime:int;
private var energyBaseTime:int;
private var weaponPlatform:WeaponPlatform;
private var controller:SimpleWeaponController = new SimpleWeaponController();
private var targetingSystem:RicochetTargetingSystem;
private var reloadingTime:int;
private var effects:RicochetEffects;
private var ammunition:RicochetAmmunition;
private var callback:RicochetWeaponCallback;
private var enabled:Boolean;
private var ricochetInitParams:RicochetCC;
private var lastEnergy:int;
private var weaponObject:WeaponObject;
private var stunEnergy:Number;
private var stunned:Boolean;
private var stunTime:int;
public function RicochetWeapon(param1:IGameObject, param2:RicochetCC) {
super();
var local3:IRicochetSFXModel = IRicochetSFXModel(param1.adapt(IRicochetSFXModel));
this.weaponObject = new WeaponObject(param1);
var local4:RicochetWeaponCallback = RicochetWeaponCallback(param1.adapt(RicochetWeaponCallback));
this.ricochetInitParams = param2;
this.recoilForce = this.weaponObject.commonData().getRecoilForce();
this.energyRechargeRate = param2.energyRechargeSpeed / 1000;
this.targetingSystem = getTargetingSystem(this.weaponObject.verticalAutoAiming(),param2);
this.reloadingTime = this.weaponObject.getReloadTimeMS();
this.effects = local3.getRicochetEffects();
this.ammunition = new RicochetAmmunition(this.weaponObject,param2,local3.getSfxData(),local4);
this.callback = local4;
}
private static function getTargetingSystem(param1:VerticalAutoAiming, param2:RicochetCC) : RicochetTargetingSystem {
var local3:Number = Number(param1.getElevationAngleUp());
var local4:int = int(param1.getNumRaysUp());
var local5:Number = Number(param1.getElevationAngleDown());
var local6:int = int(param1.getNumRaysDown());
var local7:Number = param2.shotDistance;
var local8:TanksCollisionDetector = battleService.getBattleRunner().getCollisionDetector();
return new RicochetTargetingSystem(local3,local4,local5,local6,local7,local8,battleService.getRicochetTargetEvaluator(),param2.maxRicochetCount);
}
public function init(param1:WeaponPlatform) : void {
this.weaponPlatform = param1;
this.controller.init();
}
public function destroy() : void {
this.ricochetInitParams = null;
this.effects = null;
this.callback = null;
this.targetingSystem = null;
this.controller.destroy();
}
public function activate() : void {
getBattleRunner().addLogicUnit(this);
}
public function deactivate() : void {
getBattleRunner().removeLogicUnit(this);
}
public function enable() : void {
if(!this.enabled) {
this.enabled = true;
this.controller.discardStoredAction();
}
}
public function disable(param1:Boolean) : void {
this.enabled = false;
}
public function reset() : void {
this.energyBaseTime = 0;
this.nextShotTime = 0;
this.controller.discardStoredAction();
}
public function getStatus() : Number {
if(this.stunned) {
return this.stunEnergy;
}
return this.getEnergy(getTimer()) / this.ricochetInitParams.energyCapacity;
}
public function runLogic(param1:int, param2:int) : void {
var local3:Number = NaN;
if(this.enabled) {
if(this.controller.wasActive() && param1 >= this.nextShotTime) {
local3 = this.getEnergy(param1);
if(local3 >= this.ricochetInitParams.energyPerShot && !this.stunned) {
this.shoot(param1,local3);
}
}
}
this.controller.discardStoredAction();
}
private function shoot(param1:int, param2:Number) : void {
this.lastEnergy = param2 - this.ricochetInitParams.energyPerShot;
this.nextShotTime = param1 + this.reloadingTime;
this.setEnergyBaseTime(param1,this.lastEnergy);
this.weaponPlatform.getAllGunParams(_gunParams);
this.weaponPlatform.addDust();
this.applyRecoilForceToShooter(_gunParams.muzzlePosition,_gunParams.direction,-this.recoilForce);
this.effects.createShotEffects(this.weaponPlatform.getTurret3D(),this.weaponPlatform.getLocalMuzzlePosition(),_gunParams.muzzlePosition);
this.effects.createLightEffect(this.weaponPlatform.getTurret3D(),this.weaponPlatform.getLocalMuzzlePosition());
if(BattleUtils.isTurretAboveGround(this.weaponPlatform.getBody(),_gunParams)) {
this.doRealShot(param1,_gunParams);
} else {
this.doDummyShot(param1);
}
}
private function applyRecoilForceToShooter(param1:Vector3, param2:Vector3, param3:Number) : void {
this.weaponPlatform.getBody().addWorldForceScaled(param1,param2,param3);
}
private function doRealShot(param1:int, param2:AllGlobalGunParams) : void {
if(this.barrelCollidesWithStatic(param2.barrelOrigin,param2.direction,this.weaponPlatform.getBarrelLength())) {
shotDirection.copy(param2.direction);
} else {
this.targetingSystem.getShotDirection(param2.muzzlePosition,param2.direction,param2.elevationAxis,this.weaponPlatform.getBody(),shotDirection);
}
this.createShot(param1,param2,shotDirection);
}
private function doDummyShot(param1:int) : void {
this.callback.onDummyShot(param1);
}
private function barrelCollidesWithStatic(param1:Vector3, param2:Vector3, param3:Number) : Boolean {
return getBattleRunner().getCollisionDetector().raycastStatic(param1,param2,CollisionGroup.STATIC,param3,null,rayHit);
}
private function getEnergy(param1:int) : Number {
return MathUtils.clamp(this.energyRechargeRate * (param1 - this.energyBaseTime),0,this.ricochetInitParams.energyCapacity);
}
private function setEnergyBaseTime(param1:int, param2:Number) : void {
this.energyBaseTime = param1 - param2 / this.energyRechargeRate;
}
private function createShot(param1:int, param2:AllGlobalGunParams, param3:Vector3) : void {
var local4:RicochetShot = this.ammunition.getShot();
local4.addToGame(param2,param3,this.weaponPlatform.getBody(),false,++shotId);
this.callback.onShot(param1,local4.getShotId(),param3);
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.RICOCHET_RESISTANCE;
}
public function addEnergy(param1:int) : void {
this.setEnergyBaseTime(this.nextShotTime,this.lastEnergy + param1);
}
public function reconfigure(param1:Number, param2:Number) : void {
this.ricochetInitParams.shotDistance = param1;
this.ricochetInitParams.energyPerShot = param2;
}
public function updateRecoilForce(param1:Number) : void {
this.recoilForce = param1;
}
public function fullyRecharge() : void {
this.addEnergy(this.ricochetInitParams.energyCapacity);
this.stunEnergy = 1;
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
this.nextShotTime += param2 - param1;
}
public function setBuffedMode(param1:Boolean) : void {
this.reloadingTime = this.weaponObject.getReloadTimeMS();
}
public function stun() : void {
this.stunEnergy = this.getStatus();
this.stunTime = getTimer();
this.stunned = true;
}
public function calm(param1:int) : void {
var local2:int = getTimer() - this.stunTime;
this.nextShotTime += param1;
this.energyBaseTime += local2;
this.stunned = false;
}
}
}
|
package _codec.platform.client.core.general.resourcelocale.format {
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 platform.client.core.general.resourcelocale.format.LocalizedFileFormat;
public class VectorCodecLocalizedFileFormatLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecLocalizedFileFormatLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(LocalizedFileFormat,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.<LocalizedFileFormat> = new Vector.<LocalizedFileFormat>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = LocalizedFileFormat(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:LocalizedFileFormat = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<LocalizedFileFormat> = Vector.<LocalizedFileFormat>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.model.payment.shop.crystal {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class CrystalPackageEvents implements CrystalPackage {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function CrystalPackageEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getPremiumDurationInDays() : int {
var result:int = 0;
var i:int = 0;
var m:CrystalPackage = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = CrystalPackage(this.impl[i]);
result = int(m.getPremiumDurationInDays());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.partners.impl.china.partner4399 {
public interface IPartner4399ModelBase {
}
}
|
package alternativa.tanks.models.tank.resistance {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.user.resistance.TankResistance;
public class TankResistancesAdapt implements TankResistances {
private var object:IGameObject;
private var impl:TankResistances;
public function TankResistancesAdapt(param1:IGameObject, param2:TankResistances) {
super();
this.object = param1;
this.impl = param2;
}
public function getResistance(param1:Boolean) : int {
var result:int = 0;
var update:Boolean = param1;
try {
Model.object = this.object;
result = int(this.impl.getResistance(update));
}
finally {
Model.popObject();
}
return result;
}
public function getResistances() : Vector.<TankResistance> {
var result:Vector.<TankResistance> = null;
try {
Model.object = this.object;
result = this.impl.getResistances();
}
finally {
Model.popObject();
}
return result;
}
public function updateOthersResistances() : void {
try {
Model.object = this.object;
this.impl.updateOthersResistances();
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.gui.shop.payment {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.shop.components.itemcategoriesview.ItemCategoriesView;
import alternativa.tanks.gui.shop.components.itemscategory.ItemsCategoryView;
import alternativa.tanks.gui.shop.components.paymentview.PaymentView;
import alternativa.tanks.gui.shop.payment.item.PayModeButton;
import alternativa.tanks.gui.shop.shopitems.item.base.ShopButton;
import alternativa.tanks.gui.shop.shopitems.item.base.ShopButtonClickDisable;
import alternativa.tanks.gui.shop.shopitems.item.details.ShopItemAdditionalDescriptionLabel;
import alternativa.tanks.model.payment.shop.ShopItemDetailsView;
import alternativa.tanks.model.payment.shop.ShopItemView;
import alternativa.tanks.model.payment.shop.description.ShopItemAdditionalDescription;
import alternativa.tanks.model.payment.shop.specialkit.SpecialKitPackage;
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class PayModeChooseView extends PaymentView {
[Inject]
public static var localeService:ILocaleService;
private static const COLUMN_COUNT:int = 5;
private static const COLUMN_SPACING:int = 2;
private static const PAYMENT_CATEGORY_ID:Long = Long.ZERO;
private static const PAYMENT_CATEGORY_WITH_DISCOUNT_ID:Long = Long.getLong(0,1);
private var view:ItemCategoriesView;
private var selectedItem:IGameObject;
private var _width:int;
private var _height:int;
public function PayModeChooseView(param1:IGameObject) {
super();
this.selectedItem = param1;
this.view = new ItemCategoriesView();
addChild(this.view);
this.addSelectedItemView();
}
private function addSelectedItemView() : void {
var local5:ShopItemDetailsView = null;
var local1:ItemsCategoryView = new ItemsCategoryView(localeService.getText(TanksLocale.TEXT_SHOP_WINDOW_YOUR_CHOICE),"",this.selectedItem.id);
local1.items.horizontalSpacing = 50;
var local2:ShopButton = ShopItemView(this.selectedItem.adapt(ShopItemView)).getButtonView();
var local3:ShopButtonClickDisable = ShopButtonClickDisable(local2);
local3.disableClick();
local1.addItem(local2);
if(this.selectedItem.hasModel(ShopItemDetailsView)) {
local5 = ShopItemDetailsView(this.selectedItem.adapt(ShopItemDetailsView));
if(local5.isDetailedViewRequired()) {
local1.addItem(local5.getDetailsView());
}
}
var local4:String = ShopItemAdditionalDescription(this.selectedItem.adapt(ShopItemAdditionalDescription)).getAdditionalDescription();
if(Boolean(local4)) {
local1.addItem(new ShopItemAdditionalDescriptionLabel(local4));
}
this.view.addCategory(local1);
}
public function addPaymentCategoriesWithDiscountView() : void {
this.view.addCategory(this.createPaymentCategoriesView(localeService.getText(TanksLocale.TEXT_SHOP_WINDOW_PAYMENT_CATEGORY_WITH_DISCOUNT_HEADER),localeService.getText(TanksLocale.TEXT_SHOP_WINDOW_PAYMENT_CATEGORY_WITH_DISCOUNT_DESCRIPTION),PAYMENT_CATEGORY_WITH_DISCOUNT_ID));
}
public function addPaymentCategoriesView() : void {
this.view.addCategory(this.createPaymentCategoriesView(localeService.getText(TanksLocale.TEXT_SHOP_WINDOW_PAYMENT_CATEGORY_HEADER),localeService.getText(TanksLocale.TEXT_SHOP_WINDOW_PAYMENT_CATEGORY_DESCRIPTION),PAYMENT_CATEGORY_ID));
}
public function addPaymentCategoriesViewForOdnoklassniki(param1:Boolean) : void {
this.view.addCategory(this.createPaymentCategoriesView(localeService.getText(TanksLocale.TEXT_SHOP_PAYMENT_CATEGORY_HEADER_FOR_ODNOKLASSNIKY),localeService.getText(TanksLocale.TEXT_SHOP_PAYMENT_CATEGORY_DESCRIPTION_FOR_ODNOKLASSNIKY),param1 ? PAYMENT_CATEGORY_WITH_DISCOUNT_ID : PAYMENT_CATEGORY_ID));
}
private function createPaymentCategoriesView(param1:String, param2:String, param3:Long) : ItemsCategoryView {
var local4:ItemsCategoryView = new ItemsCategoryView(param1,param2,param3);
local4.items.columnCount = COLUMN_COUNT;
local4.items.spacing = COLUMN_SPACING;
return local4;
}
public function addPayMode(param1:IGameObject) : void {
var local2:Boolean = Boolean(this.selectedItem.hasModel(SpecialKitPackage));
var local3:PayModeButton = new PayModeButton(param1,local2);
this.view.addItem(local3.hasDiscount() ? PAYMENT_CATEGORY_WITH_DISCOUNT_ID : PAYMENT_CATEGORY_ID,local3);
}
override public function render(param1:int, param2:int) : void {
this._width = param1;
this._height = param2;
this.view.render(param1,param2);
}
override public function get width() : Number {
return this._width;
}
override public function get height() : Number {
return this._height;
}
override public function destroy() : void {
super.destroy();
this.view.destroy();
this.selectedItem = null;
this.view = null;
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.common.longterm
{
import scpacker.Base;
public class LongTermBonusModelBase extends Base
{
public function LongTermBonusModelBase()
{
super();
}
}
}
|
package alternativa.tanks.model.payment.modes.braintree {
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.gui.shop.forms.WaitUrlForm;
import alternativa.tanks.model.payment.category.PayModeView;
import alternativa.tanks.model.payment.modes.PayUrl;
import alternativa.tanks.model.payment.modes.asyncurl.AsyncUrlPayMode;
import alternativa.tanks.model.payment.paymentstate.PaymentWindowService;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.panel.model.payment.modes.braintree.BraintreePaymentModelBase;
import projects.tanks.client.panel.model.payment.modes.braintree.IBraintreePaymentModelBase;
import projects.tanks.client.panel.model.payment.types.PaymentRequestUrl;
import projects.tanks.clients.fp10.libraries.tanksservices.model.payment.PayModeProceed;
[ModelInfo]
public class BraintreePaymentModel extends BraintreePaymentModelBase implements IBraintreePaymentModelBase, AsyncUrlPayMode, ObjectLoadListener, PayModeProceed, PayModeView, ObjectUnloadListener, BraintreePayment {
[Inject]
public static var paymentWindowService:PaymentWindowService;
public function BraintreePaymentModel() {
super();
}
public function requestAsyncUrl() : void {
var local1:Long = paymentWindowService.getChosenItem().id;
server.getPaymentUrl(local1);
}
public function receiveUrl(param1:PaymentRequestUrl) : void {
putData(PaymentRequestUrl,param1);
WaitUrlForm(this.getView()).onPaymentUrlReceived();
}
public function proceedPayment() : void {
PayUrl(object.adapt(PayUrl)).forceGoToUrl(PaymentRequestUrl(getData(PaymentRequestUrl)));
clearData(PaymentRequestUrl);
}
public function getView() : PayModeForm {
return PayModeForm(getData(PayModeForm));
}
public function objectLoaded() : void {
putData(PayModeForm,new WaitUrlForm(object));
}
public function objectUnloaded() : void {
this.getView().destroy();
clearData(PayModeForm);
}
public function isPayPal() : Boolean {
return getInitParam().payPal;
}
}
}
|
package com.lorentz.SVG.display {
import com.lorentz.SVG.display.base.SVGShape;
import com.lorentz.SVG.drawing.IDrawer;
import com.lorentz.SVG.utils.SVGUtil;
import flash.display.Graphics;
public class SVGCircle extends SVGShape {
private var _cxUnits:Number;
private var _cyUnits:Number;
private var _rUnits:Number;
public function SVGCircle(){
super("circle");
}
private var _svgCx:String;
public function get svgCx():String {
return _svgCx;
}
public function set svgCx(value:String):void {
if(_svgCx != value){
_svgCx = value;
invalidateRender();
}
}
private var _svgCy:String;
public function get svgCy():String {
return _svgCy;
}
public function set svgCy(value:String):void {
if(_svgCy != value){
_svgCy = value;
invalidateRender();
}
}
private var _svgR:String;
public function get svgR():String {
return _svgR;
}
public function set svgR(value:String):void {
_svgR = value;
invalidateRender();
}
override protected function beforeDraw():void {
super.beforeDraw();
_cxUnits = getViewPortUserUnit(svgCx, SVGUtil.WIDTH);
_cyUnits = getViewPortUserUnit(svgCy, SVGUtil.HEIGHT);
_rUnits = getViewPortUserUnit(svgR, SVGUtil.WIDTH); //Its based on width?
}
override protected function drawToDrawer(drawer:IDrawer):void {
drawer.moveTo(_cxUnits + _rUnits, _cyUnits);
drawer.arcTo(_rUnits, _rUnits, 0, true, false, _cxUnits - _rUnits, _cyUnits);
drawer.arcTo(_rUnits, _rUnits, 0, true, false, _cxUnits + _rUnits, _cyUnits);
}
override protected function drawDirectlyToGraphics(graphics:Graphics):void {
graphics.drawCircle(_cxUnits, _cyUnits, _rUnits);
}
override protected function get hasDrawDirectlyToGraphics():Boolean {
return true;
}
override public function clone():Object {
var c:SVGCircle = super.clone() as SVGCircle;
c.svgCx = svgCx;
c.svgCy = svgCy;
c.svgR = svgR;
return c;
}
}
}
|
package assets.combo {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.combo.combo_OVER_RIGHT.png")]
public dynamic class combo_OVER_RIGHT extends BitmapData {
public function combo_OVER_RIGHT(param1:int = 33, param2:int = 30) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.models.user.outgoing {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IClanUserOutgoingModelEvents implements IClanUserOutgoingModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IClanUserOutgoingModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getOutgoingClans() : Vector.<Long> {
var result:Vector.<Long> = null;
var i:int = 0;
var m:IClanUserOutgoingModel = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IClanUserOutgoingModel(this.impl[i]);
result = m.getOutgoingClans();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package _codec.projects.tanks.client.clans.clan.info {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import projects.tanks.client.clans.clan.info.ClanInfoCC;
public class CodecClanInfoCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_blocked:ICodec;
private var codec_createTime:ICodec;
private var codec_creatorId:ICodec;
private var codec_description:ICodec;
private var codec_flagId:ICodec;
private var codec_incomingRequestEnabled:ICodec;
private var codec_maxCharactersDescription:ICodec;
private var codec_maxMembers:ICodec;
private var codec_minRankForAddClan:ICodec;
private var codec_name:ICodec;
private var codec_reasonForBlocking:ICodec;
private var codec_self:ICodec;
private var codec_tag:ICodec;
private var codec_timeBlocking:ICodec;
private var codec_users:ICodec;
public function CodecClanInfoCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_blocked = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_createTime = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_creatorId = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_description = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_flagId = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_incomingRequestEnabled = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_maxCharactersDescription = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_maxMembers = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_minRankForAddClan = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_reasonForBlocking = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_self = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_tag = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_timeBlocking = param1.getCodec(new TypeCodecInfo(Long,false));
this.codec_users = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Long,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ClanInfoCC = new ClanInfoCC();
local2.blocked = this.codec_blocked.decode(param1) as Boolean;
local2.createTime = this.codec_createTime.decode(param1) as Long;
local2.creatorId = this.codec_creatorId.decode(param1) as Long;
local2.description = this.codec_description.decode(param1) as String;
local2.flagId = this.codec_flagId.decode(param1) as Long;
local2.incomingRequestEnabled = this.codec_incomingRequestEnabled.decode(param1) as Boolean;
local2.maxCharactersDescription = this.codec_maxCharactersDescription.decode(param1) as int;
local2.maxMembers = this.codec_maxMembers.decode(param1) as int;
local2.minRankForAddClan = this.codec_minRankForAddClan.decode(param1) as int;
local2.name = this.codec_name.decode(param1) as String;
local2.reasonForBlocking = this.codec_reasonForBlocking.decode(param1) as String;
local2.self = this.codec_self.decode(param1) as Boolean;
local2.tag = this.codec_tag.decode(param1) as String;
local2.timeBlocking = this.codec_timeBlocking.decode(param1) as Long;
local2.users = this.codec_users.decode(param1) as Vector.<Long>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ClanInfoCC = ClanInfoCC(param2);
this.codec_blocked.encode(param1,local3.blocked);
this.codec_createTime.encode(param1,local3.createTime);
this.codec_creatorId.encode(param1,local3.creatorId);
this.codec_description.encode(param1,local3.description);
this.codec_flagId.encode(param1,local3.flagId);
this.codec_incomingRequestEnabled.encode(param1,local3.incomingRequestEnabled);
this.codec_maxCharactersDescription.encode(param1,local3.maxCharactersDescription);
this.codec_maxMembers.encode(param1,local3.maxMembers);
this.codec_minRankForAddClan.encode(param1,local3.minRankForAddClan);
this.codec_name.encode(param1,local3.name);
this.codec_reasonForBlocking.encode(param1,local3.reasonForBlocking);
this.codec_self.encode(param1,local3.self);
this.codec_tag.encode(param1,local3.tag);
this.codec_timeBlocking.encode(param1,local3.timeBlocking);
this.codec_users.encode(param1,local3.users);
}
}
}
|
package projects.tanks.client.panel.model.shop.enable.paymode {
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 RestrictionByPayModeModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function RestrictionByPayModeModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.angles.verticals {
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.weapon.angles.verticals.VerticalAnglesCC;
public class VectorCodecVerticalAnglesCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecVerticalAnglesCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(VerticalAnglesCC,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.<VerticalAnglesCC> = new Vector.<VerticalAnglesCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = VerticalAnglesCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:VerticalAnglesCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<VerticalAnglesCC> = Vector.<VerticalAnglesCC>(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 forms.buttons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class MainPanelDonateButton_overBtn extends BitmapAsset
{
public function MainPanelDonateButton_overBtn()
{
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.types {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import projects.tanks.client.battlefield.types.Vector3d;
public class CodecVector3d implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_x:ICodec;
private var codec_y:ICodec;
private var codec_z:ICodec;
public function CodecVector3d() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_x = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_y = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_z = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:Vector3d = new Vector3d();
local2.x = this.codec_x.decode(param1) as Number;
local2.y = this.codec_y.decode(param1) as Number;
local2.z = this.codec_z.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector3d = Vector3d(param2);
this.codec_x.encode(param1,local3.x);
this.codec_y.encode(param1,local3.y);
this.codec_z.encode(param1,local3.z);
}
}
}
|
package alternativa.tanks.model.payment.modes {
import alternativa.tanks.model.payment.PaymentUtils;
import alternativa.tanks.model.payment.category.PayFullDescription;
import alternativa.tanks.model.payment.paymentstate.PaymentWindowService;
import alternativa.tanks.service.payment.IPaymentService;
import flash.net.navigateToURL;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.clients.fp10.libraries.alternativapartners.service.IPartnerService;
import projects.tanks.client.panel.model.payment.modes.IPaymentModeModelBase;
import projects.tanks.client.panel.model.payment.modes.PaymentModeModelBase;
import projects.tanks.client.panel.model.payment.types.PaymentRequestUrl;
[ModelInfo]
public class PaymentModeModel extends PaymentModeModelBase implements IPaymentModeModelBase, PayMode, PayFullDescription, PayUrl {
[Inject]
public static var paymentService:IPaymentService;
[Inject]
public static var partnersService:IPartnerService;
[Inject]
public static var paymentWindowService:PaymentWindowService;
public function PaymentModeModel() {
super();
}
public function setDiscount(param1:Boolean) : void {
putData(Boolean,param1);
}
public function isDiscount() : Boolean {
return getData(Boolean);
}
public function getDescription() : String {
return getInitParam().description + "\n";
}
public function hasCustomManualDescription() : Boolean {
return this.getCustomManualDescription() != null;
}
public function getCustomManualDescription() : String {
return getInitParam().customManualDescription;
}
public function getImage() : ImageResource {
return getInitParam().image;
}
public function getName() : String {
return getInitParam().name;
}
public function getOrderIndex() : int {
return getInitParam().order;
}
public function getFullDescription() : String {
var local3:String = null;
var local1:String = this.getDescription();
var local2:String = this.getManualDescription();
local1 = local1 + "\n" + local2 + "\n";
if(object.hasModel(PayModeDescription)) {
local3 = PayModeDescription(object.adapt(PayModeDescription)).getDescription();
if(local3 != null && local3 != "") {
if(PayModeDescription(object.adapt(PayModeDescription)).rewriteCategoryDescription()) {
local1 = local3 + "\n" + local2;
} else {
local1 += "\n" + local3;
}
}
}
return local1;
}
private function getManualDescription() : String {
if(partnersService.isRunningInsidePartnerEnvironment()) {
return "";
}
if(this.hasCustomManualDescription()) {
return this.getCustomManualDescription();
}
return paymentService.getManualDescription();
}
public function objectLoaded() : void {
putData(Boolean,false);
}
public function forceGoToUrl(param1:PaymentRequestUrl) : void {
navigateToURL(PaymentUtils.createUrlRequest(param1),"_blank");
paymentWindowService.switchToBeginning();
}
public function forceGoToOrderedUrl(param1:PaymentRequestUrl) : void {
navigateToURL(PaymentUtils.createOrderedUrlRequest(param1),"_blank");
paymentWindowService.switchToBeginning();
}
}
}
|
package alternativa.tanks.gui.communication.button {
import controls.buttons.IconButton;
public class CommunicationPanelTabButton extends IconButton implements CommunicationPanelTabControl {
private var category:String;
public function CommunicationPanelTabButton(param1:String, param2:String, param3:Class) {
super(param2,param3);
this.category = param1;
}
public function getCategory() : String {
return this.category;
}
}
}
|
package alternativa.tanks.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class StaticObject3DPositionProvider extends PooledObject implements Object3DPositionProvider {
private static const toCamera:Vector3 = new Vector3();
private var position:Vector3 = new Vector3();
private var offsetToCamera:Number;
public function StaticObject3DPositionProvider(param1:Pool) {
super(param1);
}
public function init(param1:Vector3, param2:Number) : void {
this.position.copy(param1);
this.offsetToCamera = param2;
}
public function initPosition(param1:Object3D) : void {
}
public function updateObjectPosition(param1:Object3D, param2:GameCamera, param3:int) : void {
toCamera.x = param2.x - this.position.x;
toCamera.y = param2.y - this.position.y;
toCamera.z = param2.z - this.position.z;
toCamera.normalize();
param1.x = this.position.x + this.offsetToCamera * toCamera.x;
param1.y = this.position.y + this.offsetToCamera * toCamera.y;
param1.z = this.position.z + this.offsetToCamera * toCamera.z;
}
public function destroy() : void {
recycle();
}
}
}
|
package alternativa.tanks.models.weapon.laser {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.weapon.laser.Laser_EmbedLaserRayBegin.png")]
public class Laser_EmbedLaserRayBegin extends BitmapAsset {
public function Laser_EmbedLaserRayBegin() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.firebird {
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 FlameThrowingSFXModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function FlameThrowingSFXModelServer(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.battleselect.model.battle {
import alternativa.types.Long;
import projects.tanks.client.battleservice.model.types.BattleSuspicionLevel;
public interface IBattleInfoModelBase {
function resetBattleName() : void;
function roundFinished() : void;
function roundStarted(param1:int) : void;
function setBattleName(param1:String) : void;
function updateSuspicion(param1:BattleSuspicionLevel) : void;
function updateUserSuspiciousState(param1:Long, param2:Boolean) : void;
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.battle {
import alternativa.types.Long;
import projects.tanks.client.battleservice.Range;
import projects.tanks.client.tanksservices.model.notifier.battle.BattleNotifierData;
import projects.tanks.client.tanksservices.types.battle.BattleInfoData;
import projects.tanks.clients.fp10.libraries.tanksservices.service.reconnect.ReconnectService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoLabelUpdater;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
public class BattleLinkData {
[Inject]
public static var userInfoService:IUserInfoService;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var reconnectService:ReconnectService;
private var _userId:Long;
private var battleData:BattleInfoData;
private var _mapName:String;
public function BattleLinkData(param1:Long, param2:BattleNotifierData) {
super();
this._userId = param1;
this.battleData = param2.battleData;
if(!this.battleData.inGroup) {
this._mapName = this.battleData.mapName;
}
}
public function get userId() : Long {
return this._userId;
}
public function get battleId() : Long {
return this.battleData.battleId;
}
public function get range() : Range {
return this.battleData.range;
}
public function getBattleData() : BattleInfoData {
return this.battleData;
}
public function isSelfBattle() : Boolean {
var local1:Long = userInfoService.getCurrentUserId();
var local2:IUserInfoLabelUpdater = userInfoService.getOrCreateUpdater(local1);
if(local2.battleLink != null) {
return int(this.battleId.toString()) != 0 && local2.battleLink.battleId == this.battleId;
}
return false;
}
public function isShowBattle() : Boolean {
var local1:Boolean = true;
if(this.battleData.privateBattle) {
local1 = this.isSelfBattle();
}
return local1;
}
public function availableRank() : Boolean {
var local1:int = int(userPropertiesService.rank);
return this.battleData.inGroup || this.isShowBattle() && (local1 >= this.battleData.range.min && local1 <= this.battleData.range.max);
}
public function isClickable() : Boolean {
return this.battleData.proBattle && !this.isSelfBattle() && this.isShowBattle();
}
public function get proBattle() : Boolean {
return this.battleData.proBattle;
}
public function get inGroup() : Boolean {
return this.battleData.inGroup;
}
public function get mapName() : String {
return this._mapName;
}
}
}
|
package alternativa.tanks.models.battle.gui.chat {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.model.chat.ShowChat;
import alternativa.tanks.models.battle.battlefield.BattleUserInfoService;
import alternativa.tanks.models.battle.gui.chat.cmdhandlers.BlockCommandHandler;
import alternativa.tanks.models.battle.gui.chat.cmdhandlers.IChatCommandHandler;
import alternativa.tanks.models.battle.gui.chat.cmdhandlers.UnblockCommandHandler;
import alternativa.tanks.models.battle.gui.statistics.ShortUserInfo;
import alternativa.tanks.models.statistics.IClientUserInfo;
import alternativa.tanks.services.battlegui.BattleGUIService;
import alternativa.tanks.services.battleinput.BattleInputLockType;
import alternativa.tanks.services.battleinput.BattleInputService;
import alternativa.types.Long;
import controls.chat.BattleChatInput;
import controls.chat.ChatInputType;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.FocusEvent;
import flash.events.KeyboardEvent;
import flash.text.TextField;
import flash.ui.Keyboard;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.blockuser.IBlockUserService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.AlertUtils;
[Event(name="sendMessage",type="alternativa.tanks.models.battle.gui.chat.BattleChatEvent")]
public class BattleChat extends Sprite implements ShowChat {
[Inject]
public static var display:IDisplay;
[Inject]
public static var battleInputLockService:BattleInputService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var blockUserService:IBlockUserService;
[Inject]
public static var battleGuiService:BattleGUIService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var userInfoService:BattleUserInfoService;
[Inject]
public static var fullscreenService:FullscreenService;
private const CMD_BLOCK:String = "/block";
private const CMD_UNBLOCK:String = "/unblock";
private const FULL_SCREEN:String = "fullScreen";
private const FULL_SCREEN_INTERACTIVE_ACCEPTED:String = "fullScreenInteractiveAccepted";
private var commandHandlers:Object;
private var spectatorList:SpectatorList;
private var _alwaysShow:Boolean;
private var inputControl:BattleChatInput;
private var input:TextField;
private var output:BattleChatOutput;
private var _chatOpened:Boolean;
private var _locked:Boolean;
private var _teamOnly:Boolean;
private var _team:BattleTeam;
private var _object:IGameObject;
public function BattleChat() {
super();
this.init();
}
public function set alwaysShow(param1:Boolean) : void {
if(this._alwaysShow != param1) {
this._alwaysShow = param1;
if(!this._chatOpened) {
this.output.visible = this._alwaysShow;
}
}
}
public function set locked(param1:Boolean) : void {
this._locked = param1;
}
public function get chatOpened() : Boolean {
return this._chatOpened;
}
public function addUserMessage(param1:Long, param2:BattleTeam, param3:String, param4:Boolean, param5:Boolean) : void {
var local6:String = null;
if(!param5) {
local6 = userInfoService.getUserName(param1);
if(blockUserService.isBlocked(local6)) {
return;
}
}
this.output.addLine(param1,param2,param3,param4,param5);
this.onResize();
}
public function addSystemMessage(param1:String) : void {
this.output.addSystemMessage(param1);
this.onResize();
}
public function clear() : void {
this.output.clear();
}
public function openChat() : void {
var local1:ShortUserInfo = null;
if(!(this._chatOpened || this._locked)) {
this.output.visible = true;
this.spectatorList.visible = this.spectatorList.getText().length > 0;
if(!battleInfoService.isSpectatorMode()) {
local1 = IClientUserInfo(this._object.adapt(IClientUserInfo)).getShortUserInfo(userPropertiesService.userId);
this._team = local1.teamType;
}
this.addEventListeners();
this._chatOpened = true;
this.input.text = "";
this.inputControl.visible = true;
display.stage.focus = this.input;
this.onResize();
battleInputLockService.lock(BattleInputLockType.CHAT);
battleEventDispatcher.dispatchEvent(new ChatEvent(ChatEvent.OPEN));
this.setInputTeam();
}
}
public function setBattleObject(param1:IGameObject) : void {
this._object = param1;
this._teamOnly = true;
}
private function setInputTeam() : void {
if(battleInfoService.isSpectatorMode()) {
if(this._teamOnly) {
this.inputControl.setInputType(ChatInputType.YELLOW);
this.inputControl.setChannelText(localeService.getText(TanksLocale.TEXT_CHAT_LABEL_SPECTATORS));
} else {
this.inputControl.setInputType(ChatInputType.STANDART);
this.inputControl.setChannelText(localeService.getText(TanksLocale.TEXT_CHAT_LABEL_ALL));
}
return;
}
if(this._teamOnly && this._team != BattleTeam.NONE) {
if(this._team == BattleTeam.BLUE) {
this.inputControl.setInputType(ChatInputType.BLUE);
} else {
this.inputControl.setInputType(ChatInputType.RED);
}
this.inputControl.setChannelText(localeService.getText(TanksLocale.TEXT_CHAT_LABEL_TEAM));
} else {
this.inputControl.setInputType(ChatInputType.STANDART);
this.inputControl.setChannelText(localeService.getText(TanksLocale.TEXT_CHAT_LABEL_ALL));
}
}
private function changeChannel() : void {
this._teamOnly = !this._teamOnly;
this.setInputTeam();
}
public function closeChat() : void {
if(this._chatOpened) {
this.output.visible = this._alwaysShow;
this.spectatorList.visible = false;
this.spectatorList.setText("");
if(this.inputControl.visible) {
this.removeEventListeners();
this._chatOpened = false;
this.inputControl.visible = false;
this.clearChatInputFocus();
this.output.minimize();
this.onResize();
}
battleInputLockService.unlock(BattleInputLockType.CHAT);
battleEventDispatcher.dispatchEvent(new ChatEvent(ChatEvent.CLOSE));
}
}
private function init() : void {
this.inputControl = new BattleChatInput();
this.inputControl.tabEnabled = false;
this.inputControl.tabChildren = false;
this.inputControl.x = 10;
addChild(this.inputControl);
this.input = this.inputControl.textField;
this.input.maxChars = 299;
this.input.addEventListener(KeyboardEvent.KEY_UP,this.onInputKeyUp);
this.input.addEventListener(FocusEvent.FOCUS_IN,this.onFocusIn);
this.output = new BattleChatOutput();
this.output.visible = this._alwaysShow;
this.output.tabEnabled = false;
this.output.tabChildren = false;
this.output.x = 10;
addChild(this.output);
this.spectatorList = new SpectatorList();
this.spectatorList.x = 10;
this.spectatorList.visible = false;
addChild(this.spectatorList);
this.initCommandHandlers();
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemovedFromStage);
}
private function initCommandHandlers() : void {
this.commandHandlers = {};
this.commandHandlers[this.CMD_BLOCK] = new BlockCommandHandler(this.output);
this.commandHandlers[this.CMD_UNBLOCK] = new UnblockCommandHandler(this.output);
}
public function setSpectatorList(param1:String) : void {
this.spectatorList.setText(param1);
}
[Obfuscation(rename="false")]
public function setShowChat(param1:Boolean) : void {
this.alwaysShow = param1;
}
private function addEventListeners() : void {
this.input.addEventListener(FocusEvent.FOCUS_OUT,this.onFocusOut);
if(fullscreenService.isAvailable()) {
display.stage.addEventListener(this.FULL_SCREEN,this.onFullscreen);
display.stage.addEventListener(this.FULL_SCREEN_INTERACTIVE_ACCEPTED,this.onFullscreen);
}
}
private function removeEventListeners() : void {
this.input.removeEventListener(FocusEvent.FOCUS_OUT,this.onFocusOut);
if(fullscreenService.isAvailable()) {
display.stage.removeEventListener(this.FULL_SCREEN,this.onFullscreen);
display.stage.removeEventListener(this.FULL_SCREEN_INTERACTIVE_ACCEPTED,this.onFullscreen);
}
}
private function onAddedToStage(param1:Event) : void {
this.inputControl.visible = false;
stage.addEventListener(Event.RESIZE,this.onResize);
this.onResize(null);
}
private function onRemovedFromStage(param1:Event) : void {
stage.removeEventListener(Event.RESIZE,this.onResize);
}
private function onResize(param1:Event = null) : void {
var local2:Number = NaN;
if(this._chatOpened) {
this.output.maximize();
}
var local3:int = int(0.25 * display.stage.stageWidth);
var local4:int = int(battleGuiService.getPositionXInventory());
if(local4 != 0 && this.inputControl.x + local3 + 10 > local4) {
local3 = local4 - this.inputControl.x - 10;
}
this.inputControl.width = local3;
this.inputControl.y = display.stage.stageHeight - this.inputControl.height - 130;
local2 = this.inputControl.y - this.output.height - 10;
if(local2 < 50) {
while(local2 < 50) {
local2 += this.output.height;
this.output.removeFirstMessage();
local2 -= this.output.height;
}
}
this.output.y = local2;
this.spectatorList.setLabelWidth(0.25 * display.stage.stageWidth);
this.spectatorList.y = local2 - 120;
if(this._chatOpened) {
this.setInputTeam();
}
}
private function onInputKeyUp(param1:KeyboardEvent) : void {
if(this.inputControl.visible) {
if(param1.keyCode == Keyboard.ENTER) {
if(this.input.text != "") {
if(!this.handleCommand(this.input.text) && hasEventListener(BattleChatEvent.SEND_MESSAGE)) {
dispatchEvent(new BattleChatEvent(BattleChatEvent.SEND_MESSAGE,this.input.text,this._teamOnly));
}
this.input.text = "";
}
param1.keyCode = 0;
this.closeChat();
}
if(AlertUtils.isCancelKey(param1.keyCode)) {
param1.keyCode = 0;
this.closeChat();
}
if(param1.keyCode == Keyboard.TAB) {
this.changeChannel();
}
}
}
private function handleCommand(param1:String) : Boolean {
if(param1.charAt(0) != "/") {
return false;
}
var local2:Array = param1.split(/\s+/);
if(local2.length == 0) {
return false;
}
var local3:String = local2.shift();
var local4:IChatCommandHandler = this.commandHandlers[local3];
if(local4 == null) {
return false;
}
local4.handleCommand(local2);
return true;
}
private function onFocusIn(param1:FocusEvent) : void {
if(!this._chatOpened) {
this.clearChatInputFocus();
}
}
private function onFocusOut(param1:FocusEvent) : void {
if(stage && this.input && this.inputControl && Boolean(this.inputControl.visible)) {
stage.focus = this.input;
} else {
this.closeChat();
}
}
private function onFullscreen(param1:Event) : void {
if(this._chatOpened) {
stage.focus = this.input;
}
}
private function clearChatInputFocus() : void {
if(display.stage.focus == this.input) {
display.stage.focus = null;
}
}
}
}
|
package projects.tanks.client.panel.model.shop.specialkit.view.singleitem {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class SingleItemKitViewModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:SingleItemKitViewModelServer;
private var client:ISingleItemKitViewModelBase = ISingleItemKitViewModelBase(this);
private var modelId:Long = Long.getLong(1606448211,-1233422259);
public function SingleItemKitViewModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new SingleItemKitViewModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(SingleItemKitViewCC,false)));
}
protected function getInitParam() : SingleItemKitViewCC {
return SingleItemKitViewCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.camera.controllers.spectator {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.camera.CameraBookmark;
import alternativa.tanks.models.battle.battlefield.SpectatorFogToggleSupport;
import alternativa.tanks.services.battleinput.BattleInputLockEvent;
import alternativa.tanks.services.battleinput.BattleInputService;
import flash.events.KeyboardEvent;
import platform.client.fp10.core.type.AutoClosable;
public class SpectatorSupport implements AutoClosable, BookmarkListener {
[Inject]
public static var display:IDisplay;
[Inject]
public static var battleService:BattleService;
[Inject]
public static var battleInputService:BattleInputService;
private const cameraController:SpectatorCameraController = new SpectatorCameraController();
private const playerCamera:PlayerCamera = new PlayerCamera(this.cameraController);
private const bookmarksHandler:BookmarksHandler = new BookmarksHandler();
private var keyboardHandlers:Vector.<KeyboardHandler>;
public function SpectatorSupport() {
super();
this.keyboardHandlers = Vector.<KeyboardHandler>([this.playerCamera,this.bookmarksHandler,new SpectatorBonusRegionController(),new SpectatorFogToggleSupport()]);
display.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
display.stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
battleService.setCameraController(this.cameraController);
battleInputService.addEventListener(BattleInputLockEvent.INPUT_LOCKED,this.onInputLocked);
battleInputService.addEventListener(BattleInputLockEvent.INPUT_UNLOCKED,this.onInputUnlocked);
if(battleInputService.isInputLocked()) {
this.cameraController.deactivateInputListeners();
}
this.bookmarksHandler.setListener(this);
}
private function onInputLocked(param1:BattleInputLockEvent) : void {
this.cameraController.deactivateInputListeners();
}
private function onInputUnlocked(param1:BattleInputLockEvent) : void {
this.cameraController.activateInputListeners();
}
private function onKeyDown(param1:KeyboardEvent) : void {
var local2:KeyboardHandler = null;
for each(local2 in this.keyboardHandlers) {
local2.handleKeyDown(param1);
}
}
private function onKeyUp(param1:KeyboardEvent) : void {
var local2:KeyboardHandler = null;
for each(local2 in this.keyboardHandlers) {
local2.handleKeyUp(param1);
}
}
public function onBookmarkSelected(param1:CameraBookmark) : void {
this.playerCamera.unfocus();
this.cameraController.setCameraState(param1.position,param1.eulerAnlges);
}
public function close() : void {
display.stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
display.stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
battleInputService.removeEventListener(BattleInputLockEvent.INPUT_LOCKED,this.onInputLocked);
battleInputService.removeEventListener(BattleInputLockEvent.INPUT_UNLOCKED,this.onInputUnlocked);
this.playerCamera.close();
}
}
}
|
package alternativa.tanks.models.statistics {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.models.battlemessages.BattlefieldMessages;
import flash.events.Event;
import platform.client.fp10.core.type.AutoClosable;
public class BattlefieldMessagesAligner implements AutoClosable {
[Inject]
public static var display:IDisplay;
private var battlefieldMessages:BattlefieldMessages;
public function BattlefieldMessagesAligner(param1:BattlefieldMessages) {
super();
this.battlefieldMessages = param1;
display.stage.addEventListener(Event.RESIZE,this.onStageResize);
this.align();
}
private function onStageResize(param1:Event) : void {
this.align();
}
private function align() : void {
var local1:int = int(display.stage.stageWidth);
this.battlefieldMessages.x = 0.5 * local1;
this.battlefieldMessages.y = 40;
}
[Obfuscation(rename="false")]
public function close() : void {
this.battlefieldMessages = null;
display.stage.removeEventListener(Event.RESIZE,this.onStageResize);
}
}
}
|
package alternativa.tanks.model.item.discount {
import controls.timer.CountDownTimer;
[ModelInterface]
public interface DiscountEndTimer {
function getEndDiscountTimer() : CountDownTimer;
}
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_SELECTED_GREEN_TL.png")]
public dynamic class bres_SELECTED_GREEN_TL extends BitmapData {
public function bres_SELECTED_GREEN_TL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.ultimate.effects.hornet {
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.ultimate.effects.hornet.HornetUltimateCC;
public class VectorCodecHornetUltimateCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecHornetUltimateCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(HornetUltimateCC,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.<HornetUltimateCC> = new Vector.<HornetUltimateCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = HornetUltimateCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:HornetUltimateCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<HornetUltimateCC> = Vector.<HornetUltimateCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.weapon.railgun {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.battle.objects.tank.WeaponPlatform;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.BasicGlobalGunParams;
import alternativa.tanks.models.weapon.WeaponForces;
import alternativa.tanks.physics.CollisionGroup;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
public class RemoteRailgunWeapon implements Weapon {
private static const allGunParams:AllGlobalGunParams = new AllGlobalGunParams();
private static const basicGunParams:BasicGlobalGunParams = new BasicGlobalGunParams();
private var effects:IRailgunEffects;
private var weaponPlatform:WeaponPlatform;
private var railgunData:RailgunData;
private var weaponForces:WeaponForces;
public function RemoteRailgunWeapon(param1:WeaponForces, param2:RailgunData, param3:IRailgunEffects) {
super();
this.weaponForces = param1;
this.railgunData = param2;
this.effects = param3;
}
public function init(param1:WeaponPlatform) : void {
this.weaponPlatform = param1;
}
public function destroy() : void {
this.effects.stopEffects();
}
public function activate() : void {
}
public function deactivate() : void {
this.effects.stopEffects();
}
public function enable() : void {
}
public function disable(param1:Boolean) : void {
this.effects.stopEffects();
}
public function reset() : void {
this.effects.stopEffects();
}
public function getStatus() : Number {
return 0;
}
public function startCharging() : void {
this.effects.createChargeEffect(this.weaponPlatform.getLocalMuzzlePosition(),this.weaponPlatform.getTurret3D(),this.railgunData.getChargingTime());
this.weaponPlatform.getBasicGunParams(basicGunParams);
this.effects.createSoundEffect(basicGunParams.muzzlePosition,RailgunWeapon.DEFAULT_CHARGE_DURATION - this.railgunData.getChargingTime());
}
public function fire(param1:Vector3, param2:Vector.<Body>, param3:Vector.<Vector3>) : void {
var local5:Vector3 = null;
var local6:Number = NaN;
var local7:int = 0;
var local8:Body = null;
var local9:Vector3 = null;
var local10:Tank = null;
this.weaponPlatform.getAllGunParams(allGunParams);
this.weaponPlatform.getBody().addWorldForceScaled(allGunParams.muzzlePosition,allGunParams.direction,-this.weaponForces.getRecoilForce());
this.weaponPlatform.addDust();
var local4:Vector3 = param1;
if(param2 != null && param2.length > 0) {
local5 = new Vector3();
local5.diff(param3[param3.length - 1],allGunParams.barrelOrigin).normalize();
if(Vector3.isFiniteVector(local5)) {
if(local4 == null) {
local4 = RailgunUtils.getDistantPoint(allGunParams.barrelOrigin,local5);
}
local6 = 1;
local7 = 0;
while(local7 < param2.length) {
local8 = param2[local7];
if(local8 != null && local8.tank != null) {
local9 = param3[local7];
if(Vector3.isFiniteVector(local9)) {
local10 = local8.tank;
local10.applyWeaponHit(local9,local5,this.weaponForces.getImpactForce() * local6);
}
}
local6 *= this.railgunData.getWeakeningCoeff();
local7++;
}
}
this.effects.createTargetHitEffects(allGunParams.muzzlePosition,param3[param3.length - 1],param3,param2);
}
this.effects.createShotTrail(allGunParams.muzzlePosition,local4,allGunParams.direction);
if(param1 != null) {
this.effects.createStaticHitMark(allGunParams.barrelOrigin,param1);
this.effects.createStaticHitEffect(allGunParams.muzzlePosition,param1,this.getStaticHitPointNormal(allGunParams.muzzlePosition,param1));
}
}
private function getStaticHitPointNormal(param1:Vector3, param2:Vector3) : Vector3 {
var local3:Vector3 = param2.clone();
local3.subtract(param1).normalize();
var local4:Vector3 = param2.clone();
local4.subtract(local3);
var local5:RayHit = new RayHit();
if(this.weaponPlatform.getBody().scene.collisionDetector.raycastStatic(local4,local3,CollisionGroup.STATIC,100,null,local5)) {
return local5.normal;
}
local3.reverse();
return local3;
}
public function fireDummy() : void {
this.weaponPlatform.getAllGunParams(allGunParams);
this.weaponPlatform.getBody().addWorldForceScaled(allGunParams.muzzlePosition,allGunParams.direction,-this.weaponForces.getRecoilForce());
this.weaponPlatform.addDust();
}
public function getResistanceProperty() : ItemProperty {
return ItemProperty.RAILGUN_RESISTANCE;
}
public function updateRecoilForce(param1:Number) : void {
this.weaponForces.setRecoilForce(param1);
}
public function fullyRecharge() : void {
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
}
public function stun() : void {
}
public function calm(param1:int) : void {
}
}
}
|
package alternativa.tanks.models.weapon.splash {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class SplashAdapt implements Splash {
private var object:IGameObject;
private var impl:Splash;
public function SplashAdapt(param1:IGameObject, param2:Splash) {
super();
this.object = param1;
this.impl = param2;
}
public function applySplashForce(param1:Vector3, param2:Number, param3:Body, param4:SplashParams = null) : Boolean {
var result:Boolean = false;
var hitPoint:Vector3 = param1;
var impactCoeff:Number = param2;
var excludedTarget:Body = param3;
var splashParams:SplashParams = param4;
try {
Model.object = this.object;
result = Boolean(this.impl.applySplashForce(hitPoint,impactCoeff,excludedTarget,splashParams));
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.partners.impl.kongregate {
public interface IKongregatePaymentModelBase {
function receivePaymentTransaction(param1:String) : void;
}
}
|
package alternativa.tanks.models.weapons.discrete {
import alternativa.math.Vector3;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapons.common.discrete.TargetHit;
public class DiscreteWeaponListenerEvents implements DiscreteWeaponListener {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function DiscreteWeaponListenerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function onShot(param1:IGameObject, param2:Vector3, param3:Vector.<TargetHit>) : void {
var i:int = 0;
var m:DiscreteWeaponListener = null;
var shooter:IGameObject = param1;
var direction:Vector3 = param2;
var targets:Vector.<TargetHit> = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = DiscreteWeaponListener(this.impl[i]);
m.onShot(shooter,direction,targets);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package scpacker.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksLoaderWindow_bitmapWindow extends BitmapAsset
{
public function GTanksLoaderWindow_bitmapWindow()
{
super();
}
}
}
|
package alternativa.tanks.model.item.grouped {
import projects.tanks.client.garage.models.item.grouped.GroupedItemModelBase;
import projects.tanks.client.garage.models.item.grouped.IGroupedItemModelBase;
[ModelInfo]
public class GroupedItemModel extends GroupedItemModelBase implements IGroupedItemModelBase, IGroupedItem {
public function GroupedItemModel() {
super();
}
public function isGrouped() : Boolean {
return getInitParam().grouped;
}
public function getGroup() : int {
return getInitParam().group;
}
}
}
|
package _codec.platform.client.models.commons.periodtime {
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 platform.client.models.commons.periodtime.TimePeriodModelCC;
public class VectorCodecTimePeriodModelCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTimePeriodModelCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TimePeriodModelCC,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.<TimePeriodModelCC> = new Vector.<TimePeriodModelCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TimePeriodModelCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TimePeriodModelCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TimePeriodModelCC> = Vector.<TimePeriodModelCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.paygarden {
public class PayGardenProductType {
public static const CRYSTALS:PayGardenProductType = new PayGardenProductType(0,"CRYSTALS");
public static const PREMIUM:PayGardenProductType = new PayGardenProductType(1,"PREMIUM");
public static const ITEM:PayGardenProductType = new PayGardenProductType(2,"ITEM");
private var _value:int;
private var _name:String;
public function PayGardenProductType(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<PayGardenProductType> {
var local1:Vector.<PayGardenProductType> = new Vector.<PayGardenProductType>();
local1.push(CRYSTALS);
local1.push(PREMIUM);
local1.push(ITEM);
return local1;
}
public function toString() : String {
return "PayGardenProductType [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.model.payment.modes {
[ModelInterface]
public interface PayModeManualDescription {
function hasCustomManualDescription() : Boolean;
function getCustomManualDescription() : String;
}
}
|
package forms
{
import alternativa.osgi.service.locale.ILocaleService;
import controls.Label;
import controls.TankWindow;
import flash.display.Bitmap;
import flash.display.Sprite;
import resources.windowheaders.background.BackgroundHeader;
public class TankWindowWithHeader extends Sprite
{
private static const HEADER_BACKGROUND_HEIGHT:int = 25;
private static const HEADER_BACKGROUND_INNER_HEIGHT:int = 22;
public static var localeService:ILocaleService;
private const GAP_11:int = 11;
private var label:Label;
private var window:TankWindow;
private var headerBackground:Bitmap;
public function TankWindowWithHeader(param1:String = null)
{
this.label = new Label();
super();
this.window = new TankWindow();
addChild(this.window);
this.initHeaderStyle();
if(param1 != null)
{
this.setHeader(param1);
}
}
public static function createWindow(param1:String, param2:int = -1, param3:int = -1) : TankWindowWithHeader
{
var _loc4_:TankWindowWithHeader = new TankWindowWithHeader(param1);
_loc4_.width = param2;
_loc4_.height = param3;
return _loc4_;
}
private function initHeaderStyle() : void
{
this.label.size = 16;
this.label.color = 12632256;
this.label.sharpness = 40;
this.label.thickness = 70;
this.label.bold = true;
}
private function setHeader(param1:String) : void
{
this.label.text = param1;
if(this.label.width > this.label.height)
{
if(this.label.width + 2 * this.GAP_11 < BackgroundHeader.shortBackgroundHeader.width)
{
this.headerBackground = new Bitmap(BackgroundHeader.shortBackgroundHeader);
}
else
{
this.headerBackground = new Bitmap(BackgroundHeader.longBackgroundHeader);
}
}
else
{
this.headerBackground = new Bitmap(BackgroundHeader.verticalBackgroundHeader);
}
addChild(this.headerBackground);
addChild(this.label);
this.resize();
}
public function setHeaderId(param1:String) : void
{
this.setHeader(localeService.getText(param1));
}
override public function set width(param1:Number) : void
{
this.window.width = param1;
this.resize();
}
override public function get width() : Number
{
return this.window.width;
}
override public function set height(param1:Number) : void
{
this.window.height = param1;
this.resize();
}
override public function get height() : Number
{
return this.window.height;
}
private function resize() : void
{
if(this.headerBackground != null)
{
if(this.label.width > this.label.height)
{
this.headerBackground.x = this.window.width - this.headerBackground.width >> 1;
this.headerBackground.y = -HEADER_BACKGROUND_HEIGHT;
this.label.x = this.window.width - this.label.width >> 1;
this.label.y = 5 - (HEADER_BACKGROUND_INNER_HEIGHT + this.label.height >> 1);
}
else
{
this.headerBackground.x = -HEADER_BACKGROUND_HEIGHT;
this.headerBackground.y = this.window.height - this.headerBackground.height >> 1;
this.label.x = 5 - (HEADER_BACKGROUND_INNER_HEIGHT + this.label.width >> 1);
this.label.y = this.window.height - this.label.height >> 1;
}
}
}
}
}
|
package alternativa.tanks.model.item.countable {
import platform.client.fp10.core.model.IObjectLoadListener;
import projects.tanks.client.garage.models.item.countable.CountableItemModelBase;
import projects.tanks.client.garage.models.item.countable.ICountableItemModelBase;
[ModelInfo]
public class CountableItemModel extends CountableItemModelBase implements ICountableItemModelBase, ICountableItem, IObjectLoadListener {
public function CountableItemModel() {
super();
}
public function getCount() : int {
return int(getData(CountableItemModel));
}
public function setCount(param1:int) : void {
putData(CountableItemModel,param1);
}
public function objectLoaded() : void {
putData(CountableItemModel,getInitParam().count);
}
public function objectLoadedPost() : void {
}
public function objectUnloaded() : void {
}
public function objectUnloadedPost() : void {
}
}
}
|
package alternativa.tanks.models.weapons.shell {
import alternativa.math.Vector3;
[ModelInterface]
public interface ShellWeaponListener {
function onShot(param1:int, param2:int, param3:Vector3) : void;
function onDummyShot(param1:int) : void;
}
}
|
package alternativa.tanks.controller.events {
import flash.events.Event;
public class LoginButtonPressed extends Event {
public static const EVENT_TYPE:String = "LoginButtonPressed.EVENT_TYPE";
public function LoginButtonPressed() {
super(EVENT_TYPE);
}
}
}
|
package alternativa.tanks.gui.tankpreview {
public interface TankPreviewState {
function enter() : void;
function update() : void;
function exit() : void;
}
}
|
package alternativa.tanks.model.challenge
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChallengesIcons_winScoreTypeBitmap extends BitmapAsset
{
public function ChallengesIcons_winScoreTypeBitmap()
{
super();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.