code
stringlengths 57
237k
|
|---|
package alternativa.engine3d.loaders.collada {
use namespace collada;
public class DaeVisualScene extends DaeElement {
public var nodes:Vector.<DaeNode>;
public function DaeVisualScene(param1:XML, param2:DaeDocument) {
super(param1,param2);
this.constructNodes();
}
public function constructNodes() : void {
var local4:DaeNode = null;
var local1:XMLList = data.node;
var local2:int = int(local1.length());
this.nodes = new Vector.<DaeNode>(local2);
var local3:int = 0;
while(local3 < local2) {
local4 = new DaeNode(local1[local3],document,this);
if(local4.id != null) {
document.nodes[local4.id] = local4;
}
this.nodes[local3] = local4;
local3++;
}
}
}
}
|
package platform.client.fp10.core {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.command.CommandService;
import alternativa.osgi.service.command.FormattedOutput;
import alternativa.types.Long;
import flash.system.System;
import flash.utils.getQualifiedClassName;
import platform.client.fp10.core.registry.GameTypeRegistry;
import platform.client.fp10.core.registry.ModelRegistry;
import platform.client.fp10.core.registry.ResourceRegistry;
import platform.client.fp10.core.registry.SpaceRegistry;
import platform.client.fp10.core.resource.Resource;
import platform.client.fp10.core.service.transport.ITransportService;
import platform.client.fp10.core.type.IGameClass;
import platform.client.fp10.core.type.IGameObject;
import platform.client.fp10.core.type.ISpace;
public class CoreCommands {
[Inject]
public static var gameTypeRegistry:GameTypeRegistry;
[Inject]
public static var modelRegister:ModelRegistry;
[Inject]
public static var spaceRegistry:SpaceRegistry;
[Inject]
public static var resourceRegistry:ResourceRegistry;
[Inject]
public static var commandService:CommandService;
[Inject]
public static var transportService:ITransportService;
private var osgi:OSGi;
public function CoreCommands() {
super();
this.osgi = OSGi.getInstance();
commandService.registerCommand("core","objects","Список загруженных объектов",[],this.cmdObjectsList);
commandService.registerCommand("core","resource","Список ресурсов",[],this.cmdResourcesList);
commandService.registerCommand("core","spaces","Список спейсов",[],this.cmdSpacesList);
commandService.registerCommand("system","gc","Вызвать сборщик мусора (debug only)",[],this.cmdSystemGc);
}
private function cmdSystemGc(param1:FormattedOutput) : void {
System.gc();
}
private function cmdSpacesList(param1:FormattedOutput) : void {
var local3:ISpace = null;
var local2:Vector.<ISpace> = SpaceRegistry(this.osgi.getService(SpaceRegistry)).spaces;
for each(local3 in local2) {
param1.addText("space id: " + (local3.id == null ? "null" : local3.id.toString()));
}
}
private function cmdResourcesList(param1:FormattedOutput) : void {
var local4:Resource = null;
var local2:Vector.<Resource> = resourceRegistry.resources;
var local3:int = 0;
while(local3 < local2.length) {
local4 = local2[local3];
param1.addText(local4.toString());
local3++;
}
}
private function cmdObjectsList(param1:FormattedOutput) : void {
var local4:ISpace = null;
var local5:Vector.<IGameObject> = null;
var local6:IGameObject = null;
var local7:IGameClass = null;
var local8:Vector.<Long> = null;
var local9:int = 0;
var local2:Vector.<ISpace> = spaceRegistry.spaces;
var local3:int = 0;
while(local3 < local2.length) {
local4 = local2[local3];
param1.addText("space id: " + local4.id);
local5 = local4.objects;
for each(local6 in local5) {
param1.addText(" object id: " + local6.id);
local7 = local6.gameClass;
if(local7 != null) {
param1.addText(" class id: " + local7.id);
local8 = local6.gameClass.models;
if(local8.length > 0) {
param1.addText(" models:");
local9 = 0;
while(local9 < local8.length) {
param1.addText(" " + this.getClassName(modelRegister.getModel(local8[local9])) + " [" + local8[local9] + "]");
local9++;
}
}
} else {
param1.addText(" class id: null");
}
}
local3++;
}
}
private function getClassName(param1:Object) : String {
var local2:String = getQualifiedClassName(param1);
var local3:int = int(local2.indexOf("::"));
if(local3 > -1) {
return local2.substr(local3 + 2);
}
return local2;
}
}
}
|
package projects.tanks.client.battleservice.model.statistics.team {
import alternativa.types.Long;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.client.battleservice.model.statistics.UserInfo;
import projects.tanks.client.battleservice.model.statistics.UserStat;
public interface IStatisticsTeamModelBase {
function changeTeamScore(param1:BattleTeam, param2:int) : void;
function changeUserStat(param1:UserStat, param2:BattleTeam) : void;
function refreshUsersStat(param1:Vector.<UserStat>, param2:BattleTeam) : void;
function swapTeam(param1:Vector.<UserStat>, param2:Vector.<UserStat>) : void;
function userConnect(param1:Long, param2:Vector.<UserInfo>, param3:BattleTeam) : void;
function userDisconnect(param1:Long) : void;
}
}
|
package alternativa.tanks.model.shop.items.crystallitem
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class CrystalPackageItemIcons_crystalsPackage5Class extends BitmapAsset
{
public function CrystalPackageItemIcons_crystalsPackage5Class()
{
super();
}
}
}
|
package alternativa.tanks.model.payment.shop.kitviewresource {
import flash.display.BitmapData;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class KitViewResourceEvents implements KitViewResource {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function KitViewResourceEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getButtonKitImage() : BitmapData {
var result:BitmapData = null;
var i:int = 0;
var m:KitViewResource = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = KitViewResource(this.impl[i]);
result = m.getButtonKitImage();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getButtonKitOverImage() : BitmapData {
var result:BitmapData = null;
var i:int = 0;
var m:KitViewResource = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = KitViewResource(this.impl[i]);
result = m.getButtonKitOverImage();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.ActionOutputLine_aslBluePlayerDropFlagIcon.png")]
public class ActionOutputLine_aslBluePlayerDropFlagIcon extends BitmapAsset {
public function ActionOutputLine_aslBluePlayerDropFlagIcon() {
super();
}
}
}
|
package alternativa.tanks.services.battlegui {
import flash.events.Event;
public class InventoryChangePositionEvent extends Event {
public static const ON_CHANGE_POSITION:String = "BattleGUIServiceEvent.ON_CHANGE_POSITION";
public function InventoryChangePositionEvent() {
super(ON_CHANGE_POSITION);
}
}
}
|
package alternativa.tanks.models.weapon.healing.targeting {
import alternativa.math.Vector3;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapons.targeting.direction.TargetingDirection;
import alternativa.tanks.models.weapons.targeting.direction.TargetingDirectionCalculator;
public class IsisDirectionCalculator implements TargetingDirectionCalculator {
private const NUMBER_SIDE_POINTS:int = 11;
private var upDirection:Vector3 = new Vector3();
private var currentDirection:Vector3 = new Vector3();
private var angle:Number;
private var screenSize:Number;
private var bonusDirection:Vector3;
public function IsisDirectionCalculator(param1:Number) {
super();
this.angle = param1 / 2;
this.screenSize = Math.tan(this.angle) * 2;
}
public function setBonusDirection(param1:Vector3) : void {
this.bonusDirection = param1;
}
public function resetBonusDirection() : void {
this.bonusDirection = null;
}
public function getDirections(param1:AllGlobalGunParams) : Vector.<TargetingDirection> {
var local6:Number = NaN;
var local7:int = 0;
var local8:Number = NaN;
this.upDirection.cross2(param1.elevationAxis,param1.direction);
var local2:Vector.<TargetingDirection> = new Vector.<TargetingDirection>();
var local3:Number = this.screenSize / (this.NUMBER_SIDE_POINTS - 1);
var local4:Number = -this.screenSize * 0.5;
var local5:int = 0;
while(local5 < this.NUMBER_SIDE_POINTS) {
local6 = -this.screenSize * 0.5;
local7 = 0;
while(local7 < this.NUMBER_SIDE_POINTS) {
this.currentDirection.copy(param1.direction);
this.currentDirection.addScaled(local4,this.upDirection);
this.currentDirection.addScaled(local6,param1.elevationAxis);
this.currentDirection.normalize();
local8 = Math.acos(this.currentDirection.dot(param1.direction));
if(local8 <= this.angle) {
local2.push(new TargetingDirection(this.currentDirection,local8,Number.MAX_VALUE));
}
local6 += local3;
local7++;
}
local4 += local3;
local5++;
}
if(this.bonusDirection != null) {
local2.push(new TargetingDirection(this.bonusDirection,Math.acos(this.bonusDirection.dot(param1.direction)),Number.MAX_VALUE,10));
}
return local2;
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class RocketLauncherWeaponProviderEvents implements RocketLauncherWeaponProvider {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function RocketLauncherWeaponProviderEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function remoteWeapon() : RemoteRocketLauncherWeapon {
var result:RemoteRocketLauncherWeapon = null;
var i:int = 0;
var m:RocketLauncherWeaponProvider = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = RocketLauncherWeaponProvider(this.impl[i]);
result = m.remoteWeapon();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.panel.model.shop.challenges.battlepass {
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 BattlePassPackageModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BattlePassPackageModelServer(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.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.ActionOutputLine_aslRedPlayerDeliverFlagIcon.png")]
public class ActionOutputLine_aslRedPlayerDeliverFlagIcon extends BitmapAsset {
public function ActionOutputLine_aslRedPlayerDeliverFlagIcon() {
super();
}
}
}
|
package alternativa.physics.collision.colliders
{
import alternativa.math.Vector3;
import alternativa.physics.Contact;
import alternativa.physics.collision.CollisionPrimitive;
import alternativa.physics.collision.ICollider;
public class BoxCollider implements ICollider
{
public function BoxCollider()
{
super();
}
public function getContact(prim1:CollisionPrimitive, prim2:CollisionPrimitive, contact:Contact) : Boolean
{
return false;
}
public function haveCollision(prim1:CollisionPrimitive, prim2:CollisionPrimitive) : Boolean
{
return false;
}
protected function getFaceVertsByAxis(hs:Vector3, axisIdx:int, negativeFace:Boolean, result:Vector.<Vector3>) : void
{
var v:Vector3 = null;
v = null;
switch(axisIdx)
{
case 0:
if(negativeFace)
{
v = result[0];
v.x = -hs.x;
v.y = hs.y;
v.z = -hs.z;
v = result[1];
v.x = -hs.x;
v.y = -hs.y;
v.z = -hs.z;
v = result[2];
v.x = -hs.x;
v.y = -hs.y;
v.z = hs.z;
v = result[3];
v.x = -hs.x;
v.y = hs.y;
v.z = hs.z;
}
else
{
v = result[0];
v.x = hs.x;
v.y = -hs.y;
v.z = -hs.z;
v = result[1];
v.x = hs.x;
v.y = hs.y;
v.z = -hs.z;
v = result[2];
v.x = hs.x;
v.y = hs.y;
v.z = hs.z;
v = result[3];
v.x = hs.x;
v.y = -hs.y;
v.z = hs.z;
}
break;
case 1:
if(negativeFace)
{
v = result[0];
v.x = -hs.x;
v.y = -hs.y;
v.z = -hs.z;
v = result[1];
v.x = hs.x;
v.y = -hs.y;
v.z = -hs.z;
v = result[2];
v.x = hs.x;
v.y = -hs.y;
v.z = hs.z;
v = result[3];
v.x = -hs.x;
v.y = -hs.y;
v.z = hs.z;
}
else
{
v = result[0];
v.x = hs.x;
v.y = hs.y;
v.z = -hs.z;
v = result[1];
v.x = -hs.x;
v.y = hs.y;
v.z = -hs.z;
v = result[2];
v.x = -hs.x;
v.y = hs.y;
v.z = hs.z;
v = result[3];
v.x = hs.x;
v.y = hs.y;
v.z = hs.z;
}
break;
case 2:
if(negativeFace)
{
v = result[0];
v.x = -hs.x;
v.y = hs.y;
v.z = -hs.z;
v = result[1];
v.x = hs.x;
v.y = hs.y;
v.z = -hs.z;
v = result[2];
v.x = hs.x;
v.y = -hs.y;
v.z = -hs.z;
v = result[3];
v.x = -hs.x;
v.y = -hs.y;
v.z = -hs.z;
}
else
{
v = result[0];
v.x = -hs.x;
v.y = -hs.y;
v.z = hs.z;
v = result[1];
v.x = hs.x;
v.y = -hs.y;
v.z = hs.z;
v = result[2];
v.x = hs.x;
v.y = hs.y;
v.z = hs.z;
v = result[3];
v.x = -hs.x;
v.y = hs.y;
v.z = hs.z;
}
}
}
protected function clipLowX(x:Number, pnum:int, points:Vector.<Vector3>, result:Vector.<Vector3>, epsilon:Number) : int
{
var p2:Vector3 = null;
var v:Vector3 = null;
var x1:Number = NaN;
p2 = null;
var dx:Number = NaN;
var dy:Number = NaN;
var dz:Number = NaN;
var t:Number = NaN;
v = null;
x1 = x - epsilon;
var num:int = 0;
var p1:Vector3 = points[int(pnum - 1)];
for(var i:int = 0; i < pnum; i++)
{
p2 = points[i];
if(p1.x > x1)
{
v = result[num];
num++;
v.x = p1.x;
v.y = p1.y;
v.z = p1.z;
if(p2.x < x1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (x - p1.x) / dx;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
}
else if(p2.x > x1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (x - p1.x) / dx;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
p1 = p2;
}
return num;
}
protected function clipHighX(x:Number, pnum:int, points:Vector.<Vector3>, result:Vector.<Vector3>, epsilon:Number) : int
{
var p2:Vector3 = null;
var dx:Number = NaN;
var dy:Number = NaN;
var dz:Number = NaN;
var t:Number = NaN;
var v:Vector3 = null;
var x1:Number = x + epsilon;
var num:int = 0;
var p1:Vector3 = points[int(pnum - 1)];
for(var i:int = 0; i < pnum; i++)
{
p2 = points[i];
if(p1.x < x1)
{
v = result[num];
num++;
v.x = p1.x;
v.y = p1.y;
v.z = p1.z;
if(p2.x > x1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (x - p1.x) / dx;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
}
else if(p2.x < x1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (x - p1.x) / dx;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
p1 = p2;
}
return num;
}
protected function clipLowY(y:Number, pnum:int, points:Vector.<Vector3>, result:Vector.<Vector3>, epsilon:Number) : int
{
var p2:Vector3 = null;
var dx:Number = NaN;
var dy:Number = NaN;
var dz:Number = NaN;
var t:Number = NaN;
var v:Vector3 = null;
var y1:Number = y - epsilon;
var num:int = 0;
var p1:Vector3 = points[int(pnum - 1)];
for(var i:int = 0; i < pnum; i++)
{
p2 = points[i];
if(p1.y > y1)
{
v = result[num];
num++;
v.x = p1.x;
v.y = p1.y;
v.z = p1.z;
if(p2.y < y1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (y - p1.y) / dy;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
}
else if(p2.y > y1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (y - p1.y) / dy;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
p1 = p2;
}
return num;
}
protected function clipHighY(y:Number, pnum:int, points:Vector.<Vector3>, result:Vector.<Vector3>, epsilon:Number) : int
{
var p2:Vector3 = null;
var dx:Number = NaN;
var dy:Number = NaN;
var dz:Number = NaN;
var t:Number = NaN;
var v:Vector3 = null;
var y1:Number = y + epsilon;
var num:int = 0;
var p1:Vector3 = points[int(pnum - 1)];
for(var i:int = 0; i < pnum; i++)
{
p2 = points[i];
if(p1.y < y1)
{
v = result[num];
num++;
v.x = p1.x;
v.y = p1.y;
v.z = p1.z;
if(p2.y > y1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (y - p1.y) / dy;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
}
else if(p2.y < y1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (y - p1.y) / dy;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
p1 = p2;
}
return num;
}
protected function clipLowZ(z:Number, pnum:int, points:Vector.<Vector3>, result:Vector.<Vector3>, epsilon:Number) : int
{
var p2:Vector3 = null;
var dx:Number = NaN;
var dy:Number = NaN;
var dz:Number = NaN;
var t:Number = NaN;
var v:Vector3 = null;
var z1:Number = z - epsilon;
var num:int = 0;
var p1:Vector3 = points[int(pnum - 1)];
for(var i:int = 0; i < pnum; i++)
{
p2 = points[i];
if(p1.z > z1)
{
v = result[num];
num++;
v.x = p1.x;
v.y = p1.y;
v.z = p1.z;
if(p2.z < z1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (z - p1.z) / dz;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
}
else if(p2.z > z1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (z - p1.z) / dz;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
p1 = p2;
}
return num;
}
protected function clipHighZ(z:Number, pnum:int, points:Vector.<Vector3>, result:Vector.<Vector3>, epsilon:Number) : int
{
var p2:Vector3 = null;
var dx:Number = NaN;
var dy:Number = NaN;
var dz:Number = NaN;
var t:Number = NaN;
var v:Vector3 = null;
var z1:Number = z + epsilon;
var num:int = 0;
var p1:Vector3 = points[int(pnum - 1)];
for(var i:int = 0; i < pnum; i++)
{
p2 = points[i];
if(p1.z < z1)
{
v = result[num];
num++;
v.x = p1.x;
v.y = p1.y;
v.z = p1.z;
if(p2.z > z1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (z - p1.z) / dz;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
}
else if(p2.z < z1)
{
dx = p2.x - p1.x;
dy = p2.y - p1.y;
dz = p2.z - p1.z;
t = (z - p1.z) / dz;
v = result[num];
num++;
v.x = p1.x + t * dx;
v.y = p1.y + t * dy;
v.z = p1.z + t * dz;
}
p1 = p2;
}
return num;
}
public function destroy() : void
{
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.inventory.sfx {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.inventory.sfx.InventorySfxCC;
public class VectorCodecInventorySfxCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecInventorySfxCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(InventorySfxCC,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.<InventorySfxCC> = new Vector.<InventorySfxCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = InventorySfxCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:InventorySfxCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<InventorySfxCC> = Vector.<InventorySfxCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import flash.display.BitmapData;
import flash.utils.Dictionary;
import projects.tanks.client.commons.types.ItemGarageProperty;
public class ResistancesIcons {
public static const resistanceIconClass:Class = ResistancesIcons_resistanceIconClass;
public static const resistanceIcon:BitmapData = new resistanceIconClass().bitmapData;
private static const bitmapFireResistance:Class = ResistancesIcons_bitmapFireResistance;
public static const fireResistance:BitmapData = new bitmapFireResistance().bitmapData;
private static const bitmapPlasmaResistance:Class = ResistancesIcons_bitmapPlasmaResistance;
public static const plasmaResistance:BitmapData = new bitmapPlasmaResistance().bitmapData;
private static const bitmapMechResistance:Class = ResistancesIcons_bitmapMechResistance;
public static const mechResistance:BitmapData = new bitmapMechResistance().bitmapData;
private static const bitmapRailResistance:Class = ResistancesIcons_bitmapRailResistance;
public static const railResistance:BitmapData = new bitmapRailResistance().bitmapData;
private static const bitmapVampireResistance:Class = ResistancesIcons_bitmapVampireResistance;
public static const vampireResistance:BitmapData = new bitmapVampireResistance().bitmapData;
private static const bitmapThunderResistance:Class = ResistancesIcons_bitmapThunderResistance;
public static const thunderResistance:BitmapData = new bitmapThunderResistance().bitmapData;
private static const bitmapFreezeResistance:Class = ResistancesIcons_bitmapFreezeResistance;
public static const freezeResistance:BitmapData = new bitmapFreezeResistance().bitmapData;
private static const bitmapRicochetResistance:Class = ResistancesIcons_bitmapRicochetResistance;
public static const ricochetResistance:BitmapData = new bitmapRicochetResistance().bitmapData;
private static const shaftResistanceClass:Class = ResistancesIcons_shaftResistanceClass;
public static const shaftResistance:BitmapData = new shaftResistanceClass().bitmapData;
private static const mineResistanceClass:Class = ResistancesIcons_mineResistanceClass;
public static const mineResistance:BitmapData = new mineResistanceClass().bitmapData;
private static const shotgunResistanceClass:Class = ResistancesIcons_shotgunResistanceClass;
public static const shotgunResistance:BitmapData = new shotgunResistanceClass().bitmapData;
private static const machinegunResistanceClass:Class = ResistancesIcons_machinegunResistanceClass;
public static const machinegunResistance:BitmapData = new machinegunResistanceClass().bitmapData;
private static const rocketLauncherResistanceClass:Class = ResistancesIcons_rocketLauncherResistanceClass;
public static const rocketLauncherResistance:BitmapData = new rocketLauncherResistanceClass().bitmapData;
private static const artilleryResistanceClass:Class = ResistancesIcons_artilleryResistanceClass;
public static const artilleryResistance:BitmapData = new artilleryResistanceClass().bitmapData;
private static const gaussResistanceClass:Class = ResistancesIcons_gaussResistanceClass;
public static const gaussResistance:BitmapData = new gaussResistanceClass().bitmapData;
private static const gaussResistanceClass_x2:Class = ResistancesIcons_gaussResistanceClass_x2;
public static const gaussResistance_x2:BitmapData = new gaussResistanceClass_x2().bitmapData;
private static const allResistanceClass:Class = ResistancesIcons_allResistanceClass;
public static const allResistance:BitmapData = new allResistanceClass().bitmapData;
private static const bitmapFireResistance_x2:Class = ResistancesIcons_bitmapFireResistance_x2;
public static const fireResistance_x2:BitmapData = new bitmapFireResistance_x2().bitmapData;
private static const bitmapPlasmaResistance_x2:Class = ResistancesIcons_bitmapPlasmaResistance_x2;
public static const plasmaResistance_x2:BitmapData = new bitmapPlasmaResistance_x2().bitmapData;
private static const bitmapMechResistance_x2:Class = ResistancesIcons_bitmapMechResistance_x2;
public static const mechResistance_x2:BitmapData = new bitmapMechResistance_x2().bitmapData;
private static const bitmapRailResistance_x2:Class = ResistancesIcons_bitmapRailResistance_x2;
public static const railResistance_x2:BitmapData = new bitmapRailResistance_x2().bitmapData;
private static const bitmapVampireResistance_x2:Class = ResistancesIcons_bitmapVampireResistance_x2;
public static const vampireResistance_x2:BitmapData = new bitmapVampireResistance_x2().bitmapData;
private static const bitmapThunderResistance_x2:Class = ResistancesIcons_bitmapThunderResistance_x2;
public static const thunderResistance_x2:BitmapData = new bitmapThunderResistance_x2().bitmapData;
private static const bitmapFreezeResistance_x2:Class = ResistancesIcons_bitmapFreezeResistance_x2;
public static const freezeResistance_x2:BitmapData = new bitmapFreezeResistance_x2().bitmapData;
private static const bitmapRicochetResistance_x2:Class = ResistancesIcons_bitmapRicochetResistance_x2;
public static const ricochetResistance_x2:BitmapData = new bitmapRicochetResistance_x2().bitmapData;
private static const bitmapshaftResistance_x2:Class = ResistancesIcons_bitmapshaftResistance_x2;
public static const shaftResistance_x2:BitmapData = new bitmapshaftResistance_x2().bitmapData;
private static const bitmapmineResistance_x2:Class = ResistancesIcons_bitmapmineResistance_x2;
public static const mineResistance_x2:BitmapData = new bitmapmineResistance_x2().bitmapData;
private static const bitmapshotgunResistance_x2:Class = ResistancesIcons_bitmapshotgunResistance_x2;
public static const shotgunResistance_x2:BitmapData = new bitmapshotgunResistance_x2().bitmapData;
private static const bitmapmachinegunResistance_x2:Class = ResistancesIcons_bitmapmachinegunResistance_x2;
public static const machinegunResistance_x2:BitmapData = new bitmapmachinegunResistance_x2().bitmapData;
private static const bitmaprocketLauncherResistance_x2:Class = ResistancesIcons_bitmaprocketLauncherResistance_x2;
public static const rocketLauncherResistance_x2:BitmapData = new bitmaprocketLauncherResistance_x2().bitmapData;
private static const bitmapartilleryResistance_x2:Class = ResistancesIcons_bitmapartilleryResistance_x2;
public static const artilleryResistance_x2:BitmapData = new bitmapartilleryResistance_x2().bitmapData;
private static const bitmapallResistance_x2:Class = ResistancesIcons_bitmapallResistance_x2;
public static const allResistance_x2:BitmapData = new bitmapallResistance_x2().bitmapData;
private static var propertyToBitmap:Dictionary = new Dictionary();
private static var propertyToBigBitmap:Dictionary = new Dictionary();
putBitmapForProperty(ItemGarageProperty.SMOKY_RESISTANCE,ResistancesIcons.mechResistance);
putBitmapForProperty(ItemGarageProperty.FIREBIRD_RESISTANCE,ResistancesIcons.fireResistance);
putBitmapForProperty(ItemGarageProperty.TWINS_RESISTANCE,ResistancesIcons.plasmaResistance);
putBitmapForProperty(ItemGarageProperty.RAILGUN_RESISTANCE,ResistancesIcons.railResistance);
putBitmapForProperty(ItemGarageProperty.ISIS_RESISTANCE,ResistancesIcons.vampireResistance);
putBitmapForProperty(ItemGarageProperty.THUNDER_RESISTANCE,ResistancesIcons.thunderResistance);
putBitmapForProperty(ItemGarageProperty.FREEZE_RESISTANCE,ResistancesIcons.freezeResistance);
putBitmapForProperty(ItemGarageProperty.RICOCHET_RESISTANCE,ResistancesIcons.ricochetResistance);
putBitmapForProperty(ItemGarageProperty.SHAFT_RESISTANCE,ResistancesIcons.shaftResistance);
putBitmapForProperty(ItemGarageProperty.MINE_RESISTANCE,ResistancesIcons.mineResistance);
putBitmapForProperty(ItemGarageProperty.SHOTGUN_RESISTANCE,ResistancesIcons.shotgunResistance);
putBitmapForProperty(ItemGarageProperty.MACHINE_GUN_RESISTANCE,ResistancesIcons.machinegunResistance);
putBitmapForProperty(ItemGarageProperty.ROCKET_LAUNCHER_RESISTANCE,ResistancesIcons.rocketLauncherResistance);
putBitmapForProperty(ItemGarageProperty.ARTILLERY_RESISTANCE,ResistancesIcons.artilleryResistance);
putBitmapForProperty(ItemGarageProperty.GAUSS_RESISTANCE,ResistancesIcons.gaussResistance);
putBitmapForProperty(ItemGarageProperty.ALL_RESISTANCE,ResistancesIcons.allResistance);
putBigBitmapForProperty(ItemGarageProperty.SMOKY_RESISTANCE,ResistancesIcons.mechResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.FIREBIRD_RESISTANCE,ResistancesIcons.fireResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.TWINS_RESISTANCE,ResistancesIcons.plasmaResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.RAILGUN_RESISTANCE,ResistancesIcons.railResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.ISIS_RESISTANCE,ResistancesIcons.vampireResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.THUNDER_RESISTANCE,ResistancesIcons.thunderResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.FREEZE_RESISTANCE,ResistancesIcons.freezeResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.RICOCHET_RESISTANCE,ResistancesIcons.ricochetResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.SHAFT_RESISTANCE,ResistancesIcons.shaftResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.MINE_RESISTANCE,ResistancesIcons.mineResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.SHOTGUN_RESISTANCE,ResistancesIcons.shotgunResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.MACHINE_GUN_RESISTANCE,ResistancesIcons.machinegunResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.ROCKET_LAUNCHER_RESISTANCE,ResistancesIcons.rocketLauncherResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.ARTILLERY_RESISTANCE,ResistancesIcons.artilleryResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.GAUSS_RESISTANCE,ResistancesIcons.gaussResistance_x2);
putBigBitmapForProperty(ItemGarageProperty.ALL_RESISTANCE,ResistancesIcons.allResistance_x2);
public function ResistancesIcons() {
super();
}
private static function putBitmapForProperty(param1:ItemGarageProperty, param2:BitmapData) : void {
propertyToBitmap[param1.name] = param2;
}
private static function putBigBitmapForProperty(param1:ItemGarageProperty, param2:BitmapData) : void {
propertyToBigBitmap[param1.name] = param2;
}
public static function getBitmapData(param1:ItemGarageProperty) : BitmapData {
return propertyToBitmap[param1.name];
}
public static function getBigBitmapData(param1:ItemGarageProperty) : BitmapData {
return propertyToBigBitmap[param1.name];
}
public static function getBitmapDataByName(param1:String) : BitmapData {
return propertyToBitmap[param1];
}
}
}
|
package alternativa.tanks.controller.commands {
import alternativa.tanks.controller.events.CheckEmailEvent;
import alternativa.tanks.service.IEntranceServerFacade;
import org.robotlegs.mvcs.Command;
public class CheckEmailCommand extends Command {
[Inject]
public var serverFacade:IEntranceServerFacade;
[Inject]
public var checkEmailEvent:CheckEmailEvent;
public function CheckEmailCommand() {
super();
}
override public function execute() : void {
this.serverFacade.checkEmail(this.checkEmailEvent.email);
}
}
}
|
package projects.tanks.client.clans.notifier {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class ClanNotifierModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ClanNotifierModelServer;
private var client:IClanNotifierModelBase = IClanNotifierModelBase(this);
private var modelId:Long = Long.getLong(1850785827,-2022019480);
private var _sendDataId:Long = Long.getLong(2052398186,-511753871);
private var _sendData_userDataCodec:ICodec;
public function ClanNotifierModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ClanNotifierModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ClanNotifierData,false)));
this._sendData_userDataCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanNotifierData,false),false,1));
}
protected function getInitParam() : ClanNotifierData {
return ClanNotifierData(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._sendDataId:
this.client.sendData(this._sendData_userDataCodec.decode(param2) as Vector.<ClanNotifierData>);
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.utils
{
public class CircularObjectBuffer
{
private var buffer:Array;
private var writeIndex:int;
private var headIndex:int;
public function CircularObjectBuffer(size:int)
{
super();
this.buffer = new Array(size + 1);
}
public function addObject(object:Object) : void
{
this.buffer[this.writeIndex] = object;
this.writeIndex = this.incIndex(this.writeIndex);
if(this.headIndex == this.writeIndex)
{
this.headIndex = this.incIndex(this.headIndex);
}
}
public function clear() : void
{
var len:int = this.buffer.length;
for(var i:int = 0; i < len; i++)
{
this.buffer[i] = null;
}
this.writeIndex = 0;
this.headIndex = 0;
}
public function getObjects() : Array
{
var i:int = 0;
var j:int = 0;
var num:int = this.writeIndex - this.headIndex;
if(num < 0)
{
num += this.buffer.length;
}
var res:Array = new Array(num);
var len:int = this.buffer.length;
for(i = 0,j = this.headIndex; i < num; i++,j++)
{
if(j == len)
{
j = 0;
}
res[i] = this.buffer[j];
}
return res;
}
private function incIndex(index:int) : int
{
return ++index == this.buffer.length ? int(0) : int(index);
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
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;
import projects.tanks.client.battlefield.models.battle.battlefield.fps.FpsStatisticType;
public class BattlefieldModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _dgId:Long = Long.getLong(312624829,1518890877);
private var _dg_deltasCodec:ICodec;
private var _kdId:Long = Long.getLong(312624829,1518890663);
private var _kd_typeCodec:ICodec;
private var _sendTimeStatisticsCommandId:Long = Long.getLong(1789749753,1049490765);
private var _sendTimeStatisticsCommand_statisticTypeCodec:ICodec;
private var _sendTimeStatisticsCommand_averageFPSCodec:ICodec;
private var _xcId:Long = Long.getLong(312624829,1518890261);
private var model:IModel;
public function BattlefieldModelServer(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._dg_deltasCodec = this.protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(int,false),false,1));
this._kd_typeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._sendTimeStatisticsCommand_statisticTypeCodec = this.protocol.getCodec(new EnumCodecInfo(FpsStatisticType,false));
this._sendTimeStatisticsCommand_averageFPSCodec = this.protocol.getCodec(new TypeCodecInfo(Float,false));
}
public function dg(param1:Vector.<int>) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._dg_deltasCodec.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._dgId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function kd(param1:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._kd_typeCodec.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._kdId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function sendTimeStatisticsCommand(param1:FpsStatisticType, param2:Number) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._sendTimeStatisticsCommand_statisticTypeCodec.encode(this.protocolBuffer,param1);
this._sendTimeStatisticsCommand_averageFPSCodec.encode(this.protocolBuffer,param2);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local3:SpaceCommand = new SpaceCommand(Model.object.id,this._sendTimeStatisticsCommandId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function xc() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._xcId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.terminal {
public class TerminalPaymentCC {
private var _terminals:Vector.<TerminalInstance>;
private var _text:String;
private var _withCalculator:Boolean;
public function TerminalPaymentCC(param1:Vector.<TerminalInstance> = null, param2:String = null, param3:Boolean = false) {
super();
this._terminals = param1;
this._text = param2;
this._withCalculator = param3;
}
public function get terminals() : Vector.<TerminalInstance> {
return this._terminals;
}
public function set terminals(param1:Vector.<TerminalInstance>) : void {
this._terminals = param1;
}
public function get text() : String {
return this._text;
}
public function set text(param1:String) : void {
this._text = param1;
}
public function get withCalculator() : Boolean {
return this._withCalculator;
}
public function set withCalculator(param1:Boolean) : void {
this._withCalculator = param1;
}
public function toString() : String {
var local1:String = "TerminalPaymentCC [";
local1 += "terminals = " + this.terminals + " ";
local1 += "text = " + this.text + " ";
local1 += "withCalculator = " + this.withCalculator + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.servermodels {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IGoogleEntranceModelEvents implements IGoogleEntranceModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IGoogleEntranceModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function login(param1:String) : void {
var i:int = 0;
var m:IGoogleEntranceModel = null;
var token:String = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IGoogleEntranceModel(this.impl[i]);
m.login(token);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.client.panel.model.donationalert {
import projects.tanks.client.panel.model.donationalert.types.DonationData;
public interface IDonationAlertModelBase {
function showDonationAlert(param1:DonationData) : void;
function showDonationAlertWithEmailBlock(param1:DonationData) : void;
function showEmailIsBusy(param1:String) : void;
function showEmailIsForbidden(param1:String) : void;
function showEmailIsFree(param1:String) : void;
}
}
|
package _codec.projects.tanks.client.battlefield.models.user.bossstate {
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.battlefield.models.user.bossstate.BossRelationRole;
public class VectorCodecBossRelationRoleLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBossRelationRoleLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(BossRelationRole,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.<BossRelationRole> = new Vector.<BossRelationRole>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BossRelationRole(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BossRelationRole = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BossRelationRole> = Vector.<BossRelationRole>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.logging.paymentactions {
import alternativa.types.Long;
import flash.events.EventDispatcher;
import projects.tanks.client.tanksservices.model.logging.payment.PaymentAction;
public class UserPaymentActionsServiceImpl extends EventDispatcher implements UserPaymentActionsService {
public function UserPaymentActionsServiceImpl() {
super();
}
public function openPayment(param1:String) : void {
var local2:UserPaymentActionEvent = new UserPaymentActionEvent(PaymentAction.OPEN_PAYMENT);
local2.setLayoutName(param1);
dispatchEvent(local2);
}
public function closePayment(param1:String) : void {
var local2:UserPaymentActionEvent = new UserPaymentActionEvent(PaymentAction.CLOSE_PAYMENT);
local2.setLayoutName(param1);
dispatchEvent(local2);
}
public function selectCountry(param1:String) : void {
var local2:UserPaymentActionEvent = new UserPaymentActionEvent(PaymentAction.COUNTRY_SELECT);
local2.setCountryCode(param1);
dispatchEvent(local2);
}
public function choosePaymode(param1:Long, param2:Long) : void {
var local3:UserPaymentActionEvent = new UserPaymentActionEvent(PaymentAction.MODE_CHOOSE);
local3.setPayModeId(param1.toString());
local3.setShopItemId(param2.toString());
dispatchEvent(local3);
}
public function chooseItem(param1:Long) : void {
var local2:UserPaymentActionEvent = new UserPaymentActionEvent(PaymentAction.ITEM_CHOOSE);
local2.setShopItemId(param1.toString());
dispatchEvent(local2);
}
public function proceed(param1:Long, param2:Long) : void {
var local3:UserPaymentActionEvent = new UserPaymentActionEvent(PaymentAction.PROCEED);
local3.setPayModeId(param1.toString());
local3.setShopItemId(param2.toString());
dispatchEvent(local3);
}
}
}
|
package alternativa.tanks.loader {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.loader.LoaderWindow_back.png")]
public class LoaderWindow_back extends BitmapAsset {
public function LoaderWindow_back() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.sfx {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
public class ShotgunSFXModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ShotgunSFXModelServer(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.osgi.service.focus
{
import flash.display.DisplayObject;
public interface IFocusService
{
function addFocusListener(param1:IFocusListener) : void;
function removeFocusListener(param1:IFocusListener) : void;
function getFocus() : Object;
function clearFocus(param1:DisplayObject) : void;
}
}
|
package projects.tanks.client.panel.model.shop.androidspecialoffer.offers.purchaseofupgrades {
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 AndroidPurchaseOfUpgradesUserModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _purchaseOfUpgradesId:Long = Long.getLong(2006049977,-922995975);
private var _purchaseOfUpgrades_itemIdCodec:ICodec;
private var model:IModel;
public function AndroidPurchaseOfUpgradesUserModelServer(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._purchaseOfUpgrades_itemIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function purchaseOfUpgrades(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._purchaseOfUpgrades_itemIdCodec.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._purchaseOfUpgradesId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package com.alternativaplatform.projects.tanks.client.garage.item3d
{
public interface IItem3DModelBase
{
}
}
|
package tankGUI_fla {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol977")]
public dynamic class iconSound_61 extends MovieClip {
public function iconSound_61() {
super();
addFrameScript(0,this.frame1);
}
internal function frame1() : * {
stop();
}
}
}
|
package projects.tanks.client.panel.model.shop.lootbox {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class LootBoxPackageModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:LootBoxPackageModelServer;
private var client:ILootBoxPackageModelBase = ILootBoxPackageModelBase(this);
private var modelId:Long = Long.getLong(2038557905,1696344636);
public function LootBoxPackageModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new LootBoxPackageModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(LootBoxPackageCC,false)));
}
protected function getInitParam() : LootBoxPackageCC {
return LootBoxPackageCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.protocol {
public interface ICodec {
function init(param1:IProtocol) : void;
function encode(param1:ProtocolBuffer, param2:Object) : void;
function decode(param1:ProtocolBuffer) : Object;
}
}
|
package projects.tanks.client.panel.model.profile.userproperties {
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 UserPropertiesModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function UserPropertiesModelServer(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 forms.events
{
import flash.events.Event;
public class SliderEvent extends Event
{
public static const CHANGE_VALUE:String = "SliderChangeValue";
public var currentValue:Number;
public function SliderEvent(value:Number)
{
this.currentValue = value;
super(CHANGE_VALUE,true,false);
}
}
}
|
package projects.tanks.client.garage.models.item.drone {
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 HasBatteriesNotifyModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function HasBatteriesNotifyModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.view.forms {
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.controller.events.CheckCallsignEvent;
import alternativa.tanks.controller.events.NavigationEvent;
import alternativa.tanks.controller.events.socialnetwork.FinishExternalRegisterEvent;
import alternativa.tanks.service.IRegistrationUXService;
import alternativa.tanks.type.RulesType;
import alternativa.tanks.view.bubbles.Bubble;
import alternativa.tanks.view.bubbles.EntranceBubbleFactory;
import alternativa.tanks.view.forms.commons.RegistrationCommonElementsSection;
import alternativa.tanks.view.forms.freeuids.FreeUidsForm;
import alternativa.tanks.view.forms.freeuids.FreeUidsFormEvent;
import alternativa.tanks.view.forms.primivites.ValidationIcon;
import alternativa.tanks.view.layers.EntranceView;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.base.TankInputBase;
import controls.checkbox.CheckBoxBase;
import controls.checkbox.CheckBoxEvent;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.FocusEvent;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.events.TextEvent;
import flash.events.TimerEvent;
import flash.ui.Keyboard;
import flash.utils.Timer;
import forms.TankWindowWithHeader;
import forms.events.LoginFormEvent;
import org.robotlegs.core.IInjector;
import projects.tanks.client.entrance.model.entrance.logging.RegistrationUXFormAction;
import projects.tanks.clients.flash.commons.services.validate.IValidateService;
import projects.tanks.clients.flash.commons.services.validate.ValidateService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.IHelpService;
public class ExternalRegistrationForm extends Sprite {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var helperService:IHelpService;
[Inject]
public static var validateService:IValidateService;
[Inject]
public static var registrationUXService:IRegistrationUXService;
[Inject]
public var entranceView:EntranceView;
[Inject]
public var injector:IInjector;
private var _callsignInput:TankInputBase;
private var _continueButton:DefaultButtonBase;
private var _rulesButton:LabelBase;
private var _goBackButton:DefaultButtonBase;
private var infoLabel:LabelBase;
private var _window:TankWindowWithHeader;
private var _freeUidsForm:FreeUidsForm;
private var _isFreeUidsFormAlreadyShowed:Boolean;
private var _margin:int = 20;
private var _border:int = 25;
private var _windowWidth:int = 400;
private var _windowHeight:int = 193;
private var _inputsLeftMargin:int = 80;
private var _callsignValidated:Boolean = false;
private var _callSignCheckIcon:ValidationIcon;
private var _checkCallsignTimer:Timer;
private const checkCallsignDelay:int = 500;
private var _nameIsNotUniqueBubble:Bubble;
private var _nameIsIncorrectBubble:Bubble;
private var _symbolIsNotAllowedBubble:Bubble;
private var _acceptRulesCheckBox:CheckBoxBase;
public function ExternalRegistrationForm() {
super();
}
[PostConstruct]
public function postConstruct() : void {
var local1:int = this._border;
this._window = TankWindowWithHeader.createWindow(TanksLocale.TEXT_HEADER_REGISTRATION,this._windowWidth,local1);
this._callsignInput = new TankInputBase();
this._callSignCheckIcon = new ValidationIcon();
this._continueButton = new DefaultButtonBase();
this._goBackButton = new DefaultButtonBase();
this.infoLabel = new LabelBase();
this._acceptRulesCheckBox = new CheckBoxBase();
this._window.addChild(this._callsignInput);
this._window.addChild(this._goBackButton);
this._window.addChild(this.infoLabel);
this.infoLabel.text = localeService.getText(TanksLocale.TEXT_PARTNER_REGISTARTION_FORM_CHOOSE_NAME_TEXT);
this.infoLabel.y = this._margin;
this.infoLabel.x = this._border;
this._inputsLeftMargin = this._border + 5 + this._callsignInput._label.width;
this._callsignInput.x = this._border;
this._callsignInput.y = this.infoLabel.y + this.infoLabel.height + this._margin - 5;
this._callsignInput.width = this._windowWidth - 2 * this._border;
this._callsignInput.maxChars = RegistrationCommonElementsSection.MAX_CHARS_CALLSIGN;
this._callsignInput.tabIndex = 0;
this._callsignInput.validValue = true;
this._callSignCheckIcon.x = this._windowWidth - this._margin - this._callSignCheckIcon.width - 10;
this._callSignCheckIcon.y = this._callsignInput.y + 7;
this._acceptRulesCheckBox.x = this._border;
this._acceptRulesCheckBox.y = this._callsignInput.y + this._callsignInput.height + this._margin - 6;
this._window.addChild(this._acceptRulesCheckBox);
this._rulesButton = new LabelBase();
this._rulesButton.x = this._border + this._acceptRulesCheckBox.width;
this._rulesButton.y = this._acceptRulesCheckBox.y;
this._rulesButton.multiline = true;
this._rulesButton.wordWrap = true;
this._rulesButton.htmlText = localeService.getText(TanksLocale.TEXT_REGISTER_FORM_AGREEMENT_NOTE_TEXT);
this._rulesButton.width = this._windowWidth - this._rulesButton.x - this._border;
this._window.addChild(this._rulesButton);
this._continueButton.label = localeService.getText(TanksLocale.TEXT_PARTNER_REGISTARTION_FORM_CONTINUE);
this._continueButton.enable = false;
this._continueButton.x = this._windowWidth - this._border - this._continueButton.width;
this._continueButton.y = this._rulesButton.y + this._rulesButton.height + this._margin - 8;
this._window.addChild(this._continueButton);
this._goBackButton.label = localeService.getText(TanksLocale.TEXT_BACK_BUTTON);
this._goBackButton.x = this._border;
this._goBackButton.y = this._continueButton.y;
this._checkCallsignTimer = new Timer(this.checkCallsignDelay,1);
this._window.addChild(this._callSignCheckIcon);
addChild(this._window);
this._freeUidsForm = new FreeUidsForm();
this._freeUidsForm.x = this._callsignInput.x;
this._freeUidsForm.y = this._callsignInput.y + this._callsignInput.height;
this._freeUidsForm.width = this._windowWidth - 2 * this._border;
addChild(this._freeUidsForm);
this.createBubbles();
this._window.height = Math.max(this._windowHeight,this._continueButton.y + this._continueButton.height + this._margin);
this.setEvent();
display.stage.focus = this._callsignInput.textField;
this.alignYourself(null);
registrationUXService.logNavigationFinish();
}
private function createBubbles() : void {
this._nameIsNotUniqueBubble = EntranceBubbleFactory.nameIsNotUniqueBubble();
this._nameIsIncorrectBubble = EntranceBubbleFactory.nameIsIncorrectBubble();
this._symbolIsNotAllowedBubble = EntranceBubbleFactory.symbolIsNotAllowedBubble();
}
private function setEvent() : void {
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
display.stage.addEventListener(Event.RESIZE,this.alignYourself);
this._callsignInput.addEventListener(LoginFormEvent.TEXT_CHANGED,this.onCallsignChanged);
this._callsignInput.addEventListener(KeyboardEvent.KEY_DOWN,this.onPlayClickedKey);
this._continueButton.addEventListener(MouseEvent.CLICK,this.onRegisterButtonClick);
this._goBackButton.addEventListener(MouseEvent.CLICK,this.onGoBackButtonClick);
this._rulesButton.addEventListener(TextEvent.LINK,this.onRules);
this._checkCallsignTimer.addEventListener(TimerEvent.TIMER_COMPLETE,this.onCallsignCheckTimerComplete);
this._freeUidsForm.addEventListener(FreeUidsFormEvent.CLICK_ITEM,this.onFreeUidsFormSelectedItem);
this._freeUidsForm.addEventListener(FreeUidsFormEvent.FOCUS_OUT,this.onFreeUidsFormFocusOut);
this._callsignInput.textField.addEventListener(FocusEvent.FOCUS_IN,this.onCallsignFocusIn);
this._acceptRulesCheckBox.addEventListener(CheckBoxEvent.STATE_CHANGED,this.onCheckRulesChanged);
}
private function removeEvent() : void {
removeEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
display.stage.removeEventListener(Event.RESIZE,this.alignYourself);
this._callsignInput.removeEventListener(LoginFormEvent.TEXT_CHANGED,this.onCallsignChanged);
this._callsignInput.removeEventListener(KeyboardEvent.KEY_DOWN,this.onPlayClickedKey);
this._continueButton.removeEventListener(MouseEvent.CLICK,this.onRegisterButtonClick);
this._goBackButton.removeEventListener(MouseEvent.CLICK,this.onGoBackButtonClick);
this._rulesButton.removeEventListener(TextEvent.LINK,this.onRules);
this._checkCallsignTimer.removeEventListener(TimerEvent.TIMER_COMPLETE,this.onCallsignCheckTimerComplete);
this._freeUidsForm.removeEventListener(FreeUidsFormEvent.CLICK_ITEM,this.onFreeUidsFormSelectedItem);
this._freeUidsForm.removeEventListener(FreeUidsFormEvent.FOCUS_OUT,this.onFreeUidsFormFocusOut);
this._callsignInput.textField.removeEventListener(FocusEvent.FOCUS_IN,this.onCallsignFocusIn);
this._acceptRulesCheckBox.removeEventListener(CheckBoxEvent.STATE_CHANGED,this.onCheckRulesChanged);
}
private function onRemoveFromStage(param1:Event) : void {
this._checkCallsignTimer.stop();
this._freeUidsForm.destroy();
this.removeEvent();
}
private function onGoBackButtonClick(param1:MouseEvent) : void {
dispatchEvent(new NavigationEvent(NavigationEvent.GO_TO_REGISTRATION_FORM));
}
private function onCallsignChanged(param1:LoginFormEvent = null) : void {
this._callsignValidated = false;
this._callsignInput.validValue = true;
this._nameIsIncorrectBubble.hide();
this._nameIsNotUniqueBubble.hide();
this._symbolIsNotAllowedBubble.hide();
this._callSignCheckIcon.turnOff();
this._isFreeUidsFormAlreadyShowed = false;
this.hideFreeUidsForm();
this._checkCallsignTimer.reset();
this._checkCallsignTimer.start();
var local2:String = this._callsignInput.value;
if(!validateService.isValidIdentificationStringForRegistration(local2)) {
registrationUXService.logCountableFormAction(RegistrationUXFormAction.FORBIDDEN_CHARACTERS_TYPED,validateService.getForbiddenCharactersCountForRegistration(local2));
registrationUXService.logCountableFormAction(RegistrationUXFormAction.FORBIDDEN_LETTERS_TYPED,validateService.getForbiddenLettersCountForRegistration(local2));
this._callsignInput.value = local2.replace(ValidateService.NOT_ALLOWED_PATTERN_FOR_REGISTRATION,"");
this.alertAboutSymbolIsNotAllowed();
}
this.togglePlayButton();
}
private function onCheckRulesChanged(param1:CheckBoxEvent) : void {
if(this._acceptRulesCheckBox.checked) {
registrationUXService.logFormAction(RegistrationUXFormAction.USER_AGREEMENT_ACCEPTED);
}
this.togglePlayButton();
}
private function togglePlayButton() : void {
this._continueButton.enable = this._callsignValidated && this._acceptRulesCheckBox.checked;
}
private function alertAboutSymbolIsNotAllowed() : void {
this._callsignInput.validValue = false;
this._callSignCheckIcon.markAsInvalid();
this._callSignCheckIcon.addChild(this._symbolIsNotAllowedBubble);
registrationUXService.logFormAction(RegistrationUXFormAction.FORBIDDEN_USERNAME_TYPED);
}
public function alertAboutFreeUid() : void {
registrationUXService.logFormAction(RegistrationUXFormAction.CORRECT_USERNAME_TYPED);
this._symbolIsNotAllowedBubble.hide();
this._callsignInput.validValue = true;
this._callsignValidated = true;
this._callSignCheckIcon.markAsValid();
this.togglePlayButton();
}
public function alertAboutBusyUid(param1:Vector.<String>) : void {
registrationUXService.logFormAction(RegistrationUXFormAction.BUSY_USERNAME_TYPED);
this._symbolIsNotAllowedBubble.hide();
this._callsignInput.validValue = false;
this._callSignCheckIcon.markAsInvalid();
this._callSignCheckIcon.addChild(this._nameIsNotUniqueBubble);
this._nameIsNotUniqueBubble.visible = true;
if(param1.length != 0) {
this._isFreeUidsFormAlreadyShowed = true;
this._nameIsNotUniqueBubble.visible = false;
this._freeUidsForm.create(param1);
}
this.togglePlayButton();
}
public function alertAboutIncorrectUid() : void {
registrationUXService.logFormAction(RegistrationUXFormAction.FORBIDDEN_USERNAME_TYPED);
this._symbolIsNotAllowedBubble.hide();
this._callsignInput.validValue = false;
this._callSignCheckIcon.markAsInvalid();
this._callSignCheckIcon.addChild(this._nameIsIncorrectBubble);
this.togglePlayButton();
}
private function onPlayClickedKey(param1:KeyboardEvent) : void {
if(param1.keyCode == Keyboard.ENTER && this._continueButton.enable) {
this.onRegisterButtonClick();
}
}
private function onCallsignCheckTimerComplete(param1:TimerEvent) : void {
if(validateService.isUidValid(this._callsignInput.value)) {
this._callSignCheckIcon.startProgress();
dispatchEvent(new CheckCallsignEvent(this.callsign));
} else {
this._callsignInput.validValue = true;
this._symbolIsNotAllowedBubble.hide();
this._callSignCheckIcon.turnOff();
if(this._callsignInput.value.length != 0) {
this.alertAboutIncorrectUid();
}
}
}
private function onRegisterButtonClick(param1:MouseEvent = null) : void {
this._continueButton.enable = false;
dispatchEvent(new FinishExternalRegisterEvent(this.callsign));
}
private function onFreeUidsFormSelectedItem(param1:FreeUidsFormEvent) : void {
this.callsign = param1.uid;
registrationUXService.logFormAction(RegistrationUXFormAction.USERNAME_OFFER_ACCEPTED);
this.hideFreeUidsForm();
}
private function onFreeUidsFormFocusOut(param1:FreeUidsFormEvent) : void {
this.hideFreeUidsForm();
}
private function hideFreeUidsForm() : void {
this._freeUidsForm.hide();
this._nameIsNotUniqueBubble.visible = true;
}
private function onCallsignFocusIn(param1:FocusEvent) : void {
if(this._isFreeUidsFormAlreadyShowed) {
this._nameIsNotUniqueBubble.visible = false;
this._freeUidsForm.show();
}
}
private function onRules(param1:TextEvent) : void {
var local2:ViewText = new ViewText();
this.entranceView.addChild(local2);
switch(param1.text) {
case RulesType.RULES:
local2.text = localeService.getText(TanksLocale.TEXT_GAME_RULES);
break;
case RulesType.EULA:
local2.text = localeService.getText(TanksLocale.TEXT_GAME_TERMS);
break;
case RulesType.PRIVACY_POLICY:
local2.text = localeService.getText(TanksLocale.TEXT_GAME_PRIVACY_POLICY);
}
}
private function alignYourself(param1:Event) : void {
this.x = int((display.stage.stageWidth - this._windowWidth) / 2);
this.y = int((display.stage.stageHeight - this._window.height) / 2);
}
public function get callsign() : String {
return this._callsignInput.textField.text;
}
public function set callsign(param1:String) : void {
this._callsignInput.value = param1;
display.stage.focus = this._callsignInput.textField;
if(param1.length != 0) {
this.onCallsignChanged();
this._callsignInput.textField.setSelection(param1.length,param1.length);
}
}
}
}
|
package alternativa.tanks.models.continuebattle {
import projects.tanks.client.battlefield.models.continuebattle.ContinueBattleModelBase;
import projects.tanks.client.battlefield.models.continuebattle.IContinueBattleModelBase;
[ModelInfo]
public class ContinueBattleModel extends ContinueBattleModelBase implements IContinueBattleModelBase, ContinueBattle {
public function ContinueBattleModel() {
super();
}
public function continueBattle() : void {
server.continueBattle();
}
}
}
|
package alternativa.tanks.gui.chat {
import flash.events.Event;
public class CautionExternalLinkWindowEvent extends Event {
public static const CLOSING:String = "CautionExternalLinkWindowClosingEvent";
public function CautionExternalLinkWindowEvent(param1:String) {
super(param1,true);
}
}
}
|
package alternativa.tanks.display.usertitle {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.display.usertitle.ProgressBarSkin_hpLeftBlueCls.png")]
public class ProgressBarSkin_hpLeftBlueCls extends BitmapAsset {
public function ProgressBarSkin_hpLeftBlueCls() {
super();
}
}
}
|
package controls.base {
import controls.ColorButton;
import utils.FontParamsUtil;
public class ColorButtonBase extends ColorButton {
public function ColorButtonBase() {
super();
}
override public function configUI() : void {
super.configUI();
_label.sharpness = FontParamsUtil.SHARPNESS_LABEL_BASE;
_label.thickness = FontParamsUtil.THICKNESS_LABEL_BASE;
}
}
}
|
package alternativa.tanks.battle.scene3d {
import alternativa.tanks.battle.DeferredAction;
public class DeferredRendererAddition implements DeferredAction {
private var renderGroup:RenderGroup;
private var renderer:Renderer;
public function DeferredRendererAddition(param1:RenderGroup, param2:Renderer) {
super();
this.renderGroup = param1;
this.renderer = param2;
}
public function execute() : void {
this.renderGroup.addRenderer(this.renderer);
}
}
}
|
package projects.tanks.client.garage.models.item.droppablegold {
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 DroppableGoldItemModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _setShowGoldAuthorId:Long = Long.getLong(1506855567,-1914637357);
private var _setShowGoldAuthor_showCodec:ICodec;
private var model:IModel;
public function DroppableGoldItemModelServer(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._setShowGoldAuthor_showCodec = this.protocol.getCodec(new TypeCodecInfo(Boolean,false));
}
public function setShowGoldAuthor(param1:Boolean) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._setShowGoldAuthor_showCodec.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._setShowGoldAuthorId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.models.tank.spawn {
import alternativa.osgi.service.logging.LogService;
import alternativa.osgi.service.logging.Logger;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.TankControlLockBits;
import alternativa.tanks.battle.objects.tank.tankchassis.TrackedChassis;
import alternativa.tanks.models.battle.battlefield.BattleUnloadEvent;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.LocalTankParams;
import alternativa.tanks.models.tank.MovementTimeoutAndDistanceAnticheatTask;
import alternativa.tanks.models.tank.SpawnCameraConfigurator;
import alternativa.tanks.models.tank.spawn.spawnhandlers.LocalTankFirstTimeSpawner;
import alternativa.tanks.models.tank.spawn.spawnhandlers.ready2spawn.LocalReadyToSpawnHandler;
import alternativa.tanks.models.tank.spawn.spawnhandlers.ready2spawn.ReadyToSpawnHandler;
import alternativa.tanks.models.tank.spawn.spawnhandlers.ready2spawn.RemoteReadyToSpawnHandler;
import alternativa.tanks.models.tank.spawn.spawnhandlers.spawn.LocalSpawnHandler;
import alternativa.tanks.models.tank.spawn.spawnhandlers.spawn.RemoteSpawnHandler;
import alternativa.tanks.models.tank.spawn.spawnhandlers.spawn.SpawnHandler;
import alternativa.tanks.models.tank.spawn.spawnhandlers.spawn.SpectatorSpawnHandler;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.battlefield.models.user.spawn.ITankSpawnerModelBase;
import projects.tanks.client.battlefield.models.user.spawn.TankSpawnerModelBase;
import projects.tanks.client.battlefield.types.Vector3d;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
[ModelInfo]
public class TankSpawnerModel extends TankSpawnerModelBase implements ITankSpawner, ITankSpawnerModelBase, ObjectUnloadListener, ObjectLoadListener {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var logService:LogService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
private static const ZERO_VECTOR_3D:Vector3d = new Vector3d(0,0,0);
private var battleEventSupport:BattleEventSupport;
private var logger:Logger;
private var damageLogger:Logger;
private var readyToPlaceTask:ReadyToPlaceTask;
private var spawnCameraConfigurator:SpawnCameraConfigurator;
public function TankSpawnerModel() {
super();
this.logger = logService.getLogger("tank");
this.damageLogger = logService.getLogger("damage");
this.battleEventSupport = new BattleEventSupport(battleEventDispatcher);
this.battleEventSupport.addEventHandler(BattleUnloadEvent,this.onBattleFinish);
this.battleEventSupport.addEventHandler(BattleFinishEvent,this.onBattleFinish);
}
private function onBattleFinish(param1:*) : void {
this.removeReadyToPlaceTask();
}
public function prepareToSpawn(param1:Vector3d, param2:Vector3d) : void {
this.spawnCameraConfigurator.setupCamera(param1,param2);
this.removeReadyToPlaceTask();
this.readyToPlaceTask = new ReadyToPlaceTask(battleService.getRespawnDurationMs(),object);
battleService.getBattleRunner().addLogicUnit(this.readyToPlaceTask);
}
public function spawn(param1:BattleTeam, param2:Vector3d, param3:Vector3d, param4:int, param5:int) : void {
var local8:Boolean = false;
var local9:int = 0;
var local10:int = 0;
var local11:MovementTimeoutAndDistanceAnticheatTask = null;
var local12:SpawnHandler = null;
var local6:ITankModel = ITankModel(object.adapt(ITankModel));
var local7:Tank = local6.getTank();
if(local6.isLocal()) {
LocalTankParams.teamType = param1;
server.confirmSpawn(param5);
}
if(local7 != null) {
local6.removeTankFromBattle();
local7.getWeaponMount().reset();
local7.spawn(param1,param5);
local7.setSemiActivatedState();
local6.doSetHealth(param4);
local6.unlockMovementControl(TankControlLockBits.DEAD | TankControlLockBits.DISABLED);
local8 = Boolean(local6.getUserInfo().isLocal);
local9 = local8 ? int(local6.getChassisController().getControlState()) : 0;
local10 = local8 ? TrackedChassis.TURN_SPEED_COUNT : 0;
local6.setChassisState(param2,param3,ZERO_VECTOR_3D,ZERO_VECTOR_3D,local9,local10);
local7.resetInterpolatedState();
local11 = local6.getMovementAnticheatTask();
if(Boolean(local11)) {
local11.updateLatestServerTankPosition(param2,param3);
}
local12 = SpawnHandler(getData(SpawnHandler));
local12.spawn(local7,battleService.getBattle());
local6.addTankToBattle();
}
}
public function getIncarnationId() : int {
return getInitParam().incarnationId;
}
public function objectLoaded() : void {
var local2:Boolean = false;
var local1:ITankModel = ITankModel(object.adapt(ITankModel));
if(local1.isLocal()) {
local2 = Boolean(battleService.isLocalTankFirstLoad());
this.spawnCameraConfigurator = new SpawnCameraConfigurator(local2);
if(local2) {
putData(LocalTankFirstTimeSpawner,new LocalTankFirstTimeSpawner(object,server));
}
battleService.setLocalTankLoaded();
putData(ReadyToSpawnHandler,new LocalReadyToSpawnHandler(object,server));
putData(SpawnHandler,new LocalSpawnHandler());
if(Boolean(this.readyToPlaceTask)) {
this.readyToPlaceTask.setTankObject(object);
}
} else {
putData(ReadyToSpawnHandler,new RemoteReadyToSpawnHandler(object));
putData(SpawnHandler,new RemoteSpawnHandler());
}
}
public function setLocal() : void {
putData(SpawnHandler,new SpectatorSpawnHandler());
}
public function setRemote() : void {
putData(SpawnHandler,new RemoteSpawnHandler());
}
public function readyToSpawn() : void {
var local1:ReadyToSpawnHandler = ReadyToSpawnHandler(getData(ReadyToSpawnHandler));
local1.handleReadyToSpawn();
}
public function setReadyToPlace() : void {
this.removeReadyToPlaceTask();
server.setReadyToPlace();
}
private function removeReadyToPlaceTask() : void {
if(Boolean(this.readyToPlaceTask)) {
battleService.getBattleRunner().removeLogicUnit(this.readyToPlaceTask);
this.readyToPlaceTask = null;
}
}
public function objectUnloaded() : void {
var local1:ITankModel = ITankModel(object.adapt(ITankModel));
if(local1.isLocal()) {
this.spawnCameraConfigurator = null;
if(Boolean(this.readyToPlaceTask)) {
this.readyToPlaceTask.setTankObject(null);
}
}
}
}
}
|
package projects.tanks.client.panel.model.shop.kitview {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class KitViewButtonWithPriceModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:KitViewButtonWithPriceModelServer;
private var client:IKitViewButtonWithPriceModelBase = IKitViewButtonWithPriceModelBase(this);
private var modelId:Long = Long.getLong(56912630,-752681015);
public function KitViewButtonWithPriceModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new KitViewButtonWithPriceModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package platform.client.fp10.core.resource {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.LoaderInfo;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.utils.ByteArray;
import flash.utils.Dictionary;
import flash.utils.setTimeout;
public class BatchImageConstructor extends EventDispatcher {
public var images:Vector.<BitmapData>;
private var imageBytes:Vector.<ByteArray>;
private var loaders:Dictionary = new Dictionary();
private var maxParallelThreads:int;
private var numRunningLoaders:int;
private var lastImageIndex:int;
private var isRunning:Boolean;
private var numCreatedImages:int;
public function BatchImageConstructor() {
super();
}
public function buildImages(param1:Vector.<ByteArray>, param2:int) : void {
if(this.isRunning) {
throw new Error("Already running");
}
if(param1 == null) {
throw new ArgumentError("Parameter imageDatas is null");
}
this.imageBytes = param1;
this.maxParallelThreads = param2;
this.isRunning = true;
this.images = new Vector.<BitmapData>(param1.length);
this.numCreatedImages = 0;
this.numRunningLoaders = 0;
this.lastImageIndex = 0;
if(param1.length > 0) {
this.runLoaders();
} else {
setTimeout(this.complete,0);
}
}
private function runLoaders() : void {
var local1:ImageLoader = null;
while(this.numRunningLoaders < this.maxParallelThreads && this.lastImageIndex < this.imageBytes.length) {
local1 = this.createLoader(this.lastImageIndex);
this.loaders[local1] = true;
++this.numRunningLoaders;
++this.lastImageIndex;
}
}
private function onImageComplete(param1:Event) : void {
var local2:ImageLoader = ImageLoader(LoaderInfo(param1.target).loader);
--this.numRunningLoaders;
++this.numCreatedImages;
delete this.loaders[local2];
this.images[local2.index] = Bitmap(local2.content).bitmapData;
if(this.numCreatedImages == this.imageBytes.length) {
this.complete();
} else {
this.runLoaders();
}
}
private function createLoader(param1:int) : ImageLoader {
var local2:ImageLoader = new ImageLoader(param1);
local2.contentLoaderInfo.addEventListener(Event.COMPLETE,this.onImageComplete);
local2.loadBytes(this.imageBytes[this.lastImageIndex]);
return local2;
}
private function complete() : void {
this.isRunning = false;
this.imageBytes = null;
dispatchEvent(new Event(Event.COMPLETE));
}
}
}
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.InteractiveObject;
import flash.display.Loader;
import flash.events.EventDispatcher;
class ImageLoader extends Loader {
public var index:int;
public function ImageLoader(param1:int) {
super();
this.index = param1;
}
}
|
package alternativa.service
{
import alternativa.network.CommandSocket;
import alternativa.network.ICommandSender;
import alternativa.network.command.ControlCommand;
import alternativa.osgi.service.log.ILogService;
import alternativa.osgi.service.log.LogLevel;
import flash.display.Stage;
import flash.utils.Dictionary;
public class ServerLogService implements ILogService
{
private var controlSocket:CommandSocket;
private var errorLog:ErrorLog;
private var localErrorLevels:Dictionary;
public function ServerLogService(controlSocket:CommandSocket, stage:Stage, localErrorLevels:Array)
{
var i:int = 0;
super();
this.controlSocket = controlSocket;
this.errorLog = new ErrorLog(stage);
if(localErrorLevels != null)
{
this.localErrorLevels = new Dictionary();
for each(i in localErrorLevels)
{
this.localErrorLevels[i] = true;
}
}
}
public function log(level:int, message:String, exception:String = null) : void
{
ICommandSender(this.controlSocket).sendCommand(new ControlCommand(ControlCommand.LOG,"log",[level,message]));
if(this.localErrorLevels == null || this.localErrorLevels[level] != null)
{
this.errorLog.addLogMessage(LogLevel.toString(level),message);
}
}
}
}
|
package alternativa.tanks.service.battlelinkactivator {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.types.Long;
import flash.events.EventDispatcher;
import projects.tanks.client.tanksservices.types.battle.BattleInfoData;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.AlertServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.activator.BattleLinkActivatorServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.activator.BattleLinkAliveEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.activator.IBattleLinkActivatorService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import services.alertservice.AlertAnswer;
public class BattleLinkActivatorService extends EventDispatcher implements IBattleLinkActivatorService {
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var userPropertyService:IUserPropertiesService;
[Inject]
public static var userInfoService:IUserInfoService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var localeService:ILocaleService;
private var battleData:BattleInfoData;
public function BattleLinkActivatorService() {
super();
}
private static function rememberShowAlertDeadBattle() : void {
var local1:String = userPropertyService.userName;
storageService.getStorage().data.showAlertDeadBattle = local1 + "_true";
}
public function navigateToBattleUrlWithoutAvailableBattle(param1:BattleInfoData) : void {
this.navigateToBattleUrl(param1);
}
public function navigateToBattleUrl(param1:BattleInfoData) : void {
this.battleData = param1;
if(Boolean(userInfoService.isOffer()) || Boolean(lobbyLayoutService.inBattle())) {
this.showChangingStateAlert();
} else {
this.navigate(param1);
}
}
private function showChangingStateAlert() : void {
var local1:String = this.getTextForExitFromBattleAlert();
alertService.showAlert(local1,Vector.<String>([AlertAnswer.YES,AlertAnswer.CANCEL]));
alertService.addEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onQuitBattleDialogButtonPressed);
}
private function getTextForExitFromBattleAlert() : String {
if(!userInfoService.isOffer()) {
return localeService.getText(TanksLocale.TEXT_FRIENDS_EXIT_FROM_BATTLE_ALERT);
}
return localeService.getText(TanksLocale.TEXT_FRIENDS_EXIT_FROM_BATTLE_ALERT) + "\n" + localeService.getText(TanksLocale.TEXT_POSTFIX_OFFER_EXIT_BATTLE);
}
private function onQuitBattleDialogButtonPressed(param1:AlertServiceEvent) : void {
alertService.removeEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onQuitBattleDialogButtonPressed);
if(param1.typeButton == AlertAnswer.YES) {
this.navigate(this.battleData);
} else {
dispatchEvent(new BattleLinkActivatorServiceEvent(BattleLinkActivatorServiceEvent.NOT_CONFIRMED_NAVIGATE));
}
}
public function navigate(param1:BattleInfoData) : void {
dispatchEvent(new BattleLinkActivatorServiceEvent(BattleLinkActivatorServiceEvent.CONFIRMED_NAVIGATE));
this.activateBattle(param1);
}
public function activateBattle(param1:BattleInfoData) : void {
var local2:int = 1;
var local3:int = 30;
if(param1.range != null) {
local2 = param1.range.min;
local3 = param1.range.max;
}
battleInfoService.setCurrentSelectionBattleAndNotify(param1.battleId,local2,local3);
this.activateBattleById(param1.battleId);
}
public function activateBattleById(param1:Long) : void {
rememberShowAlertDeadBattle();
var local2:BattleLinkActivatorServiceEvent = new BattleLinkActivatorServiceEvent(BattleLinkActivatorServiceEvent.ACTIVATE_LINK,param1);
dispatchEvent(local2);
}
public function isAlive(param1:Long) : void {
dispatchEvent(new BattleLinkAliveEvent(BattleLinkAliveEvent.IS_ALIVE,param1));
}
public function alive(param1:Long) : void {
dispatchEvent(new BattleLinkAliveEvent(BattleLinkAliveEvent.ALIVE,param1));
}
public function dead(param1:Long) : void {
dispatchEvent(new BattleLinkAliveEvent(BattleLinkAliveEvent.DEAD,param1));
}
}
}
|
package projects.tanks.client.entrance.model.entrance.loginwithoutregistration {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class LoginWithoutRegistrationModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:LoginWithoutRegistrationModelServer;
private var client:ILoginWithoutRegistrationModelBase = ILoginWithoutRegistrationModelBase(this);
private var modelId:Long = Long.getLong(692477936,347605992);
public function LoginWithoutRegistrationModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new LoginWithoutRegistrationModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package controls.lifeindicator {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.lifeindicator.LineCharge_bitmapLeft.png")]
public class LineCharge_bitmapLeft extends BitmapAsset {
public function LineCharge_bitmapLeft() {
super();
}
}
}
|
package assets.button {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.button.button_blue_UP_LEFT.png")]
public dynamic class button_blue_UP_LEFT extends BitmapData {
public function button_blue_UP_LEFT(param1:int = 7, param2:int = 30) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.models.inventory
{
public class InventoryLock
{
public static const PLAYER_INACTIVE:int = 1;
public static const FORCED:int = 2;
public static const GUI:int = 4;
public static const WAITING_START:int = 8;
public function InventoryLock()
{
super();
}
}
}
|
package platform.client.fp10.core.resource {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.console.IConsole;
import alternativa.osgi.service.launcherparams.ILauncherParams;
import flash.events.TimerEvent;
import flash.utils.Timer;
import flash.utils.getTimer;
import platform.client.fp10.core.service.IResourceTimer;
public class ResourceTimer implements IResourceTimer {
private static const DEFAULT_TIMEOUT:int = 30000;
private static const DEFAULT_RELOAD_ATTEMTS:int = 3;
private static const MIN_TIMEOUT:int = 5000;
private var timer:Timer;
private var resources:Vector.<Resource>;
private var numResources:int;
private var timeout:int;
private var maxReloadAttemts:int;
public function ResourceTimer(param1:OSGi) {
super();
var local2:ILauncherParams = ILauncherParams(param1.getService(ILauncherParams));
this.timeout = int(local2.getParameter("resource_timeout") || DEFAULT_TIMEOUT);
if(this.timeout < MIN_TIMEOUT) {
this.timeout = MIN_TIMEOUT;
}
this.maxReloadAttemts = int(local2.getParameter("resource_reload") || DEFAULT_RELOAD_ATTEMTS);
if(this.maxReloadAttemts < 0) {
this.maxReloadAttemts = 0;
}
this.resources = new Vector.<Resource>();
this.timer = new Timer(1000);
var local3:IConsole = IConsole(param1.getService(IConsole));
local3.setCommandHandler("res_timer",this.onConsoleCommand);
}
public function getMaxReloadAttemts() : int {
return this.maxReloadAttemts;
}
public function addResource(param1:Resource) : void {
if(this.resources.indexOf(param1) < 0) {
var local2:* = this.numResources++;
this.resources[local2] = param1;
if(this.numResources == 1) {
this.timer.addEventListener(TimerEvent.TIMER,this.onTimer);
this.timer.start();
}
}
}
public function removeResource(param1:Resource) : void {
var local2:int = int(this.resources.indexOf(param1));
if(local2 >= 0) {
this.resources[local2] = this.resources[--this.numResources];
this.resources[this.numResources] = null;
if(this.numResources == 0) {
this.timer.stop();
this.timer.removeEventListener(TimerEvent.TIMER,this.onTimer);
}
}
}
private function onTimer(param1:TimerEvent) : void {
var local4:Resource = null;
var local2:int = getTimer();
var local3:int = 0;
while(local3 < this.numResources) {
local4 = this.resources[local3];
if(local2 - local4.lastActivityTime > this.timeout) {
this.removeResource(local4);
local3--;
local4.reload();
}
local3++;
}
}
private function onConsoleCommand(param1:IConsole, param2:Array) : void {
if(param2.length == 0) {
param1.addText("Available parameters:");
param1.addText("ls -- list currently tracked resources");
return;
}
switch(param2[0]) {
case "ls":
this.listResources(param1);
}
}
private function listResources(param1:IConsole) : void {
var local4:Resource = null;
var local5:int = 0;
var local2:int = getTimer();
var local3:int = 0;
while(local3 < this.numResources) {
local4 = this.resources[local3];
local5 = (local2 - local4.lastActivityTime) / 1000;
param1.addText(local3 + 1 + ". " + local4 + ", time: " + local5 + " second(s)");
local3++;
}
}
}
}
|
package controls.base {
import base.DiscreteSprite;
import controls.labels.MouseDisabledLabel;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.filters.DropShadowFilter;
public class ThreeLineBigButton extends BigButtonBase {
protected var infoContainer:Sprite = new DiscreteSprite();
protected var captionLabel:MouseDisabledLabel = new MouseDisabledLabel();
public function ThreeLineBigButton() {
super();
addChild(this.infoContainer);
this.infoContainer.addChild(this.captionLabel);
this.showInOneRow(this.captionLabel);
this.captionLabel.size = 14;
this.infoContainer.mouseEnabled = false;
this.infoContainer.filters = [new DropShadowFilter(1,45,0,0.7,1,1,1)];
}
public function setText(param1:String) : void {
this.captionLabel.text = param1;
this.captionLabel.x = (_width - this.captionLabel.width) * 0.5;
}
override public function set width(param1:Number) : void {
super.width = param1;
this.captionLabel.x = (_width - this.captionLabel.width) * 0.5;
}
protected function showInOneRow(param1:DisplayObject) : void {
param1.y = 15;
}
protected function showInTwoRows(param1:DisplayObject, param2:DisplayObject) : void {
param1.y = 8;
param2.y = 25;
}
protected function showInThreeRows(param1:DisplayObject, param2:DisplayObject, param3:DisplayObject) : void {
param1.y = 3;
param2.y = 16;
param3.y = 28;
}
}
}
|
package alternativa.tanks.model.item.drone {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.GarageWindowEvent;
import alternativa.tanks.gui.ItemInfoPanel;
import alternativa.tanks.gui.buttons.GarageButton;
import alternativa.tanks.gui.buttons.TimerButton;
import alternativa.tanks.gui.buttons.TimerButtonEvent;
import alternativa.tanks.gui.upgrade.ItemPropertyUpgradeEvent;
import alternativa.tanks.gui.upgrade.UpgradeButton;
import alternativa.tanks.model.item.upgradable.UpgradableItem;
import alternativa.tanks.service.delaymountcategory.IDelayMountCategoryService;
import alternativa.tanks.service.item.ItemService;
import alternativa.tanks.tracker.ITrackerService;
import controls.timer.CountDownTimer;
import flash.display.DisplayObjectContainer;
import flash.events.IEventDispatcher;
import flash.events.MouseEvent;
import platform.client.fp10.core.type.AutoClosable;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.garage.UserGarageActionsService;
public class DronePanel implements AutoClosable {
[Inject]
public static var itemService:ItemService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var trackerService:ITrackerService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var userGarageActionsService:UserGarageActionsService;
[Inject]
public static var delayMountCategoryService:IDelayMountCategoryService;
private const GA_CATEGORY:String = "garage";
private const BUTTON_WIDTH:Number = 120;
private const MARGIN:Number = 11;
private const SPACE:Number = 15;
private var buyButton:GarageButton = new GarageButton();
private var upgradeButton:UpgradeButton = new UpgradeButton();
private var equipButton:TimerButton = new TimerButton();
private var item:IGameObject;
private var garageWindowDispatcher:IEventDispatcher;
public function DronePanel() {
super();
this.buyButton.width = this.BUTTON_WIDTH;
this.upgradeButton.width = this.BUTTON_WIDTH;
this.equipButton.width = this.BUTTON_WIDTH;
this.buyButton.x = this.MARGIN;
this.upgradeButton.x = this.buyButton.x + this.BUTTON_WIDTH + this.SPACE;
this.equipButton.x = this.upgradeButton.x + this.BUTTON_WIDTH + this.SPACE;
this.buyButton.setText(localeService.getText(TanksLocale.TEXT_GARAGE_INFO_PANEL_BUTTON_BUY_TEXT));
this.buyButton.addEventListener(MouseEvent.CLICK,this.onButtonBuyClick);
this.equipButton.addEventListener(MouseEvent.CLICK,this.onButtonEquipClick);
this.upgradeButton.addEventListener(MouseEvent.CLICK,this.onButtonUpgradeClick);
}
private function onButtonUpgradeClick(param1:MouseEvent) : * {
userGarageActionsService.upgradeItem(this.item);
this.garageWindowDispatcher.dispatchEvent(new ItemPropertyUpgradeEvent(ItemPropertyUpgradeEvent.SELECT_WINDOW_OPENED));
}
private function onButtonEquipClick(param1:MouseEvent) : * {
if(itemService.isMounted(this.item)) {
trackerService.trackEvent(this.GA_CATEGORY,GarageWindowEvent.UNMOUNT_ITEM,itemService.getName(this.item));
this.garageWindowDispatcher.dispatchEvent(new GarageWindowEvent(GarageWindowEvent.UNMOUNT_ITEM,this.item));
} else {
trackerService.trackEvent(this.GA_CATEGORY,GarageWindowEvent.SETUP_ITEM,itemService.getName(this.item));
this.garageWindowDispatcher.dispatchEvent(new GarageWindowEvent(GarageWindowEvent.SETUP_ITEM,this.item));
}
this.updateButtonsLabels();
this.updateEquipButton();
}
public function onDoubleClick() : * {
if(!itemService.isMounted(this.item) && Boolean(this.equipButton.enabled)) {
this.onButtonEquipClick(null);
}
}
private function onButtonBuyClick(param1:MouseEvent) : * {
userGarageActionsService.buyItem(this.item);
trackerService.trackEvent(this.GA_CATEGORY,GarageWindowEvent.BUY_ITEM,itemService.getName(this.item));
this.garageWindowDispatcher.dispatchEvent(new GarageWindowEvent(GarageWindowEvent.BUY_ITEM,this.item));
}
public function close() : void {
this.buyButton.removeEventListener(MouseEvent.CLICK,this.onButtonBuyClick);
this.equipButton.removeEventListener(MouseEvent.CLICK,this.onButtonEquipClick);
this.equipButton.removeEventListener(TimerButtonEvent.TIME_ON_COMPLETE_TIMER_BUTTON,this.onCompletedTimer);
this.equipButton.hideTime();
}
public function updateActionElements(param1:DisplayObjectContainer, param2:IEventDispatcher, param3:IGameObject) : * {
this.item = param3;
this.garageWindowDispatcher = param2;
param1.addChild(this.buyButton);
param1.addChild(this.equipButton);
param1.addChild(this.upgradeButton);
this.updateButtons();
}
private function updateButtons() : * {
this.updateButtonsVisibility();
this.updateButtonsLabels();
this.updateEquipButton();
}
private function updateButtonsVisibility() : * {
this.buyButton.visible = itemService.canBuy(this.item);
this.upgradeButton.visible = !this.buyButton.visible;
this.equipButton.visible = !this.buyButton.visible;
}
private function updateButtonsLabels() : * {
var local1:* = ItemInfoPanel.getRequiredRank(itemService.getMinRankIndex(this.item),itemService.getMaxRankIndex(this.item));
this.buyButton.setInfo(itemService.getPrice(this.item),1,local1,itemService.isPremiumItem(this.item));
var local2:* = this.item.adapt(UpgradableItem);
if(Boolean(local2.isUpgrading())) {
this.upgradeButton.setUpgradingButton(local2.getCountDownTimer(),local2.hasSpeedUpDiscount());
} else if(itemService.isFullUpgraded(this.item)) {
this.upgradeButton.setUpgradedButton();
} else {
this.upgradeButton.setUpgradeButton(local2.hasUpgradeDiscount());
}
this.equipButton.label = this.itemCouldBeMounted() ? localeService.getText(TanksLocale.TEXT_GARAGE_INFO_PANEL_BUTTON_EQUIP_TEXT) : localeService.getText(TanksLocale.TEXT_GARAGE_INFO_PANEL_BUTTON_UNEQUIP_TEXT);
}
private function updateEquipButton() : * {
if(Boolean(lobbyLayoutService.inBattle()) && !battleInfoService.reArmorEnabled && !itemService.isMounted(this.item)) {
this.equipButton.enabled = false;
return;
}
if(!itemService.hasItem(this.item)) {
this.equipButton.enabled = false;
this.equipButton.hideTime();
return;
}
this.controlTimerEquipButton();
}
private function controlTimerEquipButton() : * {
var local1:CountDownTimer = delayMountCategoryService.getDownTimer(this.item);
if(Boolean(lobbyLayoutService.inBattle()) && local1.getRemainingSeconds() > 0 && !itemService.isMounted(this.item)) {
this.equipButton.startTimer(local1);
this.equipButton.addEventListener(TimerButtonEvent.TIME_ON_COMPLETE_TIMER_BUTTON,this.onCompletedTimer);
} else {
this.equipButton.hideTime();
this.equipButton.enabled = true;
}
}
private function onCompletedTimer(param1:TimerButtonEvent) : * {
this.equipButton.enabled = true;
this.equipButton.removeEventListener(TimerButtonEvent.TIME_ON_COMPLETE_TIMER_BUTTON,this.onCompletedTimer);
}
private function itemCouldBeMounted() : Boolean {
return Boolean(itemService.hasItem(this.item)) && !itemService.isMounted(this.item);
}
}
}
|
package alternativa.tanks.engine3d {
import alternativa.engine3d.materials.TextureMaterial;
public class TextureAnimation {
public var material:TextureMaterial;
public var frames:Vector.<UVFrame>;
public var fps:Number;
public function TextureAnimation(param1:TextureMaterial, param2:Vector.<UVFrame>, param3:Number = 0) {
super();
this.material = param1;
this.frames = param2;
this.fps = param3;
}
}
}
|
package alternativa.tanks.models.weapon.gauss.state.targetselection {
import alternativa.math.Vector3;
import alternativa.types.Long;
public class LockResult {
public var targetId:Long;
public var globalLockPoint:* = new Vector3();
public var localLockPoint:* = new Vector3();
public function LockResult() {
super();
}
public function update(param1:Long, param2:Vector3, param3:Vector3) : * {
this.targetId = param1;
this.globalLockPoint.copy(param2);
this.localLockPoint.copy(param3);
}
public function copy(param1:LockResult) : * {
this.targetId = param1.targetId;
this.globalLockPoint.copy(param1.globalLockPoint);
this.localLockPoint.copy(param1.localLockPoint);
}
}
}
|
package projects.tanks.client.garage.prototypes.item.renameitem {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class RenameModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:RenameModelServer;
private var client:IRenameModelBase = IRenameModelBase(this);
private var modelId:Long = Long.getLong(841189855,-1268110049);
private var _renameFailId:Long = Long.getLong(1282635693,192675762);
private var _renameSuccessfullId:Long = Long.getLong(2064863564,657165826);
private var _renameSuccessfull_oldNameCodec:ICodec;
private var _renameSuccessfull_newNameCodec:ICodec;
public function RenameModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new RenameModelServer(IModel(this));
this._renameSuccessfull_oldNameCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._renameSuccessfull_newNameCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._renameFailId:
this.client.renameFail();
break;
case this._renameSuccessfullId:
this.client.renameSuccessfull(String(this._renameSuccessfull_oldNameCodec.decode(param2)),String(this._renameSuccessfull_newNameCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.protocol.codec.primitive
{
import alternativa.protocol.codec.AbstractCodec;
import alternativa.protocol.codec.NullMap;
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
public class FloatCodec extends AbstractCodec
{
public function FloatCodec()
{
super();
nullValue = Number.NEGATIVE_INFINITY;
}
override protected function doDecode(reader:IDataInput, nullmap:NullMap, notnull:Boolean) : Object
{
return reader.readFloat();
}
override protected function doEncode(dest:IDataOutput, object:Object, nullmap:NullMap, notnull:Boolean) : void
{
dest.writeFloat(Number(object));
}
}
}
|
package alternativa.gfx.core
{
import alternativa.gfx.alternativagfx;
import flash.display3D.Context3D;
import flash.display3D.Context3DTextureFormat;
import flash.utils.ByteArray;
import flash.utils.Endian;
use namespace alternativagfx;
public class CompressedTextureResource extends TextureResource
{
private var _byteArray:ByteArray;
private var _width:int;
private var _height:int;
public function CompressedTextureResource(param1:ByteArray)
{
super();
this._byteArray = param1;
this._byteArray.endian = Endian.LITTLE_ENDIAN;
this._byteArray.position = 7;
this._width = 1 << this._byteArray.readByte();
this._height = 1 << this._byteArray.readByte();
this._byteArray.position = 0;
}
public function get byteArray() : ByteArray
{
return this._byteArray;
}
public function get width() : int
{
return this._width;
}
public function get height() : int
{
return this._height;
}
override public function dispose() : void
{
super.dispose();
this._byteArray = null;
this._width = 0;
this._height = 0;
}
override public function get available() : Boolean
{
return this._byteArray != null;
}
override public function create(param1:Context3D) : void
{
super.create(param1);
texture = param1.createTexture(this._width,this._height,Context3DTextureFormat.COMPRESSED,false);
}
override public function upload() : void
{
super.upload();
texture.uploadCompressedTextureFromByteArray(this._byteArray,0);
}
}
}
|
package _codec.projects.tanks.client.garage.models.shopabonement {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.shopabonement.ShopAbonementCC;
public class VectorCodecShopAbonementCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecShopAbonementCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ShopAbonementCC,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.<ShopAbonementCC> = new Vector.<ShopAbonementCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ShopAbonementCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ShopAbonementCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ShopAbonementCC> = Vector.<ShopAbonementCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapBigRank12.png")]
public class DefaultRanksBitmaps_bitmapBigRank12 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapBigRank12() {
super();
}
}
}
|
package projects.tanks.client.battleselect.model.battleselect {
import platform.client.fp10.core.type.IGameObject;
public interface IBattleSelectModelBase {
function battleItemsPacketJoinSuccess() : void;
function select(param1:IGameObject) : void;
}
}
|
package alternativa.engine3d.objects {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.engine3d.core.VG;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import alternativa.gfx.core.IndexBufferResource;
import alternativa.gfx.core.VertexBufferResource;
import flash.geom.Vector3D;
import flash.utils.Dictionary;
use namespace alternativa3d;
public class BSP extends Object3D {
public var clipping:int = 2;
public var threshold:Number = 0.01;
public var splitAnalysis:Boolean = true;
alternativa3d var vertexList:Vertex;
alternativa3d var root:Node;
alternativa3d var faces:Vector.<Face> = new Vector.<Face>();
alternativa3d var vertexBuffer:VertexBufferResource;
alternativa3d var indexBuffer:IndexBufferResource;
alternativa3d var numTriangles:int;
public function BSP() {
super();
}
public function createTree(param1:Mesh, param2:Boolean = false) : void {
this.destroyTree();
if(!param2) {
param1 = param1.clone() as Mesh;
}
var local3:Face = param1.alternativa3d::faceList;
this.alternativa3d::vertexList = param1.alternativa3d::vertexList;
param1.alternativa3d::faceList = null;
param1.alternativa3d::vertexList = null;
var local4:Vertex = this.alternativa3d::vertexList;
while(local4 != null) {
local4.alternativa3d::transformId = 0;
local4.id = null;
local4 = local4.alternativa3d::next;
}
var local5:int = 0;
var local6:Face = local3;
while(local6 != null) {
local6.alternativa3d::calculateBestSequenceAndNormal();
local6.id = null;
this.alternativa3d::faces[local5] = local6;
local5++;
local6 = local6.alternativa3d::next;
}
if(local3 != null) {
this.alternativa3d::root = this.createNode(local3);
}
calculateBounds();
}
public function destroyTree() : void {
this.alternativa3d::deleteResources();
this.alternativa3d::vertexList = null;
if(this.alternativa3d::root != null) {
this.destroyNode(this.alternativa3d::root);
this.alternativa3d::root = null;
}
this.alternativa3d::faces.length = 0;
}
public function setMaterialToAllFaces(param1:Material) : void {
var local4:Face = null;
this.alternativa3d::deleteResources();
var local2:int = int(this.alternativa3d::faces.length);
var local3:int = 0;
while(local3 < local2) {
local4 = this.alternativa3d::faces[local3];
local4.material = param1;
local3++;
}
if(this.alternativa3d::root != null) {
this.setMaterialToNode(this.alternativa3d::root,param1);
}
}
override public function intersectRay(param1:Vector3D, param2:Vector3D, param3:Dictionary = null, param4:Camera3D = null) : RayIntersectionData {
if(param3 != null && param3[this] || this.alternativa3d::root == null) {
return null;
}
if(!alternativa3d::boundIntersectRay(param1,param2,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ)) {
return null;
}
return this.intersectRayNode(this.alternativa3d::root,param1.x,param1.y,param1.z,param2.x,param2.y,param2.z);
}
private function intersectRayNode(param1:Node, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number) : RayIntersectionData {
var local8:RayIntersectionData = null;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Face = null;
var local19:Wrapper = null;
var local20:Vertex = null;
var local21:Vertex = null;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:Number = NaN;
var local25:Number = NaN;
var local26:Number = NaN;
var local27:Number = NaN;
var local9:Number = param1.normalX;
var local10:Number = param1.normalY;
var local11:Number = param1.normalZ;
var local12:Number = local9 * param2 + local10 * param3 + local11 * param4 - param1.offset;
if(local12 > 0) {
if(param1.positive != null) {
local8 = this.intersectRayNode(param1.positive,param2,param3,param4,param5,param6,param7);
if(local8 != null) {
return local8;
}
}
local13 = param5 * local9 + param6 * local10 + param7 * local11;
if(local13 < 0) {
local14 = -local12 / local13;
local15 = param2 + param5 * local14;
local16 = param3 + param6 * local14;
local17 = param4 + param7 * local14;
local18 = param1.faceList;
while(true) {
if(local18 != null) {
local19 = local18.alternativa3d::wrapper;
while(local19 != null) {
local20 = local19.alternativa3d::vertex;
local21 = local19.alternativa3d::next != null ? local19.alternativa3d::next.alternativa3d::vertex : local18.alternativa3d::wrapper.alternativa3d::vertex;
local22 = local21.x - local20.x;
local23 = local21.y - local20.y;
local24 = local21.z - local20.z;
local25 = local15 - local20.x;
local26 = local16 - local20.y;
local27 = local17 - local20.z;
if((local27 * local23 - local26 * local24) * local9 + (local25 * local24 - local27 * local22) * local10 + (local26 * local22 - local25 * local23) * local11 < 0) {
break;
}
local19 = local19.alternativa3d::next;
}
if(local19 == null) {
break;
}
local18 = local18.alternativa3d::next;
continue;
}
if(param1.negative != null) {
return this.intersectRayNode(param1.negative,param2,param3,param4,param5,param6,param7);
}
}
local8 = new RayIntersectionData();
local8.object = this;
local8.face = local18;
local8.point = new Vector3D(local15,local16,local17);
local8.uv = local18.getUV(local8.point);
local8.time = local14;
return local8;
}
} else {
if(param1.negative != null) {
local8 = this.intersectRayNode(param1.negative,param2,param3,param4,param5,param6,param7);
if(local8 != null) {
return local8;
}
}
if(param1.positive != null && param5 * local9 + param6 * local10 + param7 * local11 > 0) {
return this.intersectRayNode(param1.positive,param2,param3,param4,param5,param6,param7);
}
}
return null;
}
override alternativa3d function checkIntersection(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Dictionary) : Boolean {
return this.alternativa3d::root != null ? this.checkIntersectionNode(this.alternativa3d::root,param1,param2,param3,param4,param5,param6,param7) : false;
}
private function checkIntersectionNode(param1:Node, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number) : Boolean {
var local9:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Face = null;
var local19:Wrapper = null;
var local20:Vertex = null;
var local21:Vertex = null;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:Number = NaN;
var local25:Number = NaN;
var local26:Number = NaN;
var local27:Number = NaN;
var local10:Number = param1.normalX;
var local11:Number = param1.normalY;
var local12:Number = param1.normalZ;
var local13:Number = local10 * param2 + local11 * param3 + local12 * param4 - param1.offset;
if(local13 > 0) {
local9 = param5 * local10 + param6 * local11 + param7 * local12;
if(local9 < 0) {
local14 = -local13 / local9;
if(local14 < param8) {
local15 = param2 + param5 * local14;
local16 = param3 + param6 * local14;
local17 = param4 + param7 * local14;
local18 = param1.faceList;
while(true) {
if(local18 != null) {
local19 = local18.alternativa3d::wrapper;
while(local19 != null) {
local20 = local19.alternativa3d::vertex;
local21 = local19.alternativa3d::next != null ? local19.alternativa3d::next.alternativa3d::vertex : local18.alternativa3d::wrapper.alternativa3d::vertex;
local22 = local21.x - local20.x;
local23 = local21.y - local20.y;
local24 = local21.z - local20.z;
local25 = local15 - local20.x;
local26 = local16 - local20.y;
local27 = local17 - local20.z;
if((local27 * local23 - local26 * local24) * local10 + (local25 * local24 - local27 * local22) * local11 + (local26 * local22 - local25 * local23) * local12 < 0) {
break;
}
local19 = local19.alternativa3d::next;
}
if(local19 == null) {
break;
}
local18 = local18.alternativa3d::next;
continue;
}
if(param1.negative != null && this.checkIntersectionNode(param1.negative,param2,param3,param4,param5,param6,param7,param8)) {
return true;
}
}
return true;
}
}
return param1.positive != null && this.checkIntersectionNode(param1.positive,param2,param3,param4,param5,param6,param7,param8);
}
if(param1.negative != null && this.checkIntersectionNode(param1.negative,param2,param3,param4,param5,param6,param7,param8)) {
return true;
}
if(param1.positive != null) {
local9 = param5 * local10 + param6 * local11 + param7 * local12;
return local9 > 0 && -local13 / local9 < param8 && this.checkIntersectionNode(param1.positive,param2,param3,param4,param5,param6,param7,param8);
}
return false;
}
override alternativa3d function collectPlanes(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Vector3D, param5:Vector3D, param6:Vector.<Face>, param7:Dictionary = null) : void {
if(param7 != null && param7[this] || this.alternativa3d::root == null) {
return;
}
var local8:Vector3D = alternativa3d::calculateSphere(param1,param2,param3,param4,param5);
if(!alternativa3d::boundIntersectSphere(local8,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ)) {
return;
}
this.collectPlanesNode(this.alternativa3d::root,local8,param6);
}
private function collectPlanesNode(param1:Node, param2:Vector3D, param3:Vector.<Face>) : void {
var local5:Face = null;
var local6:Wrapper = null;
var local7:Vertex = null;
var local4:Number = param1.normalX * param2.x + param1.normalY * param2.y + param1.normalZ * param2.z - param1.offset;
if(local4 >= param2.w) {
if(param1.positive != null) {
this.collectPlanesNode(param1.positive,param2,param3);
}
} else if(local4 <= -param2.w) {
if(param1.negative != null) {
this.collectPlanesNode(param1.negative,param2,param3);
}
} else {
local5 = param1.faceList;
while(local5 != null) {
local6 = local5.alternativa3d::wrapper;
while(local6 != null) {
local7 = local6.alternativa3d::vertex;
local7.alternativa3d::cameraX = alternativa3d::ma * local7.x + alternativa3d::mb * local7.y + alternativa3d::mc * local7.z + alternativa3d::md;
local7.alternativa3d::cameraY = alternativa3d::me * local7.x + alternativa3d::mf * local7.y + alternativa3d::mg * local7.z + alternativa3d::mh;
local7.alternativa3d::cameraZ = alternativa3d::mi * local7.x + alternativa3d::mj * local7.y + alternativa3d::mk * local7.z + alternativa3d::ml;
local6 = local6.alternativa3d::next;
}
param3.push(local5);
local5 = local5.alternativa3d::next;
}
if(param1.positive != null) {
this.collectPlanesNode(param1.positive,param2,param3);
}
if(param1.negative != null) {
this.collectPlanesNode(param1.negative,param2,param3);
}
}
}
override public function clone() : Object3D {
var local1:BSP = new BSP();
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
var local3:Vertex = null;
var local4:Vertex = null;
var local8:Vertex = null;
var local9:Face = null;
var local10:Face = null;
var local11:Wrapper = null;
var local12:Wrapper = null;
var local13:Wrapper = null;
super.clonePropertiesFrom(param1);
var local2:BSP = param1 as BSP;
this.clipping = local2.clipping;
this.threshold = local2.threshold;
this.splitAnalysis = local2.splitAnalysis;
local3 = local2.alternativa3d::vertexList;
while(local3 != null) {
local8 = new Vertex();
local8.x = local3.x;
local8.y = local3.y;
local8.z = local3.z;
local8.u = local3.u;
local8.v = local3.v;
local8.normalX = local3.normalX;
local8.normalY = local3.normalY;
local8.normalZ = local3.normalZ;
local3.alternativa3d::value = local8;
if(local4 != null) {
local4.alternativa3d::next = local8;
} else {
this.alternativa3d::vertexList = local8;
}
local4 = local8;
local3 = local3.alternativa3d::next;
}
var local5:Dictionary = new Dictionary();
var local6:int = int(local2.alternativa3d::faces.length);
var local7:int = 0;
while(local7 < local6) {
local9 = local2.alternativa3d::faces[local7];
local10 = new Face();
local10.material = local9.material;
local10.smoothingGroups = local9.smoothingGroups;
local10.alternativa3d::normalX = local9.alternativa3d::normalX;
local10.alternativa3d::normalY = local9.alternativa3d::normalY;
local10.alternativa3d::normalZ = local9.alternativa3d::normalZ;
local10.alternativa3d::offset = local9.alternativa3d::offset;
local11 = null;
local12 = local9.alternativa3d::wrapper;
while(local12 != null) {
local13 = new Wrapper();
local13.alternativa3d::vertex = local12.alternativa3d::vertex.alternativa3d::value;
if(local11 != null) {
local11.alternativa3d::next = local13;
} else {
local10.alternativa3d::wrapper = local13;
}
local11 = local13;
local12 = local12.alternativa3d::next;
}
this.alternativa3d::faces[local7] = local10;
local5[local9] = local10;
local7++;
}
if(local2.alternativa3d::root != null) {
this.alternativa3d::root = local2.cloneNode(local2.alternativa3d::root,local5);
}
local3 = local2.alternativa3d::vertexList;
while(local3 != null) {
local3.alternativa3d::value = null;
local3 = local3.alternativa3d::next;
}
}
private function cloneNode(param1:Node, param2:Dictionary) : Node {
var local4:Face = null;
var local6:Face = null;
var local7:Wrapper = null;
var local8:Wrapper = null;
var local9:Wrapper = null;
var local3:Node = new Node();
var local5:Face = param1.faceList;
while(local5 != null) {
local6 = param2[local5];
if(local6 == null) {
local6 = new Face();
local6.material = local5.material;
local6.alternativa3d::normalX = local5.alternativa3d::normalX;
local6.alternativa3d::normalY = local5.alternativa3d::normalY;
local6.alternativa3d::normalZ = local5.alternativa3d::normalZ;
local6.alternativa3d::offset = local5.alternativa3d::offset;
local7 = null;
local8 = local5.alternativa3d::wrapper;
while(local8 != null) {
local9 = new Wrapper();
local9.alternativa3d::vertex = local8.alternativa3d::vertex.alternativa3d::value;
if(local7 != null) {
local7.alternativa3d::next = local9;
} else {
local6.alternativa3d::wrapper = local9;
}
local7 = local9;
local8 = local8.alternativa3d::next;
}
}
if(local3.faceList != null) {
local4.alternativa3d::next = local6;
} else {
local3.faceList = local6;
}
local4 = local6;
local5 = local5.alternativa3d::next;
}
local3.normalX = param1.normalX;
local3.normalY = param1.normalY;
local3.normalZ = param1.normalZ;
local3.offset = param1.offset;
if(param1.negative != null) {
local3.negative = this.cloneNode(param1.negative,param2);
}
if(param1.positive != null) {
local3.positive = this.cloneNode(param1.positive,param2);
}
return local3;
}
private function setMaterialToNode(param1:Node, param2:Material) : void {
var local3:Face = param1.faceList;
while(local3 != null) {
local3.material = param2;
local3 = local3.alternativa3d::next;
}
if(param1.negative != null) {
this.setMaterialToNode(param1.negative,param2);
}
if(param1.positive != null) {
this.setMaterialToNode(param1.positive,param2);
}
}
override alternativa3d function draw(param1:Camera3D) : void {
var local4:Face = null;
var local5:Face = null;
var local6:Face = null;
var local7:Face = null;
var local8:Vertex = null;
if(this.alternativa3d::root == null) {
return;
}
if(this.clipping == 0) {
if(Boolean(alternativa3d::culling & 1)) {
return;
}
alternativa3d::culling = 0;
}
this.alternativa3d::prepareResources();
if(alternativa3d::useDepth = !param1.view.alternativa3d::constrained && (param1.softTransparency && param1.softTransparencyStrength > 0 || param1.ssao && param1.ssaoStrength > 0 || param1.deferredLighting && param1.deferredLightingStrength > 0) && alternativa3d::concatenatedAlpha >= depthMapAlphaThreshold) {
param1.alternativa3d::depthObjects[param1.alternativa3d::depthCount] = this;
++param1.alternativa3d::depthCount;
}
var local2:int = param1.debug ? int(param1.alternativa3d::checkInDebug(this)) : 0;
var local3:Face = this.alternativa3d::faces[0];
if(alternativa3d::concatenatedAlpha >= 1 && alternativa3d::concatenatedBlendMode == "normal" && local3.material != null && (!local3.material.alternativa3d::transparent || local3.material.alphaTestThreshold > 0)) {
param1.alternativa3d::addOpaque(local3.material,this.alternativa3d::vertexBuffer,this.alternativa3d::indexBuffer,0,this.alternativa3d::numTriangles,this);
if(local2 > 0) {
if(Boolean(local2 & Debug.EDGES)) {
Debug.alternativa3d::drawEdges(param1,null,16777215);
}
if(Boolean(local2 & Debug.BOUNDS)) {
Debug.alternativa3d::drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ);
}
}
} else {
if(alternativa3d::transformId > 500000000) {
alternativa3d::transformId = 0;
local8 = this.alternativa3d::vertexList;
while(local8 != null) {
local8.alternativa3d::transformId = 0;
local8 = local8.alternativa3d::next;
}
}
++alternativa3d::transformId;
alternativa3d::calculateInverseMatrix();
local4 = this.collectNode(this.alternativa3d::root);
if(local4 == null) {
return;
}
if(alternativa3d::culling > 0) {
if(this.clipping == 1) {
local4 = param1.alternativa3d::cull(local4,alternativa3d::culling);
} else {
local4 = param1.alternativa3d::clip(local4,alternativa3d::culling);
}
if(local4 == null) {
return;
}
}
if(local2 > 0) {
if(Boolean(local2 & Debug.EDGES)) {
Debug.alternativa3d::drawEdges(param1,local4,16777215);
}
if(Boolean(local2 & Debug.BOUNDS)) {
Debug.alternativa3d::drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ);
}
}
local7 = local4;
while(local7 != null) {
local5 = local7.alternativa3d::processNext;
if(local5 == null || local5.material != local4.material) {
local7.alternativa3d::processNext = null;
if(local4.material != null) {
local4.alternativa3d::processNegative = local6;
local6 = local4;
} else {
while(local4 != null) {
local7 = local4.alternativa3d::processNext;
local4.alternativa3d::processNext = null;
local4 = local7;
}
}
local4 = local5;
}
local7 = local5;
}
local4 = local6;
while(local4 != null) {
local5 = local4.alternativa3d::processNegative;
local4.alternativa3d::processNegative = null;
param1.alternativa3d::addTransparent(local4,this);
local4 = local5;
}
}
alternativa3d::transformConst[0] = alternativa3d::ma;
alternativa3d::transformConst[1] = alternativa3d::mb;
alternativa3d::transformConst[2] = alternativa3d::mc;
alternativa3d::transformConst[3] = alternativa3d::md;
alternativa3d::transformConst[4] = alternativa3d::me;
alternativa3d::transformConst[5] = alternativa3d::mf;
alternativa3d::transformConst[6] = alternativa3d::mg;
alternativa3d::transformConst[7] = alternativa3d::mh;
alternativa3d::transformConst[8] = alternativa3d::mi;
alternativa3d::transformConst[9] = alternativa3d::mj;
alternativa3d::transformConst[10] = alternativa3d::mk;
alternativa3d::transformConst[11] = alternativa3d::ml;
}
override alternativa3d function getVG(param1:Camera3D) : VG {
var local4:Face = null;
var local5:Vertex = null;
if(this.alternativa3d::root == null) {
return null;
}
if(this.clipping == 0) {
if(Boolean(alternativa3d::culling & 1)) {
return null;
}
alternativa3d::culling = 0;
}
this.alternativa3d::prepareResources();
if(alternativa3d::useDepth = !param1.view.alternativa3d::constrained && (param1.softTransparency && param1.softTransparencyStrength > 0 || param1.ssao && param1.ssaoStrength > 0 || param1.deferredLighting && param1.deferredLightingStrength > 0) && alternativa3d::concatenatedAlpha >= depthMapAlphaThreshold) {
param1.alternativa3d::depthObjects[param1.alternativa3d::depthCount] = this;
++param1.alternativa3d::depthCount;
}
var local2:int = param1.debug ? int(param1.alternativa3d::checkInDebug(this)) : 0;
var local3:Face = this.alternativa3d::faces[0];
if(alternativa3d::concatenatedAlpha >= 1 && alternativa3d::concatenatedBlendMode == "normal" && local3.material != null && (!local3.material.alternativa3d::transparent || local3.material.alphaTestThreshold > 0)) {
param1.alternativa3d::addOpaque(local3.material,this.alternativa3d::vertexBuffer,this.alternativa3d::indexBuffer,0,this.alternativa3d::numTriangles,this);
if(local2 > 0) {
if(Boolean(local2 & Debug.EDGES)) {
Debug.alternativa3d::drawEdges(param1,null,16777215);
}
if(Boolean(local2 & Debug.BOUNDS)) {
Debug.alternativa3d::drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ);
}
}
alternativa3d::transformConst[0] = alternativa3d::ma;
alternativa3d::transformConst[1] = alternativa3d::mb;
alternativa3d::transformConst[2] = alternativa3d::mc;
alternativa3d::transformConst[3] = alternativa3d::md;
alternativa3d::transformConst[4] = alternativa3d::me;
alternativa3d::transformConst[5] = alternativa3d::mf;
alternativa3d::transformConst[6] = alternativa3d::mg;
alternativa3d::transformConst[7] = alternativa3d::mh;
alternativa3d::transformConst[8] = alternativa3d::mi;
alternativa3d::transformConst[9] = alternativa3d::mj;
alternativa3d::transformConst[10] = alternativa3d::mk;
alternativa3d::transformConst[11] = alternativa3d::ml;
return null;
}
if(alternativa3d::transformId > 500000000) {
alternativa3d::transformId = 0;
local5 = this.alternativa3d::vertexList;
while(local5 != null) {
local5.alternativa3d::transformId = 0;
local5 = local5.alternativa3d::next;
}
}
++alternativa3d::transformId;
alternativa3d::calculateInverseMatrix();
alternativa3d::transformConst[0] = alternativa3d::ma;
alternativa3d::transformConst[1] = alternativa3d::mb;
alternativa3d::transformConst[2] = alternativa3d::mc;
alternativa3d::transformConst[3] = alternativa3d::md;
alternativa3d::transformConst[4] = alternativa3d::me;
alternativa3d::transformConst[5] = alternativa3d::mf;
alternativa3d::transformConst[6] = alternativa3d::mg;
alternativa3d::transformConst[7] = alternativa3d::mh;
alternativa3d::transformConst[8] = alternativa3d::mi;
alternativa3d::transformConst[9] = alternativa3d::mj;
alternativa3d::transformConst[10] = alternativa3d::mk;
alternativa3d::transformConst[11] = alternativa3d::ml;
local4 = this.prepareNode(this.alternativa3d::root,alternativa3d::culling,param1);
if(local4 != null) {
return VG.alternativa3d::create(this,local4,3,local2,false);
}
return null;
}
alternativa3d function prepareResources() : void {
var local1:Vector.<Number> = null;
var local2:int = 0;
var local3:int = 0;
var local4:Vertex = null;
var local5:Vector.<uint> = null;
var local6:int = 0;
var local7:Face = null;
var local8:Wrapper = null;
var local9:uint = 0;
var local10:uint = 0;
var local11:uint = 0;
if(this.alternativa3d::vertexBuffer == null) {
local1 = new Vector.<Number>();
local2 = 0;
local3 = 0;
local4 = this.alternativa3d::vertexList;
while(local4 != null) {
local1[local2] = local4.x;
local2++;
local1[local2] = local4.y;
local2++;
local1[local2] = local4.z;
local2++;
local1[local2] = local4.u;
local2++;
local1[local2] = local4.v;
local2++;
local1[local2] = local4.normalX;
local2++;
local1[local2] = local4.normalY;
local2++;
local1[local2] = local4.normalZ;
local2++;
local4.alternativa3d::index = local3;
local3++;
local4 = local4.alternativa3d::next;
}
this.alternativa3d::vertexBuffer = new VertexBufferResource(local1,8);
local5 = new Vector.<uint>();
local6 = 0;
this.alternativa3d::numTriangles = 0;
for each(local7 in this.alternativa3d::faces) {
local8 = local7.alternativa3d::wrapper;
local9 = uint(local8.alternativa3d::vertex.alternativa3d::index);
local8 = local8.alternativa3d::next;
local10 = uint(local8.alternativa3d::vertex.alternativa3d::index);
local8 = local8.alternativa3d::next;
while(local8 != null) {
local11 = uint(local8.alternativa3d::vertex.alternativa3d::index);
local5[local6] = local9;
local6++;
local5[local6] = local10;
local6++;
local5[local6] = local11;
local6++;
local10 = local11;
++this.alternativa3d::numTriangles;
local8 = local8.alternativa3d::next;
}
}
this.alternativa3d::indexBuffer = new IndexBufferResource(local5);
}
}
alternativa3d function deleteResources() : void {
if(this.alternativa3d::vertexBuffer != null) {
this.alternativa3d::vertexBuffer.dispose();
this.alternativa3d::vertexBuffer = null;
this.alternativa3d::indexBuffer.dispose();
this.alternativa3d::indexBuffer = null;
this.alternativa3d::numTriangles = 0;
}
}
private function collectNode(param1:Node, param2:Face = null) : Face {
var local3:Face = null;
var local4:Wrapper = null;
var local5:Vertex = null;
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Number = NaN;
if(param1.normalX * alternativa3d::imd + param1.normalY * alternativa3d::imh + param1.normalZ * alternativa3d::iml > param1.offset) {
if(param1.positive != null) {
param2 = this.collectNode(param1.positive,param2);
}
local3 = param1.faceList;
while(local3 != null) {
local4 = local3.alternativa3d::wrapper;
while(local4 != null) {
local5 = local4.alternativa3d::vertex;
if(local5.alternativa3d::transformId != alternativa3d::transformId) {
local6 = local5.x;
local7 = local5.y;
local8 = local5.z;
local5.alternativa3d::cameraX = alternativa3d::ma * local6 + alternativa3d::mb * local7 + alternativa3d::mc * local8 + alternativa3d::md;
local5.alternativa3d::cameraY = alternativa3d::me * local6 + alternativa3d::mf * local7 + alternativa3d::mg * local8 + alternativa3d::mh;
local5.alternativa3d::cameraZ = alternativa3d::mi * local6 + alternativa3d::mj * local7 + alternativa3d::mk * local8 + alternativa3d::ml;
local5.alternativa3d::transformId = alternativa3d::transformId;
local5.alternativa3d::drawId = 0;
}
local4 = local4.alternativa3d::next;
}
local3.alternativa3d::processNext = param2;
param2 = local3;
local3 = local3.alternativa3d::next;
}
if(param1.negative != null) {
param2 = this.collectNode(param1.negative,param2);
}
} else {
if(param1.negative != null) {
param2 = this.collectNode(param1.negative,param2);
}
if(param1.positive != null) {
param2 = this.collectNode(param1.positive,param2);
}
}
return param2;
}
private function prepareNode(param1:Node, param2:int, param3:Camera3D) : Face {
var local4:Face = null;
var local5:Wrapper = null;
var local8:Face = null;
var local9:Vertex = null;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Vertex = null;
var local14:Vertex = null;
var local15:Vertex = null;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local20:Number = NaN;
var local21:Number = NaN;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:Number = NaN;
var local25:Number = NaN;
if(alternativa3d::imd * param1.normalX + alternativa3d::imh * param1.normalY + alternativa3d::iml * param1.normalZ > param1.offset) {
local4 = param1.faceList;
local8 = local4;
while(local8 != null) {
local5 = local8.alternativa3d::wrapper;
while(local5 != null) {
local9 = local5.alternativa3d::vertex;
if(local9.alternativa3d::transformId != alternativa3d::transformId) {
local10 = local9.x;
local11 = local9.y;
local12 = local9.z;
local9.alternativa3d::cameraX = alternativa3d::ma * local10 + alternativa3d::mb * local11 + alternativa3d::mc * local12 + alternativa3d::md;
local9.alternativa3d::cameraY = alternativa3d::me * local10 + alternativa3d::mf * local11 + alternativa3d::mg * local12 + alternativa3d::mh;
local9.alternativa3d::cameraZ = alternativa3d::mi * local10 + alternativa3d::mj * local11 + alternativa3d::mk * local12 + alternativa3d::ml;
local9.alternativa3d::transformId = alternativa3d::transformId;
local9.alternativa3d::drawId = 0;
}
local5 = local5.alternativa3d::next;
}
local8.alternativa3d::processNext = local8.alternativa3d::next;
local8 = local8.alternativa3d::next;
}
if(param2 > 0) {
if(this.clipping == 1) {
local4 = param3.alternativa3d::cull(local4,param2);
} else {
local4 = param3.alternativa3d::clip(local4,param2);
}
}
}
var local6:Face = param1.negative != null ? this.prepareNode(param1.negative,param2,param3) : null;
var local7:Face = param1.positive != null ? this.prepareNode(param1.positive,param2,param3) : null;
if(local4 != null || local6 != null && local7 != null) {
if(local4 == null) {
local4 = param1.faceList.alternativa3d::create();
param3.alternativa3d::lastFace.alternativa3d::next = local4;
param3.alternativa3d::lastFace = local4;
}
local5 = param1.faceList.alternativa3d::wrapper;
local13 = local5.alternativa3d::vertex;
local5 = local5.alternativa3d::next;
local14 = local5.alternativa3d::vertex;
local5 = local5.alternativa3d::next;
local15 = local5.alternativa3d::vertex;
if(local13.alternativa3d::transformId != alternativa3d::transformId) {
local13.alternativa3d::cameraX = alternativa3d::ma * local13.x + alternativa3d::mb * local13.y + alternativa3d::mc * local13.z + alternativa3d::md;
local13.alternativa3d::cameraY = alternativa3d::me * local13.x + alternativa3d::mf * local13.y + alternativa3d::mg * local13.z + alternativa3d::mh;
local13.alternativa3d::cameraZ = alternativa3d::mi * local13.x + alternativa3d::mj * local13.y + alternativa3d::mk * local13.z + alternativa3d::ml;
local13.alternativa3d::transformId = alternativa3d::transformId;
local13.alternativa3d::drawId = 0;
}
if(local14.alternativa3d::transformId != alternativa3d::transformId) {
local14.alternativa3d::cameraX = alternativa3d::ma * local14.x + alternativa3d::mb * local14.y + alternativa3d::mc * local14.z + alternativa3d::md;
local14.alternativa3d::cameraY = alternativa3d::me * local14.x + alternativa3d::mf * local14.y + alternativa3d::mg * local14.z + alternativa3d::mh;
local14.alternativa3d::cameraZ = alternativa3d::mi * local14.x + alternativa3d::mj * local14.y + alternativa3d::mk * local14.z + alternativa3d::ml;
local14.alternativa3d::transformId = alternativa3d::transformId;
local14.alternativa3d::drawId = 0;
}
if(local15.alternativa3d::transformId != alternativa3d::transformId) {
local15.alternativa3d::cameraX = alternativa3d::ma * local15.x + alternativa3d::mb * local15.y + alternativa3d::mc * local15.z + alternativa3d::md;
local15.alternativa3d::cameraY = alternativa3d::me * local15.x + alternativa3d::mf * local15.y + alternativa3d::mg * local15.z + alternativa3d::mh;
local15.alternativa3d::cameraZ = alternativa3d::mi * local15.x + alternativa3d::mj * local15.y + alternativa3d::mk * local15.z + alternativa3d::ml;
local15.alternativa3d::transformId = alternativa3d::transformId;
local15.alternativa3d::drawId = 0;
}
local16 = local14.alternativa3d::cameraX - local13.alternativa3d::cameraX;
local17 = local14.alternativa3d::cameraY - local13.alternativa3d::cameraY;
local18 = local14.alternativa3d::cameraZ - local13.alternativa3d::cameraZ;
local19 = local15.alternativa3d::cameraX - local13.alternativa3d::cameraX;
local20 = local15.alternativa3d::cameraY - local13.alternativa3d::cameraY;
local21 = local15.alternativa3d::cameraZ - local13.alternativa3d::cameraZ;
local22 = local21 * local17 - local20 * local18;
local23 = local19 * local18 - local21 * local16;
local24 = local20 * local16 - local19 * local17;
local25 = local22 * local22 + local23 * local23 + local24 * local24;
if(local25 > 0) {
local25 = 1 / Math.sqrt(length);
local22 *= local25;
local23 *= local25;
local24 *= local25;
}
local4.alternativa3d::normalX = local22;
local4.alternativa3d::normalY = local23;
local4.alternativa3d::normalZ = local24;
local4.alternativa3d::offset = local13.alternativa3d::cameraX * local22 + local13.alternativa3d::cameraY * local23 + local13.alternativa3d::cameraZ * local24;
local4.alternativa3d::processNegative = local6;
local4.alternativa3d::processPositive = local7;
} else {
local4 = local6 != null ? local6 : local7;
}
return local4;
}
override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void {
var local3:Vertex = this.alternativa3d::vertexList;
while(local3 != null) {
if(param2 != null) {
local3.alternativa3d::cameraX = param2.alternativa3d::ma * local3.x + param2.alternativa3d::mb * local3.y + param2.alternativa3d::mc * local3.z + param2.alternativa3d::md;
local3.alternativa3d::cameraY = param2.alternativa3d::me * local3.x + param2.alternativa3d::mf * local3.y + param2.alternativa3d::mg * local3.z + param2.alternativa3d::mh;
local3.alternativa3d::cameraZ = param2.alternativa3d::mi * local3.x + param2.alternativa3d::mj * local3.y + param2.alternativa3d::mk * local3.z + param2.alternativa3d::ml;
} else {
local3.alternativa3d::cameraX = local3.x;
local3.alternativa3d::cameraY = local3.y;
local3.alternativa3d::cameraZ = local3.z;
}
if(local3.alternativa3d::cameraX < param1.boundMinX) {
param1.boundMinX = local3.alternativa3d::cameraX;
}
if(local3.alternativa3d::cameraX > param1.boundMaxX) {
param1.boundMaxX = local3.alternativa3d::cameraX;
}
if(local3.alternativa3d::cameraY < param1.boundMinY) {
param1.boundMinY = local3.alternativa3d::cameraY;
}
if(local3.alternativa3d::cameraY > param1.boundMaxY) {
param1.boundMaxY = local3.alternativa3d::cameraY;
}
if(local3.alternativa3d::cameraZ < param1.boundMinZ) {
param1.boundMinZ = local3.alternativa3d::cameraZ;
}
if(local3.alternativa3d::cameraZ > param1.boundMaxZ) {
param1.boundMaxZ = local3.alternativa3d::cameraZ;
}
local3 = local3.alternativa3d::next;
}
}
override alternativa3d function split(param1:Vector3D, param2:Vector3D, param3:Vector3D, param4:Number) : Vector.<Object3D> {
var local9:Vertex = null;
var local10:Vertex = null;
var local14:Face = null;
var local15:Face = null;
var local16:Face = null;
var local17:Face = null;
var local22:Face = null;
var local23:Face = null;
var local24:Wrapper = null;
var local25:Vertex = null;
var local26:Vertex = null;
var local27:Vertex = null;
var local28:Boolean = false;
var local29:Boolean = false;
var local30:Face = null;
var local31:Face = null;
var local32:Wrapper = null;
var local33:Wrapper = null;
var local34:Wrapper = null;
var local35:Number = NaN;
var local36:Vertex = null;
var local5:Vector.<Object3D> = new Vector.<Object3D>(2);
var local6:Vector3D = alternativa3d::calculatePlane(param1,param2,param3);
var local7:Number = local6.w - param4;
var local8:Number = local6.w + param4;
local9 = this.alternativa3d::vertexList;
while(local9 != null) {
local10 = local9.alternativa3d::next;
local9.alternativa3d::next = null;
local9.alternativa3d::offset = local9.x * local6.x + local9.y * local6.y + local9.z * local6.z;
if(local9.alternativa3d::offset >= local7 && local9.alternativa3d::offset <= local8) {
local9.alternativa3d::value = new Vertex();
local9.alternativa3d::value.x = local9.x;
local9.alternativa3d::value.y = local9.y;
local9.alternativa3d::value.z = local9.z;
local9.alternativa3d::value.u = local9.u;
local9.alternativa3d::value.v = local9.v;
local9.alternativa3d::value.normalX = local9.normalX;
local9.alternativa3d::value.normalY = local9.normalY;
local9.alternativa3d::value.normalZ = local9.normalZ;
}
local9.alternativa3d::transformId = 0;
local9 = local10;
}
this.alternativa3d::vertexList = null;
if(this.alternativa3d::root != null) {
this.destroyNode(this.alternativa3d::root);
this.alternativa3d::root = null;
}
var local11:Vector.<Face> = this.alternativa3d::faces;
this.alternativa3d::faces = new Vector.<Face>();
var local12:BSP = this.clone() as BSP;
var local13:BSP = this.clone() as BSP;
var local18:int = 0;
var local19:int = 0;
var local20:int = int(local11.length);
var local21:int = 0;
while(local21 < local20) {
local22 = local11[local21];
local23 = local22.alternativa3d::next;
local24 = local22.alternativa3d::wrapper;
local25 = local24.alternativa3d::vertex;
local24 = local24.alternativa3d::next;
local26 = local24.alternativa3d::vertex;
local24 = local24.alternativa3d::next;
local27 = local24.alternativa3d::vertex;
local28 = local25.alternativa3d::offset < local7 || local26.alternativa3d::offset < local7 || local27.alternativa3d::offset < local7;
local29 = local25.alternativa3d::offset > local8 || local26.alternativa3d::offset > local8 || local27.alternativa3d::offset > local8;
local24 = local24.alternativa3d::next;
while(local24 != null) {
local9 = local24.alternativa3d::vertex;
if(local9.alternativa3d::offset < local7) {
local28 = true;
} else if(local9.alternativa3d::offset > local8) {
local29 = true;
}
local24 = local24.alternativa3d::next;
}
if(!local28) {
if(local17 != null) {
local17.alternativa3d::next = local22;
} else {
local16 = local22;
}
local17 = local22;
local13.alternativa3d::faces[local19] = local22;
local19++;
} else if(!local29) {
if(local15 != null) {
local15.alternativa3d::next = local22;
} else {
local14 = local22;
}
local15 = local22;
local12.alternativa3d::faces[local18] = local22;
local18++;
local24 = local22.alternativa3d::wrapper;
while(local24 != null) {
if(local24.alternativa3d::vertex.alternativa3d::value != null) {
local24.alternativa3d::vertex = local24.alternativa3d::vertex.alternativa3d::value;
}
local24 = local24.alternativa3d::next;
}
} else {
local30 = new Face();
local31 = new Face();
local32 = null;
local33 = null;
local24 = local22.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next;
while(local24.alternativa3d::next != null) {
local24 = local24.alternativa3d::next;
}
local25 = local24.alternativa3d::vertex;
local24 = local22.alternativa3d::wrapper;
while(local24 != null) {
local26 = local24.alternativa3d::vertex;
if(local25.alternativa3d::offset < local7 && local26.alternativa3d::offset > local8 || local25.alternativa3d::offset > local8 && local26.alternativa3d::offset < local7) {
local35 = (local6.w - local25.alternativa3d::offset) / (local26.alternativa3d::offset - local25.alternativa3d::offset);
local9 = new Vertex();
local9.x = local25.x + (local26.x - local25.x) * local35;
local9.y = local25.y + (local26.y - local25.y) * local35;
local9.z = local25.z + (local26.z - local25.z) * local35;
local9.u = local25.u + (local26.u - local25.u) * local35;
local9.v = local25.v + (local26.v - local25.v) * local35;
local9.normalX = local25.normalX + (local26.normalX - local25.normalX) * local35;
local9.normalY = local25.normalY + (local26.normalY - local25.normalY) * local35;
local9.normalZ = local25.normalZ + (local26.normalZ - local25.normalZ) * local35;
local34 = new Wrapper();
local34.alternativa3d::vertex = local9;
if(local32 != null) {
local32.alternativa3d::next = local34;
} else {
local30.alternativa3d::wrapper = local34;
}
local32 = local34;
local36 = new Vertex();
local36.x = local9.x;
local36.y = local9.y;
local36.z = local9.z;
local36.u = local9.u;
local36.v = local9.v;
local36.normalX = local9.normalX;
local36.normalY = local9.normalY;
local36.normalZ = local9.normalZ;
local34 = new Wrapper();
local34.alternativa3d::vertex = local36;
if(local33 != null) {
local33.alternativa3d::next = local34;
} else {
local31.alternativa3d::wrapper = local34;
}
local33 = local34;
}
if(local26.alternativa3d::offset < local7) {
local34 = local24.alternativa3d::create();
local34.alternativa3d::vertex = local26;
if(local32 != null) {
local32.alternativa3d::next = local34;
} else {
local30.alternativa3d::wrapper = local34;
}
local32 = local34;
} else if(local26.alternativa3d::offset > local8) {
local34 = local24.alternativa3d::create();
local34.alternativa3d::vertex = local26;
if(local33 != null) {
local33.alternativa3d::next = local34;
} else {
local31.alternativa3d::wrapper = local34;
}
local33 = local34;
} else {
local34 = local24.alternativa3d::create();
local34.alternativa3d::vertex = local26.alternativa3d::value;
if(local32 != null) {
local32.alternativa3d::next = local34;
} else {
local30.alternativa3d::wrapper = local34;
}
local32 = local34;
local34 = local24.alternativa3d::create();
local34.alternativa3d::vertex = local26;
if(local33 != null) {
local33.alternativa3d::next = local34;
} else {
local31.alternativa3d::wrapper = local34;
}
local33 = local34;
}
local25 = local26;
local24 = local24.alternativa3d::next;
}
local30.material = local22.material;
local30.alternativa3d::calculateBestSequenceAndNormal();
if(local15 != null) {
local15.alternativa3d::next = local30;
} else {
local14 = local30;
}
local15 = local30;
local12.alternativa3d::faces[local18] = local30;
local18++;
local31.material = local22.material;
local31.alternativa3d::calculateBestSequenceAndNormal();
if(local17 != null) {
local17.alternativa3d::next = local31;
} else {
local16 = local31;
}
local17 = local31;
local13.alternativa3d::faces[local19] = local31;
local19++;
}
local21++;
}
if(local15 != null) {
local15.alternativa3d::next = null;
++local12.alternativa3d::transformId;
local12.collectVertices();
local12.alternativa3d::root = local12.createNode(local14);
local12.calculateBounds();
local5[0] = local12;
}
if(local17 != null) {
local17.alternativa3d::next = null;
++local13.alternativa3d::transformId;
local13.collectVertices();
local13.alternativa3d::root = local13.createNode(local16);
local13.calculateBounds();
local5[1] = local13;
}
return local5;
}
private function collectVertices() : void {
var local3:Face = null;
var local4:Wrapper = null;
var local5:Vertex = null;
var local1:int = int(this.alternativa3d::faces.length);
var local2:int = 0;
while(local2 < local1) {
local3 = this.alternativa3d::faces[local2];
local4 = local3.alternativa3d::wrapper;
while(local4 != null) {
local5 = local4.alternativa3d::vertex;
if(local5.alternativa3d::transformId != alternativa3d::transformId) {
local5.alternativa3d::next = this.alternativa3d::vertexList;
this.alternativa3d::vertexList = local5;
local5.alternativa3d::transformId = alternativa3d::transformId;
local5.alternativa3d::value = null;
}
local4 = local4.alternativa3d::next;
}
local2++;
}
}
private function createNode(param1:Face) : Node {
var local3:Wrapper = null;
var local4:Vertex = null;
var local5:Vertex = null;
var local6:Vertex = null;
var local7:Vertex = null;
var local8:Boolean = false;
var local9:Boolean = false;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local21:Face = null;
var local22:Face = null;
var local25:Face = null;
var local26:Face = null;
var local27:int = 0;
var local28:Face = null;
var local29:int = 0;
var local30:Face = null;
var local31:Face = null;
var local32:Face = null;
var local33:Face = null;
var local34:Wrapper = null;
var local35:Wrapper = null;
var local36:Wrapper = null;
var local37:Number = NaN;
var local2:Node = new Node();
var local20:Face = param1;
if(this.splitAnalysis && param1.alternativa3d::next != null) {
local27 = 2147483647;
local28 = param1;
while(local28 != null) {
local14 = Number(local28.alternativa3d::normalX);
local15 = Number(local28.alternativa3d::normalY);
local16 = Number(local28.alternativa3d::normalZ);
local17 = Number(local28.alternativa3d::offset);
local18 = local17 - this.threshold;
local19 = local17 + this.threshold;
local29 = 0;
local30 = param1;
while(local30 != null) {
if(local30 != local28) {
local3 = local30.alternativa3d::wrapper;
local4 = local3.alternativa3d::vertex;
local3 = local3.alternativa3d::next;
local5 = local3.alternativa3d::vertex;
local3 = local3.alternativa3d::next;
local6 = local3.alternativa3d::vertex;
local3 = local3.alternativa3d::next;
local10 = local4.x * local14 + local4.y * local15 + local4.z * local16;
local11 = local5.x * local14 + local5.y * local15 + local5.z * local16;
local12 = local6.x * local14 + local6.y * local15 + local6.z * local16;
local8 = local10 < local18 || local11 < local18 || local12 < local18;
local9 = local10 > local19 || local11 > local19 || local12 > local19;
while(local3 != null) {
local7 = local3.alternativa3d::vertex;
local13 = local7.x * local14 + local7.y * local15 + local7.z * local16;
if(local13 < local18) {
local8 = true;
if(local9) {
break;
}
} else if(local13 > local19) {
local9 = true;
if(local8) {
break;
}
}
local3 = local3.alternativa3d::next;
}
if(local9 && local8) {
local29++;
if(local29 >= local27) {
break;
}
}
}
local30 = local30.alternativa3d::next;
}
if(local29 < local27) {
local20 = local28;
local27 = local29;
if(local27 == 0) {
break;
}
}
local28 = local28.alternativa3d::next;
}
}
var local23:Face = local20;
var local24:Face = local20.alternativa3d::next;
local14 = Number(local20.alternativa3d::normalX);
local15 = Number(local20.alternativa3d::normalY);
local16 = Number(local20.alternativa3d::normalZ);
local17 = Number(local20.alternativa3d::offset);
local18 = local17 - this.threshold;
local19 = local17 + this.threshold;
while(param1 != null) {
if(param1 != local20) {
local31 = param1.alternativa3d::next;
local3 = param1.alternativa3d::wrapper;
local4 = local3.alternativa3d::vertex;
local3 = local3.alternativa3d::next;
local5 = local3.alternativa3d::vertex;
local3 = local3.alternativa3d::next;
local6 = local3.alternativa3d::vertex;
local3 = local3.alternativa3d::next;
local10 = local4.x * local14 + local4.y * local15 + local4.z * local16;
local11 = local5.x * local14 + local5.y * local15 + local5.z * local16;
local12 = local6.x * local14 + local6.y * local15 + local6.z * local16;
local8 = local10 < local18 || local11 < local18 || local12 < local18;
local9 = local10 > local19 || local11 > local19 || local12 > local19;
while(local3 != null) {
local7 = local3.alternativa3d::vertex;
local13 = local7.x * local14 + local7.y * local15 + local7.z * local16;
if(local13 < local18) {
local8 = true;
} else if(local13 > local19) {
local9 = true;
}
local7.alternativa3d::offset = local13;
local3 = local3.alternativa3d::next;
}
if(!local8) {
if(!local9) {
if(param1.alternativa3d::normalX * local14 + param1.alternativa3d::normalY * local15 + param1.alternativa3d::normalZ * local16 > 0) {
local23.alternativa3d::next = param1;
local23 = param1;
} else {
if(local21 != null) {
local22.alternativa3d::next = param1;
} else {
local21 = param1;
}
local22 = param1;
}
} else {
if(local25 != null) {
local26.alternativa3d::next = param1;
} else {
local25 = param1;
}
local26 = param1;
}
} else if(!local9) {
if(local21 != null) {
local22.alternativa3d::next = param1;
} else {
local21 = param1;
}
local22 = param1;
} else {
local4.alternativa3d::offset = local10;
local5.alternativa3d::offset = local11;
local6.alternativa3d::offset = local12;
local32 = new Face();
local33 = new Face();
local34 = null;
local35 = null;
local3 = param1.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next;
while(local3.alternativa3d::next != null) {
local3 = local3.alternativa3d::next;
}
local4 = local3.alternativa3d::vertex;
local10 = Number(local4.alternativa3d::offset);
local3 = param1.alternativa3d::wrapper;
while(local3 != null) {
local5 = local3.alternativa3d::vertex;
local11 = Number(local5.alternativa3d::offset);
if(local10 < local18 && local11 > local19 || local10 > local19 && local11 < local18) {
local37 = (local17 - local10) / (local11 - local10);
local7 = new Vertex();
local7.alternativa3d::next = this.alternativa3d::vertexList;
this.alternativa3d::vertexList = local7;
local7.x = local4.x + (local5.x - local4.x) * local37;
local7.y = local4.y + (local5.y - local4.y) * local37;
local7.z = local4.z + (local5.z - local4.z) * local37;
local7.u = local4.u + (local5.u - local4.u) * local37;
local7.v = local4.v + (local5.v - local4.v) * local37;
local7.normalX = local4.normalX + (local5.normalX - local4.normalX) * local37;
local7.normalY = local4.normalY + (local5.normalY - local4.normalY) * local37;
local7.normalZ = local4.normalZ + (local5.normalZ - local4.normalZ) * local37;
local36 = new Wrapper();
local36.alternativa3d::vertex = local7;
if(local34 != null) {
local34.alternativa3d::next = local36;
} else {
local32.alternativa3d::wrapper = local36;
}
local34 = local36;
local36 = new Wrapper();
local36.alternativa3d::vertex = local7;
if(local35 != null) {
local35.alternativa3d::next = local36;
} else {
local33.alternativa3d::wrapper = local36;
}
local35 = local36;
}
if(local11 <= local19) {
local36 = new Wrapper();
local36.alternativa3d::vertex = local5;
if(local34 != null) {
local34.alternativa3d::next = local36;
} else {
local32.alternativa3d::wrapper = local36;
}
local34 = local36;
}
if(local11 >= local18) {
local36 = new Wrapper();
local36.alternativa3d::vertex = local5;
if(local35 != null) {
local35.alternativa3d::next = local36;
} else {
local33.alternativa3d::wrapper = local36;
}
local35 = local36;
}
local4 = local5;
local10 = local11;
local3 = local3.alternativa3d::next;
}
local32.material = param1.material;
local32.smoothingGroups = param1.smoothingGroups;
local32.alternativa3d::calculateBestSequenceAndNormal();
if(local21 != null) {
local22.alternativa3d::next = local32;
} else {
local21 = local32;
}
local22 = local32;
local33.material = param1.material;
local33.smoothingGroups = param1.smoothingGroups;
local33.alternativa3d::calculateBestSequenceAndNormal();
if(local25 != null) {
local26.alternativa3d::next = local33;
} else {
local25 = local33;
}
local26 = local33;
}
param1 = local31;
} else {
param1 = local24;
}
}
if(local21 != null) {
local22.alternativa3d::next = null;
local2.negative = this.createNode(local21);
}
local23.alternativa3d::next = null;
local2.faceList = local20;
local2.normalX = local14;
local2.normalY = local15;
local2.normalZ = local16;
local2.offset = local17;
if(local25 != null) {
local26.alternativa3d::next = null;
local2.positive = this.createNode(local25);
}
return local2;
}
private function destroyNode(param1:Node) : void {
var local3:Face = null;
if(param1.negative != null) {
this.destroyNode(param1.negative);
param1.negative = null;
}
if(param1.positive != null) {
this.destroyNode(param1.positive);
param1.positive = null;
}
var local2:Face = param1.faceList;
while(local2 != null) {
local3 = local2.alternativa3d::next;
local2.alternativa3d::next = null;
local2 = local3;
}
}
}
}
import alternativa.engine3d.core.Face;
class Node {
public var negative:Node;
public var positive:Node;
public var faceList:Face;
public var normalX:Number;
public var normalY:Number;
public var normalZ:Number;
public var offset:Number;
public function Node() {
super();
}
}
|
package _codec.projects.tanks.client.panel.model.profile.usersettings {
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.profile.usersettings.ClientStoredSettings;
public class VectorCodecClientStoredSettingsLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecClientStoredSettingsLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ClientStoredSettings,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.<ClientStoredSettings> = new Vector.<ClientStoredSettings>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ClientStoredSettings(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ClientStoredSettings = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ClientStoredSettings> = Vector.<ClientStoredSettings>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.shoot.smoky {
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 SmokyShootSFXModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function SmokyShootSFXModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package controls.buttons.h71px {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.h71px.GreyHugeButtonSkin_leftUpClass.png")]
public class GreyHugeButtonSkin_leftUpClass extends BitmapAsset {
public function GreyHugeButtonSkin_leftUpClass() {
super();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p5 extends BitmapAsset
{
public function RangIconNormal_p5()
{
super();
}
}
}
|
package projects.tanks.client.battleselect.types
{
import projects.tanks.client.battleservice.model.team.BattleTeamType;
public class UserInfoClient
{
public var id:String;
public var type:BattleTeamType;
public var name:String;
public var rank:int;
public var kills:int;
public var isBot:Boolean;
public function UserInfoClient()
{
super();
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_bitmapArmor.png")]
public class ItemInfoPanelBitmaps_bitmapArmor extends BitmapAsset {
public function ItemInfoPanelBitmaps_bitmapArmor() {
super();
}
}
}
|
package _codec.projects.tanks.client.battleservice {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battleservice.Range;
public class VectorCodecRangeLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRangeLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(Range,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.<Range> = new Vector.<Range>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = Range(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:Range = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<Range> = Vector.<Range>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.upgradeable.types {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.upgradeable.types.GaragePropertyParams;
import projects.tanks.client.garage.models.item.upgradeable.types.UpgradeParamsData;
public class CodecUpgradeParamsData implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_finalUpgradePrice:ICodec;
private var codec_initialUpgradePrice:ICodec;
private var codec_properties:ICodec;
private var codec_speedUpCoeff:ICodec;
private var codec_upgradeLevelsCount:ICodec;
private var codec_upgradeTimeCoeff:ICodec;
public function CodecUpgradeParamsData() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_finalUpgradePrice = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_initialUpgradePrice = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_properties = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(GaragePropertyParams,false),false,1));
this.codec_speedUpCoeff = param1.getCodec(new TypeCodecInfo(Number,false));
this.codec_upgradeLevelsCount = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_upgradeTimeCoeff = param1.getCodec(new TypeCodecInfo(Number,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:UpgradeParamsData = new UpgradeParamsData();
local2.finalUpgradePrice = this.codec_finalUpgradePrice.decode(param1) as int;
local2.initialUpgradePrice = this.codec_initialUpgradePrice.decode(param1) as int;
local2.properties = this.codec_properties.decode(param1) as Vector.<GaragePropertyParams>;
local2.speedUpCoeff = this.codec_speedUpCoeff.decode(param1) as Number;
local2.upgradeLevelsCount = this.codec_upgradeLevelsCount.decode(param1) as int;
local2.upgradeTimeCoeff = this.codec_upgradeTimeCoeff.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:UpgradeParamsData = UpgradeParamsData(param2);
this.codec_finalUpgradePrice.encode(param1,local3.finalUpgradePrice);
this.codec_initialUpgradePrice.encode(param1,local3.initialUpgradePrice);
this.codec_properties.encode(param1,local3.properties);
this.codec_speedUpCoeff.encode(param1,local3.speedUpCoeff);
this.codec_upgradeLevelsCount.encode(param1,local3.upgradeLevelsCount);
this.codec_upgradeTimeCoeff.encode(param1,local3.upgradeTimeCoeff);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.battle {
import alternativa.types.Long;
import flash.utils.Dictionary;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.tanksservices.model.notifier.battle.BattleNotifierData;
import projects.tanks.client.tanksservices.model.notifier.battle.BattleNotifierModelBase;
import projects.tanks.client.tanksservices.model.notifier.battle.IBattleNotifierModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.model.UserRefresh;
import projects.tanks.clients.fp10.libraries.tanksservices.model.listener.UserNotifier;
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.UserInfoConsumer;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.battle.IBattleNotifierService;
[ModelInfo]
public class BattleNotifierModel extends BattleNotifierModelBase implements IBattleNotifierModelBase, UserRefresh, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var battleNotifierService:IBattleNotifierService;
private var battleLinkData:Dictionary;
public function BattleNotifierModel() {
super();
}
public function objectLoaded() : void {
this.battleLinkData = new Dictionary();
}
public function objectUnloaded() : void {
this.battleLinkData = null;
}
public function setBattle(param1:Vector.<BattleNotifierData>) : void {
var local5:BattleNotifierData = null;
var local2:Vector.<BattleLinkData> = new Vector.<BattleLinkData>(param1.length);
var local3:int = int(param1.length);
var local4:int = 0;
while(local4 < local3) {
local5 = param1[local4];
local2[local4] = this.setAndUpdateConsumer(local5);
local4++;
}
battleNotifierService.setBattle(local2);
}
private function setAndUpdateConsumer(param1:BattleNotifierData) : BattleLinkData {
var local2:Long = param1.userId;
var local3:BattleLinkData = new BattleLinkData(local2,param1);
this.battleLinkData[local2] = local3;
this.setBattleLinkForConsumer(local2,local3);
return local3;
}
private function setBattleLinkForConsumer(param1:Long, param2:BattleLinkData) : void {
var local4:UserInfoConsumer = null;
var local3:UserNotifier = UserNotifier(object.adapt(UserNotifier));
if(local3.hasDataConsumer(param1)) {
local4 = local3.getDataConsumer(param1);
local4.setBattleUrl(param2);
}
}
public function refresh(param1:Long, param2:UserInfoConsumer) : void {
if(param1 in this.battleLinkData) {
param2.setBattleUrl(this.battleLinkData[param1]);
}
}
public function remove(param1:Long) : void {
delete this.battleLinkData[param1];
this.setBattleLinkForConsumer(param1,null);
}
public function leaveBattle(param1:Long) : void {
battleNotifierService.leaveBattle(param1);
this.remove(param1);
}
public function leaveGroup(param1:Long) : void {
this.remove(param1);
}
}
}
|
package mx.core {
public namespace mx_internal = "http://www.adobe.com/2006/flex/mx/internal";
}
|
package alternativa.tanks.service.referrals.notification {
import flash.events.EventDispatcher;
public class NewReferralsNotifierServiceImpl extends EventDispatcher implements NewReferralsNotifierService {
private var newReferralsLength:int;
public function NewReferralsNotifierServiceImpl() {
super();
}
public function newReferralsCountUpdated(param1:int) : void {
this.newReferralsLength = param1;
dispatchEvent(new NewReferralsNotifierServiceEvent(NewReferralsNotifierServiceEvent.NEW_REFERRALS_COUNT_UPDATED));
}
public function getNewReferralsCount() : int {
return this.newReferralsLength;
}
public function notifyReferralAdded(param1:int) : void {
this.newReferralsLength = param1;
dispatchEvent(new NewReferralsNotifierServiceEvent(NewReferralsNotifierServiceEvent.REFERRAL_ADDED));
}
public function requestNewReferralsCount() : void {
dispatchEvent(new NewReferralsNotifierServiceEvent(NewReferralsNotifierServiceEvent.REQUEST_NEW_REFERRALS_COUNT));
}
public function resetNewReferralsCount() : void {
dispatchEvent(new NewReferralsNotifierServiceEvent(NewReferralsNotifierServiceEvent.RESET_NEW_REFERRALS_COUNT));
}
}
}
|
package alternativa.tanks.gui.shop.components.notification {
import alternativa.tanks.gui.shop.indicators.ShopIndicators;
import alternativa.tanks.model.payment.shop.notification.service.ShopNotificationEvent;
import alternativa.tanks.model.payment.shop.notification.service.ShopNotifierService;
import flash.display.Bitmap;
import flash.display.Sprite;
public class ShopNotificationIndicator extends Sprite {
[Inject]
public static var shopNotifierService:ShopNotifierService;
private var newItemsIcon:Bitmap;
private var discountsIcon:Bitmap;
public function ShopNotificationIndicator() {
super();
this.newItemsIcon = new Bitmap(ShopIndicators.newItems);
this.newItemsIcon.visible = false;
addChild(this.newItemsIcon);
this.discountsIcon = new Bitmap(ShopIndicators.discounts);
this.discountsIcon.visible = false;
addChild(this.discountsIcon);
shopNotifierService.addEventListener(ShopNotificationEvent.SHOW_NOTIFICATION_ABOUT_NEW_ITEMS,this.onNewItemsAppearedInShop);
shopNotifierService.addEventListener(ShopNotificationEvent.SHOW_NOTIFICATION_ABOUT_DISCOUNTS,this.onDiscountsInShop);
shopNotifierService.addEventListener(ShopNotificationEvent.HIDE_NOTIFICATION,this.onNotificationViewed);
}
private function onNotificationViewed(param1:ShopNotificationEvent) : void {
this.newItemsIcon.visible = false;
this.discountsIcon.visible = false;
}
private function onNewItemsAppearedInShop(param1:ShopNotificationEvent) : void {
this.newItemsIcon.visible = true;
this.discountsIcon.visible = false;
}
private function onDiscountsInShop(param1:ShopNotificationEvent) : void {
this.newItemsIcon.visible = false;
this.discountsIcon.visible = true;
}
}
}
|
package alternativa.tanks.models.weapon.twins {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.engine3d.AnimatedSprite3D;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.splash.Splash;
import alternativa.tanks.models.weapon.weakening.DistanceWeakening;
import alternativa.tanks.models.weapons.shell.InelasticShell;
import alternativa.tanks.models.weapons.shell.states.DummyShellStates;
import alternativa.tanks.models.weapons.shell.states.ShellStates;
import alternativa.tanks.sfx.AnimatedLightEffect;
import alternativa.tanks.sfx.AnimatedSpriteEffect;
import alternativa.tanks.sfx.DecalEffect;
import alternativa.tanks.sfx.ExternalObject3DPositionProvider;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.MathUtils;
import alternativa.tanks.utils.objectpool.Pool;
import projects.tanks.client.battlefield.models.tankparts.weapon.twins.TwinsCC;
import projects.tanks.clients.flash.commons.models.gpu.GPUCapabilities;
public class TwinsShot extends InelasticShell {
private var weakening:DistanceWeakening;
private var sfxData:TwinsSFXData;
private var callback:TwinsWeaponCallback;
private var twinsInitParams:TwinsCC;
private var impactForce:Number;
private var sprite:AnimatedSprite3D;
private var lightEffect:AnimatedLightEffect;
private var lightEffectPositionProvider:ExternalObject3DPositionProvider;
private var splash:Splash;
public function TwinsShot(param1:Pool) {
super(param1);
this.sprite = new AnimatedSprite3D(TwinsShotParams.SPRITE_SIZE,TwinsShotParams.SPRITE_SIZE);
this.sprite.looped = true;
}
override protected function createShellStates() : ShellStates {
return DummyShellStates.INSTANCE;
}
public function init(param1:Number, param2:TwinsCC, param3:TwinsSFXData, param4:DistanceWeakening, param5:TwinsWeaponCallback, param6:Splash) : void {
this.impactForce = param1;
this.twinsInitParams = param2;
this.weakening = param4;
this.sfxData = param3;
this.callback = param5;
this.splash = param6;
this.sprite.setAnimationData(param3.shotAnimation);
this.sprite.setFrameIndex(this.sprite.getNumFrames() * Math.random());
this.sprite.alpha = 1;
this.sprite.rotation = MathUtils.PI2 * Math.random();
this.lightEffect = AnimatedLightEffect(battleService.getObjectPool().getObject(AnimatedLightEffect));
this.lightEffectPositionProvider = ExternalObject3DPositionProvider(battleService.getObjectPool().getObject(ExternalObject3DPositionProvider));
this.lightEffect.init(this.lightEffectPositionProvider,param3.shellLightingAnimation,AnimatedLightEffect.DEFAULT_MAX_DISTANCE,true);
}
override public function addToGame(param1:AllGlobalGunParams, param2:Vector3, param3:Body, param4:Boolean, param5:int) : void {
super.addToGame(param1,param2,param3,param4,param5);
battleService.getBattleScene3D().addObject(this.sprite);
battleService.addGraphicEffect(this.lightEffect);
}
override protected function getSpeed() : Number {
return this.twinsInitParams.speed;
}
override protected function getMaxDistance() : Number {
return this.weakening.getDistance();
}
override protected function processHitImpl(param1:Body, param2:Vector3, param3:Vector3, param4:Number, param5:int) : void {
var local8:Tank = null;
super.processHitImpl(param1,param2,param3,param4,param5);
var local6:Number = this.weakening.getImpactCoeff(param4);
this.createExplosionEffect(param2,local6);
var local7:Boolean = Boolean(this.splash.applySplashForce(param2,local6,param1));
if(BattleUtils.isTankBody(param1)) {
local8 = param1.tank;
local8.applyWeaponHit(param2,param3,this.impactForce * local6);
if(Boolean(this.callback)) {
this.callback.onTargetHit(getShotId(),param1,param2);
}
} else {
if(Boolean(this.callback) && local7) {
this.callback.onStaticHit(getShotId(),param2);
}
this.createHitMark(param2);
}
this.destroy();
}
override public function render(param1:int, param2:int) : void {
var local3:Number = param2 / thousandth.getInt();
this.sprite.update(local3);
this.sprite.x = interpolatedPosition.x;
this.sprite.y = interpolatedPosition.y;
this.sprite.z = interpolatedPosition.z;
this.sprite.rotation -= 3 * local3;
var local4:Number = this.weakening.getDistance() - totalDistance;
if(local4 < TwinsShotParams.ALPHA_FADE_DISTANCE) {
this.sprite.alpha = local4 / TwinsShotParams.ALPHA_FADE_DISTANCE;
}
this.lightEffectPositionProvider.setPosition(interpolatedPosition);
}
override protected function destroy() : void {
super.destroy();
battleService.getBattleScene3D().removeObject(this.sprite);
this.twinsInitParams = null;
this.callback = null;
shooterBody = null;
this.weakening = null;
this.sfxData = null;
this.sprite.material = null;
this.sprite.colorTransform = null;
this.lightEffect.kill();
this.lightEffect = null;
this.lightEffectPositionProvider = null;
}
override protected function getRadius() : Number {
return this.twinsInitParams.shellRadius;
}
private function createExplosionEffect(param1:Vector3, param2:Number) : void {
var local3:StaticObject3DPositionProvider = StaticObject3DPositionProvider(battleService.getObjectPool().getObject(StaticObject3DPositionProvider));
local3.init(param1,TwinsShotParams.EXPLOSION_OFFSET_TO_CAMERA);
var local4:Number = TwinsShotParams.EXPLOSION_SPRITE_SIZE * (1 + param2) / 2;
var local5:AnimatedSpriteEffect = AnimatedSpriteEffect(battleService.getObjectPool().getObject(AnimatedSpriteEffect));
local5.init(local4,local4,this.sfxData.explosionAnimation,MathUtils.PI2 * Math.random(),local3,0.5,0.5);
battleService.addGraphicEffect(local5);
this.createExplosionLightEffect(param1);
}
private function createExplosionLightEffect(param1:Vector3) : void {
var local2:AnimatedLightEffect = AnimatedLightEffect(battleService.getObjectPool().getObject(AnimatedLightEffect));
var local3:StaticObject3DPositionProvider = StaticObject3DPositionProvider(battleService.getObjectPool().getObject(StaticObject3DPositionProvider));
local3.init(param1,TwinsShotParams.EXPLOSION_OFFSET_TO_CAMERA);
local2.init(local3,this.sfxData.hitLightingAnimation);
battleService.addGraphicEffect(local2);
}
private function createHitMark(param1:Vector3) : void {
var local2:DecalEffect = null;
if(GPUCapabilities.gpuEnabled) {
local2 = DecalEffect(battleService.getObjectPool().getObject(DecalEffect));
local2.init(param1,this.sfxData.hitMarkMaterial,barrelOrigin,TwinsShotParams.HIT_MARK_RADIUS,TwinsShotParams.HIT_MARK_LIFE_TIME,TwinsShotParams.HIT_MARK_FADE_TIME);
battleService.addGraphicEffect(local2);
}
}
}
}
|
package alternativa.tanks.models.battlefield.effects.graffiti
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GraffitiMenu_leftUnlockBitmap extends BitmapAsset
{
public function GraffitiMenu_leftUnlockBitmap()
{
super();
}
}
}
|
package _codec.projects.tanks.client.users.model.switchbattleinvite {
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.users.model.switchbattleinvite.NotificationEnabledCC;
public class CodecNotificationEnabledCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_receiveBattleInvite:ICodec;
public function CodecNotificationEnabledCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_receiveBattleInvite = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:NotificationEnabledCC = new NotificationEnabledCC();
local2.receiveBattleInvite = this.codec_receiveBattleInvite.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:NotificationEnabledCC = NotificationEnabledCC(param2);
this.codec_receiveBattleInvite.encode(param1,local3.receiveBattleInvite);
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.table {
import alternativa.types.Long;
public class StatisticsData {
public var label:Object = null;
public var icon:Object = null;
public var id:Long;
public var rank:int = 0;
public var uid:String = "";
public var kills:int = 0;
public var deaths:int = 0;
public var score:int = 0;
public var reward:int = -1;
public var type:int;
public var self:Boolean;
public var loaded:Boolean;
public var suspicious:Boolean;
public var stars:int = 0;
public function StatisticsData() {
super();
}
}
}
|
package alternativa.engine3d.loaders.events {
import flash.events.Event;
import flash.events.ProgressEvent;
public class LoaderProgressEvent extends ProgressEvent {
public static const LOADER_PROGRESS:String = "loaderProgress";
private var _filesTotal:int;
private var _filesLoaded:int;
private var _totalProgress:Number = 0;
public function LoaderProgressEvent(param1:String, param2:int, param3:int, param4:Number = 0, param5:uint = 0, param6:uint = 0) {
super(param1,false,false,param5,param6);
this._filesTotal = param2;
this._filesLoaded = param3;
this._totalProgress = param4;
}
public function get filesTotal() : int {
return this._filesTotal;
}
public function get filesLoaded() : int {
return this._filesLoaded;
}
public function get totalProgress() : Number {
return this._totalProgress;
}
override public function clone() : Event {
return new LoaderProgressEvent(type,this._filesTotal,this._filesLoaded,this._totalProgress,bytesLoaded,bytesTotal);
}
override public function toString() : String {
return "[LoaderProgressEvent filesTotal=" + this._filesTotal + ", filesLoaded=" + this._filesLoaded + ", totalProgress=" + this._totalProgress.toFixed(2) + "]";
}
}
}
|
package projects.tanks.client.partners.impl.kongregate {
public interface IKongregateLoginModelBase {
}
}
|
package assets.window.bitmaps {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.window.bitmaps.WindowTop.png")]
public class WindowTop extends BitmapData {
public function WindowTop(param1:int, param2:int, param3:Boolean = true, param4:uint = 0) {
super(param1,param2,param3,param4);
}
}
}
|
package alternativa.tanks.model.garage.present {
import alternativa.types.Long;
import projects.tanks.client.garage.models.garage.present.IPresentGivenModelBase;
import projects.tanks.client.garage.models.garage.present.PresentGivenModelBase;
[ModelInfo]
public class PresentGivenModel extends PresentGivenModelBase implements IPresentGivenModelBase, PresentGiven {
public function PresentGivenModel() {
super();
}
public function removePresent(param1:Long) : void {
server.removePresent(param1);
}
}
}
|
package controls.scroller.gray {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.scroller.gray.ScrollSkinGray_trackTop.png")]
public class ScrollSkinGray_trackTop extends BitmapAsset {
public function ScrollSkinGray_trackTop() {
super();
}
}
}
|
package alternativa.physics {
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.physics.collision.CollisionShape;
public class ShapeContact {
private static var poolSize:int;
private static const pool:Vector.<ShapeContact> = new Vector.<ShapeContact>();
public var position:Vector3 = new Vector3();
public var penetration:Number;
public var normal:Vector3 = new Vector3();
public var tangent1:Vector3 = new Vector3();
public var tangent2:Vector3 = new Vector3();
public var collisionSpeed:Number;
public var contactSeparationSpeed:Number;
public var normalSpeedDelta:Number;
public var tangentSpeedDelta1:Number;
public var tangentSpeedDelta2:Number;
public var normalAngularInertiaTerm1:Number;
public var normalAngularInertiaTerm2:Number;
public var tangentAngularInertiaTerm11:Number;
public var tangentAngularInertiaTerm12:Number;
public var tangentAngularInertiaTerm21:Number;
public var tangentAngularInertiaTerm22:Number;
public var r1:Vector3 = new Vector3();
public var r2:Vector3 = new Vector3();
public var normalImpulse:Number;
public var tangentImpulse1:Number;
public var tangentImpulse2:Number;
public var satisfied:Boolean;
public var restitution:Number;
public var friction:Number;
public var shape1:CollisionShape;
public var shape2:CollisionShape;
public function ShapeContact() {
super();
}
public static function create() : ShapeContact {
if(poolSize == 0) {
return new ShapeContact();
}
--poolSize;
var local1:ShapeContact = pool[poolSize];
pool[poolSize] = null;
return local1;
}
public function dispose() : void {
this.shape1 = null;
this.shape2 = null;
pool[poolSize] = this;
++poolSize;
}
public function calculatePersistentFrameData() : void {
var local1:Body = this.shape1.body;
var local2:Body = this.shape2.body;
this.restitution = this.shape1.material.restitution;
var local3:Number = this.shape2.material.restitution;
if(local3 < this.restitution) {
this.restitution = local3;
}
this.friction = this.shape1.material.friction;
var local4:Number = this.shape2.material.friction;
if(local4 < this.friction) {
this.friction = local4;
}
if(local1.slipperyMode && !local2.movable || local2.slipperyMode && !local1.movable) {
this.friction = 0;
}
var local5:Vector3 = this.shape1.body.state.position;
this.r1.x = this.position.x - local5.x;
this.r1.y = this.position.y - local5.y;
this.r1.z = this.position.z - local5.z;
local5 = this.shape2.body.state.position;
this.r2.x = this.position.x - local5.x;
this.r2.y = this.position.y - local5.y;
this.r2.z = this.position.z - local5.z;
if(Math.abs(this.normal.x) < Math.abs(this.normal.y)) {
this.tangent1.cross2(this.normal,Vector3.X_AXIS).normalize();
} else {
this.tangent1.cross2(this.normal,Vector3.Y_AXIS).normalize();
}
this.tangent2.cross2(this.normal,this.tangent1);
this.normalImpulse = 0;
this.tangentImpulse1 = 0;
this.tangentImpulse2 = 0;
this.normalSpeedDelta = 0;
this.tangentSpeedDelta1 = 0;
this.tangentSpeedDelta2 = 0;
if(local1.movable) {
this.normalAngularInertiaTerm1 = this.calculateAngularInertiaTerm(this.normal,this.r1,local1.invInertiaWorld);
this.tangentAngularInertiaTerm11 = this.calculateAngularInertiaTerm(this.tangent1,this.r1,local1.invInertiaWorld);
this.tangentAngularInertiaTerm12 = this.calculateAngularInertiaTerm(this.tangent2,this.r1,local1.invInertiaWorld);
this.normalSpeedDelta += local1.invMass + this.normalAngularInertiaTerm1;
this.tangentSpeedDelta1 += local1.invMass + this.tangentAngularInertiaTerm11;
this.tangentSpeedDelta2 += local1.invMass + this.tangentAngularInertiaTerm12;
}
if(local2.movable) {
this.normalAngularInertiaTerm2 = this.calculateAngularInertiaTerm(this.normal,this.r2,local2.invInertiaWorld);
this.tangentAngularInertiaTerm21 = this.calculateAngularInertiaTerm(this.tangent1,this.r2,local2.invInertiaWorld);
this.tangentAngularInertiaTerm22 = this.calculateAngularInertiaTerm(this.tangent2,this.r2,local2.invInertiaWorld);
this.normalSpeedDelta += local2.invMass + this.normalAngularInertiaTerm2;
this.tangentSpeedDelta1 += local2.invMass + this.tangentAngularInertiaTerm21;
this.tangentSpeedDelta2 += local2.invMass + this.tangentAngularInertiaTerm22;
}
this.collisionSpeed = this.getSeparationVelocity();
if(this.collisionSpeed < 0) {
this.collisionSpeed = -this.restitution * this.collisionSpeed;
} else {
this.collisionSpeed = 0;
}
}
private function calculateAngularInertiaTerm(param1:Vector3, param2:Vector3, param3:Matrix3) : Number {
var local4:Number = param2.y * param1.z - param2.z * param1.y;
var local5:Number = param2.z * param1.x - param2.x * param1.z;
var local6:Number = param2.x * param1.y - param2.y * param1.x;
var local7:Number = param3.m00 * local4 + param3.m01 * local5 + param3.m02 * local6;
var local8:Number = param3.m10 * local4 + param3.m11 * local5 + param3.m12 * local6;
var local9:Number = param3.m20 * local4 + param3.m21 * local5 + param3.m22 * local6;
local4 = local8 * param2.z - local9 * param2.y;
local5 = local9 * param2.x - local7 * param2.z;
local6 = local7 * param2.y - local8 * param2.x;
return local4 * param1.x + local5 * param1.y + local6 * param1.z;
}
public function getSeparationVelocity() : Number {
var local1:Vector3 = this.shape1.body.state.angularVelocity;
var local2:Number = local1.y * this.r1.z - local1.z * this.r1.y;
var local3:Number = local1.z * this.r1.x - local1.x * this.r1.z;
var local4:Number = local1.x * this.r1.y - local1.y * this.r1.x;
var local5:Vector3 = this.shape1.body.state.velocity;
var local6:Number = local5.x + local2;
var local7:Number = local5.y + local3;
var local8:Number = local5.z + local4;
local1 = this.shape2.body.state.angularVelocity;
local2 = local1.y * this.r2.z - local1.z * this.r2.y;
local3 = local1.z * this.r2.x - local1.x * this.r2.z;
local4 = local1.x * this.r2.y - local1.y * this.r2.x;
local5 = this.shape2.body.state.velocity;
local6 -= local5.x + local2;
local7 -= local5.y + local3;
local8 -= local5.z + local4;
return local6 * this.normal.x + local7 * this.normal.y + local8 * this.normal.z;
}
public function calcualteDynamicFrameData(param1:Number, param2:Number, param3:Number, param4:Number) : void {
var local7:Number = NaN;
var local5:Body = this.shape1.body;
var local6:Body = this.shape2.body;
this.normalSpeedDelta = 0;
this.tangentSpeedDelta1 = 0;
this.tangentSpeedDelta2 = 0;
if(local5.movable) {
this.normalSpeedDelta += local5.invMass + this.normalAngularInertiaTerm1;
this.tangentSpeedDelta1 += local5.invMass + this.tangentAngularInertiaTerm11;
this.tangentSpeedDelta2 += local5.invMass + this.tangentAngularInertiaTerm12;
}
if(local6.movable) {
this.normalSpeedDelta += local6.invMass + this.normalAngularInertiaTerm2;
this.tangentSpeedDelta1 += local6.invMass + this.tangentAngularInertiaTerm21;
this.tangentSpeedDelta2 += local6.invMass + this.tangentAngularInertiaTerm22;
}
if(this.penetration > param1) {
local7 = this.penetration - param1;
if(local7 > param3) {
local7 = param3;
}
this.contactSeparationSpeed = param2 * local7 / param4;
} else {
this.contactSeparationSpeed = 0;
}
}
}
}
|
package controls.scroller.gray
{
import controls.scroller.ScrollThumbSkin;
public class ScrollThumbSkinGray extends ScrollThumbSkin
{
public function ScrollThumbSkinGray()
{
super();
}
override public function initSkin() : void
{
toppng = new ScrollSkinGray.thumbTop().bitmapData;
midpng = new ScrollSkinGray.thumbMiddle().bitmapData;
}
}
}
|
package alternativa.tanks.model.challenge.greenpanel.green
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GreenPack_left_line extends BitmapAsset
{
public function GreenPack_left_line()
{
super();
}
}
}
|
package projects.tanks.clients.flash.commons.models.layout.notify {
import alternativa.osgi.service.logging.LogService;
import alternativa.tanks.loader.ILoaderWindowService;
import alternativa.tanks.loader.IModalLoaderService;
import alternativa.tanks.ymservice.YandexMetricaService;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.client.commons.models.layout.notify.ILobbyLayoutNotifyModelBase;
import projects.tanks.client.commons.models.layout.notify.LobbyLayoutNotifyModelBase;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
[ModelInfo]
public class LobbyLayoutNotifyModel extends LobbyLayoutNotifyModelBase implements ILobbyLayoutNotifyModelBase, ILobbyLayoutNotify, ObjectUnloadListener {
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var loaderWindowService:ILoaderWindowService;
[Inject]
public static var modalLoaderService:IModalLoaderService;
[Inject]
public static var logService:LogService;
[Inject]
public static var ymService:YandexMetricaService;
private static const CHANNEL:String = "LobbyLayoutNotifyModel";
private static const BATTLE_LOAD_START:String = "BattleLoad:start";
private static const LOBBY_LOAD_FINISH:String = "LobbyLoad:finish";
private static const LOBBY_LOAD_START:String = "LobbyLoad:start";
private static const BATTLE_LOAD_FINISH:String = "BattleLoad:finish";
private var inProgress:Boolean = false;
private var origin:LayoutState;
private var lastState:LayoutState;
public function LobbyLayoutNotifyModel() {
super();
}
public function beginLayoutSwitch(param1:LayoutState) : void {
if(param1 != null) {
this.lastState = param1;
}
this.beginSwitch();
}
public function endLayoutSwitch(param1:LayoutState, param2:LayoutState) : void {
this.origin = param1;
this.lastState = param2;
this.endSwitch();
}
public function layoutSwitchPredicted() : void {
modalLoaderService.show();
}
public function cancelPredictedLayoutSwitch() : void {
this.endSwitch();
modalLoaderService.hideForcibly();
loaderWindowService.hideForcibly();
}
public function isSwitchInProgress() : Boolean {
return this.inProgress;
}
public function getCurrentState() : LayoutState {
return this.lastState;
}
public function inBattle() : Boolean {
return this.origin == LayoutState.BATTLE;
}
private function beginSwitch() : void {
if(!this.inProgress) {
this.inProgress = true;
ymService.reachGoalIfPlayerIsNewbie(this.lastState == LayoutState.BATTLE && !this.origin ? BATTLE_LOAD_START : LOBBY_LOAD_START);
if(this.lastState == LayoutState.GARAGE || this.lastState == LayoutState.CLAN || this.lastState == LayoutState.MATCHMAKING || this.lastState == LayoutState.BATTLE_SELECT) {
modalLoaderService.show();
} else if(this.lastState != LayoutState.BATTLE || !lobbyLayoutService.isBattleReady()) {
if(!modalLoaderService.isVisible()) {
loaderWindowService.show();
}
}
lobbyLayoutService.dispatchEvent(new LobbyLayoutServiceEvent(LobbyLayoutServiceEvent.BEGIN_LAYOUT_SWITCH,this.lastState));
}
}
private function endSwitch() : void {
if(this.inProgress) {
this.inProgress = false;
ymService.reachGoalIfPlayerIsNewbie(this.inBattle() && this.lastState == LayoutState.BATTLE ? BATTLE_LOAD_FINISH : LOBBY_LOAD_FINISH);
if(this.lastState != LayoutState.BATTLE) {
loaderWindowService.hide();
modalLoaderService.hideForcibly();
}
lobbyLayoutService.dispatchEvent(new LobbyLayoutServiceEvent(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.lastState));
}
}
public function objectUnloaded() : void {
}
}
}
|
package alternativa.osgi.service.logging.impl {
import alternativa.osgi.service.logging.LogLevel;
import alternativa.osgi.service.logging.LogService;
import alternativa.osgi.service.logging.LogTarget;
import alternativa.osgi.service.logging.Logger;
public class LogServiceImpl implements LogService, LogTarget {
private var logTargets:Vector.<LogTarget> = new Vector.<LogTarget>();
public function LogServiceImpl() {
super();
}
public function getLogger(param1:Object) : Logger {
return new LoggerImpl(param1,this);
}
public function addLogTarget(param1:LogTarget) : void {
if(this.logTargets.indexOf(param1) < 0) {
this.logTargets.push(param1);
}
}
public function removeLogTarget(param1:LogTarget) : void {
var local2:int = int(this.logTargets.indexOf(param1));
if(local2 >= 0) {
this.logTargets = this.logTargets.splice(local2,1);
}
}
public function log(param1:Object, param2:LogLevel, param3:String, param4:Array = null) : void {
var logTarget:LogTarget = null;
var object:Object = param1;
var level:LogLevel = param2;
var message:String = param3;
var params:Array = param4;
for each(logTarget in this.logTargets) {
try {
logTarget.log(object,level,message,params);
}
catch(e:Error) {
}
}
}
}
}
|
package projects.tanks.client.partners.impl.steam {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class SteamLoginModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:SteamLoginModelServer;
private var client:ISteamLoginModelBase = ISteamLoginModelBase(this);
private var modelId:Long = Long.getLong(194944991,-714985429);
public function SteamLoginModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new SteamLoginModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.payment.shop.featuring {
[ModelInterface]
public interface ShopItemFeaturing {
function isLocatedInFeaturingCategory() : Boolean;
function isHiddenInOriginalCategory() : Boolean;
function getPosition() : int;
}
}
|
package alternativa.tanks.model.item {
import alternativa.types.Long;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class BattleFriendsListenerEvents implements BattleFriendsListener {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function BattleFriendsListenerEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function onAddFriend(param1:Long) : void {
var i:int = 0;
var m:BattleFriendsListener = null;
var userId:Long = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattleFriendsListener(this.impl[i]);
m.onAddFriend(userId);
i++;
}
}
finally {
Model.popObject();
}
}
public function onDeleteFriend(param1:Long) : void {
var i:int = 0;
var m:BattleFriendsListener = null;
var userId:Long = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattleFriendsListener(this.impl[i]);
m.onDeleteFriend(userId);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.help {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperAlign;
public class MoneyHelper extends PanelBubbleHelper {
public function MoneyHelper(param1:Number, param2:Number, param3:Number) {
super(param1,param2,param3);
var local4:ILocaleService = ILocaleService(OSGi.getInstance().getService(ILocaleService));
text = local4.getText(TanksLocale.TEXT_HELP_PANEL_MONEY_HELPER_TEXT);
arrowLehgth = int(local4.getText(TanksLocale.TEXT_HELP_PANEL_MONEY_HELPER_ARROW_LENGTH)) + 55;
arrowAlign = HelperAlign.TOP_CENTER;
}
}
}
|
package _codec.projects.tanks.client.chat.models.news.showing {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.chat.models.news.showing.NewsItemData;
import projects.tanks.client.chat.models.news.showing.NewsShowingCC;
public class CodecNewsShowingCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_newsItems:ICodec;
public function CodecNewsShowingCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_newsItems = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(NewsItemData,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:NewsShowingCC = new NewsShowingCC();
local2.newsItems = this.codec_newsItems.decode(param1) as Vector.<NewsItemData>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:NewsShowingCC = NewsShowingCC(param2);
this.codec_newsItems.encode(param1,local3.newsItems);
}
}
}
|
package alternativa.protocol.impl {
import alternativa.protocol.ProtocolBuffer;
public class LengthCodecHelper {
public function LengthCodecHelper() {
super();
}
public static function encodeLength(param1:ProtocolBuffer, param2:int) : void {
var local3:Number = NaN;
if(param2 < 0) {
throw new Error("Length is incorrect (" + param2 + ")");
}
if(param2 < 128) {
param1.writer.writeByte(int(param2 & 0x7F));
} else if(param2 < 16384) {
local3 = (param2 & 0x3FFF) + 32768;
param1.writer.writeByte(int((local3 & 0xFF00) >> 8));
param1.writer.writeByte(int(local3 & 0xFF));
} else {
if(param2 >= 4194304) {
throw new Error("Length is incorrect (" + param2 + ")");
}
local3 = (param2 & 0x3FFFFF) + 12582912;
param1.writer.writeByte(int((local3 & 0xFF0000) >> 16));
param1.writer.writeByte(int((local3 & 0xFF00) >> 8));
param1.writer.writeByte(int(local3 & 0xFF));
}
}
public static function decodeLength(param1:ProtocolBuffer) : int {
var local4:int = 0;
var local5:Boolean = false;
var local6:int = 0;
var local2:int = int(param1.reader.readByte());
var local3:Boolean = (local2 & 0x80) == 0;
if(local3) {
return local2;
}
local4 = int(param1.reader.readByte());
local5 = (local2 & 0x40) == 0;
if(local5) {
return ((local2 & 0x3F) << 8) + (local4 & 0xFF);
}
local6 = int(param1.reader.readByte());
return ((local2 & 0x3F) << 16) + ((local4 & 0xFF) << 8) + (local6 & 0xFF);
}
}
}
|
package controls.buttons.skins {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.buttons.skins.GoldBigButtonSkin_leftDownClass.png")]
public class GoldBigButtonSkin_leftDownClass extends BitmapAsset {
public function GoldBigButtonSkin_leftDownClass() {
super();
}
}
}
|
package controls {
import controls.base.TextFieldUtf8Base;
import flash.display.GradientType;
import flash.display.Graphics;
import flash.display.Shape;
import flash.display.Sprite;
import flash.geom.Matrix;
import flash.text.AntiAliasType;
import flash.text.GridFitType;
import flash.text.TextFieldAutoSize;
import flash.text.TextFieldType;
import flash.text.TextFormat;
import fonts.TanksFontService;
import utils.FontParamsUtil;
public class TextArea extends Sprite {
private var shadow:Shape = new Shape();
private var bg:TankWindowInner = new TankWindowInner(0);
private const format:TextFormat = TanksFontService.getTextFormat(12);
public var tf:TextFieldUtf8Base = new TextFieldUtf8Base();
private var _width:int;
private var _height:int;
public function TextArea(param1:Boolean = true) {
super();
if(param1) {
addChild(this.shadow);
addChild(this.bg);
}
this.shadow.x = this.shadow.y = 1;
addChild(this.tf);
this.format.color = 16777215;
this.tf.defaultTextFormat = this.format;
this.tf.antiAliasType = AntiAliasType.ADVANCED;
this.tf.gridFitType = GridFitType.PIXEL;
this.tf.embedFonts = TanksFontService.isEmbedFonts();
this.tf.sharpness = FontParamsUtil.SHARPNESS_TANK_INPUT_BASE;
this.tf.thickness = FontParamsUtil.THICKNESS_TANK_INPUT_BASE;
this.tf.x = this.tf.y = 5;
this.tf.multiline = true;
this.tf.wordWrap = true;
this.tf.type = TextFieldType.INPUT;
this.tf.selectable = true;
this.tf.autoSize = TextFieldAutoSize.NONE;
}
override public function set width(param1:Number) : void {
this._width = int(param1);
this.bg.width = this._width;
this.tf.width = this._width - 10;
this.draw();
}
override public function get width() : Number {
return this._width;
}
override public function set height(param1:Number) : void {
this._height = int(param1);
this.bg.height = this._height;
this.tf.height = this._height - 10;
this.draw();
}
override public function get height() : Number {
return this._height;
}
public function get text() : String {
return this.tf.text;
}
public function set text(param1:String) : void {
this.tf.text = param1;
}
private function draw() : void {
var local1:Graphics = this.shadow.graphics;
var local2:Matrix = new Matrix();
local2.createGradientBox(this._width - 2,this._height - 2,Math.PI * 0.5);
local1.clear();
local1.beginGradientFill(GradientType.LINEAR,[0,0],[0.8,0],[0,255],local2);
local1.drawRect(0,0,this._width - 2,this._height - 2);
local1.endFill();
}
public function set maxChars(param1:int) : void {
this.tf.maxChars = param1;
}
}
}
|
package alternativa.tanks.models.weapon {
import alternativa.math.Vector3;
public class AllGlobalGunParams {
public const muzzlePosition:Vector3 = new Vector3();
public const barrelOrigin:Vector3 = new Vector3();
public const elevationAxis:Vector3 = new Vector3();
public const direction:Vector3 = new Vector3();
public function AllGlobalGunParams() {
super();
}
}
}
|
package alternativa.tanks.model.settings {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.settings.SettingsWindow;
import alternativa.tanks.gui.settings.SettingsWindowEvent;
import alternativa.tanks.gui.settings.tabs.account.AccountSettingsEvent;
import alternativa.tanks.gui.settings.tabs.account.AccountSettingsTab;
import alternativa.tanks.gui.settings.tabs.game.ReceivePersonalMessagesSettingEvent;
import alternativa.tanks.model.antiaddiction.IAntiAddictionAlert;
import alternativa.tanks.model.useremailandpassword.IUserEmailAndPassword;
import alternativa.tanks.model.useremailandpassword.PasswordService;
import alternativa.tanks.service.panel.IPanelView;
import alternativa.tanks.service.settings.ISettingsService;
import flash.display.Bitmap;
import flash.events.Event;
import forms.events.MainButtonBarEvents;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.chat.models.chat.users.personalmessagereceiver.PersonalMessageReceiveMode;
import projects.tanks.client.commons.models.captcha.CaptchaLocation;
import projects.tanks.client.panel.model.profile.usersettings.ClientStoredSettings;
import projects.tanks.client.panel.model.profile.usersettings.ISettingsModelBase;
import projects.tanks.client.panel.model.profile.usersettings.SettingsModelBase;
import projects.tanks.clients.flash.commons.models.captcha.CaptchaClientFacade;
import projects.tanks.clients.flash.commons.models.captcha.CaptchaParser;
import projects.tanks.clients.flash.commons.models.captcha.IServerCaptcha;
import projects.tanks.clients.flash.commons.models.captcha.RefreshCaptchaClickedEvent;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.battleinvite.IBattleInviteService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenService;
import services.alertservice.Alert;
import services.alertservice.AlertAnswer;
[ModelInfo]
public class SettingsModel extends SettingsModelBase implements ISettingsModelBase, ObjectLoadPostListener, ObjectUnloadListener, CaptchaClientFacade {
[Inject]
public static var settingsService:ISettingsService;
[Inject]
public static var panelView:IPanelView;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var battleInviteService:IBattleInviteService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var fullscreenService:FullscreenService;
[Inject]
public static var passwordService:PasswordService;
private var settingsWindow:SettingsWindow;
private var emailConfirmed:Boolean;
private var receivePersonalMessageOnlyFromFriends:Boolean;
public function SettingsModel() {
super();
}
public function openAntiAddictionSettings(param1:PersonalMessageReceiveMode, param2:String, param3:String) : void {
this.openSettingsWindow(param1,true,param2,param3);
}
public function openSettings(param1:PersonalMessageReceiveMode) : void {
this.openSettingsWindow(param1,false,"","");
}
private function openSettingsWindow(param1:PersonalMessageReceiveMode, param2:Boolean, param3:String, param4:String) : void {
this.emailConfirmed = settingsService.isEmailConfirmed();
if(this.settingsWindow != null) {
return;
}
this.receivePersonalMessageOnlyFromFriends = param1 == PersonalMessageReceiveMode.FRIENDS_ONLY;
this.settingsWindow = new SettingsWindow(settingsService.getEmail(),this.emailConfirmed,this.receivePersonalMessageOnlyFromFriends,param2,param3,param4);
if(!this.emailConfirmed) {
this.settingsWindow.addEventListener(AccountSettingsEvent.SET_EMAIL,getFunctionWrapper(this.onSetEmail));
this.settingsWindow.addEventListener(AccountSettingsEvent.CHANGE_PASSWORD,getFunctionWrapper(this.callbackCheckPassword));
}
this.settingsWindow.addEventListener(SettingsWindowEvent.CLOSE_SETTINGS,getFunctionWrapper(this.onSettingsClose));
this.settingsWindow.addEventListener(AccountSettingsEvent.CHANGE_PASSWORD_BY_EMAIL,getFunctionWrapper(this.onChangePasswordOnEmail));
this.settingsWindow.addEventListener(AccountSettingsEvent.CHECK_PASSWORD,getFunctionWrapper(this.onCheckPassword));
this.settingsWindow.addEventListener(AccountSettingsEvent.SET_ANTI_ADDICTION,getFunctionWrapper(this.onSetAntiAddictionInfo));
this.settingsWindow.addEventListener(ReceivePersonalMessagesSettingEvent.RECEIVE_PERSONAL_MESSAGES_CHANGE,getFunctionWrapper(this.onChangeReceivePersonalMessageOnlyFromFriends));
panelView.unlock();
if(!settingsService.isPasswordSet) {
passwordService.checkIsPasswordSet(this.callbackIsPasswordSet);
} else {
this.settingsWindow.show();
}
IServerCaptcha(object.adapt(IServerCaptcha)).bindFacade(this);
var local5:AccountSettingsTab = this.settingsWindow.getAccountSettings();
if(Boolean(local5)) {
local5.addEventListener(RefreshCaptchaClickedEvent.CLICKED,getFunctionWrapper(this.onRefreshCaptcha));
this.getNewCaptcha();
}
}
private function onCheckPassword(param1:AccountSettingsEvent) : void {
passwordService.checkPassword(this.settingsWindow.getAccountSettings().getOldPassword(),this.callbackCheckPassword);
}
private function onSetAntiAddictionInfo(param1:AccountSettingsEvent) : void {
var local2:AccountSettingsTab = this.settingsWindow.getAccountSettings();
if(local2.initialRealName != local2.realName || local2.idNumber != local2.initialIDNumber) {
IAntiAddictionAlert(object.adapt(IAntiAddictionAlert)).setIdNumberAndRealName(local2.realName,local2.idNumber);
}
}
private function destroySettingsWindow() : void {
IServerCaptcha(object.adapt(IServerCaptcha)).unbindFacade();
if(!this.emailConfirmed) {
this.settingsWindow.removeEventListener(AccountSettingsEvent.SET_EMAIL,getFunctionWrapper(this.onSetEmail));
this.settingsWindow.removeEventListener(AccountSettingsEvent.CHANGE_PASSWORD,getFunctionWrapper(this.callbackCheckPassword));
}
this.settingsWindow.removeEventListener(SettingsWindowEvent.CLOSE_SETTINGS,getFunctionWrapper(this.onSettingsClose));
this.settingsWindow.removeEventListener(AccountSettingsEvent.CHANGE_PASSWORD_BY_EMAIL,getFunctionWrapper(this.onChangePasswordOnEmail));
this.settingsWindow.removeEventListener(AccountSettingsEvent.CHECK_PASSWORD,getFunctionWrapper(this.onCheckPassword));
this.settingsWindow.removeEventListener(ReceivePersonalMessagesSettingEvent.RECEIVE_PERSONAL_MESSAGES_CHANGE,getFunctionWrapper(this.onChangeReceivePersonalMessageOnlyFromFriends));
this.settingsWindow.removeEventListener(AccountSettingsEvent.SET_ANTI_ADDICTION,getFunctionWrapper(this.onSetAntiAddictionInfo));
panelView.getPanel().buttonBar.settingsButton.enable = true;
this.uploadSettingsToServer();
this.settingsWindow.destroy();
this.settingsWindow = null;
}
private function onChangePasswordOnEmail(param1:AccountSettingsEvent) : void {
var local2:AccountSettingsTab = null;
if(this.emailConfirmed) {
local2 = this.settingsWindow.getAccountSettings();
IServerCaptcha(object.adapt(IServerCaptcha)).checkCaptcha(local2.getCaptchaAnswer(),CaptchaLocation.ACCOUNT_SETTINGS_FORM);
}
}
private function onSettingsClose(param1:Event = null) : void {
this.destroySettingsWindow();
}
private function onSetEmail(param1:Event = null) : void {
var local2:AccountSettingsTab = null;
if(!this.emailConfirmed) {
local2 = this.settingsWindow.getAccountSettings();
if(Boolean(local2.email)) {
IServerCaptcha(object.adapt(IServerCaptcha)).checkCaptcha(local2.getCaptchaAnswer(),CaptchaLocation.ACCOUNT_SETTINGS_FORM);
}
}
}
private function callbackCheckPassword(param1:Boolean) : void {
var local2:AccountSettingsTab = null;
if(param1) {
local2 = this.settingsWindow.getAccountSettings();
if(!this.emailConfirmed && local2.password != "") {
this.setOrUpdatePassword();
}
} else {
this.settingsWindow.getAccountSettings().highlightIncorrectOldPassword();
}
}
private function setOrUpdatePassword() : void {
var local1:AccountSettingsTab = this.settingsWindow.getAccountSettings();
if(local1.getOldPassword() == "") {
passwordService.setPassword(local1.password);
} else {
passwordService.updatePassword(local1.getOldPassword(),local1.password);
}
}
private function onChangeReceivePersonalMessageOnlyFromFriends(param1:ReceivePersonalMessagesSettingEvent) : void {
if(this.receivePersonalMessageOnlyFromFriends != param1.getValue()) {
server.setReceivePersonalMessages(param1.getValue() ? PersonalMessageReceiveMode.FRIENDS_ONLY : PersonalMessageReceiveMode.ALL);
}
}
public function objectLoadedPost() : void {
panelView.getPanel().buttonBar.soundOn = !settingsService.muteSound;
settingsService.initSoundValue();
panelView.getPanel().buttonBar.addEventListener(MainButtonBarEvents.PANEL_BUTTON_PRESSED,getFunctionWrapper(this.onButtonBarButtonClick));
var local1:String = IUserEmailAndPassword(object.adapt(IUserEmailAndPassword)).getEmail();
this.uploadSettingsToServer();
}
private function uploadSettingsToServer() : void {
var local1:ClientStoredSettings = new ClientStoredSettings();
local1.showDamageEnabled = settingsService.showDamage;
server.uploadClientSettings(local1);
}
private function onButtonBarButtonClick(param1:MainButtonBarEvents) : void {
switch(param1.typeButton) {
case MainButtonBarEvents.SOUND:
this.toggleSoundMute();
break;
case MainButtonBarEvents.SETTINGS:
server.showSettings();
}
}
public function objectUnloaded() : void {
if(panelView.getPanel() != null) {
panelView.getPanel().buttonBar.removeEventListener(MainButtonBarEvents.PANEL_BUTTON_PRESSED,getFunctionWrapper(this.onButtonBarButtonClick));
}
}
private function toggleSoundMute() : void {
settingsService.muteSound = !settingsService.muteSound;
panelView.unlock();
}
public function callbackIsPasswordSet(param1:Boolean) : void {
if(param1) {
settingsService.isPasswordSet = true;
} else {
this.settingsWindow.getAccountSettings().hideOldPasswordField();
}
this.settingsWindow.show();
}
public function captchaUpdated(param1:CaptchaLocation, param2:Vector.<int>) : void {
CaptchaParser.parse(param2,this.onCaptchaParsed,param1);
}
private function onCaptchaParsed(param1:Bitmap, param2:CaptchaLocation) : void {
var local3:AccountSettingsTab = null;
if(param2 == CaptchaLocation.ACCOUNT_SETTINGS_FORM) {
local3 = this.settingsWindow.getAccountSettings();
local3.setCaptchaImage(param1);
}
}
public function setCaptchaLocations(param1:Vector.<CaptchaLocation>) : void {
}
public function captchaAnswerCorrect(param1:CaptchaLocation) : void {
this.getNewCaptcha();
var local2:AccountSettingsTab = this.settingsWindow.getAccountSettings();
if(this.emailConfirmed) {
local2.disableChangePasswordPanel();
alertService.showAlert(localeService.getText(TanksLocale.TEXT_SETTINGS_CHANGE_PASSWORD_CONFIRMATION_SENT_TEXT),Vector.<String>([AlertAnswer.OK]));
IUserEmailAndPassword(object.adapt(IUserEmailAndPassword)).sendChangeInstruction();
} else {
IUserEmailAndPassword(object.adapt(IUserEmailAndPassword)).changeEmail(local2.email);
}
}
public function captchaAnswerIncorrect(param1:CaptchaLocation, param2:Vector.<int>) : void {
alertService.showAlertById(Alert.CAPTCHA_INCORRECT);
this.captchaUpdated(param1,param2);
}
private function onRefreshCaptcha(param1:RefreshCaptchaClickedEvent) : void {
this.getNewCaptcha();
}
private function getNewCaptcha() : void {
IServerCaptcha(object.adapt(IServerCaptcha)).getNewCaptcha(CaptchaLocation.ACCOUNT_SETTINGS_FORM);
}
}
}
|
package alternativa.tanks.models.sfx.flame
{
import alternativa.console.ConsoleVarFloat;
import alternativa.engine3d.core.Object3D;
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.weapon.weakening.IWeaponWeakeningModel;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import alternativa.tanks.sfx.IGraphicEffect;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.utils.getTimer;
public class FlamethrowerGraphicEffect extends PooledObject implements IGraphicEffect
{
private static const ANIMATION_FPS:Number = 30;
private static const START_SCALE:Number = 0.5;
private static const END_SCALE:Number = 4;
private static var particleBaseSize:ConsoleVarFloat = new ConsoleVarFloat("flame_base_size",100,1,1000);
private static var matrix:Matrix3 = new Matrix3();
private static var particlePosition:Vector3 = new Vector3();
private static var barrelOrigin:Vector3 = new Vector3();
private static var gunDirection:Vector3 = new Vector3();
private static var xAxis:Vector3 = new Vector3();
private static var globalMuzzlePosition:Vector3 = new Vector3();
private static var intersection:RayIntersection = new RayIntersection();
private var range:Number;
private var scalePerDistance:Number;
private var coneHalfAngleTan:Number;
private var maxParticles:int;
private var particleSpeed:Number;
private var localMuzzlePosition:Vector3;
private var turret:Object3D;
private var sfxData:FlamethrowerSFXData;
private var container:Scene3DContainer;
private var particles:Vector.<Particle>;
private var numParticles:int;
private var numFrames:int;
private var collisionDetector:TanksCollisionDetector;
private var dead:Boolean;
private var emissionDelta:int;
private var nextEmissionTime:int;
private var time:int;
private var collisionGroup:int = 16;
private var weakeningModel:IWeaponWeakeningModel;
private var shooterData:TankData;
private var animatedTexture:TextureAnimation;
public function FlamethrowerGraphicEffect(objectPool:ObjectPool)
{
this.localMuzzlePosition = new Vector3();
this.particles = new Vector.<Particle>();
super(objectPool);
}
public function init(shooterData:TankData, range:Number, coneAngle:Number, maxParticles:int, particleSpeed:Number, muzzleLocalPos:Vector3, turret:Object3D, sfxData:FlamethrowerSFXData, collisionDetector:TanksCollisionDetector, weakeningModel:IWeaponWeakeningModel) : void
{
this.shooterData = shooterData;
this.range = range;
this.scalePerDistance = 2 * (END_SCALE - START_SCALE) / range;
this.coneHalfAngleTan = Math.tan(0.5 * coneAngle);
this.maxParticles = maxParticles;
this.particleSpeed = particleSpeed;
this.localMuzzlePosition.vCopy(muzzleLocalPos);
this.turret = turret;
this.sfxData = sfxData;
this.collisionDetector = collisionDetector;
this.weakeningModel = weakeningModel;
this.numFrames = sfxData.materials.length;
this.emissionDelta = 1000 * range / (maxParticles * particleSpeed);
this.time = this.nextEmissionTime = getTimer();
this.particles.length = maxParticles;
this.dead = false;
this.animatedTexture = sfxData.data;
}
public function get owner() : ClientObject
{
return null;
}
public function addToContainer(container:Scene3DContainer) : void
{
this.container = container;
}
public function play(millis:int, camera:GameCamera) : Boolean
{
var particle:Particle = null;
particle = null;
var velocity:Vector3 = null;
var scale:Number = NaN;
var size:Number = NaN;
if(!this.dead && this.numParticles < this.maxParticles && this.time >= this.nextEmissionTime)
{
this.nextEmissionTime += this.emissionDelta;
this.tryToAddParticle();
}
var dt:Number = 0.001 * millis;
for(var i:int = 0; i < this.numParticles; i++)
{
particle = this.particles[i];
particlePosition.x = particle.x;
particlePosition.y = particle.y;
particlePosition.z = particle.z;
if(particle.distance > this.range || this.collisionDetector.intersectRayWithStatic(particlePosition,particle.velocity,this.collisionGroup,dt,null,intersection))
{
this.removeParticle(i--);
}
else
{
velocity = particle.velocity;
particle.x += dt * velocity.x;
particle.y += dt * velocity.y;
particle.z += dt * velocity.z;
particle.distance += this.particleSpeed * dt;
particle.update(dt);
scale = START_SCALE + this.scalePerDistance * particle.distance;
if(scale > END_SCALE)
{
scale = END_SCALE;
}
size = scale * particleBaseSize.value;
particle.width = size;
particle.height = size;
particle.updateColorTransofrm(this.range,this.sfxData.colorTransformPoints);
}
}
this.time += millis;
return !this.dead || this.numParticles > 0;
}
public function destroy() : void
{
while(this.numParticles > 0)
{
this.removeParticle(0);
}
this.collisionDetector = null;
this.turret = null;
this.shooterData = null;
this.sfxData = null;
}
public function kill() : void
{
this.dead = true;
}
override protected function getClass() : Class
{
return FlamethrowerGraphicEffect;
}
private function tryToAddParticle() : void
{
var offset:Number = NaN;
var barrelLength:Number = NaN;
matrix.setRotationMatrix(this.turret.rotationX,this.turret.rotationY,this.turret.rotationZ);
barrelOrigin.x = 0;
barrelOrigin.y = 0;
barrelOrigin.z = this.localMuzzlePosition.z;
barrelOrigin.vTransformBy3(matrix);
barrelOrigin.x += this.turret.x;
barrelOrigin.y += this.turret.y;
barrelOrigin.z += this.turret.z;
gunDirection.x = matrix.b;
gunDirection.y = matrix.f;
gunDirection.z = matrix.j;
offset = Math.random() * 50;
if(!this.collisionDetector.intersectRayWithStatic(barrelOrigin,gunDirection,CollisionGroup.STATIC,this.localMuzzlePosition.y + offset,null,intersection))
{
barrelLength = this.localMuzzlePosition.y;
globalMuzzlePosition.x = barrelOrigin.x + gunDirection.x * barrelLength;
globalMuzzlePosition.y = barrelOrigin.y + gunDirection.y * barrelLength;
globalMuzzlePosition.z = barrelOrigin.z + gunDirection.z * barrelLength;
xAxis.x = matrix.a;
xAxis.y = matrix.e;
xAxis.z = matrix.i;
this.addParticle(globalMuzzlePosition,gunDirection,xAxis,offset);
}
}
private function addParticle(globalMuzzlePosition:Vector3, direction:Vector3, gunAxisX:Vector3, offset:Number) : void
{
var particle:Particle = null;
particle = Particle.getParticle(this.animatedTexture);
particle.currFrame = Math.random() * this.numFrames;
var angle:Number = 2 * Math.PI * Math.random();
matrix.fromAxisAngle(direction,angle);
gunAxisX.vTransformBy3(matrix);
var d:Number = this.range * this.coneHalfAngleTan * Math.random();
direction.x = direction.x * this.range + gunAxisX.x * d;
direction.y = direction.y * this.range + gunAxisX.y * d;
direction.z = direction.z * this.range + gunAxisX.z * d;
direction.vNormalize();
particle.velocity.x = this.particleSpeed * direction.x;
particle.velocity.y = this.particleSpeed * direction.y;
particle.velocity.z = this.particleSpeed * direction.z;
particle.velocity.vAdd(this.shooterData.tank.state.velocity);
particle.distance = offset;
particle.x = globalMuzzlePosition.x + offset * direction.x;
particle.y = globalMuzzlePosition.y + offset * direction.y;
particle.z = globalMuzzlePosition.z + offset * direction.z;
var _loc8_:* = this.numParticles++;
this.particles[_loc8_] = particle;
this.container.addChild(particle);
}
private function removeParticle(index:int) : void
{
var particle:Particle = this.particles[index];
this.particles[index] = this.particles[--this.numParticles];
this.particles[this.numParticles] = null;
particle.dispose();
particle.destroy();
particle = null;
}
}
}
import alternativa.engine3d.alternativa3d;
import alternativa.math.Vector3;
import alternativa.tanks.engine3d.AnimatedSprite3D;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.sfx.colortransform.ColorTransformEntry;
import flash.geom.ColorTransform;
class Particle extends AnimatedSprite3D
{
private static var INITIAL_POOL_SIZE:int = 20;
private static var pool:Vector.<Particle> = new Vector.<Particle>(INITIAL_POOL_SIZE);
private static var poolIndex:int = -1;
public var velocity:Vector3;
public var distance:Number = 0;
public var currFrame:Number;
function Particle(animData:TextureAnimation)
{
this.velocity = new Vector3();
super(100,100);
colorTransform = new ColorTransform();
this.softAttenuation = 140;
super.setAnimationData(animData);
super.setFrameIndex(0);
super.looped = true;
}
public static function getParticle(animData:TextureAnimation) : Particle
{
return new Particle(animData);
}
public function dispose() : void
{
alternativa3d::removeFromParent();
material = null;
var _loc1_:* = ++poolIndex;
pool[_loc1_] = this;
}
public function updateColorTransofrm(maxDistance:Number, points:Vector.<ColorTransformEntry>) : void
{
var point1:ColorTransformEntry = null;
var point2:ColorTransformEntry = null;
var i:int = 0;
if(points == null)
{
return;
}
var t:Number = this.distance / maxDistance;
if(t <= 0)
{
point1 = points[0];
this.copyStructToColorTransform(point1,colorTransform);
}
else if(t >= 1)
{
point1 = points[points.length - 1];
this.copyStructToColorTransform(point1,colorTransform);
}
else
{
i = 1;
point1 = points[0];
point2 = points[1];
while(point2.t < t)
{
i++;
point1 = point2;
point2 = points[i];
}
t = (t - point1.t) / (point2.t - point1.t);
this.interpolateColorTransform(point1,point2,t,colorTransform);
}
alpha = colorTransform.alphaMultiplier;
}
private function interpolateColorTransform(ct1:ColorTransformEntry, ct2:ColorTransformEntry, t:Number, result:ColorTransform) : void
{
result.alphaMultiplier = ct1.alphaMultiplier + t * (ct2.alphaMultiplier - ct1.alphaMultiplier);
result.alphaOffset = ct1.alphaOffset + t * (ct2.alphaOffset - ct1.alphaOffset);
result.redMultiplier = ct1.redMultiplier + t * (ct2.redMultiplier - ct1.redMultiplier);
result.redOffset = ct1.redOffset + t * (ct2.redOffset - ct1.redOffset);
result.greenMultiplier = ct1.greenMultiplier + t * (ct2.greenMultiplier - ct1.greenMultiplier);
result.greenOffset = ct1.greenOffset + t * (ct2.greenOffset - ct1.greenOffset);
result.blueMultiplier = ct1.blueMultiplier + t * (ct2.blueMultiplier - ct1.blueMultiplier);
result.blueOffset = ct1.blueOffset + t * (ct2.blueOffset - ct1.blueOffset);
}
private function copyStructToColorTransform(source:ColorTransformEntry, result:ColorTransform) : void
{
result.alphaMultiplier = source.alphaMultiplier;
result.alphaOffset = source.alphaOffset;
result.redMultiplier = source.redMultiplier;
result.redOffset = source.redOffset;
result.greenMultiplier = source.greenMultiplier;
result.greenOffset = source.greenOffset;
result.blueMultiplier = source.blueMultiplier;
result.blueOffset = source.blueOffset;
}
}
|
package alternativa.tanks.models.weapon.shaft.states {
import alternativa.tanks.models.weapon.shaft.ShaftEventType;
public interface IShaftState {
function enter(param1:int) : void;
function exit() : void;
function update(param1:int, param2:int) : void;
function processEvent(param1:ShaftEventType, param2:*) : void;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.