code stringlengths 57 237k |
|---|
package forms.friends
{
public interface IFriendsListState
{
function initList() : void;
function hide() : void;
function filter(param1:String, param2:String) : void;
function resetFilter() : void;
function resize(param1:Number, param2:Number) : void;
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.online {
import alternativa.types.Long;
import flash.events.IEventDispatcher;
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.online.ClientOnlineNotifierData;
public interface IOnlineNotifierService extends IEventDispatcher {
function setOnline(param1:Vector.<ClientOnlineNotifierData>) : void;
function addUserOnlineData(param1:ClientOnlineNotifierData) : void;
function removeUserOnlineData(param1:Long) : void;
function hasUserOnlineData(param1:Long) : Boolean;
function getUserOnlineData(param1:Long) : ClientOnlineNotifierData;
}
}
|
package projects.tanks.client.chat.models.news.showing {
public class NewsShowingCC {
private var _newsItems:Vector.<NewsItemData>;
public function NewsShowingCC(param1:Vector.<NewsItemData> = null) {
super();
this._newsItems = param1;
}
public function get newsItems() : Vector.<NewsItemData> {
return this._newsItems;
}
public function set newsItems(param1:Vector.<NewsItemData>) : void {
this._newsItems = param1;
}
public function toString() : String {
var local1:String = "NewsShowingCC [";
local1 += "newsItems = " + this.newsItems + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.view.mainview.grouplist.item {
import alternativa.tanks.gui.friends.list.renderer.background.UserOfflineCellNormal;
import alternativa.tanks.gui.friends.list.renderer.background.UserOfflineCellSelected;
import controls.cellrenderer.ButtonState;
import controls.cellrenderer.CellNormal;
import controls.cellrenderer.CellNormalSelected;
import flash.display.Sprite;
public class GroupUserCellStyle extends Sprite {
protected var _width:int = 100;
private var background:ButtonState;
public function GroupUserCellStyle(param1:Boolean, param2:Boolean) {
super();
if(param2) {
this.background = param1 ? new CellNormalSelected() : new UserOfflineCellSelected();
} else {
this.background = param1 ? new CellNormal() : new UserOfflineCellNormal();
}
addChild(this.background);
this.resize();
}
private function resize() : void {
this.background.width = this._width;
}
override public function set width(param1:Number) : void {
this._width = Math.floor(param1);
this.resize();
}
}
}
|
package alternativa.tanks.models.tank.explosion
{
import alternativa.object.ClientObject;
import alternativa.tanks.models.tank.TankData;
public interface ITankExplosionModel
{
function createExplosionEffects(param1:ClientObject, param2:TankData) : void;
}
}
|
package scpacker.test.spectator
{
import flash.events.KeyboardEvent;
import flash.ui.Keyboard;
public class SpectatorBonusRegionController implements KeyboardHandler
{
[Inject]
public static var bonusRegionService:Object;
public function SpectatorBonusRegionController()
{
super();
}
public function handleKeyDown(param1:KeyboardEvent) : void
{
if(param1.keyCode == Keyboard.QUOTE)
{
}
}
public function handleKeyUp(param1:KeyboardEvent) : void
{
}
}
}
|
package alternativa.tanks.model.matchmaking.notify {
import alternativa.osgi.service.locale.ILocaleService;
import controls.base.LabelBase;
import forms.ColorConstants;
import projects.tanks.clients.flash.commons.services.notification.Notification;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class MatchmakingTimeoutNotification extends Notification {
[Inject]
public static var localeService:ILocaleService;
private var _messageLabel:LabelBase;
public function MatchmakingTimeoutNotification() {
super(null,TanksLocale.TEXT_MATCHMAKING_TIMEOUT_MESSAGE);
}
override protected function init() : void {
super.init();
this._messageLabel = new LabelBase();
this._messageLabel.mouseEnabled = false;
addChild(this._messageLabel);
this._messageLabel.color = ColorConstants.GREEN_LABEL;
this._messageLabel.text = localeService.getText(TanksLocale.TEXT_MATCHMAKING_TIMEOUT_MESSAGE);
}
override protected function resize() : void {
this._messageLabel.x = GAP + 7;
this._messageLabel.y = GAP + 5;
_innerHeight = this._messageLabel.y + this._messageLabel.height - 3;
var local1:int = this._messageLabel.x + this._messageLabel.width + GAP * 2;
if(local1 > _width) {
_width = local1;
}
_height = _innerHeight + GAP * 2 + 1;
super.resize();
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _fdfea708716e61412b5eb06a2b47e0d0ff96589e1b683dee5d4bba149e1024cb_flash_display_Sprite extends Sprite {
public function _fdfea708716e61412b5eb06a2b47e0d0ff96589e1b683dee5d4bba149e1024cb_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 alternativa.tanks.models.user.outgoing {
import alternativa.tanks.gui.notinclan.clanslist.ClansListEvent;
import alternativa.tanks.models.user.ClanUserService;
import alternativa.tanks.models.user.IClanUserModel;
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.clans.user.outgoing.ClanUserOutgoingModelBase;
import projects.tanks.client.clans.user.outgoing.IClanUserOutgoingModelBase;
[ModelInfo]
public class ClanUserOutgoingModel extends ClanUserOutgoingModelBase implements IClanUserOutgoingModelBase, ObjectLoadListener, ObjectUnloadListener, IClanUserOutgoingModel {
[Inject]
public static var clanUserService:ClanUserService;
private var clans:Vector.<Long>;
public function ClanUserOutgoingModel() {
super();
}
public function objectLoaded() : void {
if(!this.isServiceSpace()) {
return;
}
this.clans = getInitParam().objects.concat();
}
public function objectUnloaded() : void {
if(!this.isServiceSpace()) {
return;
}
this.clans.length = 0;
}
public function onAdding(param1:Long) : void {
if(!this.isServiceSpace()) {
return;
}
this.clans.push(param1);
ClansListEvent.getDispatcher().dispatchEvent(new ClansListEvent(ClansListEvent.OUTGOING + ClansListEvent.ADD,param1));
}
public function onRemoved(param1:Long) : void {
if(!this.isServiceSpace()) {
return;
}
var local2:int = int(this.clans.indexOf(param1));
if(local2 >= 0) {
this.clans.splice(local2,1);
ClansListEvent.getDispatcher().dispatchEvent(new ClansListEvent(ClansListEvent.OUTGOING + ClansListEvent.REMOVE,param1));
}
}
public function getOutgoingClans() : Vector.<Long> {
return this.clans;
}
private function isServiceSpace() : Boolean {
return IClanUserModel(object.adapt(IClanUserModel)).loadingInServiceSpace();
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.rarity {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.EnumCodecInfo;
import projects.tanks.client.garage.models.item.rarity.Rarity;
public class VectorCodecRarityLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRarityLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(Rarity,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.<Rarity> = new Vector.<Rarity>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = Rarity(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:Rarity = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<Rarity> = Vector.<Rarity>(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.gui.settings.tabs.control {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.gui.settings.SettingsWindow;
import alternativa.tanks.gui.settings.tabs.ScrollableSettingsTabView;
import alternativa.tanks.service.settings.SettingEnum;
import base.DiscreteSprite;
import controls.Slider;
import controls.TankWindowInner;
import controls.base.LabelBase;
import controls.containers.VerticalStackPanel;
import forms.events.SliderEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenService;
public class ControlSettingsTab extends ScrollableSettingsTabView {
[Inject]
public static var fullScreenService:FullscreenService;
[Inject]
public static var display:IDisplay;
public static const MIN_SENSITIVITY_MOUSE:int = 1;
public static const MAX_SENSITIVITY_MOUSE:int = 20;
private var mouseSensitivity:Slider;
public function ControlSettingsTab() {
super();
var local1:TankWindowInner = new TankWindowInner(SettingsWindow.TAB_VIEW_MAX_WIDTH,SettingsWindow.TAB_VIEW_MAX_HEIGHT,TankWindowInner.TRANSPARENT);
addChildAt(local1,0);
var local2:VerticalStackPanel = new VerticalStackPanel();
local2.setMargin(MARGIN);
local2.x = MARGIN;
local2.y = TOP_MARGIN_FOR_SCROLL_TAB;
if(fullScreenService.isMouseLockEnabled()) {
local2.addItem(this.createMouseControlPanel());
}
local2.addItem(createCheckBox(SettingEnum.INVERSE_BACK_DRIVING,localeService.getText(TanksLocale.TEXT_SETTINGS_INVERSE_TURN_CONTROL_CHECKBOX_LABEL_TEXT),settingsService.inverseBackDriving));
local2.addItem(new KeyBindingsPanel());
addItem(local2);
}
private function createMouseControlPanel() : DiscreteSprite {
var local1:VerticalStackPanel = new VerticalStackPanel();
local1.setMargin(MARGIN);
local1.addItem(createCheckBox(SettingEnum.MOUSE_CONTROL,localeService.getText(TanksLocale.TEXT_SETTINGS_MOUSE_CONTROL_CHECKBOX),settingsService.mouseControl));
local1.addItem(this.createMouseSensitivityBlock());
local1.addItem(createCheckBox(SettingEnum.MOUSE_Y_INVERSE,localeService.getText(TanksLocale.TEXT_SETTINGS_MOUSE_INVERSION_CHECKBOX_LABEL),settingsService.mouseYInverse));
local1.addItem(createCheckBox(SettingEnum.MOUSE_Y_INVERSE_SHAFT_AIM,localeService.getText(TanksLocale.TEXT_SETTINGS_MOUSE_SHAFT_SCOPE_VERTICAL_INVERSION),settingsService.mouseYInverseShaftAim));
return local1;
}
private function createMouseSensitivityBlock() : DiscreteSprite {
var local1:DiscreteSprite = new DiscreteSprite();
var local2:LabelBase = new LabelBase();
local2.text = localeService.getText(TanksLocale.TEXT_SETTINGS_MOUSE_SENSITIVITY_CHECKBOX_LABEL) + ":";
local1.addChild(local2);
this.mouseSensitivity = new Slider();
this.mouseSensitivity.maxValue = MAX_SENSITIVITY_MOUSE;
this.mouseSensitivity.minValue = MIN_SENSITIVITY_MOUSE;
this.mouseSensitivity.tickInterval = 1;
this.mouseSensitivity.width = SettingsWindow.TAB_VIEW_MAX_WIDTH - MARGIN * 4 - local2.width;
this.mouseSensitivity.x = local2.width + MARGIN;
this.mouseSensitivity.value = settingsService.mouseSensitivity;
this.mouseSensitivity.addEventListener(SliderEvent.CHANGE_VALUE,this.onChangeMouseSensitivity);
local2.y = Math.round((this.mouseSensitivity.height - local2.textHeight) * 0.5) - 2;
local1.addChild(this.mouseSensitivity);
return local1;
}
private function onChangeMouseSensitivity(param1:SliderEvent) : void {
settingsService.setClientSetting(SettingEnum.MOUSE_SENSITIVITY,this.mouseSensitivity.value);
}
override public function destroy() : void {
if(fullScreenService.isMouseLockEnabled()) {
this.mouseSensitivity.removeEventListener(SliderEvent.CHANGE_VALUE,this.onChangeMouseSensitivity);
}
super.destroy();
}
}
}
|
package alternativa.tanks.model.challenge.greenpanel
{
import alternativa.tanks.model.challenge.greenpanel.black.BlackPack;
import alternativa.tanks.model.challenge.greenpanel.gray.GrayPacket;
import alternativa.tanks.model.challenge.greenpanel.green.GreenPack;
import flash.display.Bitmap;
import flash.display.Sprite;
public class GreenPanel extends Sprite
{
private var texturePack:Object;
private var topLeftCorner:Bitmap;
private var topCenterLine:Bitmap;
private var topRightCorner:Bitmap;
private var bottomLeftCorner:Bitmap;
private var bottomCenterLine:Bitmap;
private var bottomRightCorner:Bitmap;
private var leftLine:Bitmap;
private var dailyQuestPanelRightLine:Bitmap;
private var dailyQuestPanelBackground:Bitmap;
private var _width:int;
private var _height:int;
private var state:State;
public function GreenPanel(param1:int, param2:int)
{
this.texturePack = GreenPack;
this.state = State.CURRENT;
super();
this._width = param1;
this._height = param2;
this.drawTopLine();
this.drawBottomLine();
this.drawLeftLine();
this.drawRightLine();
this.drawBackground();
this.updatePanelSize();
}
private function drawTopLine() : void
{
this.topLeftCorner = new Bitmap(this.texturePack._topLeftCorner);
addChild(this.topLeftCorner);
this.topCenterLine = new Bitmap(this.texturePack._topCenterLine);
addChild(this.topCenterLine);
this.topRightCorner = new Bitmap(this.texturePack._topRightCorner);
addChild(this.topRightCorner);
}
private function drawBottomLine() : void
{
this.bottomLeftCorner = new Bitmap(this.texturePack._bottomLeftCorner);
addChild(this.bottomLeftCorner);
this.bottomCenterLine = new Bitmap(this.texturePack._bottomCenterLine);
addChild(this.bottomCenterLine);
this.bottomRightCorner = new Bitmap(this.texturePack._bottomRightCorner);
addChild(this.bottomRightCorner);
}
private function drawLeftLine() : void
{
this.leftLine = new Bitmap(this.texturePack._leftLine);
addChild(this.leftLine);
}
private function drawRightLine() : void
{
this.dailyQuestPanelRightLine = new Bitmap(this.texturePack._dailyQuestPanelRightLine);
addChild(this.dailyQuestPanelRightLine);
}
private function drawBackground() : void
{
this.dailyQuestPanelBackground = new Bitmap(this.texturePack._dailyQuestPanelBackground);
addChild(this.dailyQuestPanelBackground);
}
private function updatePanelSize() : void
{
if(this.state == State.CURRENT)
{
this.texturePack = GreenPack;
}
else if(this.state == State.BLOCKED)
{
this.texturePack = GrayPacket;
}
else
{
this.texturePack = BlackPack;
}
this.drawTopLine();
this.drawBottomLine();
this.drawLeftLine();
this.drawRightLine();
this.drawBackground();
this.topCenterLine.x = this.topLeftCorner.width;
this.topRightCorner.x = this._width - this.topRightCorner.width;
this.topCenterLine.width = this.topRightCorner.x - this.topCenterLine.x;
this.bottomLeftCorner.y = this._height - this.bottomLeftCorner.height;
this.bottomCenterLine.y = this.bottomLeftCorner.y;
this.bottomCenterLine.x = this.bottomLeftCorner.width;
this.bottomCenterLine.width = this.topCenterLine.width;
this.bottomRightCorner.y = this.bottomLeftCorner.y;
this.bottomRightCorner.x = this.topRightCorner.x;
this.leftLine.y = this.topLeftCorner.height;
this.leftLine.height = this._height - this.topLeftCorner.height - this.bottomLeftCorner.height;
this.dailyQuestPanelRightLine.y = this.leftLine.y;
this.dailyQuestPanelRightLine.x = this.bottomRightCorner.x;
this.dailyQuestPanelRightLine.height = this.leftLine.height;
this.dailyQuestPanelBackground.y = this.topLeftCorner.height + this.topLeftCorner.y;
this.dailyQuestPanelBackground.x = this.topLeftCorner.width;
this.dailyQuestPanelBackground.height = this._height - this.bottomLeftCorner.height - this.topLeftCorner.height;
this.dailyQuestPanelBackground.width = this._width - this.topLeftCorner.width - this.topRightCorner.width;
}
public function setState(state:State) : void
{
if(this.state == state)
{
return;
}
this.state = state;
this.updatePanelSize();
}
override public function get width() : Number
{
return this._width;
}
override public function set width(param1:Number) : void
{
this._width = param1;
this.updatePanelSize();
}
override public function get height() : Number
{
return this._height;
}
override public function set height(param1:Number) : void
{
this._height = param1;
this.updatePanelSize();
}
}
}
|
package projects.tanks.client.clans.space.createclan {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.network.command.SpaceCommand;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class ClanCreateModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _createClanId:Long = Long.getLong(153047394,1401385547);
private var _createClan_nameCodec:ICodec;
private var _createClan_tagCodec:ICodec;
private var _createClan_flagIdCodec:ICodec;
private var _validateNameId:Long = Long.getLong(940455925,-1899445316);
private var _validateName_nameCodec:ICodec;
private var _validateTagId:Long = Long.getLong(445979284,1324195135);
private var _validateTag_tagCodec:ICodec;
private var model:IModel;
public function ClanCreateModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
this._createClan_nameCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._createClan_tagCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._createClan_flagIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._validateName_nameCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._validateTag_tagCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function createClan(param1:String, param2:String, param3:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._createClan_nameCodec.encode(this.protocolBuffer,param1);
this._createClan_tagCodec.encode(this.protocolBuffer,param2);
this._createClan_flagIdCodec.encode(this.protocolBuffer,param3);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local4:SpaceCommand = new SpaceCommand(Model.object.id,this._createClanId,this.protocolBuffer);
var local5:IGameObject = Model.object;
var local6:ISpace = local5.space;
local6.commandSender.sendCommand(local4);
this.protocolBuffer.optionalMap.clear();
}
public function validateName(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._validateName_nameCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._validateNameId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function validateTag(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._validateTag_tagCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._validateTagId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.models.ctf
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Mesh;
import alternativa.init.Main;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.collision.CollisionPrimitive;
import alternativa.physics.collision.primitives.CollisionBox;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.tanks.engine3d.AnimatedSprite3D;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.battlefield.hidableobjects.HidableObject3DWrapper;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import alternativa.tanks.utils.GraphicsUtils;
import alternativa.tanks.vehicles.tanks.Tank;
import flash.display.BitmapData;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
public class CTFFlag
{
public static const Z_DISPLACEMENT:Number = 50;
private static const SKIN_BASE_SIZE:int = 100;
private static const SKIN_HEIGHT:int = 400;
private static var intersection:RayIntersection = new RayIntersection();
private static var rayDirection:Vector3 = new Vector3(0,0,-20000);
private static var matrix:Matrix3 = new Matrix3();
private static var flagPosition:Vector3 = new Vector3();
public var teamType:BattleTeamType;
public var takeCommandSent:Boolean;
public var triggerCollisionPrimitive:CollisionPrimitive;
private var _carrierData:TankData;
private var _carrierId:String;
private var _state:CTFFlagState;
private var _basePosition:Vector3;
private var skin:AnimatedSprite3D;
private var container:Scene3DContainer;
private var startTime:int;
private var frameInterval:int = 1000;
private var originalTexture:BitmapData;
public function CTFFlag(teamType:BattleTeamType, basePos:Vector3, frameWidth:int, frameHeight:int, materials:Vector.<Material>, originalTexture:BitmapData, collisionDetector:TanksCollisionDetector)
{
this._state = CTFFlagState.AT_BASE;
super();
this.teamType = teamType;
this._basePosition = basePos.vClone();
this._state = CTFFlagState.AT_BASE;
this.originalTexture = originalTexture;
this.createSkin(frameWidth,frameHeight,materials);
this._basePosition.z += 50;
if(collisionDetector.intersectRayWithStatic(this._basePosition,rayDirection,CollisionGroup.STATIC,1,null,intersection))
{
this._basePosition.vCopy(intersection.pos);
}
this._basePosition.z += Z_DISPLACEMENT;
this.setPosition(this._basePosition);
this.startTime = this.frameInterval * Math.random();
}
public function get carrierData() : TankData
{
return this._carrierData;
}
public function get carrierId() : String
{
return this._carrierId;
}
public function get basePosition() : Vector3
{
return this._basePosition;
}
private function setPosition(value:Vector3) : void
{
this.skin.x = value.x;
this.skin.y = value.y;
this.skin.z = value.z;
this.triggerCollisionPrimitive.transform.d = value.x;
this.triggerCollisionPrimitive.transform.h = value.y;
this.triggerCollisionPrimitive.transform.l = value.z + 0.5 * SKIN_HEIGHT;
this.triggerCollisionPrimitive.calculateAABB();
}
public function addToContainer(container:Scene3DContainer) : void
{
this.container = container;
this.container.addChild(this.skin);
BattlefieldModel(Main.osgi.getService(IBattleField)).hidableObjects.add(new HidableObject3DWrapper(this.skin));
}
public function get state() : CTFFlagState
{
return this._state;
}
public function setCarrier(carrierId:String, carrierData:TankData) : void
{
this._carrierId = carrierId;
this._carrierData = carrierData;
this.skin.visible = carrierData != null;
this.takeCommandSent = false;
if(carrierData != null)
{
this.skin.alpha = carrierData == TankData.localTankData ? Number(Number(0.5)) : Number(Number(1));
}
this._state = CTFFlagState.CARRIED;
}
public function returnToBase() : void
{
this.reset();
this.setPosition(this._basePosition);
this._state = CTFFlagState.AT_BASE;
}
public function dropAt(dropPos:Vector3, collisionDetector:TanksCollisionDetector) : void
{
this.reset();
if(collisionDetector.intersectRayWithStatic(dropPos,rayDirection,CollisionGroup.STATIC,1,null,intersection))
{
this.setPosition(intersection.pos);
}
else
{
this.setPosition(dropPos);
}
this._state = CTFFlagState.DROPPED;
}
public function toString() : String
{
return "[CTFFlag teamType=" + this.teamType + ", state=" + this._state + ", carrierId=" + this._carrierId + ", takeCommandSent=" + this.takeCommandSent + "]";
}
public function dispose() : void
{
this.skin.alternativa3d::removeFromParent();
}
public function update(time:int) : void
{
var turretMesh:Mesh = null;
var carrierTank:Tank = null;
turretMesh = null;
this.skin.update(time * 0.001);
if(this._carrierData != null)
{
carrierTank = this._carrierData.tank;
if(carrierTank == null || carrierTank.skin == null)
{
return;
}
turretMesh = carrierTank.skin.turretMesh;
matrix.setRotationMatrix(turretMesh.rotationX,turretMesh.rotationY,turretMesh.rotationZ);
matrix.transformVector(carrierTank.skin.turretDescriptor.flagMountPoint,flagPosition);
flagPosition.x += turretMesh.x;
flagPosition.y += turretMesh.y;
flagPosition.z += turretMesh.z - 40;
this.setPosition(flagPosition);
}
}
private function createSkin(frameWidth:int, frameHeight:int, materials:Vector.<Material>) : void
{
var w:Number = frameWidth * SKIN_HEIGHT / frameHeight;
var animSprite:AnimatedSprite3D = new AnimatedSprite3D(w,SKIN_HEIGHT);
var animation:TextureAnimation = GraphicsUtils.getTextureAnimation(null,this.originalTexture,frameWidth,frameHeight);
animation.fps = 1;
animSprite.setAnimationData(animation);
animSprite.setFrameIndex(1);
animSprite.originY = 1;
animSprite.looped = true;
this.skin = animSprite;
this.triggerCollisionPrimitive = new CollisionBox(new Vector3(0.5 * SKIN_BASE_SIZE,0.5 * SKIN_BASE_SIZE,0.5 * SKIN_HEIGHT),CollisionGroup.TANK);
}
private function reset() : void
{
this._carrierId = null;
this._carrierData = null;
this.skin.alpha = 1;
this.skin.visible = true;
this.takeCommandSent = false;
}
public function isAtBase() : Boolean
{
return this.skin.x == this._basePosition.x && this.skin.y == this._basePosition.y && this.skin.z == this._basePosition.z;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_thermitemixIconClass.png")]
public class DeviceIcons_thermitemixIconClass extends BitmapAsset {
public function DeviceIcons_thermitemixIconClass() {
super();
}
}
}
|
package alternativa.tanks.model.payment.modes.leogaming {
import alternativa.tanks.gui.payment.forms.PayModeForm;
import alternativa.tanks.gui.payment.forms.leogaming.LeogamingMobileForm;
import alternativa.tanks.model.payment.category.PayModeView;
import alternativa.tanks.model.payment.paymentstate.PaymentWindowService;
import alternativa.tanks.service.paymentcomplete.PaymentCompleteEvent;
import alternativa.tanks.service.paymentcomplete.PaymentCompleteService;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.panel.model.payment.modes.leogaming.mobile.ILeogamingPaymentMobileModelBase;
import projects.tanks.client.panel.model.payment.modes.leogaming.mobile.LeogamingPaymentMobileModelBase;
[ModelInfo]
public class LeogamingPaymentMobileModel extends LeogamingPaymentMobileModelBase implements ILeogamingPaymentMobileModelBase, ObjectLoadListener, PayModeView, ObjectUnloadListener, LeogamingPaymentMode {
[Inject]
public static var paymentWindowService:PaymentWindowService;
[Inject]
public static var paymentCompleteService:PaymentCompleteService;
public function LeogamingPaymentMobileModel() {
super();
}
public function error() : void {
LeogamingMobileForm(this.getFormInternal()).reset();
}
public function proceed() : void {
LeogamingMobileForm(this.getFormInternal()).proceed();
}
public function objectLoaded() : void {
putData(LeogamingMobileForm,new LeogamingMobileForm(object));
paymentCompleteService.addEventListener(PaymentCompleteEvent.COMPLETED,getFunctionWrapper(this.onPaymentComplete));
}
private function onPaymentComplete(param1:PaymentCompleteEvent) : void {
if(paymentWindowService.getChosenPayMode() == object) {
paymentWindowService.switchToBeginning();
}
}
public function getView() : PayModeForm {
var local1:LeogamingMobileForm = this.getFormInternal();
local1.reset();
return local1;
}
private function getFormInternal() : LeogamingMobileForm {
return LeogamingMobileForm(getData(LeogamingMobileForm));
}
public function objectUnloaded() : void {
this.getView().destroy();
clearData(LeogamingMobileForm);
paymentCompleteService.removeEventListener(PaymentCompleteEvent.COMPLETED,getFunctionWrapper(this.onPaymentComplete));
}
public function sendPhone(param1:String) : void {
server.createOrder(paymentWindowService.getChosenItem(),param1);
}
public function sendCode(param1:String) : void {
server.confirmOrder(param1);
}
}
}
|
package projects.tanks.client.users.model.referrerbonus {
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 RankUpReferrerAwardModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function RankUpReferrerAwardModelServer(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.base {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.events.MouseEvent;
import flash.text.TextFieldAutoSize;
public class MainPanelButtonBase extends TankBaseButton {
private static const LABEL_POSITION_Y:int = 4;
private var _labelBase:LabelBase;
private var iconData:BitmapData;
public function MainPanelButtonBase(param1:Class) {
this.iconData = new param1().bitmapData;
_icon = new Bitmap(this.iconData);
setIconCoords(3,2);
super();
this._labelBase = new LabelBase();
this._labelBase.x = 18;
this._labelBase.y = LABEL_POSITION_Y;
this._labelBase.width = this.width - 18;
this._labelBase.autoSize = TextFieldAutoSize.CENTER;
this._labelBase.mouseEnabled = false;
addChild(this._labelBase);
}
override public function set label(param1:String) : void {
this._labelBase.text = param1;
}
override protected function onMouseEvent(param1:MouseEvent) : void {
super.onMouseEvent(param1);
var local2:int = param1.type == MouseEvent.MOUSE_DOWN ? 1 : 0;
this._labelBase.y = LABEL_POSITION_Y + local2;
}
}
}
|
package controls.scroller.gray {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.scroller.gray.ScrollSkinGray_trackBottom.png")]
public class ScrollSkinGray_trackBottom extends BitmapAsset {
public function ScrollSkinGray_trackBottom() {
super();
}
}
}
|
package projects.tanks.clients.flash.commons.services.autobattleenter {
import flash.events.Event;
public class AutomaticBattleEnterEvent extends Event {
public static const SPECTATOR:String = "AutomaticBattleEnterEvent_spectator";
public static const TANK:String = "AutomaticBattleEnterEvent_tank";
public function AutomaticBattleEnterEvent(param1:String) {
super(param1);
}
override public function clone() : Event {
return new AutomaticBattleEnterEvent(type);
}
}
}
|
package alternativa.tanks.models.tank.support {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventListener;
import alternativa.tanks.battle.events.PauseActivationEvent;
import alternativa.tanks.battle.events.PauseDeactivationEvent;
import alternativa.tanks.battle.events.ShowPauseIndicatorEvent;
import alternativa.tanks.battle.events.reload.ReloadActivateEvent;
import alternativa.tanks.battle.events.reload.ReloadDeactivateEvent;
import alternativa.tanks.battle.events.suicide.SuicideActivationEvent;
import alternativa.tanks.battle.events.suicide.SuicideDeactivationEvent;
import alternativa.tanks.models.tank.IdleKickTime;
import alternativa.tanks.models.tank.pause.ITankPause;
import alternativa.tanks.service.settings.keybinding.GameActionEnum;
import alternativa.tanks.service.settings.keybinding.KeysBindingService;
import alternativa.tanks.services.battlegui.BattleGUIService;
import alternativa.tanks.services.battleinput.BattleInputService;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.ui.Keyboard;
import platform.client.fp10.core.type.AutoClosable;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.IDialogsService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogwindowdispatcher.DialogWindowsDispatcherServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogwindowdispatcher.IDialogWindowsDispatcherService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenStateService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
public class PauseSupport implements AutoClosable, BattleEventListener {
[Inject]
public static var display:IDisplay;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var battleInputService:BattleInputService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var dialogWindowsDispatcherService:IDialogWindowsDispatcherService;
[Inject]
public static var dialogsService:IDialogsService;
[Inject]
public static var battleService:BattleService;
[Inject]
public static var battleGUIService:BattleGUIService;
[Inject]
public static var fullscreenStateService:FullscreenStateService;
[Inject]
public static var keysBindingService:KeysBindingService;
private var _localUser:IGameObject;
private var _idleKickTime:IdleKickTime;
private var _paused:Boolean;
private var _suicideEnable:Boolean;
private var _rearmorEnable:Boolean;
private var _isManuallyInclusion:Boolean;
public function PauseSupport(param1:IGameObject, param2:IdleKickTime, param3:Boolean) {
super();
this._localUser = param1;
this._idleKickTime = param2;
this._paused = param3;
this.init();
}
private function init() : void {
display.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
display.stage.addEventListener(Event.ACTIVATE,this.onFocusInFlash);
display.stage.addEventListener(Event.DEACTIVATE,this.onFocusOutFlash);
battleEventDispatcher.addBattleEventListener(SuicideActivationEvent,this);
battleEventDispatcher.addBattleEventListener(SuicideDeactivationEvent,this);
battleEventDispatcher.addBattleEventListener(ReloadActivateEvent,this);
battleEventDispatcher.addBattleEventListener(ReloadDeactivateEvent,this);
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.BEGIN_LAYOUT_SWITCH,this.onBeginLayoutSwitch);
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.onEndLayoutSwitch);
dialogWindowsDispatcherService.addEventListener(DialogWindowsDispatcherServiceEvent.OPEN,this.onOpenDialogWindow);
dialogWindowsDispatcherService.addEventListener(DialogWindowsDispatcherServiceEvent.CLOSE,this.onCloseDialogWindow);
battleGUIService.getViewportContainer().addEventListener(MouseEvent.CLICK,this.onClickViewportContainer);
}
private function onKeyDown(param1:KeyboardEvent) : void {
if(this._paused) {
this.handleKeyWhenPaused(param1);
} else {
this.handleKeyWhenUnpaused(param1);
}
}
private function handleKeyWhenPaused(param1:KeyboardEvent) : void {
if(param1.keyCode != Keyboard.ALTERNATE && !param1.altKey && !battleInputService.isInputLocked()) {
this.manualDisablePause();
}
}
private function manualDisablePause() : void {
this._isManuallyInclusion = false;
this.disablePause();
}
private function disablePause() : void {
var local1:ITankPause = null;
if(!this._paused || this._isManuallyInclusion || Boolean(lobbyLayoutService.isWindowOpenOverBattle())) {
return;
}
this._paused = false;
battleService.getBattleView().setFocus();
if(this._localUser.hasModel(ITankPause)) {
local1 = ITankPause(this._localUser.adapt(ITankPause));
local1.disablePause();
battleEventDispatcher.dispatchEvent(new PauseDeactivationEvent());
}
}
private function handleKeyWhenUnpaused(param1:KeyboardEvent) : void {
var local2:GameActionEnum = null;
if(!battleInputService.isInputLocked() && !this._suicideEnable && !this._rearmorEnable) {
local2 = keysBindingService.getBindingAction(param1.keyCode);
if(local2 == GameActionEnum.BATTLE_PAUSE) {
this._isManuallyInclusion = true;
this.enablePause();
}
}
}
private function enablePause(param1:Boolean = true) : void {
if(this._paused) {
return;
}
this._paused = true;
var local2:ITankPause = ITankPause(this._localUser.adapt(ITankPause));
local2.enablePause();
battleEventDispatcher.dispatchEvent(new PauseActivationEvent(this._idleKickTime.getTimeLeft()));
if(param1) {
battleEventDispatcher.dispatchEvent(new ShowPauseIndicatorEvent(this._idleKickTime.getTimeLeft()));
}
}
private function onOpenDialogWindow(param1:DialogWindowsDispatcherServiceEvent) : void {
this.enablePause(false);
}
private function onCloseDialogWindow(param1:DialogWindowsDispatcherServiceEvent) : void {
this.disablePause();
}
private function onFocusInFlash(param1:Event) : void {
this.disablePause();
}
private function onFocusOutFlash(param1:Event) : void {
if(!fullscreenStateService.isFullscreen()) {
this.enablePause();
}
}
private function onBeginLayoutSwitch(param1:LobbyLayoutServiceEvent) : void {
this.enablePause(false);
}
private function onEndLayoutSwitch(param1:LobbyLayoutServiceEvent) : void {
if(!lobbyLayoutService.isWindowOpenOverBattle() && Boolean(lobbyLayoutService.inBattle())) {
this.disablePause();
}
}
private function onClickViewportContainer(param1:MouseEvent) : void {
if(this._paused && this._isManuallyInclusion) {
this.manualDisablePause();
}
}
public function handleBattleEvent(param1:Object) : void {
if(param1 is SuicideActivationEvent) {
this._suicideEnable = true;
} else if(param1 is SuicideDeactivationEvent) {
this._suicideEnable = false;
} else if(param1 is ReloadActivateEvent) {
this._rearmorEnable = true;
this.manualDisablePause();
} else if(param1 is ReloadDeactivateEvent) {
this._rearmorEnable = false;
}
}
[Obfuscation(rename="false")]
public function close() : void {
display.stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
display.stage.removeEventListener(Event.ACTIVATE,this.onFocusInFlash);
display.stage.removeEventListener(Event.DEACTIVATE,this.onFocusOutFlash);
battleEventDispatcher.removeBattleEventListener(SuicideActivationEvent,this);
battleEventDispatcher.removeBattleEventListener(SuicideDeactivationEvent,this);
battleEventDispatcher.removeBattleEventListener(ReloadActivateEvent,this);
battleEventDispatcher.removeBattleEventListener(ReloadDeactivateEvent,this);
dialogWindowsDispatcherService.removeEventListener(DialogWindowsDispatcherServiceEvent.OPEN,this.onOpenDialogWindow);
dialogWindowsDispatcherService.removeEventListener(DialogWindowsDispatcherServiceEvent.CLOSE,this.onCloseDialogWindow);
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.BEGIN_LAYOUT_SWITCH,this.onBeginLayoutSwitch);
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.onEndLayoutSwitch);
battleGUIService.getViewportContainer().removeEventListener(MouseEvent.CLICK,this.onClickViewportContainer);
this._localUser = null;
}
}
}
|
package org1.osflash.signals {
import flash.errors.IllegalOperationError;
import flash.utils.getQualifiedClassName;
public class Signal implements ISignal {
private var _valueClasses:Array;
private var slots:SlotList = SlotList.NIL;
public function Signal(... rest) {
super();
this.setValueClasses(rest.length == 1 && rest[0] is Array ? rest[0] : rest);
}
public function getValueClasses() : Array {
return this._valueClasses;
}
public function setValueClasses(param1:Array) : void {
this._valueClasses = Boolean(param1) ? param1.slice() : [];
var local2:int = int(this._valueClasses.length);
while(Boolean(local2--)) {
if(!(this._valueClasses[local2] is Class)) {
throw new ArgumentError("Invalid valueClasses argument: " + "item at index " + local2 + " should be a Class but was:<" + this._valueClasses[local2] + ">." + getQualifiedClassName(this._valueClasses[local2]));
}
}
}
public function getNumListeners() : uint {
return this.slots.getLength();
}
public function addOnce(param1:Function) : ISlot {
return this.registerListener(param1,true);
}
public function add(param1:Function) : ISlot {
return this.registerListener(param1);
}
public function remove(param1:Function) : ISlot {
var local2:ISlot = this.slots.find(param1);
if(!local2) {
return null;
}
this.slots = this.slots.filterNot(param1);
return local2;
}
public function removeAll() : void {
this.slots = SlotList.NIL;
}
public function dispatch(... rest) : void {
var local2:int = int(this._valueClasses.length);
var local3:int = int(rest.length);
if(local3 < local2) {
throw new ArgumentError("Incorrect number of arguments. " + "Expected at least " + local2 + " but received " + local3 + ".");
}
var local4:int = 0;
while(local4 < local2) {
if(!(rest[local4] is this._valueClasses[local4] || rest[local4] === null)) {
throw new ArgumentError("Value object <" + rest[local4] + "> is not an instance of <" + this._valueClasses[local4] + ">.");
}
local4++;
}
var local5:SlotList = this.slots;
if(local5.nonEmpty) {
while(local5.nonEmpty) {
local5.head.execute(rest);
local5 = local5.tail;
}
}
}
public function registerListener(param1:Function, param2:Boolean = false) : ISlot {
var local3:ISlot = null;
if(this.registrationPossible(param1,param2)) {
local3 = new Slot(param1,this,param2);
this.slots = this.slots.prepend(local3);
return local3;
}
return this.slots.find(param1);
}
public function registrationPossible(param1:Function, param2:Boolean) : Boolean {
if(!this.slots.nonEmpty) {
return true;
}
var local3:ISlot = this.slots.find(param1);
if(!local3) {
return true;
}
if(local3.getOnce() != param2) {
throw new IllegalOperationError("You cannot addOnce() then add() the same listener without removing the relationship first.");
}
return false;
}
}
}
|
package alternativa.tanks.view {
import alternativa.tanks.controller.events.CaptchaAnswerIsIncorrectEvent;
import alternativa.tanks.controller.events.CaptchaUpdatedEvent;
import alternativa.tanks.controller.events.ChangeEmailCaptchaEvent;
import alternativa.tanks.controller.events.CheckCaptchaAnswerEvent;
import alternativa.tanks.controller.events.GetNewCaptchaEvent;
import alternativa.tanks.controller.events.NavigationEvent;
import alternativa.tanks.controller.events.SendNewPasswordAndEmailToChangeEvent;
import alternativa.tanks.controller.events.SetPasswordChangeResultEvent;
import alternativa.tanks.view.forms.ChangeEmailAndPasswordForm;
import org.robotlegs.mvcs.Mediator;
import projects.tanks.client.commons.models.captcha.CaptchaLocation;
import projects.tanks.clients.flash.commons.models.captcha.RefreshCaptchaClickedEvent;
public class ChangeEmailAndPasswordFormMediator extends Mediator {
[Inject]
public var view:ChangeEmailAndPasswordForm;
public function ChangeEmailAndPasswordFormMediator() {
super();
}
override public function onRegister() : void {
addViewListener(ChangeEmailCaptchaEvent.CAPTCHA,this.onChangeEmailCaptcha,ChangeEmailCaptchaEvent);
addViewListener(NavigationEvent.GO_TO_LOGIN_FORM,dispatch,NavigationEvent);
addViewListener(RefreshCaptchaClickedEvent.CLICKED,this.onRefreshCaptchaClicked,RefreshCaptchaClickedEvent);
addContextListener(SetPasswordChangeResultEvent.SET,this.onPasswordChangeResult,SetPasswordChangeResultEvent);
addContextListener(CaptchaUpdatedEvent.EMAIL_CHANGE_HASH_CAPTCHA_UPDATED,this.onCaptchaUpdated,CaptchaUpdatedEvent);
addContextListener(CaptchaAnswerIsIncorrectEvent.EVENT_TYPE,this.onCaptchaFailed);
}
private function onChangeEmailCaptcha(param1:ChangeEmailCaptchaEvent) : void {
var local2:SendNewPasswordAndEmailToChangeEvent = new SendNewPasswordAndEmailToChangeEvent(param1.getPassword(),param1.getEmail());
dispatch(new CheckCaptchaAnswerEvent(param1.getCaptchaAnswer(),CaptchaLocation.EMAIL_CHANGE_HASH,local2));
}
private function onPasswordChangeResult(param1:SetPasswordChangeResultEvent) : void {
this.view.setPasswordChangeResult(param1.success,param1.error);
}
private function onCaptchaFailed(param1:CaptchaAnswerIsIncorrectEvent) : void {
this.view.captchaFailed();
}
private function onRefreshCaptchaClicked(param1:RefreshCaptchaClickedEvent) : void {
dispatch(new GetNewCaptchaEvent(CaptchaLocation.EMAIL_CHANGE_HASH));
}
private function onCaptchaUpdated(param1:CaptchaUpdatedEvent) : void {
this.view.setCaptchaImage(param1.image);
}
}
}
|
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.forms.ApproveOneTimePurchaseForm;
import alternativa.tanks.gui.shop.paymentform.item.PaymentFormItemBase;
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.base.ShopButtonDiscount;
import alternativa.tanks.model.payment.shop.ShopItemView;
import alternativa.tanks.model.payment.shop.indemnity.Indemnity;
import alternativa.tanks.model.payment.shop.quantityrestriction.QuantityRestriction;
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class PaymentFormOneTimePurchaseView extends PaymentView {
[Inject]
public static var localeService:ILocaleService;
private static const PAYMENT_MODE_ID:Long = Long.ZERO;
private var view:ItemCategoriesView;
private var selectedItem:IGameObject;
private var chosenPayMode:IGameObject;
private var _width:int;
private var _height:int;
public function PaymentFormOneTimePurchaseView(param1:IGameObject, param2:IGameObject) {
super();
this.selectedItem = param1;
this.chosenPayMode = param2;
this.view = new ItemCategoriesView();
addChild(this.view);
this.addSelectedItemView();
this.addPaymentCategory();
this.addApproveForm();
}
private function addSelectedItemView() : void {
var local1:ItemsCategoryView = new ItemsCategoryView(localeService.getText(TanksLocale.TEXT_SHOP_WINDOW_YOUR_CHOICE),"",this.selectedItem.id);
var local2:ShopButton = ShopItemView(this.selectedItem.adapt(ShopItemView)).getButtonView();
ShopButtonClickDisable(local2).disableClick();
ShopButtonDiscount(local2).applyPayModeDiscountAndUpdatePriceLabel(this.chosenPayMode);
local1.addItem(local2);
this.view.addCategory(local1);
}
private function addPaymentCategory() : void {
var local1:ItemsCategoryView = new ItemsCategoryView(localeService.getText(TanksLocale.TEXT_SHOP_ONE_TIME_PURCHASE_CONDITIONS_HEADER),"",PAYMENT_MODE_ID);
this.view.addCategory(local1);
}
private function addApproveForm() : void {
var local1:String = !!this.selectedItem.hasModel(QuantityRestriction) ? localeService.getText(TanksLocale.TEXT_SHOP_ONE_TIME_PURCHASE_CONDITIONS_DESCRIPTION_WITH_LIMIT) : localeService.getText(TanksLocale.TEXT_SHOP_ONE_TIME_PURCHASE_CONDITIONS_DESCRIPTION);
var local2:ApproveOneTimePurchaseForm = new ApproveOneTimePurchaseForm(this.chosenPayMode,Indemnity(this.selectedItem.adapt(Indemnity)).getIndemnitySize(),local1);
this.view.addItem(PAYMENT_MODE_ID,new PaymentFormItemBase(local2));
local2.activate();
}
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.chosenPayMode = null;
this.view = null;
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapBigRank10.png")]
public class DefaultRanksBitmaps_bitmapBigRank10 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapBigRank10() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.artillery.sfx {
[ModelInterface]
public interface ArtillerySfx {
function getSfxData() : ArtillerySfxData;
}
}
|
package alternativa.tanks.models.battlefield.scene3dcontainer
{
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Object3DContainer;
import flash.utils.Dictionary;
public class Object3DContainerProxy implements Scene3DContainer
{
private var container:Object3DContainer;
private const objects:Dictionary = new Dictionary();
public function Object3DContainerProxy(param1:Object3DContainer = null)
{
this.container = new Object3DContainer();
super();
this.setContainer(param1);
}
public function addChild(param1:Object3D) : void
{
if(param1 == null)
{
throw new ArgumentError("Parameter is null");
}
this.objects[param1] = true;
this.container.addChild(param1);
}
public function addChildAt(param1:Object3D, param2:int) : void
{
if(param1 == null)
{
throw new ArgumentError("Parameter is null");
}
this.objects[param1] = true;
this.container.addChildAt(param1,param2);
}
public function addChildren(param1:Vector.<Object3D>) : void
{
var _loc2_:Object3D = null;
if(param1 == null)
{
throw new ArgumentError("Parameter is null");
}
for each(_loc2_ in param1)
{
this.addChild(_loc2_);
}
}
public function removeChild(param1:Object3D) : void
{
if(param1 == null)
{
throw new ArgumentError("Parameter is null");
}
if(this.objects[param1])
{
delete this.objects[param1];
this.container.removeChild(param1);
}
}
public function setContainer(param1:Object3DContainer) : void
{
var _loc2_:Vector.<Object3D> = this.removeAllChildren();
this.container = param1 || new Object3DContainer();
this.addChildren(_loc2_);
}
private function removeAllChildren() : Vector.<Object3D>
{
var _loc2_:* = undefined;
var _loc1_:Vector.<Object3D> = new Vector.<Object3D>();
for(_loc2_ in this.objects)
{
delete this.objects[_loc2_];
this.container.removeChild(_loc2_);
_loc1_.push(_loc2_);
}
return _loc1_;
}
}
}
|
package utils.tweener.easing {
public class Linear {
public static const power:uint = 0;
public function Linear() {
super();
}
public static function easeNone(param1:Number, param2:Number, param3:Number, param4:Number) : Number {
return param3 * param1 / param4 + param2;
}
public static function easeIn(param1:Number, param2:Number, param3:Number, param4:Number) : Number {
return param3 * param1 / param4 + param2;
}
public static function easeOut(param1:Number, param2:Number, param3:Number, param4:Number) : Number {
return param3 * param1 / param4 + param2;
}
public static function easeInOut(param1:Number, param2:Number, param3:Number, param4:Number) : Number {
return param3 * param1 / param4 + param2;
}
}
}
|
package alternativa.tanks.models.weapon.common {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.type.IGameObject;
public class WeaponSoundEvents implements WeaponSound {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function WeaponSoundEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getTurretRotationSound() : SoundResource {
var result:SoundResource = null;
var i:int = 0;
var m:WeaponSound = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = WeaponSound(this.impl[i]);
result = m.getTurretRotationSound();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package {
import controls.panel.BaseButton;
[Embed(source="/_assets/assets.swf", symbol="symbol1027")]
public dynamic class MainPanelConfigButton extends BaseButton {
public function MainPanelConfigButton() {
super();
}
}
}
|
package org.osflash.signals.natives {
import flash.events.Event;
import flash.events.IEventDispatcher;
public interface INativeDispatcher {
function get eventType() : String;
function get eventClass() : Class;
function get target() : IEventDispatcher;
function dispatch(event:Event) : Boolean;
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.china.tmall {
import flash.net.URLRequest;
import flash.net.navigateToURL;
import flash.utils.Dictionary;
import platform.client.core.general.socialnetwork.types.LoginParameters;
import platform.client.fp10.core.service.address.AddressService;
import platform.clients.fp10.libraries.alternativapartners.type.IParametersListener;
import platform.clients.fp10.libraries.alternativapartners.type.IPartner;
import projects.tanks.client.partners.impl.china.tmall.ITmallModelBase;
import projects.tanks.client.partners.impl.china.tmall.TmallModelBase;
[ModelInfo]
public class TmallModel extends TmallModelBase implements ITmallModelBase, IPartner {
[Inject]
public static var addressService:AddressService;
private static const PAYMENT_URL:String = "http://game.taobao.com/webgame/pay.htm?game_id=45069435178&service_area_id=";
private var gatewayId:String;
public function TmallModel() {
super();
}
public function getLoginParameters(param1:IParametersListener) : void {
var local2:Dictionary = new Dictionary();
local2["tbCoopId"] = addressService.getQueryParameter("tbCoopId");
local2["gameId"] = addressService.getQueryParameter("gameId");
local2["gatewayId"] = addressService.getQueryParameter("gatewayId");
this.gatewayId = local2["gatewayId"];
local2["tbUid"] = unescape(addressService.getQueryParameter("tbUid"));
local2["isAdult"] = addressService.getQueryParameter("isAdult");
local2["loginTime"] = addressService.getQueryParameter("loginTime");
local2["sign"] = addressService.getQueryParameter("sign");
param1.onSetParameters(new LoginParameters(local2));
}
public function getFailRedirectUrl() : String {
return "http://game.taobao.com/webgame/detail.htm?id=45069435178";
}
public function isExternalLoginAllowed() : Boolean {
return false;
}
public function hasPaymentAction() : Boolean {
return true;
}
public function paymentAction() : void {
navigateToURL(new URLRequest(PAYMENT_URL + this.gatewayId),"_blank");
}
public function hasRatings() : Boolean {
return false;
}
}
}
|
package alternativa.tanks.models.weapon.ricochet {
import alternativa.physics.Body;
public interface RicochetTargetEvaluator {
function getTargetPriority(param1:Body, param2:int, param3:Number, param4:Number, param5:Number, param6:Number) : Number;
}
}
|
package projects.tanks.client.partners.impl.china.kuaiwan {
public interface IKuaiwanModelBase {
}
}
|
package alternativa.tanks.models.weapon.artillery {
import alternativa.tanks.models.weapon.artillery.sfx.ArtilleryEffects;
[ModelInterface]
public interface ArtilleryEffectsProvider {
function getArtilleryEffects() : ArtilleryEffects;
}
}
|
package alternativa.tanks.controller.events.socialnetwork {
import flash.events.Event;
public class FinishExternalRegisterEvent extends Event {
public static const FINISH_REGISTRATION:String = "FinishExternalRegisterEvent.FINISH_REGISTRATION";
public var uid:String;
public function FinishExternalRegisterEvent(param1:String) {
super(FINISH_REGISTRATION);
this.uid = param1;
}
override public function clone() : Event {
return new FinishExternalRegisterEvent(this.uid);
}
}
}
|
package alternativa.tanks.models.weapon.thunder {
[ModelInterface]
public interface IThunderSFXModel {
function getEffects() : IThunderEffects;
}
}
|
package controls.scroller.blue
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ScrollSkinBlue_thumbMiddle extends BitmapAsset
{
public function ScrollSkinBlue_thumbMiddle()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.billboard {
import platform.client.fp10.core.resource.types.TextureResource;
public class BillboardCC {
private var _defaultBillboardImage:TextureResource;
public function BillboardCC(param1:TextureResource = null) {
super();
this._defaultBillboardImage = param1;
}
public function get defaultBillboardImage() : TextureResource {
return this._defaultBillboardImage;
}
public function set defaultBillboardImage(param1:TextureResource) : void {
this._defaultBillboardImage = param1;
}
public function toString() : String {
var local1:String = "BillboardCC [";
local1 += "defaultBillboardImage = " + this.defaultBillboardImage + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.achievement
{
public interface IAchievementModel
{
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.gauss {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.types.Vector3d;
public interface IGaussModelBase {
function dummyShot() : void;
function primaryShot(param1:int, param2:Vector3d) : void;
function secondaryHitTargetCommand(param1:IGameObject, param2:Vector3d) : void;
function startAiming() : void;
function stopAiming() : void;
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.meteors {
import projects.tanks.client.battlefield.types.Vector3d;
public class MeteorDescriptor {
private var _groundPosition:Vector3d;
private var _lifeTimeMs:int;
private var _timeToFlyMs:int;
private var _upperPosition:Vector3d;
public function MeteorDescriptor(param1:Vector3d = null, param2:int = 0, param3:int = 0, param4:Vector3d = null) {
super();
this._groundPosition = param1;
this._lifeTimeMs = param2;
this._timeToFlyMs = param3;
this._upperPosition = param4;
}
public function get groundPosition() : Vector3d {
return this._groundPosition;
}
public function set groundPosition(param1:Vector3d) : void {
this._groundPosition = param1;
}
public function get lifeTimeMs() : int {
return this._lifeTimeMs;
}
public function set lifeTimeMs(param1:int) : void {
this._lifeTimeMs = param1;
}
public function get timeToFlyMs() : int {
return this._timeToFlyMs;
}
public function set timeToFlyMs(param1:int) : void {
this._timeToFlyMs = param1;
}
public function get upperPosition() : Vector3d {
return this._upperPosition;
}
public function set upperPosition(param1:Vector3d) : void {
this._upperPosition = param1;
}
public function toString() : String {
var local1:String = "MeteorDescriptor [";
local1 += "groundPosition = " + this.groundPosition + " ";
local1 += "lifeTimeMs = " + this.lifeTimeMs + " ";
local1 += "timeToFlyMs = " + this.timeToFlyMs + " ";
local1 += "upperPosition = " + this.upperPosition + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.view.battleinfo.renderer {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battleinfo.renderer.CellBlue_cellFullLeft.png")]
public class CellBlue_cellFullLeft extends BitmapAsset {
public function CellBlue_cellFullLeft() {
super();
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _00c3961a998da121dd1fef7aa674e2095bee87007976935d0dd2e4d0485d6e79_flash_display_Sprite extends Sprite {
public function _00c3961a998da121dd1fef7aa674e2095bee87007976935d0dd2e4d0485d6e79_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain(rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain(rest);
}
}
}
|
package projects.tanks.client.chat.models.news.showing {
import alternativa.types.Long;
public interface INewsShowingModelBase {
function removeNewsItem(param1:Long) : void;
function sendNewsItem(param1:NewsItemData) : void;
}
}
|
package alternativa.tanks.models.weapon.streamweapon {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Matrix3;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.physics.collision.CollisionDetector;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.sfx.colortransform.ColorTransformEntry;
import alternativa.tanks.models.weapon.shared.StreamWeaponParticle;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.sfx.SFXUtils;
import alternativa.tanks.utils.EncryptedInt;
import alternativa.tanks.utils.EncryptedIntImpl;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.geom.ColorTransform;
import flash.utils.getTimer;
public class StreamWeaponGraphicEffect extends PooledObject implements GraphicEffect {
private static const thousand:EncryptedInt = new EncryptedIntImpl(1000);
private static const MAX_PARTICLES_PER_DISTANCE_METER:Number = 1.1;
private static const ABSOLUTE_MAX_PARTICLES:int = 50;
private static const ADDITIONAL_PARTICLE_CHANCE:Number = 0.8;
private static const ADDITIONAL_PARTICLE_MIN_FACTOR:Number = 0.6;
private static const BUFFED_MODE_PARTICLE_SCALE:Number = 2;
private static const PARTICLE_ROTATON_SPEED:Number = 3;
private static const matrix:Matrix3 = new Matrix3();
private static const turretMatrix:Matrix4 = new Matrix4();
private static const barrelOrigin:Vector3 = new Vector3();
private static const direction:Vector3 = new Vector3();
private static const turretAxisX:Vector3 = new Vector3();
private static const particlePosition:Vector3 = new Vector3();
private static const globalMuzzlePosition:Vector3 = new Vector3();
private static const intersection:RayHit = new RayHit();
private var _range:Number;
private var coneHalfAngleTan:Number;
private var particleSpeedPerDistanceMeter:Number;
private var particleSpeed:Number;
private var localMuzzlePosition:Vector3 = new Vector3();
private var turret:Object3D;
private var sfxData:StreamWeaponSFXData;
private var collisionDetector:CollisionDetector;
private var _particles:Vector.<StreamWeaponParticle> = new Vector.<StreamWeaponParticle>(ABSOLUTE_MAX_PARTICLES);
private var particleSizePerDistance:Number;
private var particleEmissionPeriod:Number;
private var time:int;
private var nextEmissionTime:int;
private var _numParticles:int;
private var container:Scene3DContainer;
private var dead:Boolean;
private var muzzlePlane:StreamWeaponMuzzlePlane;
private var shooterBody:Body;
private var particleStartSize:Number;
private var particleEndSize:Number;
private var particleMuzzleOffset:Number;
private var particleMuzzleRandomOffset:Number;
private var attenuationStartDistance:Number;
private var buffedMode:Boolean;
private var maxParticles:int;
public function StreamWeaponGraphicEffect(param1:Pool) {
super(param1);
this.muzzlePlane = new StreamWeaponMuzzlePlane();
}
public function init(param1:Body, param2:Number, param3:Number, param4:Number, param5:Vector3, param6:Object3D, param7:StreamWeaponSFXData, param8:CollisionDetector, param9:Number, param10:Number, param11:Number, param12:Number, param13:Number, param14:Number, param15:Boolean) : void {
this.shooterBody = param1;
this.coneHalfAngleTan = Math.tan(0.5 * param3);
this.particleSpeedPerDistanceMeter = param4;
this.localMuzzlePosition.copy(param5);
this.turret = param6;
this.sfxData = param7;
this.collisionDetector = param8;
this.particleStartSize = param11;
this.particleEndSize = param12;
this.particleMuzzleOffset = param13;
this.particleMuzzleRandomOffset = param14;
this.muzzlePlane.resize(param9,param10);
this.updateRangeParams(param2);
this._numParticles = 0;
this.time = this.nextEmissionTime = getTimer();
this.buffedMode = param15;
this.initMuzzlePlane(param7);
this.dead = false;
}
private function updateRangeParams(param1:Number) : void {
this._range = param1;
this.maxParticles = Math.floor(MAX_PARTICLES_PER_DISTANCE_METER * this._range * 0.01);
if(this.maxParticles > ABSOLUTE_MAX_PARTICLES) {
this.maxParticles = ABSOLUTE_MAX_PARTICLES;
}
this.particleSpeed = this.particleSpeedPerDistanceMeter * param1 * 0.01;
this.attenuationStartDistance = param1 * 0.8;
this.particleSizePerDistance = 2 * (this.particleEndSize - this.particleStartSize) / param1;
this.particleEmissionPeriod = 1000 * param1 / (this.maxParticles * this.particleSpeed);
}
private function initMuzzlePlane(param1:StreamWeaponSFXData) : void {
var local2:ColorTransformEntry = null;
var local3:ColorTransform = null;
this.muzzlePlane.init(param1.getMuzzlePlaneAnimation(this.buffedMode));
if(param1.muzzlePlaneColorTransformPoints != null) {
local2 = param1.muzzlePlaneColorTransformPoints[0];
local3 = this.muzzlePlane.colorTransform == null ? new ColorTransform() : this.muzzlePlane.colorTransform;
local3.alphaMultiplier = local2.alphaMultiplier;
local3.alphaOffset = local2.alphaOffset;
local3.redMultiplier = local2.redMultiplier;
local3.redOffset = local2.redOffset;
local3.greenMultiplier = local2.greenMultiplier;
local3.greenOffset = local2.greenOffset;
local3.blueMultiplier = local2.blueMultiplier;
local3.blueOffset = local2.blueOffset;
this.muzzlePlane.colorTransform = local3;
} else {
this.muzzlePlane.colorTransform = null;
}
}
public function destroy() : void {
while(this._numParticles > 0) {
this.removeParticle(0);
}
this.container.removeChild(this.muzzlePlane);
this.muzzlePlane.clear();
this.container = null;
this.shooterBody = null;
this.turret = null;
this.sfxData = null;
this.collisionDetector = null;
recycle();
}
public function play(param1:int, param2:GameCamera) : Boolean {
var local3:Number = NaN;
var local5:StreamWeaponParticle = null;
var local6:Vector3 = null;
var local7:Number = NaN;
this.calculateParameters();
local3 = param1 / thousand.getInt();
if(this.collisionDetector.raycastStatic(barrelOrigin,direction,CollisionGroup.STATIC,this.localMuzzlePosition.y + this.muzzlePlane.length,null,intersection)) {
this.muzzlePlane.visible = false;
} else {
this.muzzlePlane.visible = true;
this.muzzlePlane.update(local3,this.sfxData.getMuzzlePlaneAnimation(this.buffedMode).fps);
SFXUtils.alignObjectPlaneToView(this.muzzlePlane,globalMuzzlePosition,direction,param2.position);
}
if(!this.dead && this._numParticles < this.maxParticles && this.time >= this.nextEmissionTime) {
this.nextEmissionTime += this.particleEmissionPeriod;
this.addParticle();
}
var local4:int = 0;
while(local4 < this._numParticles) {
local5 = this._particles[local4];
particlePosition.x = local5.x;
particlePosition.y = local5.y;
particlePosition.z = local5.z;
if(local5.particleDistance > this._range || Boolean(this.collisionDetector.raycastStatic(particlePosition,local5.velocity,CollisionGroup.WEAPON,local3,null,intersection))) {
this.removeParticle(local4--);
} else {
local6 = local5.velocity;
local5.x += local6.x * local3;
local5.y += local6.y * local3;
local5.z += local6.z * local3;
local5.particleDistance += this.particleSpeed * local3;
local5.rotation += PARTICLE_ROTATON_SPEED * local3 * local5.rotationDirection;
local5.setFrameIndex(local5.currFrame);
local5.currFrame += this.sfxData.getParticleAnimation(this.buffedMode).fps * local3;
local7 = this.particleStartSize + this.particleSizePerDistance * local5.particleDistance;
if(local7 > this.particleEndSize) {
local7 = this.particleEndSize;
}
local5.width = local7;
local5.height = local7;
if(local5.particleDistance > this.attenuationStartDistance) {
local5.alpha = (this._range - local5.particleDistance) / (this._range - this.attenuationStartDistance);
}
}
local4++;
}
this.time += param1;
return !this.dead || this._numParticles > 0;
}
public function kill() : void {
if(!this.dead) {
this.dead = true;
this.container.removeChild(this.muzzlePlane);
}
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.muzzlePlane);
}
private function calculateParameters() : void {
turretMatrix.setMatrix(this.turret.x,this.turret.y,this.turret.z,this.turret.rotationX,this.turret.rotationY,this.turret.rotationZ);
turretAxisX.x = turretMatrix.m00;
turretAxisX.y = turretMatrix.m10;
turretAxisX.z = turretMatrix.m20;
direction.x = turretMatrix.m01;
direction.y = turretMatrix.m11;
direction.z = turretMatrix.m21;
turretMatrix.transformVector(this.localMuzzlePosition,globalMuzzlePosition);
var local1:Number = this.localMuzzlePosition.y;
barrelOrigin.x = globalMuzzlePosition.x - local1 * direction.x;
barrelOrigin.y = globalMuzzlePosition.y - local1 * direction.y;
barrelOrigin.z = globalMuzzlePosition.z - local1 * direction.z;
}
private function addParticle() : void {
var local1:Number = NaN;
var local3:StreamWeaponParticle = null;
var local4:Number = NaN;
local1 = this.particleMuzzleOffset + Math.random() * this.particleMuzzleRandomOffset;
if(!this.muzzlePlane.visible && intersection.t < this.localMuzzlePosition.y + local1) {
return;
}
var local2:Number = Math.random();
this.getParticleFlightDirection(direction,local2);
if(this.buffedMode && Math.random() < ADDITIONAL_PARTICLE_CHANCE && local2 > ADDITIONAL_PARTICLE_MIN_FACTOR) {
local3 = StreamWeaponParticle.getParticle(false);
local3.material = this.sfxData.getAdditionalElementTexture();
local3.scaleX = 1;
local3.scaleY = 1;
local3.scaleZ = 1;
} else {
local3 = StreamWeaponParticle.getParticle(true);
local3.setAnimationData(this.sfxData.getParticleAnimation(this.buffedMode));
local4 = this.buffedMode ? BUFFED_MODE_PARTICLE_SCALE : 1;
local3.scaleX = local4;
local3.scaleY = local4;
local3.scaleZ = local4;
}
local3.rotation = Math.random() * Math.PI * 2;
local3.currFrame = Math.random() * local3.getNumFrames();
local3.velocity.x = this.particleSpeed * direction.x;
local3.velocity.y = this.particleSpeed * direction.y;
local3.velocity.z = this.particleSpeed * direction.z;
local3.velocity.add(this.shooterBody.state.velocity);
local3.particleDistance = local1;
local3.x = globalMuzzlePosition.x + local1 * direction.x;
local3.y = globalMuzzlePosition.y + local1 * direction.y;
local3.z = globalMuzzlePosition.z + local1 * direction.z;
local3.rotationDirection = Math.random() < 0.5 ? 1 : -1;
var local5:* = this._numParticles++;
this._particles[local5] = local3;
this.container.addChild(local3);
}
private function removeParticle(param1:int) : void {
var local2:StreamWeaponParticle = this._particles[param1];
this._particles[param1] = this._particles[--this._numParticles];
this._particles[this._numParticles] = null;
this.container.removeChild(local2);
local2.dispose();
}
private function getParticleFlightDirection(param1:Vector3, param2:Number) : void {
var local3:Number = 2 * Math.PI * Math.random();
matrix.fromAxisAngle(param1,local3);
turretAxisX.transform3(matrix);
var local4:Number = this._range * this.coneHalfAngleTan * param2;
param1.x = param1.x * this._range + turretAxisX.x * local4;
param1.y = param1.y * this._range + turretAxisX.y * local4;
param1.z = param1.z * this._range + turretAxisX.z * local4;
param1.normalize();
}
public function get particles() : Vector.<StreamWeaponParticle> {
return this._particles;
}
public function get numParticles() : int {
return this._numParticles;
}
public function get range() : Number {
return this._range;
}
public function updateRange(param1:Number) : void {
this.updateRangeParams(param1);
}
public function setBuffedMode(param1:Boolean) : void {
this.buffedMode = param1;
this.muzzlePlane.init(this.sfxData.getMuzzlePlaneAnimation(this.buffedMode));
}
}
}
|
package alternativa.tanks.models.weapon.gauss.state {
import alternativa.tanks.models.weapon.gauss.GaussEventType;
import alternativa.tanks.models.weapon.gauss.LocalGaussWeapon;
public class ReloadState implements IGaussState {
private var weapon:LocalGaussWeapon;
private var reloadDuration:int = 0;
private var accumulatedReloadTime:int = 0;
private var lastUpdateTime:int = 0;
public function ReloadState(param1:LocalGaussWeapon) {
super();
this.weapon = param1;
}
public function enter(param1:int, param2:GaussEventType, param3:*) : void {
this.lastUpdateTime = this.weapon.getTime();
switch(param2) {
case GaussEventType.RELOAD:
this.reloadDuration = param3;
this.accumulatedReloadTime = 0;
this.update(param1,0);
break;
case GaussEventType.STUNNED:
this.reloadDuration = param3;
this.accumulatedReloadTime = 0;
}
}
public function update(param1:int, param2:int) : void {
param2 = this.weapon.getTime() - this.lastUpdateTime;
this.lastUpdateTime = this.weapon.getTime();
this.accumulatedReloadTime += param2;
this.weapon.weaponStatus = this.accumulatedReloadTime / this.reloadDuration;
if(this.accumulatedReloadTime >= this.reloadDuration) {
this.weapon.processEvent(GaussEventType.RELOAD_COMPLETED);
}
}
public function setReloadDuration(param1:int) : * {
this.reloadDuration = param1;
}
}
}
|
package alternativa.tanks.gui.device {
import flash.display.BitmapData;
public class DevicesIcons {
private static const iconDefaultDeviceClass:Class = DevicesIcons_iconDefaultDeviceClass;
public static const iconDefaultDeviceBitmap:BitmapData = new iconDefaultDeviceClass().bitmapData;
private static const iconDefaultSkinClass:Class = DevicesIcons_iconDefaultSkinClass;
public static const iconDefaultSkinBitmap:BitmapData = new iconDefaultSkinClass().bitmapData;
private static const iconDefaultShotColorClass:Class = DevicesIcons_iconDefaultShotColorClass;
public static const iconDefaultShotColorBitmap:BitmapData = new iconDefaultShotColorClass().bitmapData;
private static const lockedIconClass:Class = DevicesIcons_lockedIconClass;
public static const lockedIcon:BitmapData = new lockedIconClass().bitmapData;
public function DevicesIcons() {
super();
}
}
}
|
package alternativa.utils.textureutils
{
public interface ITextureConstructorListener
{
function onTextureReady(param1:TextureConstructor) : void;
}
}
|
package projects.tanks.client.battlefield.models.effects.activationsfx {
import platform.client.fp10.core.resource.types.TextureResource;
public class EffectSFXRecordCC {
private var _beam:TextureResource;
private var _effectTag:int;
private var _star:TextureResource;
public function EffectSFXRecordCC(param1:TextureResource = null, param2:int = 0, param3:TextureResource = null) {
super();
this._beam = param1;
this._effectTag = param2;
this._star = param3;
}
public function get beam() : TextureResource {
return this._beam;
}
public function set beam(param1:TextureResource) : void {
this._beam = param1;
}
public function get effectTag() : int {
return this._effectTag;
}
public function set effectTag(param1:int) : void {
this._effectTag = param1;
}
public function get star() : TextureResource {
return this._star;
}
public function set star(param1:TextureResource) : void {
this._star = param1;
}
public function toString() : String {
var local1:String = "EffectSFXRecordCC [";
local1 += "beam = " + this.beam + " ";
local1 += "effectTag = " + this.effectTag + " ";
local1 += "star = " + this.star + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.weapon.terminator.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.models.weapon.terminator.TerminatorToggleCallback;
import flash.utils.getTimer;
public class TerminatorOpenEffect implements Renderer {
[Inject]
public static var battleService:BattleService;
private static const OPEN_LENGTH:Number = 50;
private static const OPEN_TIME:Number = 500;
private var leftBox:Object3D;
private var rightBox:Object3D;
private var elapsedTime:int;
private var startTime:int;
private var reverse:Boolean;
private var toggleCallback:TerminatorToggleCallback;
public function TerminatorOpenEffect(param1:Object3D, param2:Object3D, param3:TerminatorToggleCallback) {
super();
this.rightBox = param2;
this.leftBox = param1;
this.toggleCallback = param3;
}
private function toggle(param1:Boolean) : void {
battleService.getBattleScene3D().addRenderer(this);
this.reverse = param1;
var local2:* = getTimer();
var local3:* = local2 - this.startTime;
this.elapsedTime = local3 < OPEN_TIME ? int(OPEN_TIME - local3) : 0;
this.startTime = local2;
}
public function turnOn() : void {
this.toggle(false);
}
public function turnOff() : void {
this.toggle(true);
}
public function reset() : void {
this.rightBox.x = 0;
this.leftBox.x = 0;
}
public function render(param1:int, param2:int) : void {
this.elapsedTime += param2;
if(this.elapsedTime >= OPEN_TIME) {
battleService.getBattleScene3D().removeRenderer(this);
if(this.reverse) {
this.reset();
this.toggleCallback.onClosed();
} else {
this.toggleCallback.onOpened();
}
return;
}
var local3:Number = this.reverse ? OPEN_LENGTH : 0;
var local4:Number = (this.reverse ? this.elapsedTime : -this.elapsedTime) / OPEN_TIME * OPEN_LENGTH;
this.rightBox.x = local3 - local4;
this.leftBox.x = local4 - local3;
}
public function destroy() : void {
battleService.getBattleScene3D().removeRenderer(this);
}
}
}
|
package alternativa.tanks.engine3d.debug
{
import alternativa.tanks.engine3d.IndexedTextureConstructor;
import alternativa.utils.ITextureConstructorListener;
import alternativa.utils.TextureByteData;
import flash.display.BitmapData;
import flash.utils.setTimeout;
public class DummyIndexedTextureConstructor extends IndexedTextureConstructor
{
private static var bmp:BitmapData;
private var listener:ITextureConstructorListener;
public function DummyIndexedTextureConstructor()
{
var size:int = 0;
var i:int = 0;
var ii:int = 0;
var j:int = 0;
var jj:int = 0;
super();
if(bmp == null)
{
size = 100;
bmp = new BitmapData(size,size,false,8355711);
for(i = 0; i < size; i++)
{
ii = i * 5 / size;
for(j = 0; j < size; j++)
{
jj = j * 5 / size;
if(ii + jj & 1 == 1)
{
bmp.setPixel(i,j,3355443);
}
}
}
}
}
override public function get texture() : BitmapData
{
return bmp;
}
override public function createTexture(textureData:TextureByteData, listener:ITextureConstructorListener) : void
{
this.listener = listener;
setTimeout(this.notify,0);
}
private function notify() : void
{
var lsnr:ITextureConstructorListener = this.listener;
this.listener = null;
lsnr.onTextureReady(this);
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.event {
import flash.events.Event;
import platform.client.fp10.core.type.IGameObject;
public class ShopItemChosen extends Event {
public static const EVENT_TYPE:String = "ShopItemChosenEVENT";
public var item:IGameObject;
public function ShopItemChosen(param1:IGameObject) {
super(EVENT_TYPE,true);
this.item = param1;
}
}
}
|
package alternativa.tanks.model.payment.shop.kitviewresource {
import flash.display.BitmapData;
import projects.tanks.client.panel.model.shop.kitview.IKitViewResourceModelBase;
import projects.tanks.client.panel.model.shop.kitview.KitViewResourceModelBase;
[ModelInfo]
public class KitViewResourceModel extends KitViewResourceModelBase implements IKitViewResourceModelBase, KitViewResource {
public function KitViewResourceModel() {
super();
}
public function getButtonKitImage() : BitmapData {
return getInitParam().buttonKit.data;
}
public function getButtonKitOverImage() : BitmapData {
return getInitParam().buttonKitOver.data;
}
}
}
|
package projects.tanks.client.panel.model.payment.modes {
public class PaymentRequestVariable {
private var _value:String;
private var _variable:String;
public function PaymentRequestVariable(param1:String = null, param2:String = null) {
super();
this._value = param1;
this._variable = param2;
}
public function get value() : String {
return this._value;
}
public function set value(param1:String) : void {
this._value = param1;
}
public function get variable() : String {
return this._variable;
}
public function set variable(param1:String) : void {
this._variable = param1;
}
public function toString() : String {
var local1:String = "PaymentRequestVariable [";
local1 += "value = " + this.value + " ";
local1 += "variable = " + this.variable + " ";
return local1 + "]";
}
}
}
|
package alternativa.model.description {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IDescriptionAdapt implements IDescription {
private var object:IGameObject;
private var impl:IDescription;
public function IDescriptionAdapt(param1:IGameObject, param2:IDescription) {
super();
this.object = param1;
this.impl = param2;
}
public function getName() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getName();
}
finally {
Model.popObject();
}
return result;
}
public function getDescription() : String {
var result:String = null;
try {
Model.object = this.object;
result = this.impl.getDescription();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_9 extends BitmapAsset
{
public function BigRangIcon_rang_9()
{
super();
}
}
}
|
package alternativa.tanks.services.colortransform {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.command.FormattedOutput;
public class ColorTransformServiceConsoleCommands {
private static var keys:Array;
private var osgi:OSGi;
public function ColorTransformServiceConsoleCommands(param1:OSGi) {
super();
this.osgi = param1;
}
private function initKeys() : void {
}
private function initConsoleCommands(param1:OSGi) : void {
}
private function _cmdShowColorTransform(param1:FormattedOutput) : void {
}
private function _cmdSetColorTransform(param1:FormattedOutput, param2:String) : void {
}
private function getColorTransformService() : ColorTransformService {
return ColorTransformService(this.osgi.getService(ColorTransformService));
}
}
}
|
package alternativa.tanks.service.itempropertyparams.aggregationmodes {
import alternativa.tanks.model.item.upgradable.calculators.BasePropertyCalculator;
import alternativa.tanks.model.item.upgradable.calculators.PropertyCalculator;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParams;
import alternativa.tanks.service.itempropertyparams.ItemPropertyParamsService;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
import projects.tanks.client.garage.models.item.upgradeable.types.GaragePropertyParams;
import projects.tanks.client.garage.models.item.upgradeable.types.PropertyData;
public class InvertUpgradeAggregationMode implements UpgradeAggregationMode {
[Inject]
public static var propertyParamsService:ItemPropertyParamsService;
public function InvertUpgradeAggregationMode() {
super();
}
public function createValueCalculator(param1:int, param2:GaragePropertyParams) : PropertyCalculator {
var local7:PropertyData = null;
var local8:Number = NaN;
var local3:ItemPropertyParams = propertyParamsService.getParams(param2.property);
var local4:Vector.<ItemProperty> = local3.getProperties();
var local5:Number = 0;
var local6:Number = 0;
for each(local7 in param2.properties) {
if(local4.indexOf(local7.property) != -1) {
local5 += local7.initialValue;
local6 += local7.finalValue;
}
}
local8 = local3.getMultiplier();
local5 /= local8;
local6 /= local8;
return new BasePropertyCalculator(param2.precision,new InvertPropertyCalculator(local5,local6,param1));
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.notifier {
import alternativa.types.Long;
[ModelInterface]
public interface Notifier {
function subscribe(param1:Long, param2:UserInfoConsumer) : void;
function unSubscribe(param1:Long) : void;
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.proabonement {
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.tanksservices.model.proabonementnotifier.IProBattleNotifierModelBase;
import projects.tanks.client.tanksservices.model.proabonementnotifier.ProBattleNotifierModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.probattle.IUserProBattleService;
[ModelInfo]
public class ProBattleNotifierModel extends ProBattleNotifierModelBase implements IProBattleNotifierModelBase, ObjectLoadListener {
[Inject]
public static var userProBattleService:IUserProBattleService;
public function ProBattleNotifierModel() {
super();
}
public function objectLoaded() : void {
userProBattleService.setAbonementRemainingTimeSec(getInitParam().abonementRemainingTimeInSec);
}
public function setRemainingAbonementTimeSec(param1:int) : void {
userProBattleService.setAbonementRemainingTimeSec(param1);
}
}
}
|
package alternativa.utils
{
import flash.utils.Dictionary;
public function clearDictionary(param1:Dictionary) : void
{
var _loc2_:* = undefined;
for(_loc2_ in param1)
{
delete param1[_loc2_];
}
}
}
|
package controls.buttons {
import flash.display.BitmapData;
public class FixedHeightRectangleSkin {
private var _left:BitmapData;
private var _middle:BitmapData;
private var _right:BitmapData;
public function FixedHeightRectangleSkin(param1:Class = null, param2:Class = null, param3:Class = null) {
super();
if(param1 == null || param2 == null || param3 == null) {
return;
}
this._left = new param1().bitmapData;
this._middle = new param2().bitmapData;
this._right = new param3().bitmapData;
}
public static function createSkin(param1:BitmapData, param2:BitmapData, param3:BitmapData) : FixedHeightRectangleSkin {
var local4:FixedHeightRectangleSkin = new FixedHeightRectangleSkin();
local4._left = param1;
local4._right = param3;
local4._middle = param2;
return local4;
}
public function get left() : BitmapData {
return this._left;
}
public function get middle() : BitmapData {
return this._middle;
}
public function get right() : BitmapData {
return this._right;
}
}
}
|
package controls.buttons.h71px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h71px.GreyHugeButtonSkin_leftOverClass.png")]
public class GreyHugeButtonSkin_leftOverClass extends BitmapAsset {
public function GreyHugeButtonSkin_leftOverClass() {
super();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.logging.paymentactions {
import alternativa.types.Long;
import flash.events.IEventDispatcher;
public interface UserPaymentActionsService extends IEventDispatcher {
function openPayment(param1:String) : void;
function closePayment(param1:String) : void;
function selectCountry(param1:String) : void;
function choosePaymode(param1:Long, param2:Long) : void;
function chooseItem(param1:Long) : void;
function proceed(param1:Long, param2:Long) : void;
}
}
|
package projects.tanks.client.panel.model.challenge.rewarding {
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 ChallengesRewardingUserModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ChallengesRewardingUserModelServer(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.materials {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.MipMapping;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.*;
import alternativa.gfx.core.BitmapTextureResource;
import alternativa.gfx.core.Device;
import alternativa.gfx.core.IndexBufferResource;
import alternativa.gfx.core.ProgramResource;
import alternativa.gfx.core.VertexBufferResource;
import flash.display.BitmapData;
import flash.display3D.Context3DProgramType;
import flash.display3D.Context3DVertexBufferFormat;
import flash.utils.ByteArray;
import flash.utils.Dictionary;
use namespace alternativa3d;
public class PaintMaterial extends TextureMaterial {
protected var fragConst:Vector.<Number>;
private var programs:Dictionary = new Dictionary();
protected var spriteSheetBitmap:BitmapData;
protected var lightMapBitmap:BitmapData;
protected var spriteSheetResource:BitmapTextureResource;
protected var lightMapResource:BitmapTextureResource;
public function PaintMaterial(param1:BitmapData, param2:BitmapData, param3:BitmapData, param4:int = 0) {
super(param3,true,true,param4);
this.spriteSheetBitmap = param1;
this.lightMapBitmap = param2;
this.spriteSheetResource = TextureResourcesRegistry.getTextureResource(param1,alternativa3d::_mipMapping > 0,true,false);
this.lightMapResource = TextureResourcesRegistry.getTextureResource(param2,alternativa3d::_mipMapping > 0,true,false);
this.fragConst = Vector.<Number>([0,0.5,1,2,0.999,0.999,0,0]);
uvTransformConst[0] = param3.width / param1.width;
uvTransformConst[5] = param3.height / param1.height;
alternativa3d::_mipMapping = this.spriteSheetResource.mipMapping ? MipMapping.PER_PIXEL : 0;
}
override alternativa3d function get transparent() : Boolean {
return false;
}
override public function set mipMapping(param1:int) : void {
alternativa3d::_mipMapping = param1;
alternativa3d::textureResource = TextureResourcesRegistry.getTextureResource(bitmap,alternativa3d::_mipMapping > 0,repeat,alternativa3d::_hardwareMipMaps);
this.spriteSheetResource = TextureResourcesRegistry.getTextureResource(this.spriteSheetBitmap,alternativa3d::_mipMapping > 0,true,false);
this.lightMapResource = TextureResourcesRegistry.getTextureResource(this.lightMapBitmap,alternativa3d::_mipMapping > 0,true,false);
}
override alternativa3d function drawOpaque(param1:Camera3D, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D) : void {
var local7:BitmapData = texture;
if(local7 == null && alternativa3d::_textureATF == null) {
return;
}
var local8:Device = param1.alternativa3d::device;
var local9:Boolean = param1.fogAlpha > 0 && param1.fogStrength > 0;
var local10:Boolean = !param1.view.alternativa3d::constrained && param1.ssao && param1.ssaoStrength > 0 && Boolean(param6.alternativa3d::useDepth);
var local11:Boolean = !param1.view.alternativa3d::constrained && param1.directionalLight != null && param1.directionalLightStrength > 0 && param6.useLight;
var local12:Boolean = !param1.view.alternativa3d::constrained && param1.shadowMap != null && param1.shadowMapStrength > 0 && param6.useLight && param6.useShadowMap;
var local13:Boolean = !param1.view.alternativa3d::constrained && param1.deferredLighting && param1.deferredLightingStrength > 0 && Boolean(param6.alternativa3d::useDepth) && param6.useLight;
var local14:Boolean = alphaTestThreshold > 0 && this.alternativa3d::transparent;
local8.setProgram(this.getProgram(!local14,false,false,false,param1.view.alternativa3d::quality,repeat,alternativa3d::_mipMapping > 0,param6.alternativa3d::concatenatedColorTransform != null,false,local9,false,local10,local11,local12,local7 == null,false,local13,false,param1.view.alternativa3d::correction,param6.alternativa3d::concatenatedBlendMode != "normal",local14,false));
local8.setTextureAt(0,alternativa3d::textureResource);
uvCorrection[0] = alternativa3d::textureResource.correctionU;
uvCorrection[1] = alternativa3d::textureResource.correctionV;
if(local10) {
local8.setTextureAt(1,param1.alternativa3d::depthMap);
} else {
local8.setTextureAt(1,null);
}
if(local12) {
local8.setTextureAt(2,param1.shadowMap.alternativa3d::map);
local8.setTextureAt(3,param1.shadowMap.alternativa3d::noise);
} else {
local8.setTextureAt(2,null);
local8.setTextureAt(3,null);
}
local8.setTextureAt(4,this.spriteSheetResource);
local8.setTextureAt(6,this.lightMapResource);
if(local13) {
local8.setTextureAt(5,param1.alternativa3d::lightMap);
} else {
local8.setTextureAt(5,null);
}
local8.setVertexBufferAt(0,param2,0,Context3DVertexBufferFormat.FLOAT_3);
local8.setVertexBufferAt(1,param2,3,Context3DVertexBufferFormat.FLOAT_2);
if(local11) {
local8.setVertexBufferAt(2,param2,5,Context3DVertexBufferFormat.FLOAT_3);
} else {
local8.setVertexBufferAt(2,null);
}
local8.setProgramConstantsFromVector(Context3DProgramType.VERTEX,0,param6.alternativa3d::transformConst,3,false);
local8.setProgramConstantsFromVector(Context3DProgramType.VERTEX,4,uvCorrection,1);
local8.setProgramConstantsFromVector(Context3DProgramType.VERTEX,14,uvTransformConst,2);
local8.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,23,this.fragConst,2,false);
if(param6.alternativa3d::concatenatedColorTransform != null) {
local8.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,0,param6.alternativa3d::colorConst,2,false);
}
if(local14) {
fragmentConst[3] = alphaTestThreshold;
local8.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,14,fragmentConst,1,false);
}
try {
local8.drawTriangles(param3,param4,param5);
}
catch(e:Error) {
}
++param1.alternativa3d::numDraws;
param1.alternativa3d::numTriangles += param5;
}
override alternativa3d function drawTransparent(param1:Camera3D, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D, param7:Boolean = false) : void {
var local8:BitmapData = texture;
if(local8 == null && alternativa3d::_textureATF == null) {
return;
}
var local9:Device = param1.alternativa3d::device;
var local10:Boolean = param1.fogAlpha > 0 && param1.fogStrength > 0;
var local11:Boolean = !param1.view.alternativa3d::constrained && param1.softTransparency && param1.softTransparencyStrength > 0 && param6.softAttenuation > 0;
var local12:Boolean = !param1.view.alternativa3d::constrained && param1.ssao && param1.ssaoStrength > 0 && Boolean(param6.alternativa3d::useDepth);
var local13:Boolean = !param1.view.alternativa3d::constrained && param1.directionalLight != null && param1.directionalLightStrength > 0 && param6.useLight;
var local14:Boolean = !param1.view.alternativa3d::constrained && param1.shadowMap != null && param1.shadowMapStrength > 0 && param6.useLight && param6.useShadowMap;
var local15:Boolean = !param1.view.alternativa3d::constrained && param1.deferredLighting && param1.deferredLightingStrength > 0;
var local16:Boolean = local15 && Boolean(param6.alternativa3d::useDepth) && param6.useLight;
local9.setProgram(this.getProgram(false,false,false,false,param1.view.alternativa3d::quality,repeat,alternativa3d::_mipMapping > 0,param6.alternativa3d::concatenatedColorTransform != null,param6.alternativa3d::concatenatedAlpha < 1,local10,local11,local12,local13,local14,local8 == null,local8 == null && alternativa3d::_textureATFAlpha != null,local16,false,param1.view.alternativa3d::correction,param6.alternativa3d::concatenatedBlendMode != "normal",false,param7));
local9.setTextureAt(0,alternativa3d::textureResource);
uvCorrection[0] = alternativa3d::textureResource.correctionU;
uvCorrection[1] = alternativa3d::textureResource.correctionV;
if(local12 || local11) {
local9.setTextureAt(1,param1.alternativa3d::depthMap);
} else {
local9.setTextureAt(1,null);
}
if(local14) {
local9.setTextureAt(2,param1.shadowMap.alternativa3d::map);
local9.setTextureAt(3,param1.shadowMap.alternativa3d::noise);
} else {
local9.setTextureAt(2,null);
local9.setTextureAt(3,null);
}
local9.setTextureAt(4,this.spriteSheetResource);
local9.setTextureAt(6,this.lightMapResource);
if(local16) {
local9.setTextureAt(5,param1.alternativa3d::lightMap);
} else {
local9.setTextureAt(5,null);
}
local9.setVertexBufferAt(0,param2,0,Context3DVertexBufferFormat.FLOAT_1);
local9.setVertexBufferAt(1,null);
local9.setVertexBufferAt(2,null);
local9.setProgramConstantsFromVector(Context3DProgramType.VERTEX,0,param6.alternativa3d::transformConst,3,false);
local9.setProgramConstantsFromVector(Context3DProgramType.VERTEX,4,uvCorrection,1);
local9.setProgramConstantsFromVector(Context3DProgramType.VERTEX,14,uvTransformConst,2);
local9.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,23,this.fragConst,2,false);
if(local11) {
fragmentConst[2] = param6.softAttenuation;
local9.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,14,fragmentConst,1);
}
if(param6.alternativa3d::concatenatedColorTransform != null) {
local9.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,0,param6.alternativa3d::colorConst,2,false);
} else if(param6.alternativa3d::concatenatedAlpha < 1) {
local9.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,0,param6.alternativa3d::colorConst,1);
}
local9.drawTriangles(param3,param4,param5);
++param1.alternativa3d::numDraws;
param1.alternativa3d::numTriangles += param5;
}
override public function disposeResource() : void {
if(alternativa3d::textureResource != null) {
alternativa3d::textureResource.dispose();
alternativa3d::textureResource = null;
}
if(this.spriteSheetResource != null) {
this.spriteSheetResource.dispose();
this.spriteSheetResource = null;
}
if(this.lightMapResource != null) {
this.lightMapResource.dispose();
this.lightMapResource = null;
}
}
override public function dispose() : void {
this.disposeResource();
this.spriteSheetBitmap = null;
this.lightMapBitmap = null;
}
override protected function getProgram(param1:Boolean, param2:Boolean, param3:Boolean, param4:Boolean, param5:Boolean, param6:Boolean, param7:Boolean, param8:Boolean, param9:Boolean, param10:Boolean, param11:Boolean, param12:Boolean, param13:Boolean, param14:Boolean, param15:Boolean, param16:Boolean, param17:Boolean, param18:Boolean, param19:Boolean, param20:Boolean, param21:Boolean, param22:Boolean) : ProgramResource {
var local25:ByteArray = null;
var local26:ByteArray = null;
var local23:int = int(param1) | int(param2) << 1 | int(param3) << 2 | int(param4) << 3 | int(param5) << 4 | int(param6) << 5 | int(param7) << 6 | int(param8) << 7 | int(param9) << 8 | int(param10) << 9 | int(param11) << 10 | int(param12) << 11 | int(param13) << 12 | int(param14) << 13 | int(param15) << 14 | int(param16) << 15 | int(param17) << 16 | int(param18) << 17 | int(param19) << 18 | int(param20) << 19 | int(param21) << 20 | int(param22) << 21;
var local24:ProgramResource = this.programs[local23];
if(local24 == null) {
local25 = new PaintVertexShader(!param22,param14 || param11 || param12 || param17,param13,param4,param14,param10,param2,param3,param3,param19).agalcode;
local26 = new PaintFragmentShader(param6,param5,param7,param15,param21,!param1 && !param16 && !param15,param8,param9,param3,param13,param11,param12,param17,param18,param14,param10,param2,param20).agalcode;
local24 = new ProgramResource(local25,local26);
this.programs[local23] = local24;
}
return local24;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.shot {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.weapon.shot.ShotCC;
public class CodecShotCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_reloadMsec:ICodec;
public function CodecShotCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_reloadMsec = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ShotCC = new ShotCC();
local2.reloadMsec = this.codec_reloadMsec.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ShotCC = ShotCC(param2);
this.codec_reloadMsec.encode(param1,local3.reloadMsec);
}
}
}
|
package alternativa.tanks.model.quest.challenge {
import flash.events.IEventDispatcher;
import projects.tanks.client.panel.model.challenge.rewarding.Tier;
public interface ChallengesViewService extends IEventDispatcher {
function changeTiersInfo(param1:Vector.<Tier>) : void;
function getTierNumber(param1:int) : int;
}
}
|
package alternativa.tanks.vehicles.tanks
{
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.materials.UVMatrixProvider;
import alternativa.tanks.materials.TrackMaterial;
import flash.geom.Matrix;
import flash.utils.Dictionary;
public class TrackSkin
{
private var uvsProvider:UVMatrixProvider;
private var faces:Vector.<Face>;
private var vertices:Vector.<Vertex>;
private var ratio:Number;
private var distance:Number = 0;
public var material:TrackMaterial;
public function TrackSkin()
{
this.faces = new Vector.<Face>();
super();
}
private static function getRatio(param1:Face) : Number
{
var _vertices:Vector.<Vertex> = param1.vertices;
return getRatioForVertices(_vertices[0],_vertices[1]);
}
private static function getRatioForVertices(vertex1:Vertex, vertex2:Vertex) : Number
{
var dx:Number = vertex1.x - vertex2.x;
var dy:Number = vertex1.y - vertex2.y;
var dz:Number = vertex1.z - vertex2.z;
var vertexDistanceXYZ:Number = Math.sqrt(dx * dx + dy * dy + dz * dz);
var du:Number = vertex1.u - vertex2.u;
var dv:Number = vertex1.v - vertex2.v;
var vertexDistanceUV:Number = Math.sqrt(du * du + dv * dv);
return vertexDistanceUV / vertexDistanceXYZ;
}
public function addFace(_face:Face) : void
{
this.faces.push(_face);
}
public function init() : void
{
var polygon:Face = null;
var newVertex:* = undefined;
var vertex:Vertex = null;
var co:Number = 0;
var dictionary:Dictionary = new Dictionary();
for each(polygon in this.faces)
{
for each(vertex in polygon.vertices)
{
dictionary[vertex] = true;
}
co += getRatio(polygon);
}
this.ratio = co / this.faces.length;
this.vertices = new Vector.<Vertex>();
for(newVertex in dictionary)
{
this.vertices.push(newVertex);
}
}
public function move(delta:Number) : void
{
var m:Matrix = null;
this.distance += delta * this.ratio;
if(this.uvsProvider != null)
{
m = this.uvsProvider.getMatrix();
m.tx = this.distance;
}
}
public function setMaterial(newMaterial:Material) : void
{
newMaterial.name = "track";
var face:Face = null;
var trackMat:TrackMaterial = null;
for each(face in this.faces)
{
face.material = newMaterial;
}
if(newMaterial is TrackMaterial)
{
this.material = newMaterial as TrackMaterial;
trackMat = newMaterial as TrackMaterial;
this.uvsProvider = trackMat.uvMatrixProvider;
}
}
public function destroy() : *
{
var f:Face = null;
var v:Vertex = null;
if(this.faces != null)
{
for each(f in this.faces)
{
f.destroy();
f = null;
}
this.faces = null;
}
if(this.vertices != null)
{
for each(v in this.vertices)
{
v = null;
}
this.vertices = null;
}
}
}
}
|
package alternativa.utils.filters {
public class ColorMatrix extends DynamicMatrix {
protected static const LUMINANCER:Number = 0.3086;
protected static const LUMINANCEG:Number = 0.6094;
protected static const LUMINANCEB:Number = 0.082;
public function ColorMatrix() {
super(5,5);
LoadIdentity();
}
public function SetBrightnessMatrix(param1:Number) : void {
if(!m_matrix) {
return;
}
m_matrix[0][4] = param1;
m_matrix[1][4] = param1;
m_matrix[2][4] = param1;
}
public function SetContrastMatrix(param1:Number) : void {
if(!m_matrix) {
return;
}
var local2:Number = 0.5 * (127 - param1);
param1 /= 127;
m_matrix[0][0] = param1;
m_matrix[1][1] = param1;
m_matrix[2][2] = param1;
m_matrix[0][4] = local2;
m_matrix[1][4] = local2;
m_matrix[2][4] = local2;
}
public function SetSaturationMatrix(param1:Number) : void {
if(!m_matrix) {
return;
}
var local2:Number = 1 - param1;
var local3:Number = local2 * LUMINANCER;
m_matrix[0][0] = local3 + param1;
m_matrix[1][0] = local3;
m_matrix[2][0] = local3;
local3 = local2 * LUMINANCEG;
m_matrix[0][1] = local3;
m_matrix[1][1] = local3 + param1;
m_matrix[2][1] = local3;
local3 = local2 * LUMINANCEB;
m_matrix[0][2] = local3;
m_matrix[1][2] = local3;
m_matrix[2][2] = local3 + param1;
}
public function SetHueMatrix(param1:Number) : void {
var local11:int = 0;
if(!m_matrix) {
return;
}
LoadIdentity();
var local2:DynamicMatrix = new DynamicMatrix(3,3);
var local3:DynamicMatrix = new DynamicMatrix(3,3);
var local4:DynamicMatrix = new DynamicMatrix(3,3);
var local5:Number = Math.cos(param1);
var local6:Number = Math.sin(param1);
var local7:Number = 0.213;
var local8:Number = 0.715;
var local9:Number = 0.072;
local2.SetValue(0,0,local7);
local2.SetValue(1,0,local7);
local2.SetValue(2,0,local7);
local2.SetValue(0,1,local8);
local2.SetValue(1,1,local8);
local2.SetValue(2,1,local8);
local2.SetValue(0,2,local9);
local2.SetValue(1,2,local9);
local2.SetValue(2,2,local9);
local3.SetValue(0,0,1 - local7);
local3.SetValue(1,0,-local7);
local3.SetValue(2,0,-local7);
local3.SetValue(0,1,-local8);
local3.SetValue(1,1,1 - local8);
local3.SetValue(2,1,-local8);
local3.SetValue(0,2,-local9);
local3.SetValue(1,2,-local9);
local3.SetValue(2,2,1 - local9);
local3.MultiplyNumber(local5);
local4.SetValue(0,0,-local7);
local4.SetValue(1,0,0.143);
local4.SetValue(2,0,-(1 - local7));
local4.SetValue(0,1,-local8);
local4.SetValue(1,1,0.14);
local4.SetValue(2,1,local8);
local4.SetValue(0,2,1 - local9);
local4.SetValue(1,2,-0.283);
local4.SetValue(2,2,local9);
local4.MultiplyNumber(local6);
local2.Add(local3);
local2.Add(local4);
var local10:int = 0;
while(local10 < 3) {
local11 = 0;
while(local11 < 3) {
m_matrix[local10][local11] = local2.GetValue(local10,local11);
local11++;
}
local10++;
}
}
public function GetFlatArray() : Array {
var local4:int = 0;
if(!m_matrix) {
return null;
}
var local1:Array = new Array();
var local2:int = 0;
var local3:int = 0;
while(local3 < 4) {
local4 = 0;
while(local4 < 5) {
local1[local2] = m_matrix[local3][local4];
local2++;
local4++;
}
local3++;
}
return local1;
}
}
}
class XFormData {
public var ox:Number;
public var oy:Number;
public var oz:Number;
public function XFormData() {
super();
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.score {
import alternativa.tanks.models.battle.gui.gui.statistics.field.score.ctf.ComplexTeamScoreIndicator;
public class RugbyScoreIndicator extends ComplexTeamScoreIndicator implements TeamScoreIndicator {
private static var redScoreClass:Class = RugbyScoreIndicator_redScoreClass;
private static var blueScoreClass:Class = RugbyScoreIndicator_blueScoreClass;
private static var flagBlueLostClass:Class = RugbyScoreIndicator_flagBlueLostClass;
private static var flagRedLostClass:Class = RugbyScoreIndicator_flagRedLostClass;
private static var flagFlashClass:Class = RugbyScoreIndicator_flagFlashClass;
public function RugbyScoreIndicator() {
super(new blueScoreClass(),new flagBlueLostClass(),new flagFlashClass(),new redScoreClass(),new flagRedLostClass(),new flagFlashClass());
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.notifier.battle {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import projects.tanks.client.tanksservices.model.notifier.battle.BattleNotifierData;
import projects.tanks.client.tanksservices.types.battle.BattleInfoData;
public class CodecBattleNotifierData implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_battleData:ICodec;
private var codec_userId:ICodec;
public function CodecBattleNotifierData() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_battleData = param1.getCodec(new TypeCodecInfo(BattleInfoData,false));
this.codec_userId = param1.getCodec(new TypeCodecInfo(Long,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BattleNotifierData = new BattleNotifierData();
local2.battleData = this.codec_battleData.decode(param1) as BattleInfoData;
local2.userId = this.codec_userId.decode(param1) as Long;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BattleNotifierData = BattleNotifierData(param2);
this.codec_battleData.encode(param1,local3.battleData);
this.codec_userId.encode(param1,local3.userId);
}
}
}
|
package alternativa.tanks.gui.friends.list.renderer {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.list.renderer.FriendsAcceptedListRenderer_referralFriendClass.png")]
public class FriendsAcceptedListRenderer_referralFriendClass extends BitmapAsset {
public function FriendsAcceptedListRenderer_referralFriendClass() {
super();
}
}
}
|
package utils.graphics
{
import flash.display.Shape;
import utils.Pen;
public class SectorMask extends Shape
{
private static const MIN_PROGRESS:Number = 0;
private static const MAX_PROGRESS:Number = 1;
private var _pen:Pen;
private var _radius:int;
private var _size:int;
private var _startProgress:Number;
private var _endProgress:Number;
private var _isReverse:Boolean;
public function SectorMask(param1:Number, param2:Boolean = false)
{
super();
this._size = param1;
this._isReverse = param2;
this.init();
}
private static function clamp(param1:Number) : Number
{
return Math.max(MIN_PROGRESS,Math.min(MAX_PROGRESS,param1));
}
private function init() : void
{
this._radius = Math.ceil(Math.sqrt(this._size * this._size + this._size * this._size) / 2);
this._pen = new Pen(this.graphics);
}
public function setProgress(param1:Number, param2:Number) : void
{
if(this._startProgress == param1 && this._endProgress == param2)
{
return;
}
this._startProgress = param1;
this._endProgress = param2;
var _loc3_:Number = 360 * clamp(param1);
var _loc4_:Number = 360 * clamp(param2);
var _loc5_:Number = _loc4_ - _loc3_;
var _loc6_:Number = !!this._isReverse ? Number(Number(Number(-90))) : Number(Number(Number(_loc3_ - 90)));
this._pen.clear();
this._pen.beginFill(16711680);
this._pen.drawArc(this._size / 2,this._size / 2,this._radius,_loc5_,_loc6_,true);
this._pen.endFill();
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.healing
{
public class IsisActionType
{
public static var HEAL:IsisActionType = new IsisActionType();
public static var DAMAGE:IsisActionType = new IsisActionType();
public static var IDLE:IsisActionType = new IsisActionType();
public function IsisActionType()
{
super();
}
public static function getType(str:String) : IsisActionType
{
var obj:IsisActionType = null;
switch(str)
{
case "idle":
obj = IDLE;
break;
case "damage":
obj = DAMAGE;
break;
case "heal":
obj = HEAL;
}
return obj;
}
}
}
|
package alternativa.tanks.view.battlecreate.slider {
import controls.slider.SliderThumb;
import flash.display.BitmapData;
import flash.display.Graphics;
import flash.display.Sprite;
import flash.geom.Matrix;
import forms.ranks.SmallRankIcon;
public class SelectRankThumbSlider extends SliderThumb {
private static const bitmapArrow:Class = SelectRankThumbSlider_bitmapArrow;
private static const arrow:BitmapData = new bitmapArrow().bitmapData;
private var iconMin:SmallRankIcon;
private var iconMax:SmallRankIcon;
private var _minRang:int = 1;
private var _maxRang:int = 1;
public var leftDrag:Sprite;
public var centerDrag:Sprite;
public var rightDrag:Sprite;
public function SelectRankThumbSlider() {
var local1:Graphics = null;
this.iconMin = new SmallRankIcon();
this.iconMax = new SmallRankIcon();
super();
addChild(this.iconMax);
addChild(this.iconMin);
this.iconMin.y = this.iconMax.y = 9;
this.leftDrag = new Sprite();
local1 = this.leftDrag.graphics;
local1.beginFill(0,0);
local1.drawRect(0,0,15,30);
local1.endFill();
this.centerDrag = new Sprite();
this.centerDrag.x = 15;
this.rightDrag = new Sprite();
local1 = this.rightDrag.graphics;
local1.beginFill(0,0);
local1.drawRect(0,0,15,30);
local1.endFill();
addChild(this.leftDrag);
addChild(this.centerDrag);
addChild(this.rightDrag);
this.leftDrag.buttonMode = true;
this.centerDrag.buttonMode = true;
this.rightDrag.buttonMode = true;
}
override protected function draw() : void {
var local2:Graphics = null;
var local3:Matrix = null;
super.draw();
var local1:int = this._maxRang - this._minRang;
this.iconMin.setDefaultAccount(this._minRang);
this.iconMax.setDefaultAccount(this._maxRang);
this.iconMax.visible = local1 > 0;
if(local1 == 0) {
this.iconMax.x = this.iconMin.x = int((_width - this.iconMin.width) / 2);
} else {
this.iconMin.x = 11;
this.iconMax.x = _width - this.iconMax.width - 11;
local2 = this.graphics;
local3 = new Matrix();
local3.translate(5,12);
local2.beginBitmapFill(arrow,local3);
local2.drawRect(5,12,4,7);
local2.endFill();
local3 = new Matrix();
local3.rotate(Math.PI);
local3.translate(_width - 9,12);
local2.beginBitmapFill(arrow,local3);
local2.drawRect(_width - 9,12,4,7);
local2.endFill();
}
local2 = this.centerDrag.graphics;
local2.clear();
local2.beginFill(0,0);
local2.drawRect(0,0,_width - 30,30);
local2.endFill();
this.rightDrag.x = _width - 15;
}
public function set minRang(param1:int) : void {
this._minRang = param1;
this.draw();
}
public function set maxRang(param1:int) : void {
this._maxRang = param1;
this.draw();
}
}
}
|
package alternativa.tanks.locale.en
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class Image_bitmapReferalHeader extends BitmapAsset
{
public function Image_bitmapReferalHeader()
{
super();
}
}
}
|
package controls.buttons.h50px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h50px.GreyBigButtonSkin_leftDownClass.png")]
public class GreyBigButtonSkin_leftDownClass extends BitmapAsset {
public function GreyBigButtonSkin_leftDownClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes.sms.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.payment.modes.sms.types.SMSNumber;
public class VectorCodecSMSNumberLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecSMSNumberLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(SMSNumber,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.<SMSNumber> = new Vector.<SMSNumber>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = SMSNumber(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:SMSNumber = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<SMSNumber> = Vector.<SMSNumber>(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.gui.frames {
import flash.display.Bitmap;
import flash.display.Sprite;
public class FrameBase extends Sprite {
private var frameLeftTopCorner:Bitmap;
private var frameLeftBottomCorner:Bitmap;
private var frameLeftLine:Bitmap;
private var frameRightTopCorner:Bitmap;
private var frameRightBottomCorner:Bitmap;
private var frameRightLine:Bitmap;
private var frameTopLine:Bitmap;
private var frameBottomLine:Bitmap;
public function FrameBase(param1:int, param2:int, param3:FrameSkin) {
super();
this.setSkin(param3);
addChild(this.frameLeftTopCorner);
addChild(this.frameRightTopCorner);
this.setWidth(param1);
this.frameTopLine.x = this.frameLeftTopCorner.x + this.frameLeftTopCorner.width;
addChild(this.frameTopLine);
this.frameLeftBottomCorner.x = this.frameLeftTopCorner.x;
addChild(this.frameLeftBottomCorner);
this.setHeight(param2);
addChild(this.frameRightBottomCorner);
this.frameBottomLine.x = this.frameTopLine.x;
addChild(this.frameBottomLine);
this.frameLeftLine.x = this.frameLeftTopCorner.x;
this.frameLeftLine.y = this.frameLeftTopCorner.height;
addChild(this.frameLeftLine);
this.frameRightLine.y = this.frameLeftLine.y;
addChild(this.frameRightLine);
}
private function setSkin(param1:FrameSkin) : void {
this.frameLeftTopCorner = new Bitmap(param1.leftTopCorner);
this.frameLeftBottomCorner = new Bitmap(param1.leftBottomCorner);
this.frameLeftLine = new Bitmap(param1.frameLinePoint);
this.frameRightTopCorner = new Bitmap(param1.rightTopCorner);
this.frameRightBottomCorner = new Bitmap(param1.rightBottomCorner);
this.frameRightLine = new Bitmap(param1.frameLinePoint);
this.frameTopLine = new Bitmap(param1.frameLinePoint);
this.frameBottomLine = new Bitmap(param1.frameLinePoint);
}
public function setWidth(param1:int) : void {
this.frameRightTopCorner.x = param1 - this.frameRightTopCorner.width;
this.frameRightBottomCorner.x = this.frameRightTopCorner.x;
this.frameTopLine.width = this.frameRightTopCorner.x - this.frameTopLine.x;
this.frameBottomLine.width = this.frameTopLine.width;
this.frameRightLine.x = this.frameRightTopCorner.x + this.frameRightTopCorner.width - this.frameRightLine.width;
}
public function setHeight(param1:int) : void {
this.frameLeftBottomCorner.y = param1;
this.frameRightBottomCorner.y = this.frameLeftBottomCorner.y;
this.frameLeftLine.height = this.frameLeftBottomCorner.y - this.frameLeftTopCorner.height;
this.frameRightLine.height = this.frameLeftLine.height;
this.frameBottomLine.y = this.frameLeftBottomCorner.y + this.frameRightBottomCorner.height - this.frameBottomLine.height;
}
}
}
|
package alternativa.engine3d.materials
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import alternativa.gfx.core.IndexBufferResource;
import alternativa.gfx.core.VertexBufferResource;
import flash.utils.getQualifiedClassName;
use namespace alternativa3d;
public class Material
{
public var name:String;
public var alphaTestThreshold:Number = 0;
public var zOffset:Boolean = false;
public var uploadEveryFrame:Boolean = false;
alternativa3d var drawId:uint = 0;
alternativa3d var useVerticesNormals:Boolean = true;
private var isTransparent:Boolean;
public function Material()
{
super();
}
alternativa3d function get transparent() : Boolean
{
return this.isTransparent;
}
alternativa3d function set transparent(param1:Boolean) : void
{
this.isTransparent = param1;
}
public function clone() : Material
{
var _loc1_:Material = new Material();
_loc1_.clonePropertiesFrom(this);
return _loc1_;
}
protected function clonePropertiesFrom(param1:Material) : void
{
this.name = param1.name;
this.alphaTestThreshold = param1.alphaTestThreshold;
this.useVerticesNormals = param1.useVerticesNormals;
}
public function toString() : String
{
var _loc1_:String = getQualifiedClassName(this);
return "[" + _loc1_.substr(_loc1_.indexOf("::") + 2) + " " + this.name + "]";
}
alternativa3d function drawOpaque(param1:Camera3D, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D) : void
{
}
alternativa3d function drawTransparent(param1:Camera3D, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D, param7:Boolean = false) : void
{
}
public function dispose() : void
{
}
}
}
|
package alternativa.tanks.gui.components.indicators {
import alternativa.tanks.models.service.ClanNotificationsManager;
import alternativa.types.Long;
public class NewClanMemberIndicator extends LabelNewIndicator {
private var userId:Long;
private var data:Object;
public function NewClanMemberIndicator(param1:Long, param2:Object) {
super();
this.userId = param1;
this.data = param2;
}
override public function updateNotifications() : void {
visible = ClanNotificationsManager.userInAcceptedNotifications(this.userId) || this.isNew;
if(visible && Boolean(stage)) {
ClanNotificationsManager.removeAcceptedNotification(this.userId);
this.isNew = true;
}
}
public function get isNew() : Boolean {
return this.data.isNew;
}
public function set isNew(param1:Boolean) : void {
this.data.isNew = param1;
visible = param1;
}
}
}
|
package alternativa.physics {
import alternativa.math.Matrix3;
import alternativa.math.Matrix4;
import alternativa.math.Quaternion;
import alternativa.math.Vector3;
import alternativa.physics.collision.BodyCollisionFilter;
import alternativa.physics.collision.CollisionShape;
import alternativa.physics.collision.types.AABB;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.utils.EncryptedNumber;
import alternativa.tanks.utils.EncryptedNumberImpl;
public class Body {
public static var linearDamping:Number = 0.997;
public static var rotationalDamping:Number = 0.997;
private static const MAX_SPEED_Z:Number = 1500;
private static const _r:Vector3 = new Vector3();
private static const _f:Vector3 = new Vector3();
public var id:int;
public var tank:Tank;
public var scene:PhysicsScene;
public var movable:Boolean = true;
public var canFreeze:Boolean = false;
public var freezeCounter:int;
public var frozen:Boolean = false;
public var slipperyMode:Boolean = false;
public var aabb:AABB = new AABB();
public var postCollisionFilter:BodyCollisionFilter;
public var acceleration:Vector3 = new Vector3();
public var angularAcceleration:Vector3 = new Vector3();
public var prevState:BodyState = new BodyState();
public var mass:Number = 1;
public var invMass:Number = 1;
public var invInertia:Matrix3 = new Matrix3();
public var invInertiaWorld:Matrix3 = new Matrix3();
public var baseMatrix:Matrix3 = new Matrix3();
public var previousVelocity:Vector3 = new Vector3();
public var state:BodyState = new BodyState();
private var maxSpeedXY:EncryptedNumber = new EncryptedNumberImpl(0);
private var maxZSpeedDelta:Number = 600;
private var minZAcceleration:Number = -1100;
public var collisionShapes:Vector.<CollisionShape>;
public var numCollisionShapes:int;
public var forceAccum:Vector3 = new Vector3();
public var torqueAccum:Vector3 = new Vector3();
public var pseudoVelocity:Vector3 = new Vector3();
public var pseudoAngularVelocity:Vector3 = new Vector3();
public function Body(param1:Number, param2:Matrix3, param3:Number) {
super();
this.mass = param1;
this.invMass = 1 / param1;
this.invInertia.copy(param2);
this.maxSpeedXY.setNumber(param3);
}
public function addCollisionShape(param1:CollisionShape, param2:Matrix4 = null) : void {
if(param1 == null) {
throw new ArgumentError("Parameter is null");
}
if(this.collisionShapes == null) {
this.collisionShapes = new Vector.<CollisionShape>();
this.numCollisionShapes = 0;
}
this.collisionShapes.push(param1);
this.numCollisionShapes = this.collisionShapes.length;
param1.setBody(this,param2);
}
public function removeCollisionShape(param1:CollisionShape) : void {
var local2:int = 0;
if(this.collisionShapes != null) {
if(this.numCollisionShapes > 0) {
local2 = int(this.collisionShapes.indexOf(param1));
if(local2 >= 0) {
param1.setBody(null);
this.collisionShapes[local2] = this.collisionShapes[--this.numCollisionShapes];
if(this.numCollisionShapes == 0) {
this.collisionShapes = null;
} else {
this.collisionShapes.length = this.numCollisionShapes;
}
}
}
}
}
public function interpolate(param1:Number, param2:Vector3, param3:Quaternion) : void {
var local4:Number = NaN;
local4 = 1 - param1;
param2.x = this.prevState.position.x * local4 + this.state.position.x * param1;
param2.y = this.prevState.position.y * local4 + this.state.position.y * param1;
param2.z = this.prevState.position.z * local4 + this.state.position.z * param1;
param3.w = this.prevState.orientation.w * local4 + this.state.orientation.w * param1;
param3.x = this.prevState.orientation.x * local4 + this.state.orientation.x * param1;
param3.y = this.prevState.orientation.y * local4 + this.state.orientation.y * param1;
param3.z = this.prevState.orientation.z * local4 + this.state.orientation.z * param1;
}
public function setPosition(param1:Vector3) : void {
this.state.position.copy(param1);
}
public function setPositionXYZ(param1:Number, param2:Number, param3:Number) : void {
this.state.position.reset(param1,param2,param3);
}
public function setVelocity(param1:Vector3) : void {
this.state.velocity.copy(param1);
}
public function setVelocityXYZ(param1:Number, param2:Number, param3:Number) : void {
this.state.velocity.reset(param1,param2,param3);
}
public function setRotation(param1:Vector3) : void {
this.state.angularVelocity.copy(param1);
}
public function setRotationXYZ(param1:Number, param2:Number, param3:Number) : void {
this.state.angularVelocity.reset(param1,param2,param3);
}
public function setOrientation(param1:Quaternion) : void {
this.state.orientation.copy(param1);
}
public function setMaxSpeedXY(param1:Number) : void {
this.maxSpeedXY.setNumber(param1);
}
public function applyWorldImpulseAtLocalPoint(param1:Vector3, param2:Vector3, param3:Number) : void {
var local5:Number = NaN;
var local6:Number = NaN;
var local4:Number = param3 * this.invMass;
this.state.velocity.x += local4 * param2.x;
this.state.velocity.y += local4 * param2.y;
this.state.velocity.z += local4 * param2.z;
local5 = (param1.y * param2.z - param1.z * param2.y) * param3;
local6 = (param1.z * param2.x - param1.x * param2.z) * param3;
var local7:Number = (param1.x * param2.y - param1.y * param2.x) * param3;
this.state.angularVelocity.x += this.invInertiaWorld.m00 * local5 + this.invInertiaWorld.m01 * local6 + this.invInertiaWorld.m02 * local7;
this.state.angularVelocity.y += this.invInertiaWorld.m10 * local5 + this.invInertiaWorld.m11 * local6 + this.invInertiaWorld.m12 * local7;
this.state.angularVelocity.z += this.invInertiaWorld.m20 * local5 + this.invInertiaWorld.m21 * local6 + this.invInertiaWorld.m22 * local7;
}
public function applyWorldPseudoImpulseAtLocalPoint(param1:Vector3, param2:Vector3, param3:Number) : void {
var local5:Number = NaN;
var local7:Number = NaN;
var local4:Number = param3 * this.invMass;
this.pseudoVelocity.x += local4 * param2.x;
this.pseudoVelocity.y += local4 * param2.y;
this.pseudoVelocity.z += local4 * param2.z;
local5 = (param1.y * param2.z - param1.z * param2.y) * param3;
var local6:Number = (param1.z * param2.x - param1.x * param2.z) * param3;
local7 = (param1.x * param2.y - param1.y * param2.x) * param3;
this.pseudoAngularVelocity.x += this.invInertiaWorld.m00 * local5 + this.invInertiaWorld.m01 * local6 + this.invInertiaWorld.m02 * local7;
this.pseudoAngularVelocity.y += this.invInertiaWorld.m10 * local5 + this.invInertiaWorld.m11 * local6 + this.invInertiaWorld.m12 * local7;
this.pseudoAngularVelocity.z += this.invInertiaWorld.m20 * local5 + this.invInertiaWorld.m21 * local6 + this.invInertiaWorld.m22 * local7;
}
public function applyImpulse(param1:Vector3, param2:Number) : void {
var local3:Number = param2 * this.invMass;
this.state.velocity.x += local3 * param1.x;
this.state.velocity.y += local3 * param1.y;
this.state.velocity.z += local3 * param1.z;
}
public function addForce(param1:Vector3) : void {
this.forceAccum.add(param1);
}
public function addScaledForce(param1:Vector3, param2:Number) : void {
this.forceAccum.addScaled(param2,param1);
}
public function addForceXYZ(param1:Number, param2:Number, param3:Number) : void {
this.forceAccum.x += param1;
this.forceAccum.y += param2;
this.forceAccum.z += param3;
}
public function addWorldForceXYZ(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number) : void {
this.forceAccum.x += param4;
this.forceAccum.y += param5;
this.forceAccum.z += param6;
var local7:Vector3 = this.state.position;
var local8:Number = param1 - local7.x;
var local9:Number = param2 - local7.y;
var local10:Number = param3 - local7.z;
this.torqueAccum.x += local9 * param6 - local10 * param5;
this.torqueAccum.y += local10 * param4 - local8 * param6;
this.torqueAccum.z += local8 * param5 - local9 * param4;
}
public function addWorldForce(param1:Vector3, param2:Vector3) : void {
this.forceAccum.add(param2);
this.torqueAccum.add(_r.diff(param1,this.state.position).cross(param2));
}
public function addWorldForceScaled(param1:Vector3, param2:Vector3, param3:Number) : void {
var local10:Number = NaN;
var local4:Number = param3 * param2.x;
var local5:Number = param3 * param2.y;
var local6:Number = param3 * param2.z;
this.forceAccum.x += local4;
this.forceAccum.y += local5;
this.forceAccum.z += local6;
var local7:Vector3 = this.state.position;
var local8:Number = param1.x - local7.x;
var local9:Number = param1.y - local7.y;
local10 = param1.z - local7.z;
this.torqueAccum.x += local9 * local6 - local10 * local5;
this.torqueAccum.y += local10 * local4 - local8 * local6;
this.torqueAccum.z += local8 * local5 - local9 * local4;
}
public function addLocalForce(param1:Vector3, param2:Vector3) : void {
this.baseMatrix.transformVector(param1,_r);
this.baseMatrix.transformVector(param2,_f);
this.forceAccum.add(_f);
this.torqueAccum.add(_r.cross(_f));
}
public function addWorldForceAtLocalPoint(param1:Vector3, param2:Vector3) : void {
this.baseMatrix.transformVector(param1,_r);
this.forceAccum.add(param2);
this.torqueAccum.add(_r.cross(param2));
}
public function addScaledWorldForceAtLocalPoint(param1:Vector3, param2:Vector3, param3:Number) : void {
this.baseMatrix.transformVector(param1,_r);
this.forceAccum.addScaled(param3,param2);
this.torqueAccum.addScaled(param3,_r.cross(param2));
}
public function addTorque(param1:Vector3) : void {
this.torqueAccum.add(param1);
}
public function clearAccumulators() : void {
this.forceAccum.x = this.forceAccum.y = this.forceAccum.z = 0;
this.torqueAccum.x = this.torqueAccum.y = this.torqueAccum.z = 0;
}
public function calcAccelerations() : void {
this.acceleration.x = this.forceAccum.x * this.invMass;
this.acceleration.y = this.forceAccum.y * this.invMass;
this.acceleration.z = this.forceAccum.z * this.invMass;
this.angularAcceleration.x = this.invInertiaWorld.m00 * this.torqueAccum.x + this.invInertiaWorld.m01 * this.torqueAccum.y + this.invInertiaWorld.m02 * this.torqueAccum.z;
this.angularAcceleration.y = this.invInertiaWorld.m10 * this.torqueAccum.x + this.invInertiaWorld.m11 * this.torqueAccum.y + this.invInertiaWorld.m12 * this.torqueAccum.z;
this.angularAcceleration.z = this.invInertiaWorld.m20 * this.torqueAccum.x + this.invInertiaWorld.m21 * this.torqueAccum.y + this.invInertiaWorld.m22 * this.torqueAccum.z;
}
public function calcDerivedData() : void {
var local1:int = 0;
var local2:CollisionShape = null;
this.state.orientation.toMatrix3(this.baseMatrix);
this.invInertiaWorld.copy(this.invInertia).append(this.baseMatrix).prependTransposed(this.baseMatrix);
if(this.collisionShapes != null) {
this.aabb.infinity();
local1 = 0;
while(local1 < this.numCollisionShapes) {
local2 = this.collisionShapes[local1];
local2.transform.setFromMatrix3(this.baseMatrix,this.state.position);
if(local2.localTransform != null) {
local2.transform.prepend(local2.localTransform);
}
local2.calculateAABB();
this.aabb.addBoundBox(local2.aabb);
local1++;
}
}
}
public function saveState() : void {
this.prevState.copy(this.state);
}
public function restoreState() : void {
this.state.copy(this.prevState);
}
public function integrateVelocity(param1:Number) : void {
this.integrateLinearVelocity(param1);
this.integrateAngularVelocity(param1);
}
private function integrateLinearVelocity(param1:Number) : void {
var local7:Number = NaN;
this.previousVelocity.copy(this.state.velocity);
if(this.acceleration.z < this.minZAcceleration) {
this.acceleration.z = this.minZAcceleration;
}
this.state.velocity = this.state.velocity.clone();
this.state.velocity.x += this.acceleration.x * param1;
this.state.velocity.y += this.acceleration.y * param1;
this.state.velocity.z += this.acceleration.z * param1;
this.state.velocity.x *= linearDamping;
this.state.velocity.y *= linearDamping;
this.state.velocity.z *= linearDamping;
var local2:Number = Math.abs(this.state.velocity.z);
if(local2 > MAX_SPEED_Z) {
this.state.velocity.z *= MAX_SPEED_Z / local2;
}
if(this.state.velocity.z - this.previousVelocity.z > this.maxZSpeedDelta) {
this.state.velocity.z = this.previousVelocity.z + this.maxZSpeedDelta;
}
var local3:Number = this.state.velocity.x;
var local4:Number = this.state.velocity.y;
var local5:Number = Math.sqrt(local3 * local3 + local4 * local4);
var local6:Number = Number(this.maxSpeedXY.getNumber());
if(local5 > local6) {
local7 = local6 / local5;
this.state.velocity.x *= local7;
this.state.velocity.y *= local7;
}
}
private function integrateAngularVelocity(param1:Number) : void {
this.state.angularVelocity.x += this.angularAcceleration.x * param1;
this.state.angularVelocity.y += this.angularAcceleration.y * param1;
this.state.angularVelocity.z += this.angularAcceleration.z * param1;
this.state.angularVelocity.x *= rotationalDamping;
this.state.angularVelocity.y *= rotationalDamping;
this.state.angularVelocity.z *= rotationalDamping;
if(this.state.angularVelocity.length() > 10) {
this.state.angularVelocity.setLength(10);
}
}
public function integratePosition(param1:Number) : void {
var local2:Vector3 = null;
local2 = new Vector3();
var local3:Vector3 = this.state.position;
var local4:Vector3 = this.state.velocity;
local2.x = local3.x + local4.x * param1;
local2.y = local3.y + local4.y * param1;
local2.z = local3.z + local4.z * param1;
this.state.position = local2;
this.state.orientation.addScaledVector(this.state.angularVelocity,param1);
}
public function integratePseudoVelocity(param1:Number) : void {
this.state.position.x += this.pseudoVelocity.x * param1;
this.state.position.y += this.pseudoVelocity.y * param1;
this.state.position.z += this.pseudoVelocity.z * param1;
this.state.orientation.addScaledVector(this.pseudoAngularVelocity,param1);
this.pseudoVelocity.reset();
this.pseudoAngularVelocity.reset();
}
public function toString() : String {
return "Body{state=" + String(this.state) + "}";
}
}
}
|
package alternativa.gfx.agal
{
public class FragmentShader extends Shader
{
public static const fc:Vector.<CommonRegister> = VertexShader.vc;
public static const ft0:CommonRegister = VertexShader.vt0;
public static const ft1:CommonRegister = VertexShader.vt1;
public static const ft2:CommonRegister = VertexShader.vt2;
public static const ft3:CommonRegister = VertexShader.vt3;
public static const ft4:CommonRegister = VertexShader.vt4;
public static const ft5:CommonRegister = VertexShader.vt5;
public static const ft6:CommonRegister = VertexShader.vt6;
public static const ft7:CommonRegister = VertexShader.vt7;
public static const oc:CommonRegister = VertexShader.op;
public static const fs0:SamplerRegister = new SamplerRegister(0);
public static const fs1:SamplerRegister = new SamplerRegister(1);
public static const fs2:SamplerRegister = new SamplerRegister(2);
public static const fs3:SamplerRegister = new SamplerRegister(3);
public static const fs4:SamplerRegister = new SamplerRegister(4);
public static const fs5:SamplerRegister = new SamplerRegister(5);
public static const fs6:SamplerRegister = new SamplerRegister(6);
public static const fs7:SamplerRegister = new SamplerRegister(7);
public function FragmentShader()
{
super();
data.writeByte(1);
}
public function kil(param1:Register) : void
{
data.writeUnsignedInt(KIL);
data.position += 4;
param1.writeSource(data);
data.position += 8;
}
public function tex(param1:Register, param2:Register, param3:SamplerRegister) : void
{
data.writeUnsignedInt(TEX);
param1.writeDest(data);
param2.writeSource(data);
param3.writeSource(data);
}
}
}
|
package assets.combo {
public class ComboDownButton extends ComboButtonState {
public function ComboDownButton() {
super();
bmpLeft = new combo_DOWN_LEFT(1,1);
bmpCenter = new combo_DOWN_CENTER(1,1);
bmpRight = new combo_DOWN_RIGHT(1,1);
}
}
}
|
package projects.tanks.client.panel.model.friends {
public interface IFriendsLoaderModelBase {
function onUsersLoaded() : void;
}
}
|
package alternativa.tanks.model.shop.items.base
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GreyShopItemSkin_normalStateClass extends BitmapAsset
{
public function GreyShopItemSkin_normalStateClass()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.colortransform {
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 ColorTransformModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ColorTransformModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.model.payment.shop.renameshopitem {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.shop.shopitems.item.base.ShopButton;
import alternativa.tanks.gui.shop.shopitems.item.customname.DetailsViewWithDescription;
import alternativa.tanks.gui.shop.shopitems.item.customname.ShopButtonWithCustomName;
import alternativa.tanks.gui.shop.shopitems.item.details.ShopItemDetails;
import alternativa.tanks.model.payment.shop.ShopItemDetailsView;
import alternativa.tanks.model.payment.shop.ShopItemView;
import projects.tanks.client.panel.model.shop.renameshopitem.IRenameShopItemModelBase;
import projects.tanks.client.panel.model.shop.renameshopitem.RenameShopItemModelBase;
import projects.tanks.clients.fp10.libraries.TanksLocale;
[ModelInfo]
public class RenameShopItemModel extends RenameShopItemModelBase implements IRenameShopItemModelBase, ShopItemView, ShopItemDetailsView {
[Inject]
public static var localeService:ILocaleService;
public function RenameShopItemModel() {
super();
}
public function getButtonView() : ShopButton {
return new ShopButtonWithCustomName(object,getInitParam().name);
}
public function getDetailsView() : ShopItemDetails {
return new DetailsViewWithDescription(object,localeService.getText(TanksLocale.TEXT_RENAME_ITEM_SHOP_DESCRIPTION));
}
public function isDetailedViewRequired() : Boolean {
return true;
}
}
}
|
package alternativa.tanks.models.weapons.targeting.priority.targeting {
import alternativa.tanks.battle.objects.tank.Tank;
public interface TargetPriorityCalculator {
function getTargetPriority(param1:Tank, param2:Number, param3:Number) : Number;
}
}
|
package alternativa.tanks.model.news
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class NewsIcons_technical extends BitmapAsset
{
public function NewsIcons_technical()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.facilities {
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 BattleFacilitiesModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BattleFacilitiesModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.models.tank.gearscore {
import alternativa.tanks.models.tank.ITankModel;
import projects.tanks.client.battlefield.models.tankparts.gearscore.BattleGearScoreCC;
import projects.tanks.client.battlefield.models.tankparts.gearscore.BattleGearScoreModelBase;
import projects.tanks.client.battlefield.models.tankparts.gearscore.IBattleGearScoreModelBase;
[ModelInfo]
public class BattleGearScoreModel extends BattleGearScoreModelBase implements IBattleGearScoreModelBase, GearScoreInfo {
public function BattleGearScoreModel() {
super();
}
public function getScore() : int {
return getInitParam().score;
}
public function setGearScore(param1:int) : void {
putInitParams(new BattleGearScoreCC(param1));
ITankModel(object.adapt(ITankModel)).getTitle().updateInfo();
}
}
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_BG_RED_PIXEL.png")]
public dynamic class bres_BG_RED_PIXEL extends BitmapData {
public function bres_BG_RED_PIXEL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.smoke {
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
public class HullSmokeCC {
private var _alpha:Number;
private var _density:Number;
private var _enabled:Boolean;
private var _fadeTime:int;
private var _farDistance:Number;
private var _nearDistance:Number;
private var _particle:MultiframeTextureResource;
private var _size:Number;
public function HullSmokeCC(param1:Number = 0, param2:Number = 0, param3:Boolean = false, param4:int = 0, param5:Number = 0, param6:Number = 0, param7:MultiframeTextureResource = null, param8:Number = 0) {
super();
this._alpha = param1;
this._density = param2;
this._enabled = param3;
this._fadeTime = param4;
this._farDistance = param5;
this._nearDistance = param6;
this._particle = param7;
this._size = param8;
}
public function get alpha() : Number {
return this._alpha;
}
public function set alpha(param1:Number) : void {
this._alpha = param1;
}
public function get density() : Number {
return this._density;
}
public function set density(param1:Number) : void {
this._density = param1;
}
public function get enabled() : Boolean {
return this._enabled;
}
public function set enabled(param1:Boolean) : void {
this._enabled = param1;
}
public function get fadeTime() : int {
return this._fadeTime;
}
public function set fadeTime(param1:int) : void {
this._fadeTime = param1;
}
public function get farDistance() : Number {
return this._farDistance;
}
public function set farDistance(param1:Number) : void {
this._farDistance = param1;
}
public function get nearDistance() : Number {
return this._nearDistance;
}
public function set nearDistance(param1:Number) : void {
this._nearDistance = param1;
}
public function get particle() : MultiframeTextureResource {
return this._particle;
}
public function set particle(param1:MultiframeTextureResource) : void {
this._particle = param1;
}
public function get size() : Number {
return this._size;
}
public function set size(param1:Number) : void {
this._size = param1;
}
public function toString() : String {
var local1:String = "HullSmokeCC [";
local1 += "alpha = " + this.alpha + " ";
local1 += "density = " + this.density + " ";
local1 += "enabled = " + this.enabled + " ";
local1 += "fadeTime = " + this.fadeTime + " ";
local1 += "farDistance = " + this.farDistance + " ";
local1 += "nearDistance = " + this.nearDistance + " ";
local1 += "particle = " + this.particle + " ";
local1 += "size = " + this.size + " ";
return local1 + "]";
}
}
}
|
package
{
public interface IBattleController
{
}
}
|
package alternativa.engine3d.core
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.lights.DirectionalLight;
import alternativa.engine3d.lights.OmniLight;
import alternativa.engine3d.lights.SpotLight;
import alternativa.engine3d.lights.TubeLight;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.Decal;
import alternativa.engine3d.objects.Sprite3D;
import alternativa.gfx.core.Device;
import alternativa.gfx.core.IndexBufferResource;
import alternativa.gfx.core.TextureResource;
import alternativa.gfx.core.VertexBufferResource;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.display.StageAlign;
import flash.display3D.Context3DBlendFactor;
import flash.display3D.Context3DClearMask;
import flash.display3D.Context3DCompareMode;
import flash.display3D.Context3DProgramType;
import flash.display3D.Context3DStencilAction;
import flash.display3D.Context3DTriangleFace;
import flash.events.Event;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.geom.Vector3D;
import flash.system.System;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.utils.Dictionary;
import flash.utils.getDefinitionByName;
import flash.utils.getQualifiedClassName;
import flash.utils.getQualifiedSuperclassName;
import flash.utils.getTimer;
use namespace alternativa3d;
public class Camera3D extends Object3D
{
alternativa3d static var renderId:int = 0;
private static const constantsAttributesCount:int = 8;
private static const constantsOffset:int = 16;
private static const constantsMaxTriangles:int = 18;
private static const constants:Vector.<Number> = new Vector.<Number>(constantsMaxTriangles * 3 * constantsAttributesCount);
private static const constantsVertexBuffer:VertexBufferResource = createConstantsVertexBuffer(constantsMaxTriangles * 3);
private static const constantsIndexBuffer:IndexBufferResource = createConstantsIndexBuffer(constantsMaxTriangles * 3);
public var view:View;
public var fov:Number = 1.5707963267948966;
public var nearClipping:Number = 1;
public var farClipping:Number = 1000000;
public var onRender:Function;
alternativa3d var viewSizeX:Number;
alternativa3d var viewSizeY:Number;
alternativa3d var focalLength:Number;
alternativa3d var correctionX:Number;
alternativa3d var correctionY:Number;
alternativa3d var lights:Vector.<Light3D>;
alternativa3d var lightsLength:int = 0;
alternativa3d var occluders:Vector.<Vertex>;
alternativa3d var numOccluders:int;
alternativa3d var occludedAll:Boolean;
alternativa3d var numDraws:int;
alternativa3d var numShadows:int;
alternativa3d var numTriangles:int;
alternativa3d var device:Device;
alternativa3d var projection:Vector.<Number>;
alternativa3d var correction:Vector.<Number>;
alternativa3d var transform:Vector.<Number>;
private var opaqueMaterials:Vector.<Material>;
private var opaqueVertexBuffers:Vector.<VertexBufferResource>;
private var opaqueIndexBuffers:Vector.<IndexBufferResource>;
private var opaqueFirstIndexes:Vector.<int>;
private var opaqueNumsTriangles:Vector.<int>;
private var opaqueObjects:Vector.<Object3D>;
private var opaqueCount:int = 0;
private var skyMaterials:Vector.<Material>;
private var skyVertexBuffers:Vector.<VertexBufferResource>;
private var skyIndexBuffers:Vector.<IndexBufferResource>;
private var skyFirstIndexes:Vector.<int>;
private var skyNumsTriangles:Vector.<int>;
private var skyObjects:Vector.<Object3D>;
private var skyCount:int = 0;
private var transparentFaceLists:Vector.<Face>;
private var transparentObjects:Vector.<Object3D>;
private var transparentCount:int = 0;
private var transparentOpaqueFaceLists:Vector.<Face>;
private var transparentOpaqueObjects:Vector.<Object3D>;
private var transparentOpaqueCount:int = 0;
private var transparentBatchObjects:Vector.<Object3D>;
private var decals:Vector.<Decal>;
private var decalsCount:int = 0;
alternativa3d var depthObjects:Vector.<Object3D>;
alternativa3d var depthCount:int = 0;
alternativa3d var casterObjects:Vector.<Object3D>;
alternativa3d var casterCount:int = 0;
alternativa3d var shadowAtlases:Array;
alternativa3d var receiversVertexBuffers:Vector.<VertexBufferResource>;
alternativa3d var receiversIndexBuffers:Vector.<IndexBufferResource>;
alternativa3d var gma:Number;
alternativa3d var gmb:Number;
alternativa3d var gmc:Number;
alternativa3d var gmd:Number;
alternativa3d var gme:Number;
alternativa3d var gmf:Number;
alternativa3d var gmg:Number;
alternativa3d var gmh:Number;
alternativa3d var gmi:Number;
alternativa3d var gmj:Number;
alternativa3d var gmk:Number;
alternativa3d var gml:Number;
alternativa3d var fogParams:Vector.<Number>;
alternativa3d var fogFragment:Vector.<Number>;
private var fragmentConst:Vector.<Number>;
private var shadows:Dictionary;
private var shadowList:Vector.<Shadow>;
private var depthRenderer:DepthRenderer;
alternativa3d var depthMap:TextureResource;
alternativa3d var lightMap:TextureResource;
private var depthParams:Vector.<Number>;
private var ssaoParams:Vector.<Number>;
private var lightTransform:Vector.<Number>;
private var lightParams:Vector.<Number>;
alternativa3d var omnies:Vector.<OmniLight>;
alternativa3d var omniesCount:int = 0;
alternativa3d var spots:Vector.<SpotLight>;
alternativa3d var spotsCount:int = 0;
alternativa3d var tubes:Vector.<TubeLight>;
alternativa3d var tubesCount:int = 0;
public var fogNear:Number = 0;
public var fogFar:Number = 1000000;
public var fogAlpha:Number = 0;
public var fogColor:int = 8355711;
public var softTransparency:Boolean = false;
public var depthBufferScale:Number = 1;
public var ssao:Boolean = false;
public var ssaoRadius:Number = 100;
public var ssaoRange:Number = 1000;
public var ssaoColor:int = 0;
public var ssaoAlpha:Number = 1;
public var directionalLight:DirectionalLight;
public var shadowMap:ShadowMap;
public var ambientColor:int = 0;
public var deferredLighting:Boolean = false;
public var fogStrength:Number = 1;
public var softTransparencyStrength:Number = 1;
public var ssaoStrength:Number = 1;
public var directionalLightStrength:Number = 1;
public var _shadowMapStrength:Number = 1;
public var shadowsStrength:Number = 1;
public var shadowsDistanceMultiplier:Number = 1;
public var deferredLightingStrength:Number = 1;
public var debug:Boolean = false;
private var debugSet:Object;
private var _diagram:Sprite;
public var fpsUpdatePeriod:int = 10;
public var timerUpdatePeriod:int = 10;
private var fpsTextField:TextField;
private var memoryTextField:TextField;
private var drawsTextField:TextField;
private var shadowsTextField:TextField;
private var trianglesTextField:TextField;
private var timerTextField:TextField;
private var graph:Bitmap;
private var rect:Rectangle;
private var _diagramAlign:String = "TR";
private var _diagramHorizontalMargin:Number = 2;
private var _diagramVerticalMargin:Number = 2;
private var fpsUpdateCounter:int;
private var previousFrameTime:int;
private var previousPeriodTime:int;
private var maxMemory:int;
private var timerUpdateCounter:int;
private var timeSum:int;
private var timeCount:int;
private var timer:int;
private var firstVertex:Vertex;
private var firstFace:Face;
private var firstWrapper:Wrapper;
alternativa3d var lastWrapper:Wrapper;
alternativa3d var lastVertex:Vertex;
alternativa3d var lastFace:Face;
public function Camera3D()
{
this.lights = new Vector.<Light3D>();
this.occluders = new Vector.<Vertex>();
this.projection = new Vector.<Number>(4);
this.correction = new Vector.<Number>(4);
this.transform = new Vector.<Number>(12);
this.opaqueMaterials = new Vector.<Material>();
this.opaqueVertexBuffers = new Vector.<VertexBufferResource>();
this.opaqueIndexBuffers = new Vector.<IndexBufferResource>();
this.opaqueFirstIndexes = new Vector.<int>();
this.opaqueNumsTriangles = new Vector.<int>();
this.opaqueObjects = new Vector.<Object3D>();
this.skyMaterials = new Vector.<Material>();
this.skyVertexBuffers = new Vector.<VertexBufferResource>();
this.skyIndexBuffers = new Vector.<IndexBufferResource>();
this.skyFirstIndexes = new Vector.<int>();
this.skyNumsTriangles = new Vector.<int>();
this.skyObjects = new Vector.<Object3D>();
this.transparentFaceLists = new Vector.<Face>();
this.transparentObjects = new Vector.<Object3D>();
this.transparentOpaqueFaceLists = new Vector.<Face>();
this.transparentOpaqueObjects = new Vector.<Object3D>();
this.transparentBatchObjects = new Vector.<Object3D>();
this.decals = new Vector.<Decal>();
this.depthObjects = new Vector.<Object3D>();
this.casterObjects = new Vector.<Object3D>();
this.shadowAtlases = new Array();
this.fogParams = Vector.<Number>([1,1,0,1]);
this.fogFragment = Vector.<Number>([0,0,0,1]);
this.fragmentConst = Vector.<Number>([0,0,0,1,0.5,0.5,0,1 / 4096]);
this.shadows = new Dictionary();
this.shadowList = new Vector.<Shadow>();
this.depthRenderer = new DepthRenderer();
this.depthParams = Vector.<Number>([0,0,0,1]);
this.ssaoParams = Vector.<Number>([0,0,0,1]);
this.lightTransform = Vector.<Number>([0,0,0,1]);
this.lightParams = Vector.<Number>([0,0,0,1,0,0,0,1]);
this.omnies = new Vector.<OmniLight>();
this.spots = new Vector.<SpotLight>();
this.tubes = new Vector.<TubeLight>();
this.debugSet = new Object();
this._diagram = this.createDiagram();
this.firstVertex = new Vertex();
this.firstFace = new Face();
this.firstWrapper = new Wrapper();
this.lastWrapper = this.firstWrapper;
this.lastVertex = this.firstVertex;
this.lastFace = this.firstFace;
super();
}
private static function createConstantsVertexBuffer(param1:int) : VertexBufferResource
{
var _loc5_:int = 0;
var _loc2_:Vector.<Number> = new Vector.<Number>();
var _loc3_:int = 0;
while(_loc3_ < param1)
{
_loc2_.push((_loc3_ << 1) + constantsOffset);
_loc3_++;
}
var _loc4_:int = 0;
while(_loc4_ < param1 << 1)
{
_loc5_ = _loc4_ * 4 + 3;
constants[_loc5_] = 1;
_loc4_++;
}
return new VertexBufferResource(_loc2_,1);
}
private static function createConstantsIndexBuffer(param1:int) : IndexBufferResource
{
var _loc2_:Vector.<uint> = new Vector.<uint>();
var _loc3_:int = 0;
while(_loc3_ < param1)
{
_loc2_.push(_loc3_);
_loc3_++;
}
return new IndexBufferResource(_loc2_);
}
public function set shadowMapStrength(v:Number) : void
{
this._shadowMapStrength = v;
}
public function get shadowMapStrength() : Number
{
return this._shadowMapStrength;
}
public function addShadow(param1:Shadow) : void
{
this.shadows[param1] = true;
}
public function removeShadow(param1:Shadow) : void
{
delete this.shadows[param1];
}
public function removeAllShadows() : void
{
this.shadows = new Dictionary();
}
public function render() : void
{
var _loc1_:int = 0;
var _loc2_:int = 0;
var _loc4_:* = null;
var _loc5_:Object3D = null;
var _loc6_:Light3D = null;
var _loc7_:ShadowAtlas = null;
var _loc8_:Boolean = false;
var _loc9_:Material = null;
var _loc10_:* = undefined;
var _loc11_:Decal = null;
var _loc12_:int = 0;
var _loc13_:int = 0;
var _loc14_:int = 0;
var _loc15_:TextureResource = null;
var _loc16_:Face = null;
var _loc17_:Object3D = null;
var _loc18_:Boolean = false;
var _loc19_:Boolean = false;
var _loc20_:int = 0;
var _loc21_:Sprite3D = null;
var _loc22_:Face = null;
var _loc23_:Face = null;
var _loc24_:Object3D = null;
var _loc25_:Sprite3D = null;
this.numDraws = 0;
this.numShadows = 0;
this.numTriangles = 0;
if(this.view != null && this.view.device != null && this.view.device.ready)
{
++renderId;
this.device = this.view.device;
this.view.configure();
if(this.nearClipping < 1)
{
this.nearClipping = 1;
}
if(this.farClipping > 1000000)
{
this.farClipping = 1000000;
}
this.viewSizeX = this.view._width * 0.5;
this.viewSizeY = this.view._height * 0.5;
this.focalLength = Math.sqrt(this.viewSizeX * this.viewSizeX + this.viewSizeY * this.viewSizeY) / Math.tan(this.fov * 0.5);
this.correctionX = this.viewSizeX / this.focalLength;
this.correctionY = this.viewSizeY / this.focalLength;
this.projection[0] = 1 << this.view.zBufferPrecision;
this.projection[1] = 1;
this.projection[2] = this.farClipping / (this.farClipping - this.nearClipping);
this.projection[3] = this.nearClipping * this.farClipping / (this.nearClipping - this.farClipping);
this.composeCameraMatrix();
_loc5_ = this;
while(_loc5_._parent != null)
{
_loc5_ = _loc5_._parent;
_loc5_.composeMatrix();
appendMatrix(_loc5_);
}
this.gma = ma;
this.gmb = mb;
this.gmc = mc;
this.gmd = md;
this.gme = me;
this.gmf = mf;
this.gmg = mg;
this.gmh = mh;
this.gmi = mi;
this.gmj = mj;
this.gmk = mk;
this.gml = ml;
invertMatrix();
this.transform[0] = ma;
this.transform[1] = mb;
this.transform[2] = mc;
this.transform[3] = md;
this.transform[4] = me;
this.transform[5] = mf;
this.transform[6] = mg;
this.transform[7] = mh;
this.transform[8] = mi;
this.transform[9] = mj;
this.transform[10] = mk;
this.transform[11] = ml;
this.numOccluders = 0;
this.occludedAll = false;
if(_loc5_ != this && _loc5_.visible)
{
this.lightsLength = 0;
_loc6_ = (_loc5_ as Object3DContainer).lightList;
while(_loc6_ != null)
{
if(_loc6_.visible)
{
_loc6_.calculateCameraMatrix(this);
if(_loc6_.checkFrustumCulling(this))
{
this.lights[this.lightsLength] = _loc6_;
++this.lightsLength;
if(!this.view.constrained && this.deferredLighting && this.deferredLightingStrength > 0)
{
if(_loc6_ is OmniLight)
{
this.omnies[this.omniesCount] = _loc6_ as OmniLight;
++this.omniesCount;
}
else if(_loc6_ is SpotLight)
{
this.spots[this.spotsCount] = _loc6_ as SpotLight;
++this.spotsCount;
}
else if(_loc6_ is TubeLight)
{
this.tubes[this.tubesCount] = _loc6_ as TubeLight;
++this.tubesCount;
}
}
}
}
_loc6_ = _loc6_.nextLight;
}
_loc5_.appendMatrix(this);
_loc5_.cullingInCamera(this,63);
if(this.debug)
{
_loc1_ = 0;
while(_loc1_ < this.lightsLength)
{
(this.lights[_loc1_] as Light3D).drawDebug(this);
_loc1_++;
}
}
_loc8_ = false;
if(!this.view.constrained && this.shadowsStrength > 0)
{
for(_loc4_ in this.shadows)
{
if(_loc4_.checkVisibility(this))
{
_loc2_ = _loc4_.mapSize + _loc4_.blur;
_loc7_ = this.shadowAtlases[_loc2_];
if(_loc7_ == null)
{
_loc7_ = new ShadowAtlas(_loc4_.mapSize,_loc4_.blur);
this.shadowAtlases[_loc2_] = _loc7_;
}
_loc7_.shadows[_loc7_.shadowsCount] = _loc4_;
++_loc7_.shadowsCount;
_loc8_ = true;
}
}
}
this.device.setCulling(Context3DTriangleFace.FRONT);
this.device.setBlendFactors(Context3DBlendFactor.ONE,Context3DBlendFactor.ZERO);
this.device.setStencilActions(Context3DTriangleFace.NONE);
this.device.setStencilReferenceValue(0);
if(_loc8_)
{
this.device.setCulling(Context3DTriangleFace.BACK);
this.device.setDepthTest(true,Context3DCompareMode.GREATER_EQUAL);
this.device.setProgram(Shadow.getCasterProgram());
for each(_loc7_ in this.shadowAtlases)
{
if(_loc7_.shadowsCount > 0)
{
_loc7_.renderCasters(this);
}
}
this.device.setCulling(Context3DTriangleFace.FRONT);
this.device.setDepthTest(false,Context3DCompareMode.ALWAYS);
for each(_loc7_ in this.shadowAtlases)
{
if(_loc7_.shadowsCount > 0)
{
_loc7_.renderBlur(this);
}
}
this.device.setTextureAt(0,null);
this.device.setVertexBufferAt(1,null);
}
if(this.directionalLight != null)
{
this.directionalLight.composeAndAppend(this);
this.directionalLight.calculateInverseMatrix();
}
_loc5_.concatenatedAlpha = _loc5_.alpha;
_loc5_.concatenatedBlendMode = _loc5_.blendMode;
_loc5_.concatenatedColorTransform = _loc5_.colorTransform;
_loc5_.draw(this);
this.device.setDepthTest(true,Context3DCompareMode.LESS);
if(!this.view.constrained && this.shadowMap != null && this.shadowMapStrength > 0)
{
this.shadowMap.calculateBounds(this);
this.shadowMap.render(this,this.casterObjects,this.casterCount);
}
this.depthMap = null;
this.lightMap = null;
if(!this.view.constrained && (this.softTransparency && this.softTransparencyStrength > 0 || this.ssao && this.ssaoStrength > 0 || this.deferredLighting && this.deferredLightingStrength > 0))
{
this.depthRenderer.render(this,this.view._width,this.view._height,this.depthBufferScale,this.ssao && this.ssaoStrength > 0,this.deferredLighting && this.deferredLightingStrength > 0,this.directionalLight != null && this.directionalLightStrength > 0 || this.shadowMap != null && this.shadowMapStrength > 0 ? Number(Number(0)) : Number(Number(0.5)),this.depthObjects,this.depthCount);
if(this.softTransparency && this.softTransparencyStrength > 0 || this.ssao && this.ssaoStrength > 0)
{
this.depthMap = this.depthRenderer.depthBuffer;
}
if(this.deferredLighting && this.deferredLightingStrength > 0)
{
this.lightMap = this.depthRenderer.lightBuffer;
}
}
else
{
this.depthRenderer.resetResources();
}
if(_loc8_ || !this.view.constrained && (this.softTransparency && this.softTransparencyStrength > 0 || this.ssao && this.ssaoStrength > 0 || this.deferredLighting && this.deferredLightingStrength > 0) || !this.view.constrained && this.shadowMap != null && this.shadowMapStrength > 0)
{
this.device.setRenderToBackBuffer();
}
this.view.clearArea();
this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,3,this.projection,1);
this.fragmentConst[0] = this.farClipping;
this.fragmentConst[1] = this.farClipping / 255;
this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,17,this.fragmentConst,2);
this.correction[0] = this.view.rect.width / this.device.width;
this.correction[1] = this.view.rect.height / this.device.height;
this.correction[2] = (this.view.rect.x * 2 + this.view.rect.width - this.device.width) / this.device.width;
this.correction[3] = (this.view.rect.y * 2 + this.view.rect.height - this.device.height) / this.device.height;
this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,13,this.correction,1);
if(!this.view.constrained && (this.softTransparency && this.softTransparencyStrength > 0 || this.ssao && this.ssaoStrength > 0 || this.deferredLighting && this.deferredLightingStrength > 0 || this.shadowMap != null && this.shadowMapStrength > 0))
{
this.depthParams[0] = this.depthRenderer.correctionX;
this.depthParams[1] = this.depthRenderer.correctionY;
this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,4,this.depthParams,1);
if(this.ssao && this.ssaoStrength > 0)
{
this.ssaoParams[0] = (1 - 2 * (this.ssaoColor >> 16 & 255) / 255) * this.ssaoAlpha * this.ssaoStrength;
this.ssaoParams[1] = (1 - 2 * (this.ssaoColor >> 8 & 255) / 255) * this.ssaoAlpha * this.ssaoStrength;
this.ssaoParams[2] = (1 - 2 * (this.ssaoColor & 255) / 255) * this.ssaoAlpha * this.ssaoStrength;
this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,12,this.ssaoParams,1);
}
}
if(!this.view.constrained && this.shadowMap != null && this.shadowMapStrength > 0)
{
this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,6,this.shadowMap.transform,4);
this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,5,this.shadowMap.params,5);
}
if(this.fogAlpha > 0 && this.fogStrength > 0)
{
this.fogParams[2] = this.fogNear;
this.fogParams[3] = this.fogFar - this.fogNear;
this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,5,this.fogParams,1);
this.fogFragment[0] = (this.fogColor >> 16 & 255) / 255;
this.fogFragment[1] = (this.fogColor >> 8 & 255) / 255;
this.fogFragment[2] = (this.fogColor & 255) / 255;
this.fogFragment[3] = this.fogAlpha * this.fogStrength;
this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,2,this.fogFragment,1);
}
if(!this.view.constrained && this.directionalLight != null && this.directionalLightStrength > 0)
{
this.lightTransform[0] = -this.directionalLight.imi;
this.lightTransform[1] = -this.directionalLight.imj;
this.lightTransform[2] = -this.directionalLight.imk;
this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,10,this.lightTransform,1);
this.lightParams[0] = this.directionalLight.intensity * (this.directionalLight.color >> 16 & 255) * 2 * this.directionalLightStrength / 255;
this.lightParams[1] = this.directionalLight.intensity * (this.directionalLight.color >> 8 & 255) * 2 * this.directionalLightStrength / 255;
this.lightParams[2] = this.directionalLight.intensity * (this.directionalLight.color & 255) * 2 * this.directionalLightStrength / 255;
this.lightParams[4] = 1 + ((this.ambientColor >> 16 & 255) * 2 / 255 - 1) * this.directionalLightStrength;
this.lightParams[5] = 1 + ((this.ambientColor >> 8 & 255) * 2 / 255 - 1) * this.directionalLightStrength;
this.lightParams[6] = 1 + ((this.ambientColor & 255) * 2 / 255 - 1) * this.directionalLightStrength;
this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,10,this.lightParams,2);
}
else if(!this.view.constrained && this.shadowMap != null && this.shadowMapStrength > 0)
{
this.lightParams[0] = 0;
this.lightParams[1] = 0;
this.lightParams[2] = 0;
this.lightParams[4] = 1;
this.lightParams[5] = 1;
this.lightParams[6] = 1;
this.device.setProgramConstantsFromVector(Context3DProgramType.FRAGMENT,10,this.lightParams,2);
}
_loc1_ = 0;
while(_loc1_ < this.opaqueCount)
{
_loc9_ = this.opaqueMaterials[_loc1_];
_loc9_.drawOpaque(this,this.opaqueVertexBuffers[_loc1_],this.opaqueIndexBuffers[_loc1_],this.opaqueFirstIndexes[_loc1_],this.opaqueNumsTriangles[_loc1_],this.opaqueObjects[_loc1_]);
_loc1_++;
}
this.device.setDepthTest(false,Context3DCompareMode.LESS_EQUAL);
_loc1_ = 0;
while(_loc1_ < this.skyCount)
{
_loc9_ = this.skyMaterials[_loc1_];
_loc9_.drawOpaque(this,this.skyVertexBuffers[_loc1_],this.skyIndexBuffers[_loc1_],this.skyFirstIndexes[_loc1_],this.skyNumsTriangles[_loc1_],this.skyObjects[_loc1_]);
_loc1_++;
}
this.device.setDepthTest(false,Context3DCompareMode.LESS);
_loc1_ = this.decalsCount - 1;
while(_loc1_ >= 0)
{
_loc11_ = this.decals[_loc1_];
if(_loc11_.concatenatedBlendMode != "normal")
{
this.device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA,Context3DBlendFactor.ONE);
}
else
{
this.device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA,Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA);
}
_loc11_.faceList.material.drawOpaque(this,_loc11_.vertexBuffer,_loc11_.indexBuffer,0,_loc11_.numTriangles,_loc11_);
_loc1_--;
}
if(_loc8_)
{
this.device.setTextureAt(0,null);
this.device.setTextureAt(1,null);
this.device.setTextureAt(2,null);
this.device.setTextureAt(3,null);
this.device.setTextureAt(5,null);
this.device.setVertexBufferAt(1,null);
this.device.setVertexBufferAt(2,null);
_loc12_ = 0;
for each(_loc7_ in this.shadowAtlases)
{
_loc1_ = 0;
while(_loc1_ < _loc7_.shadowsCount)
{
this.shadowList[_loc12_] = _loc7_.shadows[_loc1_];
_loc12_++;
_loc1_++;
}
}
this.device.setDepthTest(false,Context3DCompareMode.LESS);
_loc15_ = null;
_loc1_ = 0;
while(_loc1_ < _loc12_)
{
if(_loc1_ > 0)
{
this.device.clear(0,0,0,0,1,0,Context3DClearMask.STENCIL);
}
this.device.setBlendFactors(Context3DBlendFactor.ZERO,Context3DBlendFactor.ONE);
this.device.setCulling(Context3DTriangleFace.NONE);
this.device.setStencilActions(Context3DTriangleFace.FRONT_AND_BACK,Context3DCompareMode.ALWAYS,Context3DStencilAction.INVERT);
_loc13_ = _loc1_;
_loc14_ = 1;
while(_loc13_ < _loc1_ + 8 && _loc13_ < _loc12_)
{
_loc4_ = this.shadowList[_loc13_];
if(!_loc4_.cameraInside)
{
this.device.setStencilReferenceValue(_loc14_,_loc14_,_loc14_);
_loc4_.renderVolume(this);
}
_loc13_++;
_loc14_ <<= 1;
}
this.device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA,Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA);
this.device.setCulling(Context3DTriangleFace.FRONT);
this.device.setStencilActions(Context3DTriangleFace.BACK,Context3DCompareMode.EQUAL);
_loc13_ = _loc1_;
_loc14_ = 1;
while(_loc13_ < _loc1_ + 8 && _loc13_ < _loc12_)
{
_loc4_ = this.shadowList[_loc13_];
if(_loc4_.texture != _loc15_)
{
this.device.setTextureAt(0,_loc4_.texture);
_loc15_ = _loc4_.texture;
}
if(!_loc4_.cameraInside)
{
this.device.setStencilReferenceValue(_loc14_,_loc14_,_loc14_);
_loc4_.renderReceivers(this);
}
else
{
this.device.setStencilActions(Context3DTriangleFace.BACK,Context3DCompareMode.ALWAYS);
_loc4_.renderReceivers(this);
this.device.setStencilActions(Context3DTriangleFace.BACK,Context3DCompareMode.EQUAL);
}
_loc13_++;
_loc14_ <<= 1;
}
this.device.setTextureAt(0,null);
_loc15_ = null;
_loc1_ += 8;
}
this.device.setStencilActions();
this.device.setStencilReferenceValue(0);
}
this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,13,this.correction,1);
this.device.setCulling(Context3DTriangleFace.FRONT);
_loc1_ = 0;
while(_loc1_ < this.transparentOpaqueCount)
{
if(_loc1_ < this.transparentOpaqueFaceLists.length && _loc1_ < this.transparentOpaqueObjects.length)
{
this.transparentFaceLists[this.transparentCount] = this.transparentOpaqueFaceLists[_loc1_];
this.transparentObjects[this.transparentCount] = this.transparentOpaqueObjects[_loc1_];
++this.transparentCount;
}
_loc1_++;
}
this.transparentOpaqueCount = this.transparentCount - this.transparentOpaqueCount;
this.device.setDepthTest(true,Context3DCompareMode.LESS);
_loc1_ = this.transparentCount - 1;
while(_loc1_ >= 0)
{
if(_loc1_ + 1 == this.transparentOpaqueCount)
{
this.device.setDepthTest(false,Context3DCompareMode.LESS);
}
_loc16_ = this.transparentFaceLists[_loc1_];
_loc17_ = this.transparentObjects[_loc1_];
if(_loc17_.concatenatedBlendMode != "normal")
{
this.device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA,Context3DBlendFactor.ONE);
}
else
{
this.device.setBlendFactors(Context3DBlendFactor.SOURCE_ALPHA,Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA);
}
_loc18_ = _loc17_ is Sprite3D;
if(_loc18_)
{
_loc20_ = 0;
_loc21_ = Sprite3D(_loc17_);
_loc22_ = _loc16_;
while(_loc22_.processNext != null)
{
_loc22_.distance = _loc20_;
_loc22_ = _loc22_.processNext;
}
_loc22_.distance = _loc20_;
this.transparentBatchObjects[_loc20_] = _loc17_;
_loc20_++;
_loc13_ = _loc1_ - 1;
while(_loc13_ >= 0)
{
_loc23_ = this.transparentFaceLists[_loc13_];
if(_loc16_.material != _loc23_.material)
{
break;
}
_loc24_ = this.transparentObjects[_loc13_];
if(!(_loc24_ is Sprite3D))
{
break;
}
_loc25_ = Sprite3D(_loc24_);
if(_loc21_.useLight != _loc25_.useLight || _loc21_.useShadowMap != _loc25_.useShadowMap || _loc21_.lighted || _loc25_.lighted || _loc21_.softAttenuation != _loc25_.softAttenuation || _loc21_.concatenatedAlpha != _loc25_.concatenatedAlpha || _loc21_.concatenatedColorTransform != null || _loc25_.concatenatedColorTransform != null || _loc21_.concatenatedBlendMode != _loc25_.concatenatedBlendMode)
{
break;
}
_loc22_.processNext = _loc23_;
_loc22_ = _loc23_;
while(_loc22_.processNext != null)
{
_loc22_.distance = _loc20_;
_loc22_ = _loc22_.processNext;
}
_loc22_.distance = _loc20_;
this.transparentBatchObjects[_loc20_] = _loc24_;
_loc20_++;
_loc1_--;
_loc13_--;
}
}
_loc19_ = _loc18_ && !Sprite3D(_loc17_).depthTest;
if(_loc19_)
{
this.device.setDepthTest(false,Context3DCompareMode.ALWAYS);
}
this.drawTransparentList(_loc16_,_loc17_,_loc18_);
if(_loc19_)
{
this.device.setDepthTest(false,Context3DCompareMode.LESS);
}
_loc1_--;
}
this.device.setTextureAt(0,null);
this.device.setTextureAt(1,null);
this.device.setTextureAt(2,null);
this.device.setTextureAt(3,null);
this.device.setTextureAt(5,null);
this.device.setTextureAt(6,null);
this.device.setTextureAt(7,null);
this.device.setVertexBufferAt(1,null);
this.device.setVertexBufferAt(2,null);
this.device.setVertexBufferAt(3,null);
this.device.setVertexBufferAt(4,null);
this.device.setVertexBufferAt(5,null);
this.device.setVertexBufferAt(6,null);
this.device.setVertexBufferAt(7,null);
this.opaqueMaterials.length = 0;
this.opaqueVertexBuffers.length = 0;
this.opaqueIndexBuffers.length = 0;
this.opaqueFirstIndexes.length = 0;
this.opaqueNumsTriangles.length = 0;
this.opaqueObjects.length = 0;
this.opaqueCount = 0;
this.skyMaterials.length = 0;
this.skyVertexBuffers.length = 0;
this.skyIndexBuffers.length = 0;
this.skyFirstIndexes.length = 0;
this.skyNumsTriangles.length = 0;
this.skyObjects.length = 0;
this.skyCount = 0;
this.transparentFaceLists.length = 0;
this.transparentObjects.length = 0;
this.transparentCount = 0;
this.transparentOpaqueFaceLists.length = 0;
this.transparentOpaqueObjects.length = 0;
this.transparentOpaqueCount = 0;
this.transparentBatchObjects.length = 0;
this.decals.length = 0;
this.decalsCount = 0;
this.depthObjects.length = 0;
this.depthCount = 0;
this.casterObjects.length = 0;
this.casterCount = 0;
this.omnies.length = 0;
this.omniesCount = 0;
this.spots.length = 0;
this.spotsCount = 0;
this.tubes.length = 0;
this.tubesCount = 0;
for each(_loc7_ in this.shadowAtlases)
{
if(_loc7_.shadowsCount > 0)
{
_loc7_.clear();
}
}
this.receiversVertexBuffers = null;
this.receiversIndexBuffers = null;
this.deferredDestroy();
this.clearOccluders();
this.view.onRender(this);
if(this.onRender != null)
{
this.onRender();
}
this.view.present();
}
else
{
this.view.clearArea();
if(this.onRender != null)
{
this.onRender();
}
this.view.present();
}
this.device = null;
}
}
private function drawTransparentList(param1:Face, param2:Object3D, param3:Boolean) : void
{
var _loc4_:Vertex = null;
var _loc5_:Vertex = null;
var _loc6_:Vertex = null;
var _loc7_:Wrapper = null;
var _loc8_:Face = null;
var _loc12_:int = 0;
var _loc13_:Object3D = null;
var _loc9_:int = 0;
var _loc10_:int = 0;
var _loc11_:Material = param1.material;
while(param1 != null)
{
_loc8_ = param1.processNext;
param1.processNext = null;
_loc7_ = param1.wrapper;
_loc4_ = _loc7_.vertex;
_loc7_ = _loc7_.next;
_loc5_ = _loc7_.vertex;
if(param3)
{
_loc12_ = param1.distance;
_loc13_ = this.transparentBatchObjects[_loc12_];
_loc7_ = _loc7_.next;
while(_loc7_ != null)
{
if(_loc10_ == constantsMaxTriangles)
{
if(_loc11_ != null)
{
this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,constantsOffset,constants,_loc10_ * 6,false);
_loc11_.drawTransparent(this,constantsVertexBuffer,constantsIndexBuffer,0,_loc10_,param2,true);
}
_loc10_ = 0;
_loc9_ = 0;
}
_loc6_ = _loc7_.vertex;
constants[_loc9_] = _loc4_.cameraX;
_loc9_++;
constants[_loc9_] = _loc4_.cameraY;
_loc9_++;
constants[_loc9_] = _loc4_.cameraZ;
_loc9_++;
constants[_loc9_] = -_loc13_.md;
_loc9_++;
constants[_loc9_] = _loc4_.u;
_loc9_++;
constants[_loc9_] = _loc4_.v;
_loc9_++;
constants[_loc9_] = -_loc13_.mh;
_loc9_++;
constants[_loc9_] = -_loc13_.ml;
_loc9_++;
constants[_loc9_] = _loc5_.cameraX;
_loc9_++;
constants[_loc9_] = _loc5_.cameraY;
_loc9_++;
constants[_loc9_] = _loc5_.cameraZ;
_loc9_++;
constants[_loc9_] = -_loc13_.md;
_loc9_++;
constants[_loc9_] = _loc5_.u;
_loc9_++;
constants[_loc9_] = _loc5_.v;
_loc9_++;
constants[_loc9_] = -_loc13_.mh;
_loc9_++;
constants[_loc9_] = -_loc13_.ml;
_loc9_++;
constants[_loc9_] = _loc6_.cameraX;
_loc9_++;
constants[_loc9_] = _loc6_.cameraY;
_loc9_++;
constants[_loc9_] = _loc6_.cameraZ;
_loc9_++;
constants[_loc9_] = -_loc13_.md;
_loc9_++;
constants[_loc9_] = _loc6_.u;
_loc9_++;
constants[_loc9_] = _loc6_.v;
_loc9_++;
constants[_loc9_] = -_loc13_.mh;
_loc9_++;
constants[_loc9_] = -_loc13_.ml;
_loc9_++;
_loc10_++;
_loc5_ = _loc6_;
_loc7_ = _loc7_.next;
}
}
else
{
_loc7_ = _loc7_.next;
while(_loc7_ != null)
{
if(_loc10_ == constantsMaxTriangles)
{
if(_loc11_ != null)
{
this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,constantsOffset,constants,_loc10_ * 6,false);
_loc11_.drawTransparent(this,constantsVertexBuffer,constantsIndexBuffer,0,_loc10_,param2,true);
}
_loc10_ = 0;
_loc9_ = 0;
}
_loc6_ = _loc7_.vertex;
constants[_loc9_] = _loc4_.cameraX;
_loc9_++;
constants[_loc9_] = _loc4_.cameraY;
_loc9_++;
constants[_loc9_] = _loc4_.cameraZ;
_loc9_++;
constants[_loc9_] = _loc4_.normalX;
_loc9_++;
constants[_loc9_] = _loc4_.u;
_loc9_++;
constants[_loc9_] = _loc4_.v;
_loc9_++;
constants[_loc9_] = _loc4_.normalY;
_loc9_++;
constants[_loc9_] = _loc4_.normalZ;
_loc9_++;
constants[_loc9_] = _loc5_.cameraX;
_loc9_++;
constants[_loc9_] = _loc5_.cameraY;
_loc9_++;
constants[_loc9_] = _loc5_.cameraZ;
_loc9_++;
constants[_loc9_] = _loc5_.normalX;
_loc9_++;
constants[_loc9_] = _loc5_.u;
_loc9_++;
constants[_loc9_] = _loc5_.v;
_loc9_++;
constants[_loc9_] = _loc5_.normalY;
_loc9_++;
constants[_loc9_] = _loc5_.normalZ;
_loc9_++;
constants[_loc9_] = _loc6_.cameraX;
_loc9_++;
constants[_loc9_] = _loc6_.cameraY;
_loc9_++;
constants[_loc9_] = _loc6_.cameraZ;
_loc9_++;
constants[_loc9_] = _loc6_.normalX;
_loc9_++;
constants[_loc9_] = _loc6_.u;
_loc9_++;
constants[_loc9_] = _loc6_.v;
_loc9_++;
constants[_loc9_] = _loc6_.normalY;
_loc9_++;
constants[_loc9_] = _loc6_.normalZ;
_loc9_++;
_loc10_++;
_loc5_ = _loc6_;
_loc7_ = _loc7_.next;
}
}
param1 = _loc8_;
}
if(_loc10_ > 0 && _loc11_ != null)
{
this.device.setProgramConstantsFromVector(Context3DProgramType.VERTEX,constantsOffset,constants,_loc10_ * 6,false);
_loc11_.drawTransparent(this,constantsVertexBuffer,constantsIndexBuffer,0,_loc10_,param2,true);
}
}
public function lookAt(param1:Number, param2:Number, param3:Number) : void
{
var _loc4_:Number = param1 - this.x;
var _loc5_:Number = param2 - this.y;
var _loc6_:Number = param3 - this.z;
rotationX = Math.atan2(_loc6_,Math.sqrt(_loc4_ * _loc4_ + _loc5_ * _loc5_)) - Math.PI / 2;
rotationY = 0;
rotationZ = -Math.atan2(_loc4_,_loc5_);
}
public function projectGlobal(param1:Vector3D) : Vector3D
{
if(this.view == null)
{
throw new Error("It is necessary to have view set.");
}
this.viewSizeX = this.view._width * 0.5;
this.viewSizeY = this.view._height * 0.5;
this.focalLength = Math.sqrt(this.viewSizeX * this.viewSizeX + this.viewSizeY * this.viewSizeY) / Math.tan(this.fov * 0.5);
this.composeCameraMatrix();
var _loc2_:Object3D = this;
while(_loc2_._parent != null)
{
_loc2_ = _loc2_._parent;
tA.composeMatrixFromSource(_loc2_);
appendMatrix(tA);
}
invertMatrix();
var _loc3_:Vector3D = new Vector3D();
_loc3_.x = ma * param1.x + mb * param1.y + mc * param1.z + md;
_loc3_.y = me * param1.x + mf * param1.y + mg * param1.z + mh;
_loc3_.z = mi * param1.x + mj * param1.y + mk * param1.z + ml;
_loc3_.x = _loc3_.x * this.viewSizeX / _loc3_.z + this.viewSizeX;
_loc3_.y = _loc3_.y * this.viewSizeY / _loc3_.z + this.viewSizeY;
return _loc3_;
}
public function calculateRay(param1:Vector3D, param2:Vector3D, param3:Number, param4:Number) : void
{
if(this.view == null)
{
throw new Error("It is necessary to have view set.");
}
this.viewSizeX = this.view._width * 0.5;
this.viewSizeY = this.view._height * 0.5;
this.focalLength = Math.sqrt(this.viewSizeX * this.viewSizeX + this.viewSizeY * this.viewSizeY) / Math.tan(this.fov * 0.5);
param3 -= this.viewSizeX;
param4 -= this.viewSizeY;
var _loc5_:Number = param3 * this.focalLength / this.viewSizeX;
var _loc6_:Number = param4 * this.focalLength / this.viewSizeY;
var _loc7_:Number = this.focalLength;
var _loc8_:Number = _loc5_ * this.nearClipping / this.focalLength;
var _loc9_:Number = _loc6_ * this.nearClipping / this.focalLength;
var _loc10_:Number = this.nearClipping;
this.composeCameraMatrix();
var _loc11_:Object3D = this;
while(_loc11_._parent != null)
{
_loc11_ = _loc11_._parent;
tA.composeMatrixFromSource(_loc11_);
appendMatrix(tA);
}
param1.x = ma * _loc8_ + mb * _loc9_ + mc * _loc10_ + md;
param1.y = me * _loc8_ + mf * _loc9_ + mg * _loc10_ + mh;
param1.z = mi * _loc8_ + mj * _loc9_ + mk * _loc10_ + ml;
param2.x = ma * _loc5_ + mb * _loc6_ + mc * _loc7_;
param2.y = me * _loc5_ + mf * _loc6_ + mg * _loc7_;
param2.z = mi * _loc5_ + mj * _loc6_ + mk * _loc7_;
var _loc12_:Number = 1 / Math.sqrt(param2.x * param2.x + param2.y * param2.y + param2.z * param2.z);
param2.x *= _loc12_;
param2.y *= _loc12_;
param2.z *= _loc12_;
}
override public function clone() : Object3D
{
var _loc1_:Camera3D = new Camera3D();
_loc1_.clonePropertiesFrom(this);
return _loc1_;
}
override protected function clonePropertiesFrom(param1:Object3D) : void
{
var _loc3_:* = undefined;
super.clonePropertiesFrom(param1);
var _loc2_:Camera3D = param1 as Camera3D;
this.fov = _loc2_.fov;
this.nearClipping = _loc2_.nearClipping;
this.farClipping = _loc2_.farClipping;
this.debug = _loc2_.debug;
this.fogNear = _loc2_.fogNear;
this.fogFar = _loc2_.fogFar;
this.fogAlpha = _loc2_.fogAlpha;
this.fogColor = _loc2_.fogColor;
this.softTransparency = _loc2_.softTransparency;
this.depthBufferScale = _loc2_.depthBufferScale;
this.ssao = _loc2_.ssao;
this.ssaoRadius = _loc2_.ssaoRadius;
this.ssaoRange = _loc2_.ssaoRange;
this.ssaoColor = _loc2_.ssaoColor;
this.ssaoAlpha = _loc2_.ssaoAlpha;
this.directionalLight = _loc2_.directionalLight;
this.shadowMap = _loc2_.shadowMap;
this.ambientColor = _loc2_.ambientColor;
this.deferredLighting = _loc2_.deferredLighting;
this.fogStrength = _loc2_.fogStrength;
this.softTransparencyStrength = _loc2_.softTransparencyStrength;
this.ssaoStrength = _loc2_.ssaoStrength;
this.directionalLightStrength = _loc2_.directionalLightStrength;
this.shadowMapStrength = _loc2_.shadowMapStrength;
this.shadowsStrength = _loc2_.shadowsStrength;
this.shadowsDistanceMultiplier = _loc2_.shadowsDistanceMultiplier;
this.deferredLightingStrength = _loc2_.deferredLightingStrength;
for(_loc3_ in _loc2_.shadows)
{
this.shadows[_loc3_] = true;
}
}
alternativa3d function addOpaque(param1:Material, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D) : void
{
this.opaqueMaterials[this.opaqueCount] = param1;
this.opaqueVertexBuffers[this.opaqueCount] = param2;
this.opaqueIndexBuffers[this.opaqueCount] = param3;
this.opaqueFirstIndexes[this.opaqueCount] = param4;
this.opaqueNumsTriangles[this.opaqueCount] = param5;
this.opaqueObjects[this.opaqueCount] = param6;
++this.opaqueCount;
}
alternativa3d function addSky(param1:Material, param2:VertexBufferResource, param3:IndexBufferResource, param4:int, param5:int, param6:Object3D) : void
{
this.skyMaterials[this.skyCount] = param1;
this.skyVertexBuffers[this.skyCount] = param2;
this.skyIndexBuffers[this.skyCount] = param3;
this.skyFirstIndexes[this.skyCount] = param4;
this.skyNumsTriangles[this.skyCount] = param5;
this.skyObjects[this.skyCount] = param6;
++this.skyCount;
}
alternativa3d function addTransparent(param1:Face, param2:Object3D) : void
{
this.transparentFaceLists[this.transparentCount] = param1;
this.transparentObjects[this.transparentCount] = param2;
++this.transparentCount;
}
alternativa3d function addTransparentOpaque(param1:Face, param2:Object3D) : void
{
this.transparentOpaqueFaceLists[this.transparentOpaqueCount] = param1;
this.transparentOpaqueObjects[this.transparentOpaqueCount] = param2;
++this.transparentOpaqueCount;
}
alternativa3d function addDecal(param1:Decal) : void
{
this.decals[this.decalsCount] = param1;
++this.decalsCount;
}
alternativa3d function composeCameraMatrix() : void
{
var _loc1_:Number = this.viewSizeX / this.focalLength;
var _loc2_:Number = this.viewSizeY / this.focalLength;
var _loc3_:Number = Math.cos(rotationX);
var _loc4_:Number = Math.sin(rotationX);
var _loc5_:Number = Math.cos(rotationY);
var _loc6_:Number = Math.sin(rotationY);
var _loc7_:Number = Math.cos(rotationZ);
var _loc8_:Number = Math.sin(rotationZ);
var _loc9_:Number = _loc7_ * _loc6_;
var _loc10_:Number = _loc8_ * _loc6_;
var _loc11_:Number = _loc5_ * scaleX;
var _loc12_:Number = _loc4_ * scaleY;
var _loc13_:Number = _loc3_ * scaleY;
var _loc14_:Number = _loc3_ * scaleZ;
var _loc15_:Number = _loc4_ * scaleZ;
ma = _loc7_ * _loc11_ * _loc1_;
mb = (_loc9_ * _loc12_ - _loc8_ * _loc13_) * _loc2_;
mc = _loc9_ * _loc14_ + _loc8_ * _loc15_;
md = x;
me = _loc8_ * _loc11_ * _loc1_;
mf = (_loc10_ * _loc12_ + _loc7_ * _loc13_) * _loc2_;
mg = _loc10_ * _loc14_ - _loc7_ * _loc15_;
mh = y;
mi = -_loc6_ * scaleX * _loc1_;
mj = _loc5_ * _loc12_ * _loc2_;
mk = _loc5_ * _loc14_;
ml = z;
var _loc16_:Number = this.view.offsetX / this.viewSizeX;
var _loc17_:Number = this.view.offsetY / this.viewSizeY;
mc -= ma * _loc16_ + mb * _loc17_;
mg -= me * _loc16_ + mf * _loc17_;
mk -= mi * _loc16_ + mj * _loc17_;
}
public function addToDebug(param1:int, param2:*) : void
{
if(!this.debugSet[param1])
{
this.debugSet[param1] = new Dictionary();
}
this.debugSet[param1][param2] = true;
}
public function removeFromDebug(param1:int, param2:*) : void
{
var _loc3_:* = undefined;
if(this.debugSet[param1])
{
delete this.debugSet[param1][param2];
for(_loc3_ in this.debugSet[param1])
{
}
if(!_loc3_)
{
delete this.debugSet[param1];
}
}
}
alternativa3d function checkInDebug(param1:Object3D) : int
{
var _loc4_:Class = null;
var _loc2_:int = 0;
var _loc3_:int = 1;
while(_loc3_ <= 512)
{
if(this.debugSet[_loc3_])
{
if(this.debugSet[_loc3_][Object3D] || this.debugSet[_loc3_][param1])
{
_loc2_ = _loc2_ | _loc3_;
}
else
{
_loc4_ = getDefinitionByName(getQualifiedClassName(param1)) as Class;
while(_loc4_ != Object3D)
{
if(this.debugSet[_loc3_][_loc4_])
{
_loc2_ = _loc2_ | _loc3_;
break;
}
_loc4_ = Class(getDefinitionByName(getQualifiedSuperclassName(_loc4_)));
}
}
}
_loc3_ = _loc3_ << 1;
}
return _loc2_;
}
public function startTimer() : void
{
this.timer = getTimer();
}
public function stopTimer() : void
{
this.timeSum = this.timeSum + (getTimer() - this.timer);
this.timeCount++;
}
public function get diagram() : DisplayObject
{
return this._diagram;
}
public function get diagramAlign() : String
{
return this._diagramAlign;
}
public function set diagramAlign(param1:String) : void
{
this._diagramAlign = param1;
this.resizeDiagram();
}
public function get diagramHorizontalMargin() : Number
{
return this._diagramHorizontalMargin;
}
public function set diagramHorizontalMargin(param1:Number) : void
{
this._diagramHorizontalMargin = param1;
this.resizeDiagram();
}
public function get diagramVerticalMargin() : Number
{
return this._diagramVerticalMargin;
}
public function set diagramVerticalMargin(param1:Number) : void
{
this._diagramVerticalMargin = param1;
this.resizeDiagram();
}
private function createDiagram() : Sprite
{
var diagram:Sprite = null;
diagram = null;
diagram = new Sprite();
diagram.mouseEnabled = false;
diagram.mouseChildren = false;
diagram.addEventListener(Event.ADDED_TO_STAGE,function():void
{
while(diagram.numChildren > 0)
{
diagram.removeChildAt(0);
}
fpsTextField = new TextField();
fpsTextField.defaultTextFormat = new TextFormat("Tahoma",10,13421772);
fpsTextField.autoSize = TextFieldAutoSize.LEFT;
fpsTextField.text = "FPS:";
fpsTextField.selectable = false;
fpsTextField.x = -3;
fpsTextField.y = -5;
diagram.addChild(fpsTextField);
fpsTextField = new TextField();
fpsTextField.defaultTextFormat = new TextFormat("Tahoma",10,13421772);
fpsTextField.autoSize = TextFieldAutoSize.RIGHT;
fpsTextField.text = Number(diagram.stage.frameRate).toFixed(2);
fpsTextField.selectable = false;
fpsTextField.x = -3;
fpsTextField.y = -5;
fpsTextField.width = 65;
diagram.addChild(fpsTextField);
timerTextField = new TextField();
timerTextField.defaultTextFormat = new TextFormat("Tahoma",10,26367);
timerTextField.autoSize = TextFieldAutoSize.LEFT;
timerTextField.text = "MS:";
timerTextField.selectable = false;
timerTextField.x = -3;
timerTextField.y = 4;
diagram.addChild(timerTextField);
timerTextField = new TextField();
timerTextField.defaultTextFormat = new TextFormat("Tahoma",10,26367);
timerTextField.autoSize = TextFieldAutoSize.RIGHT;
timerTextField.text = "";
timerTextField.selectable = false;
timerTextField.x = -3;
timerTextField.y = 4;
timerTextField.width = 65;
diagram.addChild(timerTextField);
memoryTextField = new TextField();
memoryTextField.defaultTextFormat = new TextFormat("Tahoma",10,13421568);
memoryTextField.autoSize = TextFieldAutoSize.LEFT;
memoryTextField.text = "MEM:";
memoryTextField.selectable = false;
memoryTextField.x = -3;
memoryTextField.y = 13;
diagram.addChild(memoryTextField);
memoryTextField = new TextField();
memoryTextField.defaultTextFormat = new TextFormat("Tahoma",10,13421568);
memoryTextField.autoSize = TextFieldAutoSize.RIGHT;
memoryTextField.text = bytesToString(System.totalMemory);
memoryTextField.selectable = false;
memoryTextField.x = -3;
memoryTextField.y = 13;
memoryTextField.width = 65;
diagram.addChild(memoryTextField);
drawsTextField = new TextField();
drawsTextField.defaultTextFormat = new TextFormat("Tahoma",10,52224);
drawsTextField.autoSize = TextFieldAutoSize.LEFT;
drawsTextField.text = "DRW:";
drawsTextField.selectable = false;
drawsTextField.x = -3;
drawsTextField.y = 22;
diagram.addChild(drawsTextField);
drawsTextField = new TextField();
drawsTextField.defaultTextFormat = new TextFormat("Tahoma",10,52224);
drawsTextField.autoSize = TextFieldAutoSize.RIGHT;
drawsTextField.text = "0";
drawsTextField.selectable = false;
drawsTextField.x = -3;
drawsTextField.y = 22;
drawsTextField.width = 52;
diagram.addChild(drawsTextField);
shadowsTextField = new TextField();
shadowsTextField.defaultTextFormat = new TextFormat("Tahoma",10,16711731);
shadowsTextField.autoSize = TextFieldAutoSize.LEFT;
shadowsTextField.text = "SHD:";
shadowsTextField.selectable = false;
shadowsTextField.x = -3;
shadowsTextField.y = 31;
diagram.addChild(shadowsTextField);
shadowsTextField = new TextField();
shadowsTextField.defaultTextFormat = new TextFormat("Tahoma",10,16711731);
shadowsTextField.autoSize = TextFieldAutoSize.RIGHT;
shadowsTextField.text = "0";
shadowsTextField.selectable = false;
shadowsTextField.x = -3;
shadowsTextField.y = 31;
shadowsTextField.width = 52;
diagram.addChild(shadowsTextField);
trianglesTextField = new TextField();
trianglesTextField.defaultTextFormat = new TextFormat("Tahoma",10,16737792);
trianglesTextField.autoSize = TextFieldAutoSize.LEFT;
trianglesTextField.text = "TRI:";
trianglesTextField.selectable = false;
trianglesTextField.x = -3;
trianglesTextField.y = 40;
diagram.addChild(trianglesTextField);
trianglesTextField = new TextField();
trianglesTextField.defaultTextFormat = new TextFormat("Tahoma",10,16737792);
trianglesTextField.autoSize = TextFieldAutoSize.RIGHT;
trianglesTextField.text = "0";
trianglesTextField.selectable = false;
trianglesTextField.x = -3;
trianglesTextField.y = 40;
trianglesTextField.width = 52;
diagram.addChild(trianglesTextField);
graph = new Bitmap(new BitmapData(60,40,true,553648127));
rect = new Rectangle(0,0,1,40);
graph.x = 0;
graph.y = 54;
diagram.addChild(graph);
previousPeriodTime = getTimer();
previousFrameTime = previousPeriodTime;
fpsUpdateCounter = 0;
maxMemory = 0;
timerUpdateCounter = 0;
timeSum = 0;
timeCount = 0;
diagram.stage.addEventListener(Event.ENTER_FRAME,updateDiagram,false,-1000);
diagram.stage.addEventListener(Event.RESIZE,resizeDiagram,false,-1000);
resizeDiagram();
});
diagram.addEventListener(Event.REMOVED_FROM_STAGE,function():void
{
while(diagram.numChildren > 0)
{
diagram.removeChildAt(0);
}
fpsTextField = null;
memoryTextField = null;
drawsTextField = null;
shadowsTextField = null;
trianglesTextField = null;
timerTextField = null;
graph.bitmapData.dispose();
graph = null;
rect = null;
diagram.stage.removeEventListener(Event.ENTER_FRAME,updateDiagram);
diagram.stage.removeEventListener(Event.RESIZE,resizeDiagram);
});
return diagram;
}
private function resizeDiagram(param1:Event = null) : void
{
var _loc2_:Point = null;
if(this._diagram.stage != null)
{
_loc2_ = this._diagram.parent.globalToLocal(new Point());
if(this._diagramAlign == StageAlign.TOP_LEFT || this._diagramAlign == StageAlign.LEFT || this._diagramAlign == StageAlign.BOTTOM_LEFT)
{
this._diagram.x = Math.round(_loc2_.x + this._diagramHorizontalMargin);
}
if(this._diagramAlign == StageAlign.TOP || this._diagramAlign == StageAlign.BOTTOM)
{
this._diagram.x = Math.round(_loc2_.x + this._diagram.stage.stageWidth / 2 - this.graph.width / 2);
}
if(this._diagramAlign == StageAlign.TOP_RIGHT || this._diagramAlign == StageAlign.RIGHT || this._diagramAlign == StageAlign.BOTTOM_RIGHT)
{
this._diagram.x = Math.round(_loc2_.x + this._diagram.stage.stageWidth - this._diagramHorizontalMargin - this.graph.width);
}
if(this._diagramAlign == StageAlign.TOP_LEFT || this._diagramAlign == StageAlign.TOP || this._diagramAlign == StageAlign.TOP_RIGHT)
{
this._diagram.y = Math.round(_loc2_.y + this._diagramVerticalMargin);
}
if(this._diagramAlign == StageAlign.LEFT || this._diagramAlign == StageAlign.RIGHT)
{
this._diagram.y = Math.round(_loc2_.y + this._diagram.stage.stageHeight / 2 - (this.graph.y + this.graph.height) / 2);
}
if(this._diagramAlign == StageAlign.BOTTOM_LEFT || this._diagramAlign == StageAlign.BOTTOM || this._diagramAlign == StageAlign.BOTTOM_RIGHT)
{
this._diagram.y = Math.round(_loc2_.y + this._diagram.stage.stageHeight - this._diagramVerticalMargin - this.graph.y - this.graph.height);
}
}
}
private function updateDiagram(param1:Event) : void
{
var _loc2_:Number = NaN;
var _loc3_:int = 0;
var _loc4_:String = null;
var _loc5_:int = getTimer();
var _loc6_:int = this._diagram.stage.frameRate;
if(++this.fpsUpdateCounter == this.fpsUpdatePeriod)
{
_loc2_ = 1000 * this.fpsUpdatePeriod / (_loc5_ - this.previousPeriodTime);
if(_loc2_ > _loc6_)
{
_loc2_ = _loc6_;
}
_loc3_ = _loc2_ * 100 % 100;
_loc4_ = _loc3_ >= 10 ? String(_loc3_) : (_loc3_ > 0 ? "0" + String(_loc3_) : "00");
this.fpsTextField.text = int(_loc2_) + "." + _loc4_;
this.previousPeriodTime = _loc5_;
this.fpsUpdateCounter = 0;
}
_loc2_ = 1000 / (_loc5_ - this.previousFrameTime);
if(_loc2_ > _loc6_)
{
_loc2_ = _loc6_;
}
this.graph.bitmapData.scroll(1,0);
this.graph.bitmapData.fillRect(this.rect,553648127);
this.graph.bitmapData.setPixel32(0,40 * (1 - _loc2_ / _loc6_),4291611852);
this.previousFrameTime = _loc5_;
if(++this.timerUpdateCounter == this.timerUpdatePeriod)
{
if(this.timeCount > 0)
{
_loc2_ = this.timeSum / this.timeCount;
_loc3_ = _loc2_ * 100 % 100;
_loc4_ = _loc3_ >= 10 ? String(_loc3_) : (_loc3_ > 0 ? "0" + String(_loc3_) : "00");
this.timerTextField.text = int(_loc2_) + "." + _loc4_;
}
else
{
this.timerTextField.text = "";
}
this.timerUpdateCounter = 0;
this.timeSum = 0;
this.timeCount = 0;
}
var _loc7_:int = System.totalMemory;
_loc2_ = _loc7_ / 1048576;
_loc3_ = _loc2_ * 100 % 100;
_loc4_ = _loc3_ >= 10 ? String(_loc3_) : (_loc3_ > 0 ? "0" + String(_loc3_) : "00");
this.memoryTextField.text = int(_loc2_) + "." + _loc4_;
if(_loc7_ > this.maxMemory)
{
this.maxMemory = _loc7_;
}
this.graph.bitmapData.setPixel32(0,40 * (1 - _loc7_ / this.maxMemory),4291611648);
this.drawsTextField.text = String(this.numDraws);
this.shadowsTextField.text = String(this.numShadows);
this.trianglesTextField.text = String(this.numTriangles);
}
private function bytesToString(param1:int) : String
{
if(param1 < 1024)
{
return param1 + "b";
}
if(param1 < 10240)
{
return (param1 / 1024).toFixed(2) + "kb";
}
if(param1 < 102400)
{
return (param1 / 1024).toFixed(1) + "kb";
}
if(param1 < 1048576)
{
return (param1 >> 10) + "kb";
}
if(param1 < 10485760)
{
return (param1 / 1048576).toFixed(2);
}
if(param1 < 104857600)
{
return (param1 / 1048576).toFixed(1);
}
return String(param1 >> 20);
}
alternativa3d function deferredDestroy() : void
{
var _loc2_:Wrapper = null;
var _loc3_:Wrapper = null;
var _loc1_:Face = this.firstFace.next;
while(_loc1_ != null)
{
_loc2_ = _loc1_.wrapper;
if(_loc2_ != null)
{
_loc3_ = null;
while(_loc2_ != null)
{
_loc2_.vertex = null;
_loc3_ = _loc2_;
_loc2_ = _loc2_.next;
}
this.lastWrapper.next = _loc1_.wrapper;
this.lastWrapper = _loc3_;
}
_loc1_.material = null;
_loc1_.wrapper = null;
_loc1_ = _loc1_.next;
}
if(this.firstFace != this.lastFace)
{
this.lastFace.next = Face.collector;
Face.collector = this.firstFace.next;
this.firstFace.next = null;
this.lastFace = this.firstFace;
}
if(this.firstWrapper != this.lastWrapper)
{
this.lastWrapper.next = Wrapper.collector;
Wrapper.collector = this.firstWrapper.next;
this.firstWrapper.next = null;
this.lastWrapper = this.firstWrapper;
}
if(this.firstVertex != this.lastVertex)
{
this.lastVertex.next = Vertex.collector;
Vertex.collector = this.firstVertex.next;
this.firstVertex.next = null;
this.lastVertex = this.firstVertex;
}
}
alternativa3d function clearOccluders() : void
{
var _loc2_:Vertex = null;
var _loc3_:Vertex = null;
var _loc1_:int = 0;
while(_loc1_ < this.numOccluders)
{
_loc2_ = this.occluders[_loc1_];
_loc3_ = _loc2_;
while(_loc3_.next != null)
{
_loc3_ = _loc3_.next;
}
_loc3_.next = Vertex.collector;
Vertex.collector = _loc2_;
this.occluders[_loc1_] = null;
_loc1_++;
}
this.numOccluders = 0;
}
alternativa3d function sortByAverageZ(param1:Face) : Face
{
var _loc2_:int = 0;
var _loc3_:Number = NaN;
var _loc4_:Wrapper = null;
var _loc5_:Face = param1;
var _loc6_:Face = param1.processNext;
while(_loc6_ != null && _loc6_.processNext != null)
{
param1 = param1.processNext;
_loc6_ = _loc6_.processNext.processNext;
}
_loc6_ = param1.processNext;
param1.processNext = null;
if(_loc5_.processNext != null)
{
_loc5_ = this.sortByAverageZ(_loc5_);
}
else
{
_loc2_ = 0;
_loc3_ = 0;
_loc4_ = _loc5_.wrapper;
while(_loc4_ != null)
{
_loc2_++;
_loc3_ = _loc3_ + _loc4_.vertex.cameraZ;
_loc4_ = _loc4_.next;
}
_loc5_.distance = _loc3_ / _loc2_;
}
if(_loc6_.processNext != null)
{
_loc6_ = this.sortByAverageZ(_loc6_);
}
else
{
_loc2_ = 0;
_loc3_ = 0;
_loc4_ = _loc6_.wrapper;
while(_loc4_ != null)
{
_loc2_++;
_loc3_ = _loc3_ + _loc4_.vertex.cameraZ;
_loc4_ = _loc4_.next;
}
_loc6_.distance = _loc3_ / _loc2_;
}
var _loc7_:Boolean = _loc5_.distance > _loc6_.distance;
if(_loc7_)
{
param1 = _loc5_;
_loc5_ = _loc5_.processNext;
}
else
{
param1 = _loc6_;
_loc6_ = _loc6_.processNext;
}
var _loc8_:Face = param1;
while(_loc5_ != null)
{
if(_loc6_ == null)
{
_loc8_.processNext = _loc5_;
return param1;
}
if(_loc7_)
{
if(_loc5_.distance > _loc6_.distance)
{
_loc8_ = _loc5_;
_loc5_ = _loc5_.processNext;
}
else
{
_loc8_.processNext = _loc6_;
_loc8_ = _loc6_;
_loc6_ = _loc6_.processNext;
_loc7_ = false;
}
}
else if(_loc6_.distance > _loc5_.distance)
{
_loc8_ = _loc6_;
_loc6_ = _loc6_.processNext;
}
else
{
_loc8_.processNext = _loc5_;
_loc8_ = _loc5_;
_loc5_ = _loc5_.processNext;
_loc7_ = true;
}
}
_loc8_.processNext = _loc6_;
return param1;
}
alternativa3d function sortByDynamicBSP(param1:Face, param2:Number, param3:Face = null) : Face
{
var _loc4_:Wrapper = null;
var _loc5_:Vertex = null;
var _loc6_:Vertex = null;
var _loc7_:Vertex = null;
var _loc8_:Vertex = null;
var _loc23_:Face = null;
var _loc24_:Face = null;
var _loc26_:Face = null;
var _loc27_:Face = null;
var _loc28_:Face = null;
var _loc33_:Number = NaN;
var _loc34_:Number = NaN;
var _loc35_:Number = NaN;
var _loc36_:Number = NaN;
var _loc37_:Number = NaN;
var _loc38_:Number = NaN;
var _loc39_:Number = NaN;
var _loc40_:Boolean = false;
var _loc41_:Boolean = false;
var _loc42_:Number = NaN;
var _loc43_:Face = null;
var _loc44_:Face = null;
var _loc45_:Wrapper = null;
var _loc46_:Wrapper = null;
var _loc47_:Wrapper = null;
var _loc48_:Boolean = false;
var _loc49_:Number = NaN;
var _loc9_:Face = 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_:Number = NaN;
var _loc20_:Number = NaN;
var _loc21_:Number = NaN;
var _loc22_:Number = NaN;
var _loc25_:Face = null;
var _loc29_:Face = null;
_loc4_ = null;
_loc5_ = null;
_loc6_ = null;
_loc7_ = null;
_loc8_ = null;
_loc23_ = null;
_loc24_ = null;
_loc26_ = null;
_loc27_ = null;
_loc28_ = null;
var _loc30_:Number = NaN;
var _loc31_:Number = NaN;
var _loc32_:Number = NaN;
_loc33_ = NaN;
_loc34_ = NaN;
_loc35_ = NaN;
_loc36_ = NaN;
_loc37_ = NaN;
_loc38_ = NaN;
_loc39_ = NaN;
_loc40_ = false;
_loc41_ = false;
_loc42_ = NaN;
_loc43_ = null;
_loc44_ = null;
_loc45_ = null;
_loc46_ = null;
_loc47_ = null;
_loc48_ = false;
_loc49_ = NaN;
_loc9_ = param1;
param1 = _loc9_.processNext;
_loc4_ = _loc9_.wrapper;
_loc5_ = _loc4_.vertex;
_loc4_ = _loc4_.next;
_loc6_ = _loc4_.vertex;
_loc10_ = _loc5_.cameraX;
_loc11_ = _loc5_.cameraY;
_loc12_ = _loc5_.cameraZ;
_loc13_ = _loc6_.cameraX - _loc10_;
_loc14_ = _loc6_.cameraY - _loc11_;
_loc15_ = _loc6_.cameraZ - _loc12_;
_loc16_ = 0;
_loc17_ = 0;
_loc18_ = 1;
_loc19_ = _loc12_;
_loc20_ = 0;
_loc4_ = _loc4_.next;
while(_loc4_ != null)
{
_loc8_ = _loc4_.vertex;
_loc30_ = _loc8_.cameraX - _loc10_;
_loc31_ = _loc8_.cameraY - _loc11_;
_loc32_ = _loc8_.cameraZ - _loc12_;
_loc33_ = _loc32_ * _loc14_ - _loc31_ * _loc15_;
_loc34_ = _loc30_ * _loc15_ - _loc32_ * _loc13_;
_loc35_ = _loc31_ * _loc13_ - _loc30_ * _loc14_;
_loc36_ = _loc33_ * _loc33_ + _loc34_ * _loc34_ + _loc35_ * _loc35_;
if(_loc36_ > param2)
{
_loc36_ = 1 / Math.sqrt(_loc36_);
_loc16_ = _loc33_ * _loc36_;
_loc17_ = _loc34_ * _loc36_;
_loc18_ = _loc35_ * _loc36_;
_loc19_ = _loc10_ * _loc16_ + _loc11_ * _loc17_ + _loc12_ * _loc18_;
break;
}
if(_loc36_ > _loc20_)
{
_loc36_ = 1 / Math.sqrt(_loc36_);
_loc16_ = _loc33_ * _loc36_;
_loc17_ = _loc34_ * _loc36_;
_loc18_ = _loc35_ * _loc36_;
_loc19_ = _loc10_ * _loc16_ + _loc11_ * _loc17_ + _loc12_ * _loc18_;
_loc20_ = _loc36_;
}
_loc4_ = _loc4_.next;
}
_loc21_ = _loc19_ - param2;
_loc22_ = _loc19_ + param2;
_loc25_ = _loc9_;
_loc29_ = param1;
while(_loc29_ != null)
{
_loc28_ = _loc29_.processNext;
_loc4_ = _loc29_.wrapper;
_loc5_ = _loc4_.vertex;
_loc4_ = _loc4_.next;
_loc6_ = _loc4_.vertex;
_loc4_ = _loc4_.next;
_loc7_ = _loc4_.vertex;
_loc4_ = _loc4_.next;
_loc37_ = _loc5_.cameraX * _loc16_ + _loc5_.cameraY * _loc17_ + _loc5_.cameraZ * _loc18_;
_loc38_ = _loc6_.cameraX * _loc16_ + _loc6_.cameraY * _loc17_ + _loc6_.cameraZ * _loc18_;
_loc39_ = _loc7_.cameraX * _loc16_ + _loc7_.cameraY * _loc17_ + _loc7_.cameraZ * _loc18_;
_loc40_ = _loc37_ < _loc21_ || _loc38_ < _loc21_ || _loc39_ < _loc21_;
_loc41_ = _loc37_ > _loc22_ || _loc38_ > _loc22_ || _loc39_ > _loc22_;
while(_loc4_ != null)
{
_loc8_ = _loc4_.vertex;
_loc42_ = _loc8_.cameraX * _loc16_ + _loc8_.cameraY * _loc17_ + _loc8_.cameraZ * _loc18_;
if(_loc42_ < _loc21_)
{
_loc40_ = true;
}
else if(_loc42_ > _loc22_)
{
_loc41_ = true;
}
_loc8_.offset = _loc42_;
_loc4_ = _loc4_.next;
}
if(!_loc40_)
{
if(!_loc41_)
{
_loc25_.processNext = _loc29_;
_loc25_ = _loc29_;
}
else
{
if(_loc26_ != null)
{
_loc27_.processNext = _loc29_;
}
else
{
_loc26_ = _loc29_;
}
_loc27_ = _loc29_;
}
}
else if(!_loc41_)
{
if(_loc23_ != null)
{
_loc24_.processNext = _loc29_;
}
else
{
_loc23_ = _loc29_;
}
_loc24_ = _loc29_;
}
else
{
_loc5_.offset = _loc37_;
_loc6_.offset = _loc38_;
_loc7_.offset = _loc39_;
_loc43_ = _loc29_.create();
_loc43_.material = _loc29_.material;
this.lastFace.next = _loc43_;
this.lastFace = _loc43_;
_loc44_ = _loc29_.create();
_loc44_.material = _loc29_.material;
this.lastFace.next = _loc44_;
this.lastFace = _loc44_;
_loc45_ = null;
_loc46_ = null;
_loc4_ = _loc29_.wrapper.next.next;
while(_loc4_.next != null)
{
_loc4_ = _loc4_.next;
}
_loc5_ = _loc4_.vertex;
_loc37_ = _loc5_.offset;
_loc48_ = _loc29_.material != null && _loc29_.material.useVerticesNormals;
_loc4_ = _loc29_.wrapper;
while(_loc4_ != null)
{
_loc6_ = _loc4_.vertex;
_loc38_ = _loc6_.offset;
if(_loc37_ < _loc21_ && _loc38_ > _loc22_ || _loc37_ > _loc22_ && _loc38_ < _loc21_)
{
_loc49_ = (_loc19_ - _loc37_) / (_loc38_ - _loc37_);
_loc8_ = _loc6_.create();
this.lastVertex.next = _loc8_;
this.lastVertex = _loc8_;
_loc8_.cameraX = _loc5_.cameraX + (_loc6_.cameraX - _loc5_.cameraX) * _loc49_;
_loc8_.cameraY = _loc5_.cameraY + (_loc6_.cameraY - _loc5_.cameraY) * _loc49_;
_loc8_.cameraZ = _loc5_.cameraZ + (_loc6_.cameraZ - _loc5_.cameraZ) * _loc49_;
_loc8_.u = _loc5_.u + (_loc6_.u - _loc5_.u) * _loc49_;
_loc8_.v = _loc5_.v + (_loc6_.v - _loc5_.v) * _loc49_;
if(_loc48_)
{
_loc8_.x = _loc5_.x + (_loc6_.x - _loc5_.x) * _loc49_;
_loc8_.y = _loc5_.y + (_loc6_.y - _loc5_.y) * _loc49_;
_loc8_.z = _loc5_.z + (_loc6_.z - _loc5_.z) * _loc49_;
_loc8_.normalX = _loc5_.normalX + (_loc6_.normalX - _loc5_.normalX) * _loc49_;
_loc8_.normalY = _loc5_.normalY + (_loc6_.normalY - _loc5_.normalY) * _loc49_;
_loc8_.normalZ = _loc5_.normalZ + (_loc6_.normalZ - _loc5_.normalZ) * _loc49_;
}
_loc47_ = _loc4_.create();
_loc47_.vertex = _loc8_;
if(_loc45_ != null)
{
_loc45_.next = _loc47_;
}
else
{
_loc43_.wrapper = _loc47_;
}
_loc45_ = _loc47_;
_loc47_ = _loc4_.create();
_loc47_.vertex = _loc8_;
if(_loc46_ != null)
{
_loc46_.next = _loc47_;
}
else
{
_loc44_.wrapper = _loc47_;
}
_loc46_ = _loc47_;
}
if(_loc38_ <= _loc22_)
{
_loc47_ = _loc4_.create();
_loc47_.vertex = _loc6_;
if(_loc45_ != null)
{
_loc45_.next = _loc47_;
}
else
{
_loc43_.wrapper = _loc47_;
}
_loc45_ = _loc47_;
}
if(_loc38_ >= _loc21_)
{
_loc47_ = _loc4_.create();
_loc47_.vertex = _loc6_;
if(_loc46_ != null)
{
_loc46_.next = _loc47_;
}
else
{
_loc44_.wrapper = _loc47_;
}
_loc46_ = _loc47_;
}
_loc5_ = _loc6_;
_loc37_ = _loc38_;
_loc4_ = _loc4_.next;
}
if(_loc23_ != null)
{
_loc24_.processNext = _loc43_;
}
else
{
_loc23_ = _loc43_;
}
_loc24_ = _loc43_;
if(_loc26_ != null)
{
_loc27_.processNext = _loc44_;
}
else
{
_loc26_ = _loc44_;
}
_loc27_ = _loc44_;
_loc29_.processNext = null;
}
_loc29_ = _loc28_;
}
if(_loc26_ != null)
{
_loc27_.processNext = null;
if(_loc26_.processNext != null)
{
param3 = this.sortByDynamicBSP(_loc26_,param2,param3);
}
else
{
_loc26_.processNext = param3;
param3 = _loc26_;
}
}
_loc25_.processNext = param3;
param3 = _loc9_;
if(_loc23_ != null)
{
_loc24_.processNext = null;
if(_loc23_.processNext != null)
{
param3 = this.sortByDynamicBSP(_loc23_,param2,param3);
}
else
{
_loc23_.processNext = param3;
param3 = _loc23_;
}
}
return param3;
}
alternativa3d function cull(param1:Face, param2:int) : Face
{
var _loc3_:Face = null;
var _loc4_:Face = null;
var _loc5_:Face = null;
var _loc6_:Vertex = null;
var _loc7_:Vertex = null;
var _loc8_:Vertex = null;
var _loc9_:Wrapper = null;
var _loc10_:Vertex = null;
var _loc11_:Wrapper = null;
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_:Number = NaN;
var _loc20_:Number = NaN;
var _loc21_:Boolean = false;
var _loc22_:Boolean = false;
var _loc23_:Boolean = false;
var _loc24_:Boolean = false;
var _loc25_:Boolean = false;
var _loc26_:Boolean = false;
var _loc27_:Number = NaN;
var _loc28_:Number = NaN;
var _loc29_:Boolean = false;
var _loc30_:Boolean = false;
var _loc31_:Face = null;
_loc3_ = null;
_loc4_ = null;
_loc5_ = null;
_loc6_ = null;
_loc7_ = null;
_loc8_ = null;
_loc9_ = null;
_loc10_ = null;
_loc11_ = null;
_loc12_ = NaN;
_loc13_ = NaN;
_loc14_ = NaN;
_loc15_ = NaN;
_loc16_ = NaN;
_loc17_ = NaN;
_loc18_ = NaN;
_loc19_ = NaN;
_loc20_ = NaN;
_loc21_ = (param2 & 1) > 0;
_loc22_ = (param2 & 2) > 0;
_loc23_ = (param2 & 4) > 0;
_loc24_ = (param2 & 8) > 0;
_loc25_ = (param2 & 16) > 0;
_loc26_ = (param2 & 32) > 0;
_loc27_ = this.nearClipping;
_loc28_ = this.farClipping;
_loc29_ = _loc23_ || _loc24_;
_loc30_ = _loc25_ || _loc26_;
for(_loc31_ = param1; _loc31_ != null; _loc31_ = _loc5_)
{
_loc5_ = _loc31_.processNext;
_loc9_ = _loc31_.wrapper;
_loc6_ = _loc9_.vertex;
_loc9_ = _loc9_.next;
_loc7_ = _loc9_.vertex;
_loc9_ = _loc9_.next;
_loc8_ = _loc9_.vertex;
_loc9_ = _loc9_.next;
if(_loc29_)
{
_loc12_ = _loc6_.cameraX;
_loc15_ = _loc7_.cameraX;
_loc18_ = _loc8_.cameraX;
}
if(_loc30_)
{
_loc13_ = _loc6_.cameraY;
_loc16_ = _loc7_.cameraY;
_loc19_ = _loc8_.cameraY;
}
_loc14_ = _loc6_.cameraZ;
_loc17_ = _loc7_.cameraZ;
_loc20_ = _loc8_.cameraZ;
if(_loc21_)
{
if(_loc14_ <= _loc27_ || _loc17_ <= _loc27_ || _loc20_ <= _loc27_)
{
_loc31_.processNext = null;
continue;
}
_loc11_ = _loc9_;
while(_loc11_ != null)
{
if(_loc11_.vertex.cameraZ <= _loc27_)
{
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ != null)
{
_loc31_.processNext = null;
continue;
}
}
if(_loc22_ && _loc14_ >= _loc28_ && _loc17_ >= _loc28_ && _loc20_ >= _loc28_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
if(_loc11_.vertex.cameraZ < _loc28_)
{
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc31_.processNext = null;
continue;
}
}
if(_loc23_ && _loc14_ <= -_loc12_ && _loc17_ <= -_loc15_ && _loc20_ <= -_loc18_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(-_loc10_.cameraX < _loc10_.cameraZ)
{
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc31_.processNext = null;
continue;
}
}
if(_loc24_ && _loc14_ <= _loc12_ && _loc17_ <= _loc15_ && _loc20_ <= _loc18_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(_loc10_.cameraX < _loc10_.cameraZ)
{
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc31_.processNext = null;
continue;
}
}
if(_loc25_ && _loc14_ <= -_loc13_ && _loc17_ <= -_loc16_ && _loc20_ <= -_loc19_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(-_loc10_.cameraY < _loc10_.cameraZ)
{
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc31_.processNext = null;
continue;
}
}
if(_loc26_ && _loc14_ <= _loc13_ && _loc17_ <= _loc16_ && _loc20_ <= _loc19_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(_loc10_.cameraY < _loc10_.cameraZ)
{
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc31_.processNext = null;
continue;
}
}
if(_loc3_ != null)
{
_loc4_.processNext = _loc31_;
}
else
{
_loc3_ = _loc31_;
}
_loc4_ = _loc31_;
}
if(_loc4_ != null)
{
_loc4_.processNext = null;
}
return _loc3_;
}
alternativa3d function clip(param1:Face, param2:int) : Face
{
var _loc3_:Face = null;
var _loc4_:Face = null;
var _loc5_:Face = null;
var _loc6_:Vertex = null;
var _loc7_:Vertex = null;
var _loc8_:Vertex = null;
var _loc9_:Wrapper = null;
var _loc10_:Vertex = null;
var _loc11_:Wrapper = null;
var _loc12_:Wrapper = null;
var _loc13_:Wrapper = null;
var _loc14_:Wrapper = null;
var _loc15_:Wrapper = null;
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_:Number = NaN;
var _loc25_:Boolean = false;
var _loc26_:Boolean = false;
var _loc27_:Boolean = false;
var _loc28_:Boolean = false;
var _loc29_:Boolean = false;
var _loc30_:Boolean = false;
var _loc31_:Number = NaN;
var _loc32_:Number = NaN;
var _loc33_:Boolean = false;
var _loc34_:Boolean = false;
var _loc35_:int = 0;
var _loc36_:Number = NaN;
var _loc37_:Face = null;
var _loc38_:Boolean = false;
var _loc39_:Face = null;
_loc3_ = null;
_loc4_ = null;
_loc5_ = null;
_loc6_ = null;
_loc7_ = null;
_loc8_ = null;
_loc9_ = null;
_loc10_ = null;
_loc11_ = null;
_loc12_ = null;
_loc13_ = null;
_loc14_ = null;
_loc15_ = null;
_loc16_ = NaN;
_loc17_ = NaN;
_loc18_ = NaN;
_loc19_ = NaN;
_loc20_ = NaN;
_loc21_ = NaN;
_loc22_ = NaN;
_loc23_ = NaN;
_loc24_ = NaN;
_loc25_ = false;
_loc26_ = false;
_loc27_ = false;
_loc28_ = false;
_loc29_ = false;
_loc30_ = false;
_loc31_ = NaN;
_loc32_ = NaN;
_loc33_ = false;
_loc34_ = false;
_loc35_ = 0;
_loc36_ = NaN;
_loc37_ = null;
_loc38_ = false;
_loc39_ = null;
_loc25_ = (param2 & 1) > 0;
_loc26_ = (param2 & 2) > 0;
_loc27_ = (param2 & 4) > 0;
_loc28_ = (param2 & 8) > 0;
_loc29_ = (param2 & 16) > 0;
_loc30_ = (param2 & 32) > 0;
_loc31_ = this.nearClipping;
_loc32_ = this.farClipping;
_loc33_ = _loc27_ || _loc28_;
_loc34_ = _loc29_ || _loc30_;
for(_loc37_ = param1; _loc37_ != null; _loc37_ = _loc5_)
{
_loc5_ = _loc37_.processNext;
_loc9_ = _loc37_.wrapper;
_loc6_ = _loc9_.vertex;
_loc9_ = _loc9_.next;
_loc7_ = _loc9_.vertex;
_loc9_ = _loc9_.next;
_loc8_ = _loc9_.vertex;
_loc9_ = _loc9_.next;
if(_loc33_)
{
_loc16_ = _loc6_.cameraX;
_loc19_ = _loc7_.cameraX;
_loc22_ = _loc8_.cameraX;
}
if(_loc34_)
{
_loc17_ = _loc6_.cameraY;
_loc20_ = _loc7_.cameraY;
_loc23_ = _loc8_.cameraY;
}
_loc18_ = _loc6_.cameraZ;
_loc21_ = _loc7_.cameraZ;
_loc24_ = _loc8_.cameraZ;
_loc35_ = 0;
if(_loc25_)
{
if(_loc18_ <= _loc31_ && _loc21_ <= _loc31_ && _loc24_ <= _loc31_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
if(_loc11_.vertex.cameraZ > _loc31_)
{
_loc35_ = _loc35_ | 1;
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc37_.processNext = null;
continue;
}
}
else if(_loc18_ > _loc31_ && _loc21_ > _loc31_ && _loc24_ > _loc31_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
if(_loc11_.vertex.cameraZ <= _loc31_)
{
_loc35_ = _loc35_ | 1;
break;
}
_loc11_ = _loc11_.next;
}
}
else
{
_loc35_ = _loc35_ | 1;
}
}
if(_loc26_)
{
if(_loc18_ >= _loc32_ && _loc21_ >= _loc32_ && _loc24_ >= _loc32_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
if(_loc11_.vertex.cameraZ < _loc32_)
{
_loc35_ = _loc35_ | 2;
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc37_.processNext = null;
continue;
}
}
else if(_loc18_ < _loc32_ && _loc21_ < _loc32_ && _loc24_ < _loc32_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
if(_loc11_.vertex.cameraZ >= _loc32_)
{
_loc35_ = _loc35_ | 2;
break;
}
_loc11_ = _loc11_.next;
}
}
else
{
_loc35_ = _loc35_ | 2;
}
}
if(_loc27_)
{
if(_loc18_ <= -_loc16_ && _loc21_ <= -_loc19_ && _loc24_ <= -_loc22_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(-_loc10_.cameraX < _loc10_.cameraZ)
{
_loc35_ = _loc35_ | 4;
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc37_.processNext = null;
continue;
}
}
else if(_loc18_ > -_loc16_ && _loc21_ > -_loc19_ && _loc24_ > -_loc22_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(-_loc10_.cameraX >= _loc10_.cameraZ)
{
_loc35_ = _loc35_ | 4;
break;
}
_loc11_ = _loc11_.next;
}
}
else
{
_loc35_ = _loc35_ | 4;
}
}
if(_loc28_)
{
if(_loc18_ <= _loc16_ && _loc21_ <= _loc19_ && _loc24_ <= _loc22_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(_loc10_.cameraX < _loc10_.cameraZ)
{
_loc35_ = _loc35_ | 8;
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc37_.processNext = null;
continue;
}
}
else if(_loc18_ > _loc16_ && _loc21_ > _loc19_ && _loc24_ > _loc22_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(_loc10_.cameraX >= _loc10_.cameraZ)
{
_loc35_ = _loc35_ | 8;
break;
}
_loc11_ = _loc11_.next;
}
}
else
{
_loc35_ = _loc35_ | 8;
}
}
if(_loc29_)
{
if(_loc18_ <= -_loc17_ && _loc21_ <= -_loc20_ && _loc24_ <= -_loc23_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(-_loc10_.cameraY < _loc10_.cameraZ)
{
_loc35_ = _loc35_ | 16;
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc37_.processNext = null;
continue;
}
}
else if(_loc18_ > -_loc17_ && _loc21_ > -_loc20_ && _loc24_ > -_loc23_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(-_loc10_.cameraY >= _loc10_.cameraZ)
{
_loc35_ = _loc35_ | 16;
break;
}
_loc11_ = _loc11_.next;
}
}
else
{
_loc35_ = _loc35_ | 16;
}
}
if(_loc30_)
{
if(_loc18_ <= _loc17_ && _loc21_ <= _loc20_ && _loc24_ <= _loc23_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(_loc10_.cameraY < _loc10_.cameraZ)
{
_loc35_ = _loc35_ | 32;
break;
}
_loc11_ = _loc11_.next;
}
if(_loc11_ == null)
{
_loc37_.processNext = null;
continue;
}
}
else if(_loc18_ > _loc17_ && _loc21_ > _loc20_ && _loc24_ > _loc23_)
{
_loc11_ = _loc9_;
while(_loc11_ != null)
{
_loc10_ = _loc11_.vertex;
if(_loc10_.cameraY >= _loc10_.cameraZ)
{
_loc35_ = _loc35_ | 32;
break;
}
_loc11_ = _loc11_.next;
}
}
else
{
_loc35_ = _loc35_ | 32;
}
}
if(_loc35_ > 0)
{
_loc38_ = _loc37_.material != null && _loc37_.material.useVerticesNormals;
_loc12_ = null;
_loc13_ = null;
_loc11_ = _loc37_.wrapper;
while(_loc11_ != null)
{
_loc15_ = _loc11_.create();
_loc15_.vertex = _loc11_.vertex;
if(_loc12_ != null)
{
_loc13_.next = _loc15_;
}
else
{
_loc12_ = _loc15_;
}
_loc13_ = _loc15_;
_loc11_ = _loc11_.next;
}
if(_loc35_ & 1)
{
_loc6_ = _loc13_.vertex;
_loc18_ = _loc6_.cameraZ;
_loc11_ = _loc12_;
_loc12_ = null;
_loc13_ = null;
while(_loc11_ != null)
{
_loc14_ = _loc11_.next;
_loc7_ = _loc11_.vertex;
_loc21_ = _loc7_.cameraZ;
if(_loc21_ > _loc31_ && _loc18_ <= _loc31_ || _loc21_ <= _loc31_ && _loc18_ > _loc31_)
{
_loc36_ = (_loc31_ - _loc18_) / (_loc21_ - _loc18_);
_loc10_ = _loc7_.create();
this.lastVertex.next = _loc10_;
this.lastVertex = _loc10_;
_loc10_.cameraX = _loc6_.cameraX + (_loc7_.cameraX - _loc6_.cameraX) * _loc36_;
_loc10_.cameraY = _loc6_.cameraY + (_loc7_.cameraY - _loc6_.cameraY) * _loc36_;
_loc10_.cameraZ = _loc18_ + (_loc21_ - _loc18_) * _loc36_;
_loc10_.x = _loc6_.x + (_loc7_.x - _loc6_.x) * _loc36_;
_loc10_.y = _loc6_.y + (_loc7_.y - _loc6_.y) * _loc36_;
_loc10_.z = _loc6_.z + (_loc7_.z - _loc6_.z) * _loc36_;
_loc10_.u = _loc6_.u + (_loc7_.u - _loc6_.u) * _loc36_;
_loc10_.v = _loc6_.v + (_loc7_.v - _loc6_.v) * _loc36_;
if(_loc38_)
{
_loc10_.normalX = _loc6_.normalX + (_loc7_.normalX - _loc6_.normalX) * _loc36_;
_loc10_.normalY = _loc6_.normalY + (_loc7_.normalY - _loc6_.normalY) * _loc36_;
_loc10_.normalZ = _loc6_.normalZ + (_loc7_.normalZ - _loc6_.normalZ) * _loc36_;
}
_loc15_ = _loc11_.create();
_loc15_.vertex = _loc10_;
if(_loc12_ != null)
{
_loc13_.next = _loc15_;
}
else
{
_loc12_ = _loc15_;
}
_loc13_ = _loc15_;
}
if(_loc21_ > _loc31_)
{
if(_loc12_ != null)
{
_loc13_.next = _loc11_;
}
else
{
_loc12_ = _loc11_;
}
_loc13_ = _loc11_;
_loc11_.next = null;
}
else
{
_loc11_.vertex = null;
_loc11_.next = Wrapper.collector;
Wrapper.collector = _loc11_;
}
_loc6_ = _loc7_;
_loc18_ = _loc21_;
_loc11_ = _loc14_;
}
if(_loc12_ == null)
{
_loc37_.processNext = null;
continue;
}
}
if(_loc35_ & 2)
{
_loc6_ = _loc13_.vertex;
_loc18_ = _loc6_.cameraZ;
_loc11_ = _loc12_;
_loc12_ = null;
_loc13_ = null;
while(_loc11_ != null)
{
_loc14_ = _loc11_.next;
_loc7_ = _loc11_.vertex;
_loc21_ = _loc7_.cameraZ;
if(_loc21_ < _loc32_ && _loc18_ >= _loc32_ || _loc21_ >= _loc32_ && _loc18_ < _loc32_)
{
_loc36_ = (_loc32_ - _loc18_) / (_loc21_ - _loc18_);
_loc10_ = _loc7_.create();
this.lastVertex.next = _loc10_;
this.lastVertex = _loc10_;
_loc10_.cameraX = _loc6_.cameraX + (_loc7_.cameraX - _loc6_.cameraX) * _loc36_;
_loc10_.cameraY = _loc6_.cameraY + (_loc7_.cameraY - _loc6_.cameraY) * _loc36_;
_loc10_.cameraZ = _loc18_ + (_loc21_ - _loc18_) * _loc36_;
_loc10_.x = _loc6_.x + (_loc7_.x - _loc6_.x) * _loc36_;
_loc10_.y = _loc6_.y + (_loc7_.y - _loc6_.y) * _loc36_;
_loc10_.z = _loc6_.z + (_loc7_.z - _loc6_.z) * _loc36_;
_loc10_.u = _loc6_.u + (_loc7_.u - _loc6_.u) * _loc36_;
_loc10_.v = _loc6_.v + (_loc7_.v - _loc6_.v) * _loc36_;
if(_loc38_)
{
_loc10_.normalX = _loc6_.normalX + (_loc7_.normalX - _loc6_.normalX) * _loc36_;
_loc10_.normalY = _loc6_.normalY + (_loc7_.normalY - _loc6_.normalY) * _loc36_;
_loc10_.normalZ = _loc6_.normalZ + (_loc7_.normalZ - _loc6_.normalZ) * _loc36_;
}
_loc15_ = _loc11_.create();
_loc15_.vertex = _loc10_;
if(_loc12_ != null)
{
_loc13_.next = _loc15_;
}
else
{
_loc12_ = _loc15_;
}
_loc13_ = _loc15_;
}
if(_loc21_ < _loc32_)
{
if(_loc12_ != null)
{
_loc13_.next = _loc11_;
}
else
{
_loc12_ = _loc11_;
}
_loc13_ = _loc11_;
_loc11_.next = null;
}
else
{
_loc11_.vertex = null;
_loc11_.next = Wrapper.collector;
Wrapper.collector = _loc11_;
}
_loc6_ = _loc7_;
_loc18_ = _loc21_;
_loc11_ = _loc14_;
}
if(_loc12_ == null)
{
_loc37_.processNext = null;
continue;
}
}
if(_loc35_ & 4)
{
_loc6_ = _loc13_.vertex;
_loc16_ = _loc6_.cameraX;
_loc18_ = _loc6_.cameraZ;
_loc11_ = _loc12_;
_loc12_ = null;
_loc13_ = null;
while(_loc11_ != null)
{
_loc14_ = _loc11_.next;
_loc7_ = _loc11_.vertex;
_loc19_ = _loc7_.cameraX;
_loc21_ = _loc7_.cameraZ;
if(_loc21_ > -_loc19_ && _loc18_ <= -_loc16_ || _loc21_ <= -_loc19_ && _loc18_ > -_loc16_)
{
_loc36_ = (_loc16_ + _loc18_) / (_loc16_ + _loc18_ - _loc19_ - _loc21_);
_loc10_ = _loc7_.create();
this.lastVertex.next = _loc10_;
this.lastVertex = _loc10_;
_loc10_.cameraX = _loc16_ + (_loc19_ - _loc16_) * _loc36_;
_loc10_.cameraY = _loc6_.cameraY + (_loc7_.cameraY - _loc6_.cameraY) * _loc36_;
_loc10_.cameraZ = _loc18_ + (_loc21_ - _loc18_) * _loc36_;
_loc10_.x = _loc6_.x + (_loc7_.x - _loc6_.x) * _loc36_;
_loc10_.y = _loc6_.y + (_loc7_.y - _loc6_.y) * _loc36_;
_loc10_.z = _loc6_.z + (_loc7_.z - _loc6_.z) * _loc36_;
_loc10_.u = _loc6_.u + (_loc7_.u - _loc6_.u) * _loc36_;
_loc10_.v = _loc6_.v + (_loc7_.v - _loc6_.v) * _loc36_;
if(_loc38_)
{
_loc10_.normalX = _loc6_.normalX + (_loc7_.normalX - _loc6_.normalX) * _loc36_;
_loc10_.normalY = _loc6_.normalY + (_loc7_.normalY - _loc6_.normalY) * _loc36_;
_loc10_.normalZ = _loc6_.normalZ + (_loc7_.normalZ - _loc6_.normalZ) * _loc36_;
}
_loc15_ = _loc11_.create();
_loc15_.vertex = _loc10_;
if(_loc12_ != null)
{
_loc13_.next = _loc15_;
}
else
{
_loc12_ = _loc15_;
}
_loc13_ = _loc15_;
}
if(_loc21_ > -_loc19_)
{
if(_loc12_ != null)
{
_loc13_.next = _loc11_;
}
else
{
_loc12_ = _loc11_;
}
_loc13_ = _loc11_;
_loc11_.next = null;
}
else
{
_loc11_.vertex = null;
_loc11_.next = Wrapper.collector;
Wrapper.collector = _loc11_;
}
_loc6_ = _loc7_;
_loc16_ = _loc19_;
_loc18_ = _loc21_;
_loc11_ = _loc14_;
}
if(_loc12_ == null)
{
_loc37_.processNext = null;
continue;
}
}
if(_loc35_ & 8)
{
_loc6_ = _loc13_.vertex;
_loc16_ = _loc6_.cameraX;
_loc18_ = _loc6_.cameraZ;
_loc11_ = _loc12_;
_loc12_ = null;
_loc13_ = null;
while(_loc11_ != null)
{
_loc14_ = _loc11_.next;
_loc7_ = _loc11_.vertex;
_loc19_ = _loc7_.cameraX;
_loc21_ = _loc7_.cameraZ;
if(_loc21_ > _loc19_ && _loc18_ <= _loc16_ || _loc21_ <= _loc19_ && _loc18_ > _loc16_)
{
_loc36_ = (_loc18_ - _loc16_) / (_loc18_ - _loc16_ + _loc19_ - _loc21_);
_loc10_ = _loc7_.create();
this.lastVertex.next = _loc10_;
this.lastVertex = _loc10_;
_loc10_.cameraX = _loc16_ + (_loc19_ - _loc16_) * _loc36_;
_loc10_.cameraY = _loc6_.cameraY + (_loc7_.cameraY - _loc6_.cameraY) * _loc36_;
_loc10_.cameraZ = _loc18_ + (_loc21_ - _loc18_) * _loc36_;
_loc10_.x = _loc6_.x + (_loc7_.x - _loc6_.x) * _loc36_;
_loc10_.y = _loc6_.y + (_loc7_.y - _loc6_.y) * _loc36_;
_loc10_.z = _loc6_.z + (_loc7_.z - _loc6_.z) * _loc36_;
_loc10_.u = _loc6_.u + (_loc7_.u - _loc6_.u) * _loc36_;
_loc10_.v = _loc6_.v + (_loc7_.v - _loc6_.v) * _loc36_;
if(_loc38_)
{
_loc10_.normalX = _loc6_.normalX + (_loc7_.normalX - _loc6_.normalX) * _loc36_;
_loc10_.normalY = _loc6_.normalY + (_loc7_.normalY - _loc6_.normalY) * _loc36_;
_loc10_.normalZ = _loc6_.normalZ + (_loc7_.normalZ - _loc6_.normalZ) * _loc36_;
}
_loc15_ = _loc11_.create();
_loc15_.vertex = _loc10_;
if(_loc12_ != null)
{
_loc13_.next = _loc15_;
}
else
{
_loc12_ = _loc15_;
}
_loc13_ = _loc15_;
}
if(_loc21_ > _loc19_)
{
if(_loc12_ != null)
{
_loc13_.next = _loc11_;
}
else
{
_loc12_ = _loc11_;
}
_loc13_ = _loc11_;
_loc11_.next = null;
}
else
{
_loc11_.vertex = null;
_loc11_.next = Wrapper.collector;
Wrapper.collector = _loc11_;
}
_loc6_ = _loc7_;
_loc16_ = _loc19_;
_loc18_ = _loc21_;
_loc11_ = _loc14_;
}
if(_loc12_ == null)
{
_loc37_.processNext = null;
continue;
}
}
if(_loc35_ & 16)
{
_loc6_ = _loc13_.vertex;
_loc17_ = _loc6_.cameraY;
_loc18_ = _loc6_.cameraZ;
_loc11_ = _loc12_;
_loc12_ = null;
_loc13_ = null;
while(_loc11_ != null)
{
_loc14_ = _loc11_.next;
_loc7_ = _loc11_.vertex;
_loc20_ = _loc7_.cameraY;
_loc21_ = _loc7_.cameraZ;
if(_loc21_ > -_loc20_ && _loc18_ <= -_loc17_ || _loc21_ <= -_loc20_ && _loc18_ > -_loc17_)
{
_loc36_ = (_loc17_ + _loc18_) / (_loc17_ + _loc18_ - _loc20_ - _loc21_);
_loc10_ = _loc7_.create();
this.lastVertex.next = _loc10_;
this.lastVertex = _loc10_;
_loc10_.cameraX = _loc6_.cameraX + (_loc7_.cameraX - _loc6_.cameraX) * _loc36_;
_loc10_.cameraY = _loc17_ + (_loc20_ - _loc17_) * _loc36_;
_loc10_.cameraZ = _loc18_ + (_loc21_ - _loc18_) * _loc36_;
_loc10_.x = _loc6_.x + (_loc7_.x - _loc6_.x) * _loc36_;
_loc10_.y = _loc6_.y + (_loc7_.y - _loc6_.y) * _loc36_;
_loc10_.z = _loc6_.z + (_loc7_.z - _loc6_.z) * _loc36_;
_loc10_.u = _loc6_.u + (_loc7_.u - _loc6_.u) * _loc36_;
_loc10_.v = _loc6_.v + (_loc7_.v - _loc6_.v) * _loc36_;
if(_loc38_)
{
_loc10_.normalX = _loc6_.normalX + (_loc7_.normalX - _loc6_.normalX) * _loc36_;
_loc10_.normalY = _loc6_.normalY + (_loc7_.normalY - _loc6_.normalY) * _loc36_;
_loc10_.normalZ = _loc6_.normalZ + (_loc7_.normalZ - _loc6_.normalZ) * _loc36_;
}
_loc15_ = _loc11_.create();
_loc15_.vertex = _loc10_;
if(_loc12_ != null)
{
_loc13_.next = _loc15_;
}
else
{
_loc12_ = _loc15_;
}
_loc13_ = _loc15_;
}
if(_loc21_ > -_loc20_)
{
if(_loc12_ != null)
{
_loc13_.next = _loc11_;
}
else
{
_loc12_ = _loc11_;
}
_loc13_ = _loc11_;
_loc11_.next = null;
}
else
{
_loc11_.vertex = null;
_loc11_.next = Wrapper.collector;
Wrapper.collector = _loc11_;
}
_loc6_ = _loc7_;
_loc17_ = _loc20_;
_loc18_ = _loc21_;
_loc11_ = _loc14_;
}
if(_loc12_ == null)
{
_loc37_.processNext = null;
continue;
}
}
if(_loc35_ & 32)
{
_loc6_ = _loc13_.vertex;
_loc17_ = _loc6_.cameraY;
_loc18_ = _loc6_.cameraZ;
_loc11_ = _loc12_;
_loc12_ = null;
_loc13_ = null;
while(_loc11_ != null)
{
_loc14_ = _loc11_.next;
_loc7_ = _loc11_.vertex;
_loc20_ = _loc7_.cameraY;
_loc21_ = _loc7_.cameraZ;
if(_loc21_ > _loc20_ && _loc18_ <= _loc17_ || _loc21_ <= _loc20_ && _loc18_ > _loc17_)
{
_loc36_ = (_loc18_ - _loc17_) / (_loc18_ - _loc17_ + _loc20_ - _loc21_);
_loc10_ = _loc7_.create();
this.lastVertex.next = _loc10_;
this.lastVertex = _loc10_;
_loc10_.cameraX = _loc6_.cameraX + (_loc7_.cameraX - _loc6_.cameraX) * _loc36_;
_loc10_.cameraY = _loc17_ + (_loc20_ - _loc17_) * _loc36_;
_loc10_.cameraZ = _loc18_ + (_loc21_ - _loc18_) * _loc36_;
_loc10_.x = _loc6_.x + (_loc7_.x - _loc6_.x) * _loc36_;
_loc10_.y = _loc6_.y + (_loc7_.y - _loc6_.y) * _loc36_;
_loc10_.z = _loc6_.z + (_loc7_.z - _loc6_.z) * _loc36_;
_loc10_.u = _loc6_.u + (_loc7_.u - _loc6_.u) * _loc36_;
_loc10_.v = _loc6_.v + (_loc7_.v - _loc6_.v) * _loc36_;
if(_loc38_)
{
_loc10_.normalX = _loc6_.normalX + (_loc7_.normalX - _loc6_.normalX) * _loc36_;
_loc10_.normalY = _loc6_.normalY + (_loc7_.normalY - _loc6_.normalY) * _loc36_;
_loc10_.normalZ = _loc6_.normalZ + (_loc7_.normalZ - _loc6_.normalZ) * _loc36_;
}
_loc15_ = _loc11_.create();
_loc15_.vertex = _loc10_;
if(_loc12_ != null)
{
_loc13_.next = _loc15_;
}
else
{
_loc12_ = _loc15_;
}
_loc13_ = _loc15_;
}
if(_loc21_ > _loc20_)
{
if(_loc12_ != null)
{
_loc13_.next = _loc11_;
}
else
{
_loc12_ = _loc11_;
}
_loc13_ = _loc11_;
_loc11_.next = null;
}
else
{
_loc11_.vertex = null;
_loc11_.next = Wrapper.collector;
Wrapper.collector = _loc11_;
}
_loc6_ = _loc7_;
_loc17_ = _loc20_;
_loc18_ = _loc21_;
_loc11_ = _loc14_;
}
if(_loc12_ == null)
{
_loc37_.processNext = null;
continue;
}
}
_loc37_.processNext = null;
_loc39_ = _loc37_.create();
_loc39_.material = _loc37_.material;
this.lastFace.next = _loc39_;
this.lastFace = _loc39_;
_loc39_.wrapper = _loc12_;
_loc37_ = _loc39_;
}
if(_loc3_ != null)
{
_loc4_.processNext = _loc37_;
}
else
{
_loc3_ = _loc37_;
}
_loc4_ = _loc37_;
}
if(_loc4_ != null)
{
_loc4_.processNext = null;
}
return _loc3_;
}
}
}
|
package alternativa.tanks.gui.friends.list.refferals {
import flash.display.Bitmap;
import flash.display.Sprite;
public class ReferalStatLineBackgroundSelected extends Sprite {
public static var bg:Bitmap = new Bitmap();
public function ReferalStatLineBackgroundSelected() {
super();
addChild(new Bitmap(bg.bitmapData));
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.KillMessageOutputLine_artilleryIconClass.png")]
public class KillMessageOutputLine_artilleryIconClass extends BitmapAsset {
public function KillMessageOutputLine_artilleryIconClass() {
super();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.