code stringlengths 57 237k |
|---|
package com.alternativaplatform.client.models.core.community.chat.types
{
public class ChatMessage
{
public var sourceUser:UserChat;
public var targetUser:UserChat;
public var system:Boolean;
public var text:String;
public var sysCollor:uint;
public function ChatMessage()
{
super();
}
}
}
|
package alternativa.tanks.controller.commands {
import alternativa.tanks.controller.events.RegisterEvent;
import alternativa.tanks.model.EntranceServerParamsModel;
import alternativa.tanks.model.EntranceUrlParamsModel;
import alternativa.tanks.service.AccountService;
import alternativa.tanks.service.IEntranceServerFacade;
import alternativa.tanks.tracker.ITrackerService;
import org.robotlegs.mvcs.Command;
public class RegisterUserCommand extends Command {
[Inject]
public var event:RegisterEvent;
[Inject]
public var serverFacade:IEntranceServerFacade;
[Inject]
public var urlParams:EntranceUrlParamsModel;
[Inject]
public var accountService:AccountService;
[Inject]
public var serverParams:EntranceServerParamsModel;
[Inject]
public var trackerService:ITrackerService;
public function RegisterUserCommand() {
super();
}
override public function execute() : void {
this.accountService.storedUserName = this.event.callsign;
this.trackerService.trackEventAfter("entrance","registerUser","showRegistrationForm");
if(this.serverParams.registrationThroughEmail) {
this.serverFacade.registerThroughEmail(this.event.callsign,this.event.email,this.urlParams.domain,this.urlParams.referralHash,this.event.realName,this.event.idNumber);
} else {
this.serverFacade.registerUserThroughPassword(this.event.callsign,this.event.password,this.urlParams.domain,this.event.rememberMe,this.urlParams.referralHash,this.event.realName,this.event.idNumber);
}
}
}
}
|
package alternativa.osgi.service.dump {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.console.IConsole;
import flash.utils.Dictionary;
public class DumpService implements IDumpService {
public function DumpService(param1:OSGi) {
super();
}
public function registerDumper(param1:IDumper) : void {
}
public function unregisterDumper(param1:String) : void {
}
public function dump(param1:String, param2:Array) : String {
return "unsupported";
}
public function get dumpersByName() : Dictionary {
return new Dictionary();
}
public function get dumpersList() : Vector.<IDumper> {
return new Vector.<IDumper>();
}
private function getDumperList() : String {
return "";
}
private function hadleConsoleCommand(param1:IConsole, param2:Array) : void {
}
}
}
|
package alternativa.tanks.service.matchmaking {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.controllers.mainview.MatchmakingGroupEvent;
import alternativa.tanks.controllers.mainview.SwitchToBattleSelectEvent;
import alternativa.tanks.controllers.mathmacking.MatchmakingFormController;
import alternativa.tanks.controllers.mathmacking.ShowGroupInviteWindowEvent;
import alternativa.tanks.service.battlelist.MatchmakingEvent;
import alternativa.tanks.view.mainview.HolidayParams;
import alternativa.tanks.view.mainview.MatchmakingLayout;
import alternativa.types.Long;
import flash.events.EventDispatcher;
import flash.utils.Dictionary;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.MatchmakingUserData;
import projects.tanks.client.battleselect.model.matchmaking.group.notify.MountItemsUserData;
import projects.tanks.client.battleselect.model.matchmaking.queue.MatchmakingMode;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.matchmakinggroup.MatchmakingGroupService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
public class MatchmakingFormServiceImpl extends EventDispatcher implements MatchmakingFormService, MatchmakingGroupFormService, MatchmakingGroupInviteService {
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var matchmakingGroupService:MatchmakingGroupService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var storageService:IStorageService;
private static var MM_GAME_MODE:String = "MM_GAME_MODE";
private var matchmakingLayout:MatchmakingLayout;
private var registrationFormController:MatchmakingFormController = new MatchmakingFormController();
public function MatchmakingFormServiceImpl() {
super();
}
private static function onShowBattleSelect(param1:SwitchToBattleSelectEvent) : void {
lobbyLayoutService.showBattleSelect();
}
public function showMatchmakingLayout(param1:Dictionary, param2:HolidayParams, param3:int) : void {
if(this.matchmakingLayout == null) {
this.matchmakingLayout = new MatchmakingLayout(param1,param2,param3);
}
this.matchmakingLayout.addEventListener(SwitchToBattleSelectEvent.EVENT,onShowBattleSelect);
this.matchmakingLayout.addEventListener(MatchmakingEvent.REGISTRATION,this.onRegistration);
this.matchmakingLayout.addEventListener(MatchmakingEvent.ENTER_AS_SPECTATOR,this.onEnterAsSpectator);
this.matchmakingLayout.addEventListener(MatchmakingGroupEvent.CREATE,this.onCreateGroup);
this.matchmakingLayout.addEventListener(MatchmakingGroupEvent.LEAVE,this.onLeaveGroup);
this.matchmakingLayout.show();
}
public function hideMatchmakingLayout() : void {
if(this.matchmakingLayout == null) {
return;
}
this.matchmakingLayout.removeEventListener(SwitchToBattleSelectEvent.EVENT,onShowBattleSelect);
this.matchmakingLayout.removeEventListener(MatchmakingEvent.REGISTRATION,this.onRegistration);
this.matchmakingLayout.removeEventListener(MatchmakingEvent.ENTER_AS_SPECTATOR,this.onEnterAsSpectator);
this.matchmakingLayout.removeEventListener(MatchmakingGroupEvent.CREATE,this.onCreateGroup);
this.matchmakingLayout.removeEventListener(MatchmakingGroupEvent.LEAVE,this.onLeaveGroup);
this.matchmakingLayout.hide();
}
public function showGroupView(param1:Vector.<MatchmakingUserData>, param2:Boolean) : void {
this.matchmakingLayout.showGroupView(param1,param2);
}
public function hideGroupView() : void {
this.matchmakingLayout.hideGroupView();
}
public function addUserToGroup(param1:MatchmakingUserData) : void {
matchmakingGroupService.addUser(param1.id);
this.matchmakingLayout.addUserToGroup(param1);
}
public function updateMountedItem(param1:MountItemsUserData) : void {
this.matchmakingLayout.updateMountedItem(param1);
}
public function removeUserFromGroup(param1:Long) : void {
matchmakingGroupService.removeUser(param1);
this.matchmakingLayout.removeUserFromGroup(param1);
}
public function showUserReady(param1:Long) : void {
this.matchmakingLayout.showUserReady(param1);
}
public function showUserNotReady(param1:Long) : void {
this.matchmakingLayout.showUserNotReady(param1);
}
public function showRegistrationWindow(param1:int, param2:MatchmakingMode) : void {
this.setLastRegistrationMode(param2);
this.registrationFormController.addEventListener(MatchmakingEvent.UNREGISTRATION,this.onCancelRegistration);
this.registrationFormController.showForm(this.getModeName(param2),param1);
}
public function hideRegistrationWindow() : void {
this.registrationFormController.removeEventListener(MatchmakingEvent.UNREGISTRATION,this.onCancelRegistration);
this.registrationFormController.hideForm();
}
public function getLastRegistrationMode() : MatchmakingMode {
var local3:MatchmakingMode = null;
var local1:int = 0;
var local2:Object = storageService.getStorage().data[MM_GAME_MODE];
if(local2 != null) {
local1 = int(local2);
}
for each(local3 in MatchmakingMode.values) {
if(local3.value == local1) {
return local3;
}
}
return MatchmakingMode.TEAM_MODE;
}
private function onEnterAsSpectator(param1:MatchmakingEvent) : void {
dispatchEvent(param1);
}
private function setLastRegistrationMode(param1:MatchmakingMode) : void {
storageService.getStorage().data[MM_GAME_MODE] = param1.value;
storageService.getStorage().flush();
}
private function onRegistration(param1:MatchmakingEvent) : void {
this.setLastRegistrationMode(param1.getMode());
dispatchEvent(param1);
}
private function onCancelRegistration(param1:MatchmakingEvent) : void {
dispatchEvent(param1);
}
private function onCreateGroup(param1:MatchmakingGroupEvent) : void {
dispatchEvent(param1);
}
private function onLeaveGroup(param1:MatchmakingGroupEvent) : void {
dispatchEvent(param1);
}
public function openInviteWindow() : void {
dispatchEvent(new ShowGroupInviteWindowEvent());
}
public function getModeName(param1:MatchmakingMode) : String {
var local2:String = null;
switch(param1) {
case MatchmakingMode.TEAM_MODE:
local2 = TanksLocale.TEXT_QUICK_PLAY_MODE_NAME;
break;
case MatchmakingMode.HOLIDAY:
local2 = TanksLocale.TEXT_DM_MODE_NAME;
break;
default:
local2 = TanksLocale.TEXT_DM_MODE_NAME.replace("DM_",param1.name.substr(0,param1.name.indexOf("_") + 1));
}
return localeService.getText(local2);
}
}
}
|
package alternativa.tanks.display.usertitle {
import flash.display.BitmapData;
import flash.display.Graphics;
import flash.display.Shape;
import flash.geom.Matrix;
import flash.geom.Rectangle;
public class ProgressBar {
private static var matrix:Matrix = new Matrix();
private var maxValue:int;
private var barWidth:int;
private var shadowTipWidth:int;
private var shadowHeight:int;
private var barOffsetX:int;
private var barOffsetY:int;
private var skin:ProgressBarSkin;
private var barTipWidth:int;
private var barHeight:int;
private var _progress:int;
private var canvas:Shape = new Shape();
private var x:int;
private var y:int;
private var rect:Rectangle;
public function ProgressBar(param1:int, param2:int, param3:int, param4:int, param5:ProgressBarSkin) {
super();
this.x = param1;
this.y = param2;
this.maxValue = param3;
this.barWidth = param4;
this.setSkin(param5);
this.rect = new Rectangle(param1,param2,2 * this.shadowTipWidth + param4,this.shadowHeight);
}
public function setSkin(param1:ProgressBarSkin) : void {
this.skin = param1;
this.barTipWidth = param1.leftTipBg.width;
this.barHeight = param1.leftTipBg.height;
this.shadowTipWidth = param1.shadowLeftTip.width;
this.shadowHeight = param1.shadow.height;
this.barOffsetX = this.shadowTipWidth - this.barTipWidth;
this.barOffsetY = this.shadowHeight - this.barHeight >> 1;
}
public function get progress() : int {
return this._progress;
}
public function set progress(param1:int) : void {
if(param1 < 0) {
param1 = 0;
} else if(param1 > this.maxValue) {
param1 = this.maxValue;
}
this._progress = param1;
}
public function draw(param1:BitmapData) : void {
var local4:int = 0;
var local2:Graphics = this.canvas.graphics;
local2.clear();
local2.beginBitmapFill(this.skin.shadowLeftTip);
local2.drawRect(0,0,this.shadowTipWidth,this.shadowHeight);
local2.beginBitmapFill(this.skin.shadow);
local2.drawRect(this.shadowTipWidth,0,this.barWidth - 2 * this.barTipWidth,this.shadowHeight);
local2.beginBitmapFill(this.skin.shadowRightTip);
local2.drawRect(this.shadowTipWidth + this.barWidth - 2 * this.barTipWidth,0,this.shadowTipWidth,this.shadowHeight);
local2.endFill();
var local3:int = this.barWidth * this._progress / this.maxValue;
var local5:int = this.barWidth - this.barTipWidth;
if(local3 >= this.barTipWidth) {
if(local3 == this.barWidth) {
this.drawFullBar(local2,this.skin.color,this.skin.leftTipFg,this.skin.rightTipFg);
local4 = local3;
} else {
matrix.tx = this.barOffsetX;
matrix.ty = this.barOffsetY;
local2.beginBitmapFill(this.skin.leftTipFg,matrix,false);
local2.drawRect(this.barOffsetX,this.barOffsetY,this.barTipWidth,this.barHeight);
if(local3 > this.barTipWidth) {
if(local3 > local5) {
local3 = local5;
}
local4 = local3;
local2.beginFill(this.skin.color);
local2.drawRect(this.barOffsetX + this.barTipWidth,this.barOffsetY,local3 - this.barTipWidth,this.barHeight);
} else {
local4 = this.barTipWidth;
}
}
}
if(local4 == 0) {
this.drawFullBar(local2,this.skin.bgColor,this.skin.leftTipBg,this.skin.rightTipBg);
} else if(local4 < this.barWidth) {
local2.beginFill(this.skin.bgColor);
local2.drawRect(this.barOffsetX + local4,this.barOffsetY,local5 - local4,this.barHeight);
matrix.tx = this.barOffsetX + local5;
matrix.ty = this.barOffsetY;
local2.beginBitmapFill(this.skin.rightTipBg,matrix,false);
local2.drawRect(this.barOffsetX + local5,this.barOffsetY,this.barTipWidth,this.barHeight);
}
local2.endFill();
param1.fillRect(this.rect,0);
matrix.tx = this.x;
matrix.ty = this.y;
param1.draw(this.canvas,matrix);
}
private function drawFullBar(param1:Graphics, param2:uint, param3:BitmapData, param4:BitmapData) : void {
var local5:int = this.barWidth - this.barTipWidth;
matrix.tx = this.barOffsetX;
matrix.ty = this.barOffsetY;
param1.beginBitmapFill(param3,matrix,false);
param1.drawRect(this.barOffsetX,this.barOffsetY,this.barTipWidth,this.barHeight);
param1.beginFill(param2);
param1.drawRect(this.barOffsetX + this.barTipWidth,this.barOffsetY,local5 - this.barTipWidth,this.barHeight);
matrix.tx = this.barOffsetX + local5;
param1.beginBitmapFill(param4,matrix,false);
param1.drawRect(this.barOffsetX + local5,this.barOffsetY,this.barTipWidth,this.barHeight);
}
}
}
|
package projects.tanks.client.panel.model.usercountry {
public class CountryInfo {
private var _countryCode:String;
private var _countryName:String;
public function CountryInfo(param1:String = null, param2:String = null) {
super();
this._countryCode = param1;
this._countryName = param2;
}
public function get countryCode() : String {
return this._countryCode;
}
public function set countryCode(param1:String) : void {
this._countryCode = param1;
}
public function get countryName() : String {
return this._countryName;
}
public function set countryName(param1:String) : void {
this._countryName = param1;
}
public function toString() : String {
var local1:String = "CountryInfo [";
local1 += "countryCode = " + this.countryCode + " ";
local1 += "countryName = " + this.countryName + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.challenge
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChallengeCongratulationWindow_n2oBitmap extends BitmapAsset
{
public function ChallengeCongratulationWindow_n2oBitmap()
{
super();
}
}
}
|
package controls.dropdownlist {
import flash.display.Bitmap;
import flash.display.Sprite;
import flash.events.MouseEvent;
public class DropDownButton extends Sprite {
private var buttonClass:Class = DropDownButton_buttonClass;
private var buttonUpClass:Class = DropDownButton_buttonUpClass;
private var back:Bitmap = new this.buttonClass();
private var backMouseUp:Bitmap = new this.buttonUpClass();
public function DropDownButton() {
super();
addChild(this.back);
buttonMode = true;
addEventListener(MouseEvent.ROLL_OVER,this.onMouseOver);
addEventListener(MouseEvent.ROLL_OUT,this.onMouseOut);
}
private function onMouseOver(param1:MouseEvent) : void {
removeChildren();
addChild(this.backMouseUp);
}
private function onMouseOut(param1:MouseEvent) : void {
addChild(this.back);
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p27 extends BitmapAsset
{
public function RangIconNormal_p27()
{
super();
}
}
}
|
package projects.tanks.client.entrance.model.entrance.entrance {
public class EntranceModelCC {
private var _antiAddictionEnabled:Boolean;
public function EntranceModelCC(param1:Boolean = false) {
super();
this._antiAddictionEnabled = param1;
}
public function get antiAddictionEnabled() : Boolean {
return this._antiAddictionEnabled;
}
public function set antiAddictionEnabled(param1:Boolean) : void {
this._antiAddictionEnabled = param1;
}
public function toString() : String {
var local1:String = "EntranceModelCC [";
local1 += "antiAddictionEnabled = " + this.antiAddictionEnabled + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.panel.model.quest.daily {
import projects.tanks.client.panel.model.quest.showing.QuestInfoWithLevel;
public class DailyQuestInfo extends QuestInfoWithLevel {
private var _canSkipForFree:Boolean;
private var _skipCost:int;
public function DailyQuestInfo(param1:Boolean = false, param2:int = 0) {
super();
this._canSkipForFree = param1;
this._skipCost = param2;
}
public function get canSkipForFree() : Boolean {
return this._canSkipForFree;
}
public function set canSkipForFree(param1:Boolean) : void {
this._canSkipForFree = param1;
}
public function get skipCost() : int {
return this._skipCost;
}
public function set skipCost(param1:int) : void {
this._skipCost = param1;
}
override public function toString() : String {
var local1:String = "DailyQuestInfo [";
local1 += "canSkipForFree = " + this.canSkipForFree + " ";
local1 += "skipCost = " + this.skipCost + " ";
local1 += super.toString();
return local1 + "]";
}
}
}
|
package projects.tanks.client.users.model.friends.incoming {
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 FriendsIncomingModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function FriendsIncomingModelServer(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 {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol1087")]
public dynamic class ScrollArrowUp_overSkin extends MovieClip {
public function ScrollArrowUp_overSkin() {
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank20.png")]
public class PremiumRankBitmaps_bitmapBigRank20 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank20() {
super();
}
}
}
|
package _codec.projects.tanks.client.commons.models.challenge.time {
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.commons.models.challenge.time.ChallengesTimeCC;
public class CodecChallengesTimeCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_timeLeftSec:ICodec;
public function CodecChallengesTimeCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_timeLeftSec = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ChallengesTimeCC = new ChallengesTimeCC();
local2.timeLeftSec = this.codec_timeLeftSec.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ChallengesTimeCC = ChallengesTimeCC(param2);
this.codec_timeLeftSec.encode(param1,local3.timeLeftSec);
}
}
}
|
package alternativa.tanks.model.shop.items.crystallitem
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class CrystalPackageItemIcons_crystalsPackage4Class extends BitmapAsset
{
public function CrystalPackageItemIcons_crystalsPackage4Class()
{
super();
}
}
}
|
package alternativa.physics.collision.colliders
{
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.physics.Contact;
import alternativa.physics.ContactPoint;
import alternativa.physics.collision.CollisionPrimitive;
import alternativa.physics.collision.primitives.CollisionBox;
import alternativa.physics.collision.primitives.CollisionTriangle;
public class BoxTriangleCollider extends BoxCollider
{
public var epsilon:Number = 0.001;
private var bestAxisIndex:int;
private var minOverlap:Number;
private var toBox:Vector3;
private var axis:Vector3;
private var colNormal:Vector3;
private var axis10:Vector3;
private var axis11:Vector3;
private var axis12:Vector3;
private var axis20:Vector3;
private var axis21:Vector3;
private var axis22:Vector3;
private var point1:Vector3;
private var point2:Vector3;
private var vector:Vector3;
private var points1:Vector.<Vector3>;
private var points2:Vector.<Vector3>;
public function BoxTriangleCollider()
{
this.toBox = new Vector3();
this.axis = new Vector3();
this.colNormal = new Vector3();
this.axis10 = new Vector3();
this.axis11 = new Vector3();
this.axis12 = new Vector3();
this.axis20 = new Vector3();
this.axis21 = new Vector3();
this.axis22 = new Vector3();
this.point1 = new Vector3();
this.point2 = new Vector3();
this.vector = new Vector3();
this.points1 = new Vector.<Vector3>(8,true);
this.points2 = new Vector.<Vector3>(8,true);
super();
for(var i:int = 0; i < 8; i++)
{
this.points1[i] = new Vector3();
this.points2[i] = new Vector3();
}
}
override public function getContact(prim1:CollisionPrimitive, prim2:CollisionPrimitive, contact:Contact) : Boolean
{
var box:CollisionBox = null;
if(!this.haveCollision(prim1,prim2))
{
return false;
}
var tri:CollisionTriangle = prim1 as CollisionTriangle;
if(tri == null)
{
box = CollisionBox(prim1);
tri = CollisionTriangle(prim2);
}
else
{
box = CollisionBox(prim2);
}
if(this.bestAxisIndex < 4)
{
if(!this.findFaceContactPoints(box,tri,this.toBox,this.bestAxisIndex,contact))
{
return false;
}
}
else
{
this.bestAxisIndex -= 4;
if(!this.findEdgesIntersection(box,tri,this.toBox,this.bestAxisIndex % 3,int(this.bestAxisIndex / 3),contact))
{
return false;
}
}
contact.body1 = box.body;
contact.body2 = tri.body;
if(tri.transform.k > 0.99999)
{
contact.normal.x = 0;
contact.normal.y = 0;
contact.normal.z = 1;
}
return true;
}
override public function haveCollision(prim1:CollisionPrimitive, prim2:CollisionPrimitive) : Boolean
{
var tri:CollisionTriangle = null;
var box:CollisionBox = null;
var boxTransform:Matrix4 = null;
var triTransform:Matrix4 = null;
var v:Vector3 = null;
tri = null;
box = null;
boxTransform = null;
triTransform = null;
v = null;
tri = prim1 as CollisionTriangle;
if(tri == null)
{
box = CollisionBox(prim1);
tri = CollisionTriangle(prim2);
}
else
{
box = CollisionBox(prim2);
}
boxTransform = box.transform;
triTransform = tri.transform;
this.toBox.x = boxTransform.d - triTransform.d;
this.toBox.y = boxTransform.h - triTransform.h;
this.toBox.z = boxTransform.l - triTransform.l;
this.minOverlap = 1e+308;
this.axis.x = triTransform.c;
this.axis.y = triTransform.g;
this.axis.z = triTransform.k;
if(!this.testMainAxis(box,tri,this.axis,0,this.toBox))
{
return false;
}
this.axis10.x = boxTransform.a;
this.axis10.y = boxTransform.e;
this.axis10.z = boxTransform.i;
if(!this.testMainAxis(box,tri,this.axis10,1,this.toBox))
{
return false;
}
this.axis11.x = boxTransform.b;
this.axis11.y = boxTransform.f;
this.axis11.z = boxTransform.j;
if(!this.testMainAxis(box,tri,this.axis11,2,this.toBox))
{
return false;
}
this.axis12.x = boxTransform.c;
this.axis12.y = boxTransform.g;
this.axis12.z = boxTransform.k;
if(!this.testMainAxis(box,tri,this.axis12,3,this.toBox))
{
return false;
}
v = tri.e0;
this.axis20.x = triTransform.a * v.x + triTransform.b * v.y + triTransform.c * v.z;
this.axis20.y = triTransform.e * v.x + triTransform.f * v.y + triTransform.g * v.z;
this.axis20.z = triTransform.i * v.x + triTransform.j * v.y + triTransform.k * v.z;
if(!this.testDerivedAxis(box,tri,this.axis10,this.axis20,4,this.toBox))
{
return false;
}
if(!this.testDerivedAxis(box,tri,this.axis11,this.axis20,5,this.toBox))
{
return false;
}
if(!this.testDerivedAxis(box,tri,this.axis12,this.axis20,6,this.toBox))
{
return false;
}
v = tri.e1;
this.axis21.x = triTransform.a * v.x + triTransform.b * v.y + triTransform.c * v.z;
this.axis21.y = triTransform.e * v.x + triTransform.f * v.y + triTransform.g * v.z;
this.axis21.z = triTransform.i * v.x + triTransform.j * v.y + triTransform.k * v.z;
if(!this.testDerivedAxis(box,tri,this.axis10,this.axis21,7,this.toBox))
{
return false;
}
if(!this.testDerivedAxis(box,tri,this.axis11,this.axis21,8,this.toBox))
{
return false;
}
if(!this.testDerivedAxis(box,tri,this.axis12,this.axis21,9,this.toBox))
{
return false;
}
v = tri.e2;
this.axis22.x = triTransform.a * v.x + triTransform.b * v.y + triTransform.c * v.z;
this.axis22.y = triTransform.e * v.x + triTransform.f * v.y + triTransform.g * v.z;
this.axis22.z = triTransform.i * v.x + triTransform.j * v.y + triTransform.k * v.z;
if(!this.testDerivedAxis(box,tri,this.axis10,this.axis22,10,this.toBox))
{
return false;
}
if(!this.testDerivedAxis(box,tri,this.axis11,this.axis22,11,this.toBox))
{
return false;
}
if(!this.testDerivedAxis(box,tri,this.axis12,this.axis22,12,this.toBox))
{
return false;
}
return true;
}
private function testMainAxis(box:CollisionBox, tri:CollisionTriangle, axis:Vector3, axisIndex:int, toBox:Vector3) : Boolean
{
var overlap:Number = this.overlapOnAxis(box,tri,axis,toBox);
if(overlap < -this.epsilon)
{
return false;
}
if(overlap + this.epsilon < this.minOverlap)
{
this.minOverlap = overlap;
this.bestAxisIndex = axisIndex;
}
return true;
}
private function testDerivedAxis(box:CollisionBox, tri:CollisionTriangle, axis1:Vector3, axis2:Vector3, axisIndex:int, toBox:Vector3) : Boolean
{
var k:Number = NaN;
this.axis.x = axis1.y * axis2.z - axis1.z * axis2.y;
this.axis.y = axis1.z * axis2.x - axis1.x * axis2.z;
this.axis.z = axis1.x * axis2.y - axis1.y * axis2.x;
var lenSqr:Number = this.axis.x * this.axis.x + this.axis.y * this.axis.y + this.axis.z * this.axis.z;
if(lenSqr < 0.0001)
{
return true;
}
k = 1 / Math.sqrt(lenSqr);
this.axis.x *= k;
this.axis.y *= k;
this.axis.z *= k;
var overlap:Number = this.overlapOnAxis(box,tri,this.axis,toBox);
if(overlap < -this.epsilon)
{
return false;
}
if(overlap + this.epsilon < this.minOverlap)
{
this.minOverlap = overlap;
this.bestAxisIndex = axisIndex;
}
return true;
}
private function overlapOnAxis(box:CollisionBox, tri:CollisionTriangle, axis:Vector3, toBox:Vector3) : Number
{
var t:Matrix4 = box.transform;
var projection:Number = (t.a * axis.x + t.e * axis.y + t.i * axis.z) * box.hs.x;
if(projection < 0)
{
projection = -projection;
}
var d:Number = (t.b * axis.x + t.f * axis.y + t.j * axis.z) * box.hs.y;
projection += d < 0 ? -d : d;
d = (t.c * axis.x + t.g * axis.y + t.k * axis.z) * box.hs.z;
projection += d < 0 ? -d : d;
var vectorProjection:Number = toBox.x * axis.x + toBox.y * axis.y + toBox.z * axis.z;
t = tri.transform;
var ax:Number = t.a * axis.x + t.e * axis.y + t.i * axis.z;
var ay:Number = t.b * axis.x + t.f * axis.y + t.j * axis.z;
var az:Number = t.c * axis.x + t.g * axis.y + t.k * axis.z;
var max:Number = 0;
if(vectorProjection < 0)
{
vectorProjection = -vectorProjection;
d = tri.v0.x * ax + tri.v0.y * ay + tri.v0.z * az;
if(d < max)
{
max = d;
}
d = tri.v1.x * ax + tri.v1.y * ay + tri.v1.z * az;
if(d < max)
{
max = d;
}
d = tri.v2.x * ax + tri.v2.y * ay + tri.v2.z * az;
if(d < max)
{
max = d;
}
max = -max;
}
else
{
d = tri.v0.x * ax + tri.v0.y * ay + tri.v0.z * az;
if(d > max)
{
max = d;
}
d = tri.v1.x * ax + tri.v1.y * ay + tri.v1.z * az;
if(d > max)
{
max = d;
}
d = tri.v2.x * ax + tri.v2.y * ay + tri.v2.z * az;
if(d > max)
{
max = d;
}
}
return projection + max - vectorProjection;
}
private function findFaceContactPoints(box:CollisionBox, tri:CollisionTriangle, toBox:Vector3, faceAxisIndex:int, contact:Contact) : Boolean
{
if(faceAxisIndex == 0)
{
return this.getBoxToTriContact(box,tri,toBox,contact);
}
return this.getTriToBoxContact(box,tri,toBox,faceAxisIndex,contact);
}
private function getBoxToTriContact(box:CollisionBox, tri:CollisionTriangle, toBox:Vector3, contact:Contact) : Boolean
{
var over:Boolean = false;
var cp:ContactPoint = null;
var dot:Number = NaN;
var absDot:Number = NaN;
var v:Vector3 = null;
var cpPos:Vector3 = null;
var r:Vector3 = null;
var boxTransform:Matrix4 = box.transform;
var triTransform:Matrix4 = tri.transform;
this.colNormal.x = triTransform.c;
this.colNormal.y = triTransform.g;
this.colNormal.z = triTransform.k;
over = toBox.x * this.colNormal.x + toBox.y * this.colNormal.y + toBox.z * this.colNormal.z > 0;
if(!over)
{
this.colNormal.x = -this.colNormal.x;
this.colNormal.y = -this.colNormal.y;
this.colNormal.z = -this.colNormal.z;
}
var incFaceAxisIdx:int = 0;
var incAxisDot:Number = 0;
var maxDot:Number = 0;
for(var axisIdx:int = 0; axisIdx < 3; axisIdx++)
{
boxTransform.getAxis(axisIdx,this.axis);
dot = this.axis.x * this.colNormal.x + this.axis.y * this.colNormal.y + this.axis.z * this.colNormal.z;
absDot = dot < 0 ? Number(Number(-dot)) : Number(Number(dot));
if(absDot > maxDot)
{
maxDot = absDot;
incAxisDot = dot;
incFaceAxisIdx = axisIdx;
}
}
var negativeFace:Boolean = incAxisDot > 0;
var code:int = 1 << (incFaceAxisIdx << 1);
if(negativeFace)
{
code <<= 1;
}
if((code & box.excludedFaces) != 0)
{
return false;
}
getFaceVertsByAxis(box.hs,incFaceAxisIdx,negativeFace,this.points1);
boxTransform.transformVectorsN(this.points1,this.points2,4);
triTransform.transformVectorsInverseN(this.points2,this.points1,4);
var pnum:int = this.clipByTriangle(tri);
contact.pcount = 0;
for(var i:int = 0; i < pnum; i++)
{
v = this.points2[i];
if(over && v.z < 0 || !over && v.z > 0)
{
cp = contact.points[contact.pcount++];
cpPos = cp.pos;
cpPos.x = triTransform.a * v.x + triTransform.b * v.y + triTransform.c * v.z + triTransform.d;
cpPos.y = triTransform.e * v.x + triTransform.f * v.y + triTransform.g * v.z + triTransform.h;
cpPos.z = triTransform.i * v.x + triTransform.j * v.y + triTransform.k * v.z + triTransform.l;
r = cp.r1;
r.x = cpPos.x - boxTransform.d;
r.y = cpPos.y - boxTransform.h;
r.z = cpPos.z - boxTransform.l;
r = cp.r2;
r.x = cpPos.x - triTransform.d;
r.y = cpPos.y - triTransform.h;
r.z = cpPos.z - triTransform.l;
cp.penetration = !!over ? Number(Number(-v.z)) : Number(Number(v.z));
}
}
contact.normal.x = this.colNormal.x;
contact.normal.y = this.colNormal.y;
contact.normal.z = this.colNormal.z;
return true;
}
private function getTriToBoxContact(box:CollisionBox, tri:CollisionTriangle, toBox:Vector3, faceAxisIdx:int, contact:Contact) : Boolean
{
var penetration:Number = NaN;
var cp:ContactPoint = null;
var cpPos:Vector3 = null;
var r:Vector3 = null;
faceAxisIdx--;
var boxTransform:Matrix4 = box.transform;
var triTransform:Matrix4 = tri.transform;
boxTransform.getAxis(faceAxisIdx,this.colNormal);
var negativeFace:Boolean = toBox.x * this.colNormal.x + toBox.y * this.colNormal.y + toBox.z * this.colNormal.z > 0;
var code:int = 1 << (faceAxisIdx << 1);
if(negativeFace)
{
code <<= 1;
}
if((code & box.excludedFaces) != 0)
{
return false;
}
if(!negativeFace)
{
this.colNormal.x = -this.colNormal.x;
this.colNormal.y = -this.colNormal.y;
this.colNormal.z = -this.colNormal.z;
}
var v:Vector3 = this.points1[0];
v.x = tri.v0.x;
v.y = tri.v0.y;
v.z = tri.v0.z;
v = this.points1[1];
v.x = tri.v1.x;
v.y = tri.v1.y;
v.z = tri.v1.z;
v = this.points1[2];
v.x = tri.v2.x;
v.y = tri.v2.y;
v.z = tri.v2.z;
triTransform.transformVectorsN(this.points1,this.points2,3);
boxTransform.transformVectorsInverseN(this.points2,this.points1,3);
var pnum:int = this.clipByBox(box.hs,faceAxisIdx);
contact.pcount = 0;
for(var i:int = 0; i < pnum; i++)
{
v = this.points1[i];
penetration = this.getPointBoxPenetration(box.hs,v,faceAxisIdx,negativeFace);
if(penetration > -this.epsilon)
{
cp = contact.points[contact.pcount++];
cpPos = cp.pos;
cpPos.x = boxTransform.a * v.x + boxTransform.b * v.y + boxTransform.c * v.z + boxTransform.d;
cpPos.y = boxTransform.e * v.x + boxTransform.f * v.y + boxTransform.g * v.z + boxTransform.h;
cpPos.z = boxTransform.i * v.x + boxTransform.j * v.y + boxTransform.k * v.z + boxTransform.l;
r = cp.r1;
r.x = cpPos.x - boxTransform.d;
r.y = cpPos.y - boxTransform.h;
r.z = cpPos.z - boxTransform.l;
r = cp.r2;
r.x = cpPos.x - triTransform.d;
r.y = cpPos.y - triTransform.h;
r.z = cpPos.z - triTransform.l;
cp.penetration = penetration;
}
}
contact.normal.x = this.colNormal.x;
contact.normal.y = this.colNormal.y;
contact.normal.z = this.colNormal.z;
return true;
}
private function getPointBoxPenetration(hs:Vector3, p:Vector3, faceAxisIdx:int, negativeFace:Boolean) : Number
{
switch(faceAxisIdx)
{
case 0:
if(negativeFace)
{
return p.x + hs.x;
}
return hs.x - p.x;
break;
case 1:
if(negativeFace)
{
return p.y + hs.y;
}
return hs.y - p.y;
break;
case 2:
if(negativeFace)
{
return p.z + hs.z;
}
return hs.z - p.z;
break;
default:
return 0;
}
}
private function clipByBox(hs:Vector3, faceAxisIdx:int) : int
{
var pnum:int = 3;
switch(faceAxisIdx)
{
case 0:
if((pnum = clipLowZ(-hs.z,pnum,this.points1,this.points2,this.epsilon)) == 0)
{
return 0;
}
if((pnum = clipHighZ(hs.z,pnum,this.points2,this.points1,this.epsilon)) == 0)
{
return 0;
}
if((pnum = clipLowY(-hs.y,pnum,this.points1,this.points2,this.epsilon)) == 0)
{
return 0;
}
return clipHighY(hs.y,pnum,this.points2,this.points1,this.epsilon);
break;
case 1:
if((pnum = clipLowZ(-hs.z,pnum,this.points1,this.points2,this.epsilon)) == 0)
{
return 0;
}
if((pnum = clipHighZ(hs.z,pnum,this.points2,this.points1,this.epsilon)) == 0)
{
return 0;
}
if((pnum = clipLowX(-hs.x,pnum,this.points1,this.points2,this.epsilon)) == 0)
{
return 0;
}
return clipHighX(hs.x,pnum,this.points2,this.points1,this.epsilon);
break;
case 2:
if((pnum = clipLowX(-hs.x,pnum,this.points1,this.points2,this.epsilon)) == 0)
{
return 0;
}
if((pnum = clipHighX(hs.x,pnum,this.points2,this.points1,this.epsilon)) == 0)
{
return 0;
}
if((pnum = clipLowY(-hs.y,pnum,this.points1,this.points2,this.epsilon)) == 0)
{
return 0;
}
return clipHighY(hs.y,pnum,this.points2,this.points1,this.epsilon);
break;
default:
return 0;
}
}
private function clipByTriangle(tri:CollisionTriangle) : int
{
var vnum:int = 4;
vnum = this.clipByLine(tri.v0,tri.e0,this.points1,vnum,this.points2);
if(vnum == 0)
{
return 0;
}
vnum = this.clipByLine(tri.v1,tri.e1,this.points2,vnum,this.points1);
if(vnum == 0)
{
return 0;
}
return this.clipByLine(tri.v2,tri.e2,this.points1,vnum,this.points2);
}
private function clipByLine(linePoint:Vector3, lineDir:Vector3, verticesIn:Vector.<Vector3>, vnum:int, verticesOut:Vector.<Vector3>) : int
{
var t:Number = NaN;
var v:Vector3 = null;
var v2:Vector3 = null;
var offset2:Number = NaN;
var nx:Number = -lineDir.y;
var ny:Number = lineDir.x;
var offset:Number = linePoint.x * nx + linePoint.y * ny;
var v1:Vector3 = verticesIn[int(vnum - 1)];
var offset1:Number = v1.x * nx + v1.y * ny;
var num:int = 0;
for(var i:int = 0; i < vnum; i++)
{
v2 = verticesIn[i];
offset2 = v2.x * nx + v2.y * ny;
if(offset1 < offset)
{
if(offset2 > offset)
{
t = (offset - offset1) / (offset2 - offset1);
v = verticesOut[num];
v.x = v1.x + t * (v2.x - v1.x);
v.y = v1.y + t * (v2.y - v1.y);
v.z = v1.z + t * (v2.z - v1.z);
num++;
}
}
else
{
v = verticesOut[num];
v.x = v1.x;
v.y = v1.y;
v.z = v1.z;
num++;
if(offset2 < offset)
{
t = (offset - offset1) / (offset2 - offset1);
v = verticesOut[num];
v.x = v1.x + t * (v2.x - v1.x);
v.y = v1.y + t * (v2.y - v1.y);
v.z = v1.z + t * (v2.z - v1.z);
num++;
}
}
v1 = v2;
offset1 = offset2;
}
return num;
}
private function findEdgesIntersection(box:CollisionBox, tri:CollisionTriangle, toBox:Vector3, boxAxisIdx:int, triAxisIdx:int, contact:Contact) : Boolean
{
var tmpx1:Number = NaN;
var tmpy1:Number = NaN;
var tmpz1:Number = NaN;
var tmpx2:Number = NaN;
var tmpy2:Number = NaN;
var tmpz2:Number = NaN;
var boxHalfLen:Number = NaN;
var k:Number = NaN;
switch(triAxisIdx)
{
case 0:
tmpx1 = tri.e0.x;
tmpy1 = tri.e0.y;
tmpz1 = tri.e0.z;
tmpx2 = tri.v0.x;
tmpy2 = tri.v0.y;
tmpz2 = tri.v0.z;
break;
case 1:
tmpx1 = tri.e1.x;
tmpy1 = tri.e1.y;
tmpz1 = tri.e1.z;
tmpx2 = tri.v1.x;
tmpy2 = tri.v1.y;
tmpz2 = tri.v1.z;
break;
case 2:
tmpx1 = tri.e2.x;
tmpy1 = tri.e2.y;
tmpz1 = tri.e2.z;
tmpx2 = tri.v2.x;
tmpy2 = tri.v2.y;
tmpz2 = tri.v2.z;
}
var triTransform:Matrix4 = tri.transform;
this.axis20.x = triTransform.a * tmpx1 + triTransform.b * tmpy1 + triTransform.c * tmpz1;
this.axis20.y = triTransform.e * tmpx1 + triTransform.f * tmpy1 + triTransform.g * tmpz1;
this.axis20.z = triTransform.i * tmpx1 + triTransform.j * tmpy1 + triTransform.k * tmpz1;
var x2:Number = triTransform.a * tmpx2 + triTransform.b * tmpy2 + triTransform.c * tmpz2 + triTransform.d;
var y2:Number = triTransform.e * tmpx2 + triTransform.f * tmpy2 + triTransform.g * tmpz2 + triTransform.h;
var z2:Number = triTransform.i * tmpx2 + triTransform.j * tmpy2 + triTransform.k * tmpz2 + triTransform.l;
var boxTransform:Matrix4 = box.transform;
boxTransform.getAxis(boxAxisIdx,this.axis10);
var v:Vector3 = contact.normal;
v.x = this.axis10.y * this.axis20.z - this.axis10.z * this.axis20.y;
v.y = this.axis10.z * this.axis20.x - this.axis10.x * this.axis20.z;
v.z = this.axis10.x * this.axis20.y - this.axis10.y * this.axis20.x;
k = 1 / Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
v.x *= k;
v.y *= k;
v.z *= k;
if(v.x * toBox.x + v.y * toBox.y + v.z * toBox.z < 0)
{
v.x = -v.x;
v.y = -v.y;
v.z = -v.z;
}
tmpx1 = box.hs.x;
tmpy1 = box.hs.y;
tmpz1 = box.hs.z;
if(boxAxisIdx == 0)
{
tmpx1 = 0;
boxHalfLen = box.hs.x;
}
else if(boxTransform.a * v.x + boxTransform.e * v.y + boxTransform.i * v.z > 0)
{
tmpx1 = -tmpx1;
if((box.excludedFaces & 2) != 0)
{
return false;
}
}
else if((box.excludedFaces & 1) != 0)
{
return false;
}
if(boxAxisIdx == 1)
{
tmpy1 = 0;
boxHalfLen = box.hs.y;
}
else if(boxTransform.b * v.x + boxTransform.f * v.y + boxTransform.j * v.z > 0)
{
tmpy1 = -tmpy1;
if((box.excludedFaces & 8) != 0)
{
return false;
}
}
else if((box.excludedFaces & 4) != 0)
{
return false;
}
if(boxAxisIdx == 2)
{
tmpz1 = 0;
boxHalfLen = box.hs.z;
}
else if(boxTransform.c * v.x + boxTransform.g * v.y + boxTransform.k * v.z > 0)
{
tmpz1 = -tmpz1;
if((box.excludedFaces & 32) != 0)
{
return false;
}
}
else if((box.excludedFaces & 16) != 0)
{
return false;
}
var x1:Number = boxTransform.a * tmpx1 + boxTransform.b * tmpy1 + boxTransform.c * tmpz1 + boxTransform.d;
var y1:Number = boxTransform.e * tmpx1 + boxTransform.f * tmpy1 + boxTransform.g * tmpz1 + boxTransform.h;
var z1:Number = boxTransform.i * tmpx1 + boxTransform.j * tmpy1 + boxTransform.k * tmpz1 + boxTransform.l;
k = this.axis10.x * this.axis20.x + this.axis10.y * this.axis20.y + this.axis10.z * this.axis20.z;
var det:Number = k * k - 1;
var vx:Number = x2 - x1;
var vy:Number = y2 - y1;
var vz:Number = z2 - z1;
var c1:Number = this.axis10.x * vx + this.axis10.y * vy + this.axis10.z * vz;
var c2:Number = this.axis20.x * vx + this.axis20.y * vy + this.axis20.z * vz;
var t1:Number = (c2 * k - c1) / det;
var t2:Number = (c2 - c1 * k) / det;
contact.pcount = 1;
var cp:ContactPoint = contact.points[0];
cp.penetration = this.minOverlap;
v = cp.pos;
v.x = 0.5 * (x1 + this.axis10.x * t1 + x2 + this.axis20.x * t2);
v.y = 0.5 * (y1 + this.axis10.y * t1 + y2 + this.axis20.y * t2);
v.z = 0.5 * (z1 + this.axis10.z * t1 + z2 + this.axis20.z * t2);
var r:Vector3 = cp.r1;
r.x = v.x - boxTransform.d;
r.y = v.y - boxTransform.h;
r.z = v.z - boxTransform.l;
r = cp.r2;
r.x = v.x - triTransform.d;
r.y = v.y - triTransform.h;
r.z = v.z - triTransform.l;
return true;
}
}
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_NORMAL_RED_PIXEL.png")]
public dynamic class bres_NORMAL_RED_PIXEL extends BitmapData {
public function bres_NORMAL_RED_PIXEL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package projects.tanks.client.battlefield.models.user.speedcharacteristics {
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 SpeedCharacteristicsModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function SpeedCharacteristicsModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.battlefield.gui.models.effectsvisualization
{
public class BattleEffect
{
public var userID:String;
public var itemIndex:int;
public var durationTime:int;
public function BattleEffect()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.ultimate.effects.hornet.radar {
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 BattleUltimateRadarModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BattleUltimateRadarModelServer;
private var client:IBattleUltimateRadarModelBase = IBattleUltimateRadarModelBase(this);
private var modelId:Long = Long.getLong(214258581,-1769245933);
private var _updateDiscoveredTanksListId:Long = Long.getLong(157548406,1377428332);
private var _updateDiscoveredTanksList_discoveredTanksCodec:ICodec;
public function BattleUltimateRadarModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BattleUltimateRadarModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(BattleUltimateRadarCC,false)));
this._updateDiscoveredTanksList_discoveredTanksCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Long,false),false,1));
}
protected function getInitParam() : BattleUltimateRadarCC {
return BattleUltimateRadarCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._updateDiscoveredTanksListId:
this.client.updateDiscoveredTanksList(this._updateDiscoveredTanksList_discoveredTanksCodec.decode(param2) as Vector.<Long>);
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.engine3d {
import alternativa.engine3d.materials.TextureMaterial;
import flash.display.BitmapData;
public class MutableTextureMaterialRegistry extends TextureMaterialRegistryBase {
private var textureRegistry:MutableTextureRegistry;
public function MutableTextureMaterialRegistry(param1:TextureMaterialFactory, param2:MutableTextureRegistry) {
super(param1);
this.textureRegistry = param2;
param2.addTextureChangeHandler(this.onTextureChange);
}
private function onTextureChange() : void {
forEachMaterial(this._updateTexture);
}
private function _updateTexture(param1:TextureMaterial) : void {
var local2:MaterialEntry = getEntry(param1);
param1.texture = this.textureRegistry.getTexture(local2.texture);
}
override protected function getTexture(param1:BitmapData, param2:Boolean) : BitmapData {
return this.textureRegistry.getTexture(param1,param2);
}
}
}
|
package alternativa.tanks.model.shop.bugreport
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import controls.TankWindowInner;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.net.URLRequest;
import flash.net.navigateToURL;
public class PaymentBugReportBlock extends Sprite
{
public static var localeService:ILocaleService = Main.osgi.getService(ILocaleService) as ILocaleService;
public static const WINDOW_MARGIN:int = 11;
public static const SPACE_MODULE:int = 7;
[Embed(source="1195.png")]
private static const bitmapError:Class;
private static const errorBd:BitmapData = new bitmapError().bitmapData;
private var errorInner:TankWindowInner;
public var errorButton:DefaultButtonBase;
private var errorIcon:Bitmap;
private var errorLabel:LabelBase;
private var _height:Number;
private var _width:Number;
public function PaymentBugReportBlock()
{
super();
this.errorInner = new TankWindowInner(0,0,TankWindowInner.TRANSPARENT);
addChild(this.errorInner);
this.errorIcon = new Bitmap(errorBd);
addChild(this.errorIcon);
this.errorLabel = new LabelBase();
addChild(this.errorLabel);
this.errorLabel.multiline = true;
this.errorLabel.wordWrap = true;
this.errorLabel.text = "Если ваш платёж не дошел или возникла проблема — сообщите нам об этом.";
this.errorButton = new DefaultButtonBase();
this.errorButton.label = "Сообщить";
this.errorButton.addEventListener(MouseEvent.CLICK,this.openGroup);
addChild(this.errorButton);
this.errorButton.y = SPACE_MODULE;
this._height = 45;
this.errorInner.height = this._height;
this.errorIcon.x = WINDOW_MARGIN;
this.errorIcon.y = int((this._height - this.errorIcon.height) * 0.5);
this.errorLabel.x = this.errorIcon.x + this.errorIcon.width + WINDOW_MARGIN;
}
private function openGroup(param1:MouseEvent) : void
{
navigateToURL(new URLRequest("https://vk.com/mytanksonline_official"),"_blank");
}
override public function get height() : Number
{
return this._height;
}
override public function set height(param1:Number) : void
{
}
override public function get width() : Number
{
return this._width;
}
override public function set width(param1:Number) : void
{
this._width = param1;
this.errorInner.width = this._width;
this.errorButton.x = this._width - this.errorButton.width - WINDOW_MARGIN;
this.errorLabel.width = this.errorButton.x - this.errorLabel.x - WINDOW_MARGIN;
this.errorLabel.y = int((this._height - this.errorLabel.height) * 0.5);
}
}
}
|
package alternativa.engine3d.loaders {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.FillMaterial;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import flash.geom.Matrix;
import flash.geom.Vector3D;
import flash.utils.ByteArray;
import flash.utils.Endian;
use namespace alternativa3d;
public class Parser3DS {
private static const CHUNK_MAIN:int = 19789;
private static const CHUNK_VERSION:int = 2;
private static const CHUNK_SCENE:int = 15677;
private static const CHUNK_ANIMATION:int = 45056;
private static const CHUNK_OBJECT:int = 16384;
private static const CHUNK_TRIMESH:int = 16640;
private static const CHUNK_VERTICES:int = 16656;
private static const CHUNK_FACES:int = 16672;
private static const CHUNK_FACESMATERIAL:int = 16688;
private static const CHUNK_FACESSMOOTH:int = 16720;
private static const CHUNK_MAPPINGCOORDS:int = 16704;
private static const CHUNK_TRANSFORMATION:int = 16736;
private static const CHUNK_MATERIAL:int = 45055;
private var data:ByteArray;
private var objectDatas:Object;
private var animationDatas:Array;
private var materialDatas:Object;
public var objects:Vector.<Object3D>;
public var parents:Vector.<Object3D>;
public var materials:Vector.<Material>;
public var textureMaterials:Vector.<TextureMaterial>;
public function Parser3DS() {
super();
}
public function getObjectByName(param1:String) : Object3D {
var local2:Object3D = null;
for each(local2 in this.objects) {
if(local2.name == param1) {
return local2;
}
}
return null;
}
public function parse(param1:ByteArray, param2:String = "", param3:Number = 1) : void {
if(param1.bytesAvailable < 6) {
return;
}
this.data = param1;
param1.endian = Endian.LITTLE_ENDIAN;
this.parse3DSChunk(param1.position,param1.bytesAvailable);
this.objects = new Vector.<Object3D>();
this.parents = new Vector.<Object3D>();
this.materials = new Vector.<Material>();
this.textureMaterials = new Vector.<TextureMaterial>();
this.buildContent(param2,param3);
param1 = null;
this.objectDatas = null;
this.animationDatas = null;
this.materialDatas = null;
}
private function readChunkInfo(param1:int) : ChunkInfo {
this.data.position = param1;
var local2:ChunkInfo = new ChunkInfo();
local2.id = this.data.readUnsignedShort();
local2.size = this.data.readUnsignedInt();
local2.dataSize = local2.size - 6;
local2.dataPosition = this.data.position;
local2.nextChunkPosition = param1 + local2.size;
return local2;
}
private function parse3DSChunk(param1:int, param2:int) : void {
if(param2 < 6) {
return;
}
var local3:ChunkInfo = this.readChunkInfo(param1);
this.data.position = param1;
switch(local3.id) {
case CHUNK_MAIN:
this.parseMainChunk(local3.dataPosition,local3.dataSize);
}
this.parse3DSChunk(local3.nextChunkPosition,param2 - local3.size);
}
private function parseMainChunk(param1:int, param2:int) : void {
if(param2 < 6) {
return;
}
var local3:ChunkInfo = this.readChunkInfo(param1);
switch(local3.id) {
case CHUNK_VERSION:
break;
case CHUNK_SCENE:
this.parse3DChunk(local3.dataPosition,local3.dataSize);
break;
case CHUNK_ANIMATION:
this.parseAnimationChunk(local3.dataPosition,local3.dataSize);
}
this.parseMainChunk(local3.nextChunkPosition,param2 - local3.size);
}
private function parse3DChunk(param1:int, param2:int) : void {
var local3:ChunkInfo = null;
var local4:MaterialData = null;
while(param2 >= 6) {
local3 = this.readChunkInfo(param1);
switch(local3.id) {
case CHUNK_MATERIAL:
local4 = new MaterialData();
this.parseMaterialChunk(local4,local3.dataPosition,local3.dataSize);
break;
case CHUNK_OBJECT:
this.parseObject(local3);
break;
}
param1 = local3.nextChunkPosition;
param2 -= local3.size;
}
}
private function parseObject(param1:ChunkInfo) : void {
if(this.objectDatas == null) {
this.objectDatas = new Object();
}
var local2:ObjectData = new ObjectData();
local2.name = this.getString(param1.dataPosition);
this.objectDatas[local2.name] = local2;
var local3:int = local2.name.length + 1;
this.parseObjectChunk(local2,param1.dataPosition + local3,param1.dataSize - local3);
}
private function parseObjectChunk(param1:ObjectData, param2:int, param3:int) : void {
if(param3 < 6) {
return;
}
var local4:ChunkInfo = this.readChunkInfo(param2);
switch(local4.id) {
case CHUNK_TRIMESH:
this.parseMeshChunk(param1,local4.dataPosition,local4.dataSize);
break;
case 17920:
case 18176:
}
this.parseObjectChunk(param1,local4.nextChunkPosition,param3 - local4.size);
}
private function parseMeshChunk(param1:ObjectData, param2:int, param3:int) : void {
if(param3 < 6) {
return;
}
var local4:ChunkInfo = this.readChunkInfo(param2);
switch(local4.id) {
case CHUNK_VERTICES:
this.parseVertices(param1);
break;
case CHUNK_MAPPINGCOORDS:
this.parseUVs(param1);
break;
case CHUNK_TRANSFORMATION:
this.parseMatrix(param1);
break;
case CHUNK_FACES:
this.parseFaces(param1,local4);
}
this.parseMeshChunk(param1,local4.nextChunkPosition,param3 - local4.size);
}
private function parseVertices(param1:ObjectData) : void {
var local2:int = int(this.data.readUnsignedShort());
param1.vertices = new Vector.<Number>();
var local3:int = 0;
var local4:int = 0;
while(local3 < local2) {
var local5:* = local4++;
param1.vertices[local5] = this.data.readFloat();
var local6:* = local4++;
param1.vertices[local6] = this.data.readFloat();
var local7:* = local4++;
param1.vertices[local7] = this.data.readFloat();
local3++;
}
}
private function parseUVs(param1:ObjectData) : void {
var local2:int = int(this.data.readUnsignedShort());
param1.uvs = new Vector.<Number>();
var local3:int = 0;
var local4:int = 0;
while(local3 < local2) {
var local5:* = local4++;
param1.uvs[local5] = this.data.readFloat();
var local6:* = local4++;
param1.uvs[local6] = this.data.readFloat();
local3++;
}
}
private function parseMatrix(param1:ObjectData) : void {
param1.a = this.data.readFloat();
param1.e = this.data.readFloat();
param1.i = this.data.readFloat();
param1.b = this.data.readFloat();
param1.f = this.data.readFloat();
param1.j = this.data.readFloat();
param1.c = this.data.readFloat();
param1.g = this.data.readFloat();
param1.k = this.data.readFloat();
param1.d = this.data.readFloat();
param1.h = this.data.readFloat();
param1.l = this.data.readFloat();
}
private function parseFaces(param1:ObjectData, param2:ChunkInfo) : void {
var local3:int = int(this.data.readUnsignedShort());
param1.faces = new Vector.<int>(local3 * 3);
param1.smoothingGroups = new Vector.<uint>(local3);
var local4:int = 0;
var local5:int = 0;
while(local4 < local3) {
var local7:* = local5++;
param1.faces[local7] = this.data.readUnsignedShort();
var local8:* = local5++;
param1.faces[local8] = this.data.readUnsignedShort();
var local9:* = local5++;
param1.faces[local9] = this.data.readUnsignedShort();
this.data.position += 2;
local4++;
}
var local6:int = 2 + 8 * local3;
this.parseFacesChunk(param1,param2.dataPosition + local6,param2.dataSize - local6);
}
private function parseFacesChunk(param1:ObjectData, param2:int, param3:int) : void {
if(param3 < 6) {
return;
}
var local4:ChunkInfo = this.readChunkInfo(param2);
switch(local4.id) {
case CHUNK_FACESMATERIAL:
this.parseSurface(param1);
break;
case CHUNK_FACESSMOOTH:
this.parseSmoothingGroups(param1);
}
this.parseFacesChunk(param1,local4.nextChunkPosition,param3 - local4.size);
}
private function parseSurface(param1:ObjectData) : void {
if(param1.surfaces == null) {
param1.surfaces = new Object();
}
var local2:Vector.<int> = new Vector.<int>();
param1.surfaces[this.getString(this.data.position)] = local2;
var local3:int = int(this.data.readUnsignedShort());
var local4:int = 0;
while(local4 < local3) {
local2[local4] = this.data.readUnsignedShort();
local4++;
}
}
private function parseSmoothingGroups(param1:ObjectData) : void {
var local2:int = param1.faces.length / 3;
var local3:int = 0;
while(local3 < local2) {
param1.smoothingGroups[local3] = this.data.readUnsignedInt();
local3++;
}
}
private function parseAnimationChunk(param1:int, param2:int) : void {
var local3:ChunkInfo = null;
var local4:AnimationData = null;
while(param2 >= 6) {
local3 = this.readChunkInfo(param1);
switch(local3.id) {
case 45057:
case 45058:
case 45059:
case 45060:
case 45061:
case 45062:
case 45063:
if(this.animationDatas == null) {
this.animationDatas = new Array();
}
local4 = new AnimationData();
this.animationDatas.push(local4);
this.parseObjectAnimationChunk(local4,local3.dataPosition,local3.dataSize);
break;
case 45064:
break;
}
param1 = local3.nextChunkPosition;
param2 -= local3.size;
}
}
private function parseObjectAnimationChunk(param1:AnimationData, param2:int, param3:int) : void {
if(param3 < 6) {
return;
}
var local4:ChunkInfo = this.readChunkInfo(param2);
switch(local4.id) {
case 45072:
param1.objectName = this.getString(this.data.position);
this.data.position += 4;
param1.parentIndex = this.data.readUnsignedShort();
break;
case 45073:
param1.objectName = this.getString(this.data.position);
break;
case 45075:
param1.pivot = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
break;
case 45088:
this.data.position += 20;
param1.position = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
break;
case 45089:
this.data.position += 20;
param1.rotation = this.getRotationFrom3DSAngleAxis(this.data.readFloat(),this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
break;
case 45090:
this.data.position += 20;
param1.scale = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
}
this.parseObjectAnimationChunk(param1,local4.nextChunkPosition,param3 - local4.size);
}
private function parseMaterialChunk(param1:MaterialData, param2:int, param3:int) : void {
if(param3 < 6) {
return;
}
var local4:ChunkInfo = this.readChunkInfo(param2);
switch(local4.id) {
case 40960:
this.parseMaterialName(param1);
break;
case 40976:
break;
case 40992:
this.data.position = local4.dataPosition + 6;
param1.color = (this.data.readUnsignedByte() << 16) + (this.data.readUnsignedByte() << 8) + this.data.readUnsignedByte();
break;
case 41008:
break;
case 41024:
this.data.position = local4.dataPosition + 6;
param1.glossiness = this.data.readUnsignedShort();
break;
case 41025:
this.data.position = local4.dataPosition + 6;
param1.specular = this.data.readUnsignedShort();
break;
case 41040:
this.data.position = local4.dataPosition + 6;
param1.transparency = this.data.readUnsignedShort();
break;
case 41472:
param1.diffuseMap = new MapData();
this.parseMapChunk(param1.name,param1.diffuseMap,local4.dataPosition,local4.dataSize);
break;
case 41786:
break;
case 41488:
param1.opacityMap = new MapData();
this.parseMapChunk(param1.name,param1.opacityMap,local4.dataPosition,local4.dataSize);
break;
case 41520:
case 41788:
case 41476:
case 41789:
case 41504:
}
this.parseMaterialChunk(param1,local4.nextChunkPosition,param3 - local4.size);
}
private function parseMaterialName(param1:MaterialData) : void {
if(this.materialDatas == null) {
this.materialDatas = new Object();
}
param1.name = this.getString(this.data.position);
this.materialDatas[param1.name] = param1;
}
private function parseMapChunk(param1:String, param2:MapData, param3:int, param4:int) : void {
if(param4 < 6) {
return;
}
var local5:ChunkInfo = this.readChunkInfo(param3);
switch(local5.id) {
case 41728:
param2.filename = this.getString(local5.dataPosition).toLowerCase();
break;
case 41809:
break;
case 41812:
param2.scaleU = this.data.readFloat();
break;
case 41814:
param2.scaleV = this.data.readFloat();
break;
case 41816:
param2.offsetU = this.data.readFloat();
break;
case 41818:
param2.offsetV = this.data.readFloat();
break;
case 41820:
param2.rotation = this.data.readFloat();
}
this.parseMapChunk(param1,param2,local5.nextChunkPosition,param4 - local5.size);
}
private function buildContent(param1:String, param2:Number) : void {
var local3:String = null;
var local4:String = null;
var local5:ObjectData = null;
var local6:Object3D = null;
var local7:MaterialData = null;
var local8:MapData = null;
var local9:Matrix = null;
var local10:Number = NaN;
var local11:TextureMaterial = null;
var local12:FillMaterial = null;
var local13:int = 0;
var local14:int = 0;
var local15:AnimationData = null;
var local16:int = 0;
var local17:int = 0;
var local18:AnimationData = null;
var local19:ObjectData = null;
var local20:String = null;
for(local3 in this.materialDatas) {
local7 = this.materialDatas[local3];
local8 = local7.diffuseMap;
if(local8 != null) {
local9 = new Matrix();
local10 = local8.rotation * Math.PI / 180;
local9.translate(-local8.offsetU,local8.offsetV);
local9.translate(-0.5,-0.5);
local9.rotate(-local10);
local9.scale(local8.scaleU,local8.scaleV);
local9.translate(0.5,0.5);
local7.matrix = local9;
local11 = new TextureMaterial();
local11.name = local3;
local11.diffuseMapURL = param1 + local8.filename;
local11.opacityMapURL = local7.opacityMap != null ? param1 + local7.opacityMap.filename : null;
local7.material = local11;
local11.name = local7.name;
this.textureMaterials.push(local11);
} else {
local12 = new FillMaterial(local7.color);
local7.material = local12;
local12.name = local7.name;
}
this.materials.push(local7.material);
}
if(this.animationDatas != null) {
if(this.objectDatas != null) {
local14 = int(this.animationDatas.length);
local13 = 0;
while(local13 < local14) {
local15 = this.animationDatas[local13];
local4 = local15.objectName;
local5 = this.objectDatas[local4];
if(local5 != null) {
local16 = local13 + 1;
local17 = 1;
while(local16 < local14) {
local18 = this.animationDatas[local16];
if(!local18.isInstance && local4 == local18.objectName) {
local19 = new ObjectData();
local20 = local4 + local17++;
local19.name = local20;
this.objectDatas[local20] = local19;
local18.objectName = local20;
local19.vertices = local5.vertices;
local19.uvs = local5.uvs;
local19.faces = local5.faces;
local19.smoothingGroups = local5.smoothingGroups;
local19.surfaces = local5.surfaces;
local19.a = local5.a;
local19.b = local5.b;
local19.c = local5.c;
local19.d = local5.d;
local19.e = local5.e;
local19.f = local5.f;
local19.g = local5.g;
local19.h = local5.h;
local19.i = local5.i;
local19.j = local5.j;
local19.k = local5.k;
local19.l = local5.l;
}
local16++;
}
}
if(local5 != null && local5.vertices != null) {
local6 = new Mesh();
this.buildMesh(local6 as Mesh,local5,local15,param2);
} else {
local6 = new Object3D();
}
local6.name = local4;
local15.object = local6;
if(local15.position != null) {
local6.x = local15.position.x * param2;
local6.y = local15.position.y * param2;
local6.z = local15.position.z * param2;
}
if(local15.rotation != null) {
local6.rotationX = local15.rotation.x;
local6.rotationY = local15.rotation.y;
local6.rotationZ = local15.rotation.z;
}
if(local15.scale != null) {
local6.scaleX = local15.scale.x;
local6.scaleY = local15.scale.y;
local6.scaleZ = local15.scale.z;
}
local13++;
}
local13 = 0;
while(local13 < local14) {
local15 = this.animationDatas[local13];
this.objects.push(local15.object);
this.parents.push(local15.parentIndex == 65535 ? null : AnimationData(this.animationDatas[local15.parentIndex]).object);
local13++;
}
}
} else {
for(local4 in this.objectDatas) {
local5 = this.objectDatas[local4];
if(local5.vertices != null) {
local6 = new Mesh();
local6.name = local4;
this.buildMesh(local6 as Mesh,local5,null,param2);
this.objects.push(local6);
this.parents.push(null);
}
}
}
}
private function buildMesh(param1:Mesh, param2:ObjectData, param3:AnimationData, param4:Number) : void {
var local9:int = 0;
var local10:int = 0;
var local11:Face = null;
var local12:Vertex = null;
var local14:int = 0;
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;
var local26:Number = NaN;
var local27:Number = NaN;
var local28:Number = NaN;
var local29:Boolean = false;
var local30:Number = NaN;
var local31:Number = NaN;
var local32:Number = NaN;
var local33:Face = null;
var local34:String = null;
var local35:Vector.<int> = null;
var local36:MaterialData = null;
var local37:Material = null;
var local38:Wrapper = null;
var local39:Number = NaN;
var local40:Number = NaN;
var local5:Vector.<Vertex> = new Vector.<Vertex>();
var local6:Vector.<Face> = new Vector.<Face>();
var local7:int = 0;
var local8:int = 0;
var local13:Boolean = false;
if(param3 != null) {
local16 = param2.a;
local17 = param2.b;
local18 = param2.c;
local19 = param2.d;
local20 = param2.e;
local21 = param2.f;
local22 = param2.g;
local23 = param2.h;
local24 = param2.i;
local25 = param2.j;
local26 = param2.k;
local27 = param2.l;
local28 = 1 / (-local18 * local21 * local24 + local17 * local22 * local24 + local18 * local20 * local25 - local16 * local22 * local25 - local17 * local20 * local26 + local16 * local21 * local26);
param2.a = (-local22 * local25 + local21 * local26) * local28;
param2.b = (local18 * local25 - local17 * local26) * local28;
param2.c = (-local18 * local21 + local17 * local22) * local28;
param2.d = (local19 * local22 * local25 - local18 * local23 * local25 - local19 * local21 * local26 + local17 * local23 * local26 + local18 * local21 * local27 - local17 * local22 * local27) * local28;
param2.e = (local22 * local24 - local20 * local26) * local28;
param2.f = (-local18 * local24 + local16 * local26) * local28;
param2.g = (local18 * local20 - local16 * local22) * local28;
param2.h = (local18 * local23 * local24 - local19 * local22 * local24 + local19 * local20 * local26 - local16 * local23 * local26 - local18 * local20 * local27 + local16 * local22 * local27) * local28;
param2.i = (-local21 * local24 + local20 * local25) * local28;
param2.j = (local17 * local24 - local16 * local25) * local28;
param2.k = (-local17 * local20 + local16 * local21) * local28;
param2.l = (local19 * local21 * local24 - local17 * local23 * local24 - local19 * local20 * local25 + local16 * local23 * local25 + local17 * local20 * local27 - local16 * local21 * local27) * local28;
if(param3.pivot != null) {
param2.d -= param3.pivot.x;
param2.h -= param3.pivot.y;
param2.l -= param3.pivot.z;
}
local13 = true;
}
if(param2.vertices != null) {
local29 = param2.uvs != null && param2.uvs.length > 0;
local9 = 0;
local10 = 0;
local14 = int(param2.vertices.length);
while(local9 < local14) {
local12 = new Vertex();
if(local13) {
local30 = param2.vertices[local9++];
local31 = param2.vertices[local9++];
local32 = param2.vertices[local9++];
local12.x = param2.a * local30 + param2.b * local31 + param2.c * local32 + param2.d;
local12.y = param2.e * local30 + param2.f * local31 + param2.g * local32 + param2.h;
local12.z = param2.i * local30 + param2.j * local31 + param2.k * local32 + param2.l;
} else {
local12.x = param2.vertices[local9++];
local12.y = param2.vertices[local9++];
local12.z = param2.vertices[local9++];
}
local12.x *= param4;
local12.y *= param4;
local12.z *= param4;
if(local29) {
local12.u = param2.uvs[local10++];
local12.v = 1 - param2.uvs[local10++];
}
local12.alternativa3d::transformId = -1;
var local41:* = local7++;
local5[local41] = local12;
local12.alternativa3d::next = param1.alternativa3d::vertexList;
param1.alternativa3d::vertexList = local12;
}
}
if(param2.faces != null) {
local9 = 0;
local10 = 0;
local14 = int(param2.faces.length);
while(local9 < local14) {
local11 = new Face();
local11.alternativa3d::wrapper = new Wrapper();
local11.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local11.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local11.alternativa3d::wrapper.alternativa3d::vertex = local5[param2.faces[local9++]];
local11.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = local5[param2.faces[local9++]];
local11.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = local5[param2.faces[local9++]];
local11.smoothingGroups = param2.smoothingGroups[local10++];
local41 = local8++;
local6[local41] = local11;
if(local33 != null) {
local33.alternativa3d::next = local11;
} else {
param1.alternativa3d::faceList = local11;
}
local33 = local11;
}
}
if(param2.surfaces != null) {
for(local34 in param2.surfaces) {
local35 = param2.surfaces[local34];
local36 = this.materialDatas[local34];
local37 = local36.material;
local9 = 0;
while(local9 < local35.length) {
local11 = local6[local35[local9]];
local11.material = local37;
if(local36.matrix != null) {
local38 = local11.alternativa3d::wrapper;
while(local38 != null) {
local12 = local38.alternativa3d::vertex;
if(local12.alternativa3d::transformId < 0) {
local39 = local12.u;
local40 = local12.v;
local12.u = local36.matrix.a * local39 + local36.matrix.b * local40 + local36.matrix.tx;
local12.v = local36.matrix.c * local39 + local36.matrix.d * local40 + local36.matrix.ty;
local12.alternativa3d::transformId = 0;
}
local38 = local38.alternativa3d::next;
}
}
local9++;
}
}
}
var local15:FillMaterial = new FillMaterial(8355711);
local15.name = "default";
local11 = param1.alternativa3d::faceList;
while(local11 != null) {
if(local11.material == null) {
local11.material = local15;
}
local11 = local11.alternativa3d::next;
}
param1.calculateFacesNormals(true);
param1.calculateBounds();
}
private function getString(param1:int) : String {
var local2:int = 0;
this.data.position = param1;
var local3:String = "";
while(true) {
local2 = this.data.readByte();
if(local2 == 0) {
break;
}
local3 += String.fromCharCode(local2);
}
return local3;
}
private function getRotationFrom3DSAngleAxis(param1:Number, param2:Number, param3:Number, param4:Number) : Vector3D {
var local10:Number = NaN;
var local5:Vector3D = new Vector3D();
var local6:Number = Math.sin(param1);
var local7:Number = Math.cos(param1);
var local8:Number = 1 - local7;
var local9:Number = param2 * param4 * local8 + param3 * local6;
if(local9 >= 1) {
local10 = param1 / 2;
local5.z = -2 * Math.atan2(param2 * Math.sin(local10),Math.cos(local10));
local5.y = -Math.PI / 2;
local5.x = 0;
return local5;
}
if(local9 <= -1) {
local10 = param1 / 2;
local5.z = 2 * Math.atan2(param2 * Math.sin(local10),Math.cos(local10));
local5.y = Math.PI / 2;
local5.x = 0;
return local5;
}
local5.z = -Math.atan2(param4 * local6 - param2 * param3 * local8,1 - (param4 * param4 + param3 * param3) * local8);
local5.y = -Math.asin(param2 * param4 * local8 + param3 * local6);
local5.x = -Math.atan2(param2 * local6 - param4 * param3 * local8,1 - (param2 * param2 + param3 * param3) * local8);
return local5;
}
}
}
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.Material;
import flash.geom.Matrix;
import flash.geom.Vector3D;
class MaterialData {
public var name:String;
public var color:int;
public var specular:int;
public var glossiness:int;
public var transparency:int;
public var diffuseMap:MapData;
public var opacityMap:MapData;
public var matrix:Matrix;
public var material:Material;
public function MaterialData() {
super();
}
}
class MapData {
public var filename:String;
public var scaleU:Number = 1;
public var scaleV:Number = 1;
public var offsetU:Number = 0;
public var offsetV:Number = 0;
public var rotation:Number = 0;
public function MapData() {
super();
}
}
class ObjectData {
public var name:String;
public var vertices:Vector.<Number>;
public var uvs:Vector.<Number>;
public var faces:Vector.<int>;
public var smoothingGroups:Vector.<uint>;
public var surfaces:Object;
public var a:Number;
public var b:Number;
public var c:Number;
public var d:Number;
public var e:Number;
public var f:Number;
public var g:Number;
public var h:Number;
public var i:Number;
public var j:Number;
public var k:Number;
public var l:Number;
public function ObjectData() {
super();
}
}
class AnimationData {
public var objectName:String;
public var object:Object3D;
public var parentIndex:int;
public var pivot:Vector3D;
public var position:Vector3D;
public var rotation:Vector3D;
public var scale:Vector3D;
public var isInstance:Boolean;
public function AnimationData() {
super();
}
}
class ChunkInfo {
public var id:int;
public var size:int;
public var dataSize:int;
public var dataPosition:int;
public var nextChunkPosition:int;
public function ChunkInfo() {
super();
}
}
|
package projects.tanks.client.garage.models.item.rarity {
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 ItemRarityModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ItemRarityModelServer;
private var client:IItemRarityModelBase = IItemRarityModelBase(this);
private var modelId:Long = Long.getLong(153388210,-1322539468);
public function ItemRarityModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ItemRarityModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ItemRarityCC,false)));
}
protected function getInitParam() : ItemRarityCC {
return ItemRarityCC(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 projects.tanks.clients.fp10.Prelauncher.controls.selector {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Shape;
import flash.display.Sprite;
import flash.geom.Point;
import flash.geom.Rectangle;
import projects.tanks.clients.fp10.Prelauncher.Locale;
import projects.tanks.clients.fp10.Prelauncher.LocalesFactory;
import projects.tanks.clients.fp10.Prelauncher.controls.selector.flagbutton.FlagButton;
import projects.tanks.clients.fp10.Prelauncher.locales.Locales;
public class LocalesList extends Sprite {
private static var flagsPng:Class = LocalesList_flagsPng;
private static var flagsBitmapData:BitmapData = (new flagsPng() as Bitmap).bitmapData;
private static var panel:Class = LocalesList_panel;
private static var panelData:BitmapData = (new panel() as Bitmap).bitmapData;
public var flags:Vector.<FlagButton> = new Vector.<FlagButton>();
private var _panel:Shape;
public function LocalesList() {
super();
this.y = panelData.height + 27;
this.x = 4;
this._panel = new Shape();
this.drawPanel();
this.createFlags();
addEventListener(LocaleSelectionEvent.SELECTION,this.localeSelected);
}
private function drawPanel() : void {
var top:Number = NaN;
var j:int = 0;
var rect:Rectangle = new Rectangle(9,9,1,1);
var gridX:Array = [rect.left,rect.right,panelData.width];
var gridY:Array = [rect.top,rect.bottom,panelData.height];
this._panel.graphics.clear();
var left:Number = 0;
for(var i:int = 0; i < 3; i++) {
top = 0;
for(j = 0; j < 3; j++) {
this._panel.graphics.beginBitmapFill(panelData);
this._panel.graphics.drawRect(left,top,gridX[i] - left,gridY[j] - top);
this._panel.graphics.endFill();
top = Number(gridY[j]);
}
left = Number(gridX[i]);
}
this._panel.scale9Grid = rect;
this._panel.scaleX = 70 / panelData.width;
this._panel.scaleY = (Locales.list.length - 1) * 28 / panelData.height;
}
public function createFlags() : void {
var size:Point = null;
var bmpData:BitmapData = null;
var fb:FlagButton = null;
var locales:Array = Locales.list;
for(var i:int = 0; i < locales.length; i++) {
size = new Point(flagsBitmapData.width / locales.length,flagsBitmapData.height);
bmpData = new BitmapData(size.x,size.y);
bmpData.copyPixels(flagsBitmapData,new Rectangle(size.x * i,0,size.x,size.y),new Point(0,0));
fb = new FlagButton(bmpData,LocalesFactory.getLocale(locales[i]));
this.flags.push(fb);
}
}
public function addFlags() : void {
var fb:FlagButton = null;
addChild(this._panel);
var j:int = 0;
for(var i:int = 0; i < this.flags.length; i++) {
fb = this.flags[i];
if(fb.locale != Locale.current) {
fb.x = 10;
fb.y = 26 * j + 11;
fb.selectorItem = false;
fb.redraw(false);
addChild(fb);
j++;
}
}
}
private function localeSelected(e:LocaleSelectionEvent) : void {
removeChildren();
}
}
}
|
package alternativa.tanks.models.dom.hud
{
import alternativa.tanks.models.dom.sfx.PointState;
import flash.display.BitmapData;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.utils.Dictionary;
public class MarkerBitmaps
{
[Embed(source="833.png")]
private static const blueMarkerClass:Class;
private static const blueMarkerBitmapData:BitmapData = new blueMarkerClass().bitmapData;
[Embed(source="934.png")]
private static const grayMarkerClass:Class;
private static const grayMarkerBitmapData:BitmapData = new grayMarkerClass().bitmapData;
[Embed(source="1054.png")]
private static const redMarkerClass:Class;
private static const redMarkerBitmapData:BitmapData = new redMarkerClass().bitmapData;
[Embed(source="1190.png")]
private static const letters:Class;
private static const markerBitmaps:Dictionary = new Dictionary();
private static const markerWidth:int = redMarkerBitmapData.width;
private static const letterBar:BitmapData = new letters().bitmapData;
private static const letterBitmaps:Dictionary = new Dictionary();
{
markerBitmaps[PointState.NEUTRAL] = grayMarkerBitmapData;
markerBitmaps[PointState.BLUE] = blueMarkerBitmapData;
markerBitmaps[PointState.RED] = redMarkerBitmapData;
}
public function MarkerBitmaps()
{
super();
}
public static function getMarkerBitmapData(param1:PointState) : BitmapData
{
return markerBitmaps[param1];
}
public static function getLetterImage(param1:String) : BitmapData
{
var _loc2_:Number = param1.charCodeAt(0) - "A".charCodeAt(0);
var _loc3_:BitmapData = letterBitmaps[_loc2_];
if(_loc3_ == null)
{
_loc3_ = new BitmapData(markerWidth,letterBar.height,true,0);
_loc3_.copyPixels(letterBar,new Rectangle(_loc2_ * markerWidth,0,markerWidth,letterBar.height),new Point());
letterBitmaps[_loc2_] = _loc3_;
}
return _loc3_;
}
}
}
|
package alternativa.tanks.gui.panel.buttons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.panel.buttons.FriendsButton_SHOW_FRIENDS_BITMAP.png")]
public class FriendsButton_SHOW_FRIENDS_BITMAP extends BitmapAsset {
public function FriendsButton_SHOW_FRIENDS_BITMAP() {
super();
}
}
}
|
package alternativa.tanks.help
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
public class MoneyHelper extends BubbleHelper
{
public function MoneyHelper()
{
super();
var localeService:ILocaleService = ILocaleService(Main.osgi.getService(ILocaleService));
text = localeService.getText(TextConst.HELP_PANEL_MONEY_HELPER_TEXT);
arrowLehgth = int(localeService.getText(TextConst.HELP_PANEL_MONEY_HELPER_ARROW_LENGTH));
arrowAlign = HelperAlign.TOP_LEFT;
_showLimit = 3;
_targetPoint.y = 25;
}
}
}
|
package projects.tanks.clients.tankslauncershared.dishonestprogressbar {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Shape;
import flash.display.Sprite;
import flash.events.Event;
import flash.geom.Matrix;
import flash.utils.clearTimeout;
import flash.utils.setTimeout;
import projects.tanks.clients.tankslauncershared.service.Locale;
public class DishonestProgressBar extends Sprite {
private static const bgdLeftClass:Class = DishonestProgressBar_bgdLeftClass;
private static const bgdRightClass:Class = DishonestProgressBar_bgdRightClass;
private static const bgdCenterClass:Class = DishonestProgressBar_bgdCenterClass;
private static const bgdCenterBitmapData:BitmapData = new bgdCenterClass().bitmapData;
private static const blickClass:Class = DishonestProgressBar_blickClass;
private static const blickBitmapData:BitmapData = new blickClass().bitmapData;
private static const progressLineClass:Class = DishonestProgressBar_progressLineClass;
private static const DEFAULT_WIDTH:int = 585;
private static const MAX_PROGRESS_LINE_WIDTH:int = 573;
private static const DEFAULT_HEIGHT:int = 28;
private static const FAKE_RIGHT_BORDER_IN_PERCENT:Number = 0.98;
private static const MIN_STEP:Number = 0.05;
private static const STEP_DEC:Number = 0.001;
private static const COMPLETE_DELAY:int = 100;
private var _progressLineWidth:Number;
private var _fakeRightLimitProgressLineWidth:int;
private var _progressLine:Bitmap;
private var _progressLineBlick:Shape;
private var _bgdLeftIcon:Bitmap;
private var _bgdRightIcon:Bitmap;
private var _bgdCenterIcon:Shape;
private var _loadingLabel:Bitmap;
private var _blickMatrix:Matrix;
private var _complete:Function;
private var _timeOutComplete:uint;
private var _isForciblyFinish:Boolean;
private var _normalStep:Number = 0.05;
private var _forciblyStep:Number;
private var _locale:String;
public function DishonestProgressBar(param1:String, param2:Function) {
super();
this._locale = param1;
this._complete = param2;
this.init();
}
private function init() : void {
this._fakeRightLimitProgressLineWidth = MAX_PROGRESS_LINE_WIDTH * FAKE_RIGHT_BORDER_IN_PERCENT;
this._bgdLeftIcon = new bgdLeftClass();
addChild(this._bgdLeftIcon);
this._bgdRightIcon = new bgdRightClass();
addChild(this._bgdRightIcon);
this._bgdCenterIcon = new Shape();
addChild(this._bgdCenterIcon);
this._progressLine = new progressLineClass();
this._progressLine.x = 6;
this._progressLine.y = 4;
this._progressLine.width = 0;
this._progressLine.blendMode = BlendMode.OVERLAY;
addChild(this._progressLine);
this._progressLineBlick = new Shape();
this._progressLineBlick.x = this._progressLine.x;
this._progressLineBlick.y = this._progressLine.y;
this._progressLineBlick.blendMode = BlendMode.ADD;
this._progressLineBlick.alpha = 0.5;
addChild(this._progressLineBlick);
this._loadingLabel = new Bitmap(LoadingLabel.getLocalizedBitmapData(this._locale));
addChild(this._loadingLabel);
this.resize();
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
}
private function resize() : void {
this._bgdCenterIcon.graphics.clear();
this._bgdCenterIcon.graphics.beginBitmapFill(bgdCenterBitmapData);
this._bgdCenterIcon.graphics.drawRect(0,0,DEFAULT_WIDTH - this._bgdLeftIcon.width - this._bgdRightIcon.width,DEFAULT_HEIGHT);
this._bgdCenterIcon.x = this._bgdLeftIcon.width;
this._bgdRightIcon.x = this._bgdCenterIcon.x + this._bgdCenterIcon.width;
var local1:int = 26;
if(this._locale == Locale.CN) {
local1 = 22;
}
this._loadingLabel.x = DEFAULT_WIDTH - (this._loadingLabel.width - local1) >> 1;
this._loadingLabel.y = -this._loadingLabel.height - 17;
}
private function onAddedToStage(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
this.align();
stage.addEventListener(Event.RESIZE,this.onResize);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveToStage);
}
private function onResize(param1:Event) : void {
this.align();
}
private function align() : void {
this.x = stage.stageWidth - this.width >> 1;
this.y = stage.stageHeight - DEFAULT_HEIGHT >> 1;
}
private function onRemoveToStage(param1:Event) : void {
removeEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveToStage);
stage.removeEventListener(Event.RESIZE,this.onResize);
}
public function start() : void {
clearTimeout(this._timeOutComplete);
this._isForciblyFinish = false;
this._progressLine.width = 0;
this._progressLineBlick.graphics.clear();
this._progressLineWidth = 0;
this._blickMatrix = new Matrix();
this._normalStep = 1;
addEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
private function onEnterFrame(param1:Event) : void {
if(this._isForciblyFinish) {
this._progressLineWidth += this._forciblyStep;
if(this._progressLineWidth >= MAX_PROGRESS_LINE_WIDTH) {
removeEventListener(Event.ENTER_FRAME,this.onEnterFrame);
this._progressLineWidth = MAX_PROGRESS_LINE_WIDTH;
this._timeOutComplete = setTimeout(this.onCompleted,COMPLETE_DELAY);
}
} else {
this._normalStep -= STEP_DEC;
if(this._normalStep < MIN_STEP) {
this._normalStep = MIN_STEP;
}
this._progressLineWidth += this._normalStep;
if(this._progressLineWidth >= this._fakeRightLimitProgressLineWidth) {
this._progressLineWidth = this._fakeRightLimitProgressLineWidth;
}
}
this.redrawProgressLineAndBlick(this._progressLineWidth);
this._blickMatrix.tx += 3;
if(this._blickMatrix.tx > blickBitmapData.width) {
this._blickMatrix.tx = -this._blickMatrix.tx % blickBitmapData.width;
}
}
public function forciblyFinish() : void {
this._forciblyStep = (MAX_PROGRESS_LINE_WIDTH - this._progressLineWidth) / 10;
this._isForciblyFinish = true;
}
private function onCompleted() : void {
this._complete.apply();
}
private function redrawProgressLineAndBlick(param1:int) : void {
this._progressLine.width = param1;
this._progressLineBlick.graphics.clear();
this._progressLineBlick.graphics.beginBitmapFill(blickBitmapData,this._blickMatrix,true,false);
this._progressLineBlick.graphics.drawRect(0,0,param1,this._progressLine.height);
}
public function stop() : void {
removeEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
}
}
|
package projects.tanks.client.battleselect.model.matchmaking.notify {
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 MatchmakingNotifyModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function MatchmakingNotifyModelServer(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.gfx.core
{
import alternativa.gfx.alternativagfx;
import flash.display3D.Context3D;
import flash.display3D.Context3DTextureFormat;
use namespace alternativagfx;
public class RenderTargetTextureResource extends TextureResource
{
private var _width:int;
private var _height:int;
private var _available:Boolean = true;
public function RenderTargetTextureResource(param1:int, param2:int)
{
super();
this._width = param1;
this._height = param2;
}
public function get width() : int
{
return this._width;
}
public function get height() : int
{
return this._height;
}
override public function dispose() : void
{
super.dispose();
this._available = false;
}
override public function get available() : Boolean
{
return this._available;
}
override public function create(param1:Context3D) : void
{
super.create(param1);
texture = param1.createTexture(this._width,this._height,Context3DTextureFormat.BGRA,true);
}
}
}
|
package alternativa.proplib.utils {
import flash.utils.ByteArray;
public class ByteArrayMap {
private var _data:Object;
public function ByteArrayMap(data:Object = null) {
super();
this._data = data == null ? {} : data;
}
public function get data() : Object {
return this._data;
}
public function getValue(key:String) : ByteArray {
return this._data[key];
}
public function putValue(key:String, value:ByteArray) : void {
this._data[key] = value;
}
}
}
|
package alternativa.tanks.service.battery {
public class BatteriesServiceImpl implements BatteriesService {
private var _hasBatteries:Boolean;
public function BatteriesServiceImpl() {
super();
}
public function hasBatteries() : Boolean {
return this._hasBatteries;
}
public function setHasBatteries(param1:Boolean) : * {
this._hasBatteries = param1;
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.kitpackage {
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.panel.model.shop.kitpackage.KitPackageCC;
import projects.tanks.client.panel.model.shop.kitpackage.KitPackageItemInfo;
public class CodecKitPackageCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_itemInfos:ICodec;
private var codec_name:ICodec;
private var codec_showDetails:ICodec;
public function CodecKitPackageCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_itemInfos = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(KitPackageItemInfo,false),false,1));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_showDetails = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:KitPackageCC = new KitPackageCC();
local2.itemInfos = this.codec_itemInfos.decode(param1) as Vector.<KitPackageItemInfo>;
local2.name = this.codec_name.decode(param1) as String;
local2.showDetails = this.codec_showDetails.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:KitPackageCC = KitPackageCC(param2);
this.codec_itemInfos.encode(param1,local3.itemInfos);
this.codec_name.encode(param1,local3.name);
this.codec_showDetails.encode(param1,local3.showDetails);
}
}
}
|
package alternativa.tanks.view.battlelist.help {
import alternativa.tanks.view.battlelist.LocaleBattleList;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.BubbleHelper;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperAlign;
public class LockedMapsHelper extends BubbleHelper {
public function LockedMapsHelper() {
super();
text = LocaleBattleList.battleSelectLockedMapHelperName;
arrowLehgth = LocaleBattleList.battleSelectLockedMapHelperArrowLength;
arrowAlign = HelperAlign.MIDDLE_LEFT;
_showLimit = 5;
}
}
}
|
package alternativa.tanks.model.payment.shop.shopabonement {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.shopabonement.ActiveShopAbonementsModelBase;
import projects.tanks.client.panel.model.shopabonement.IActiveShopAbonementsModelBase;
[ModelInfo]
public class ActiveShopAbonementsModel extends ActiveShopAbonementsModelBase implements IActiveShopAbonementsModelBase, ShopAbonements {
public function ActiveShopAbonementsModel() {
super();
}
public function getCategoriesWithBonus() : Vector.<IGameObject> {
return getInitParam().categoriesWithBonus;
}
}
}
|
package alternativa.tanks.models.battlefield.gui.statistics.field
{
import controls.Label;
import controls.resultassets.WhiteFrame;
import flash.display.GradientType;
import flash.display.Graphics;
import flash.display.Shape;
import flash.display.SpreadMethod;
import flash.display.Sprite;
import flash.geom.Matrix;
import flash.text.TextFieldAutoSize;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
public class TeamScoreFieldBase extends Sprite
{
private static const LABEL_Y:int = 6;
protected static const BG_COLOR_RED:uint = 9249024;
protected static const FONT_COLOR_RED:uint = 16742221;
protected static const BG_COLOR_BLUE:uint = 16256;
protected static const FONT_COLOR_BLUE:uint = 4760319;
protected var _scoreRed:int;
protected var _scoreBlue:int;
protected var labelRed:Label;
protected var labelBlue:Label;
private var background:Shape;
protected var border:WhiteFrame;
public function TeamScoreFieldBase()
{
super();
addChild(this.background = new Shape());
addChild(this.border = new WhiteFrame());
this.labelRed = this.createLabel(FONT_COLOR_RED);
this.labelBlue = this.createLabel(FONT_COLOR_BLUE);
}
public function setScore(scoreRed:int, scoreBlue:int) : void
{
this._scoreRed = scoreRed;
this.labelRed.text = scoreRed.toString();
this._scoreBlue = scoreBlue;
this.labelBlue.text = scoreBlue.toString();
this.update();
}
public function setTeamScore(teamType:BattleTeamType, score:int) : void
{
switch(teamType)
{
case BattleTeamType.RED:
this.scoreRed = score;
break;
case BattleTeamType.BLUE:
this.scoreBlue = score;
}
this.update();
}
public function get scoreRed() : int
{
return this._scoreRed;
}
public function set scoreRed(value:int) : void
{
this._scoreRed = value;
this.labelRed.text = value.toString();
this.update();
}
public function get scoreBlue() : int
{
return this._scoreBlue;
}
public function set scoreBlue(value:int) : void
{
this._scoreBlue = value;
this.labelBlue.text = value.toString();
this.update();
}
public function update() : void
{
this.updateBgAndBorder(this.calculateWidth());
}
protected function calculateWidth() : int
{
return 0;
}
private function updateBgAndBorder(width:int) : void
{
this.border.width = width;
var fillType:String = GradientType.LINEAR;
var colors:Array = [BG_COLOR_RED,BG_COLOR_BLUE];
var alphas:Array = [1,1];
var r:int = 8 / width * 255;
var ratios:Array = [127 - r,127 + r];
var matrix:Matrix = new Matrix();
matrix.createGradientBox(width - 2,this.border.height - 2,0,0,0);
var spreadMethod:String = SpreadMethod.PAD;
var g:Graphics = this.background.graphics;
g.clear();
g.beginGradientFill(fillType,colors,alphas,ratios,matrix,spreadMethod);
g.drawRect(2,2,width - 2 * 2,this.border.height - 2 - 1);
g.endFill();
}
private function createLabel(color:uint) : Label
{
var label:Label = new Label();
label.color = color;
label.size = 18;
label.bold = true;
label.autoSize = TextFieldAutoSize.CENTER;
label.y = LABEL_Y;
addChild(label);
return label;
}
}
}
|
package alternativa.tanks.models.battle.gui.chat {
import alternativa.tanks.models.battle.ctf.MessageColor;
import controls.Label;
import flash.display.Sprite;
import flash.text.TextFieldAutoSize;
public class SpectatorList extends Sprite {
private var label:Label;
public function SpectatorList() {
super();
this.label = new Label();
this.label.color = MessageColor.YELLOW;
this.label.autoSize = TextFieldAutoSize.LEFT;
this.label.multiline = true;
this.label.wordWrap = true;
this.label.mouseEnabled = false;
addChild(this.label);
}
public function setText(param1:String) : void {
this.label.text = param1;
}
public function setLabelWidth(param1:Number) : void {
this.label.width = param1;
}
public function getText() : String {
return this.label.text;
}
}
}
|
package platform.client.fp10.core.service.errormessage.errors {
public class SharedObjectUsNotAccessibleError implements ErrorType {
public function SharedObjectUsNotAccessibleError() {
super();
}
public function getMessage() : String {
return "Local SharedObject is not accessible for writing";
}
}
}
|
package alternativa.tanks.models.tank.ultimate {
[ModelInterface]
public interface IUltimateModel {
function resetCharge() : void;
function initIndicator() : void;
function isUltimateEnabled() : Boolean;
function effectDeactivated() : void;
function effectActivatedOrMerged(param1:int) : void;
}
}
|
package alternativa.tanks.models.weapon.freeze {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.BattleRunnerProvider;
import alternativa.tanks.models.weapon.shared.streamweapon.StreamWeaponEffects;
import alternativa.tanks.models.weapon.streamweapon.StreamWeaponGraphicEffect;
import alternativa.tanks.models.weapon.streamweapon.StreamWeaponSFXData;
import alternativa.tanks.sfx.CollisionObject3DPositionProvider;
import alternativa.tanks.sfx.ISound3DEffect;
import alternativa.tanks.sfx.ISoundEffectDestructionListener;
import alternativa.tanks.sfx.MobileSound3DEffect;
import alternativa.tanks.sfx.MuzzlePositionProvider;
import alternativa.tanks.sfx.OmniStreamLightEffect;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.utils.objectpool.ObjectPool;
public class FreezeEffects extends BattleRunnerProvider implements StreamWeaponEffects, ISoundEffectDestructionListener {
private static const NUMBER_OF_LOOPS:int = 99999;
private var objectPool:ObjectPool;
private var range:Number;
private var coneAngle:Number;
private var sfxData:StreamWeaponSFXData;
private var graphicEffect:StreamWeaponGraphicEffect;
private var soundEffect:MobileSound3DEffect;
private var muzzleLightEffect:OmniStreamLightEffect;
private var lightEffect:OmniStreamLightEffect;
private var buffedMode:Boolean;
public function FreezeEffects(param1:ObjectPool, param2:Number, param3:Number, param4:StreamWeaponSFXData) {
super();
this.objectPool = param1;
this.range = param2;
this.coneAngle = param3;
this.sfxData = param4;
this.buffedMode = false;
}
public function startEffects(param1:Body, param2:Vector3, param3:Object3D) : void {
if(this.graphicEffect == null) {
this.createGraphicEffect(param1,param2,param3);
this.createSoundEffect(param3);
this.createLightEffect(param2,param3);
}
}
public function createLightEffect(param1:Vector3, param2:Object3D) : void {
var local3:MuzzlePositionProvider = null;
var local4:CollisionObject3DPositionProvider = null;
if(this.muzzleLightEffect == null) {
this.muzzleLightEffect = OmniStreamLightEffect(this.objectPool.getObject(OmniStreamLightEffect));
local3 = MuzzlePositionProvider(this.objectPool.getObject(MuzzlePositionProvider));
local3.init(param2,param1);
this.muzzleLightEffect.init(local3,this.sfxData.startLightAnimation,this.sfxData.loopLightAnimation);
battleService.getBattleScene3D().addGraphicEffect(this.muzzleLightEffect);
}
if(this.lightEffect == null) {
this.lightEffect = OmniStreamLightEffect(this.objectPool.getObject(OmniStreamLightEffect));
local4 = CollisionObject3DPositionProvider(this.objectPool.getObject(CollisionObject3DPositionProvider));
local4.init(param2,param1,getBattleRunner().getCollisionDetector(),FreezeEffectsParams.FIRE_LIGHT_OFFSET);
this.lightEffect.init(local4,this.sfxData.startFireAnimation,this.sfxData.loopFireAnimation);
battleService.getBattleScene3D().addGraphicEffect(this.lightEffect);
}
}
private function createGraphicEffect(param1:Body, param2:Vector3, param3:Object3D) : void {
this.graphicEffect = StreamWeaponGraphicEffect(this.objectPool.getObject(StreamWeaponGraphicEffect));
this.graphicEffect.init(param1,this.range,this.coneAngle,FreezeEffectsParams.PARTICLE_SPEED_PER_DISTANCE_METER,param2,param3,this.sfxData,getBattleRunner().getCollisionDetector(),FreezeEffectsParams.PLANE_WIDTH,FreezeEffectsParams.PLANE_LENGTH,FreezeEffectsParams.PARTICLE_START_SIZE,FreezeEffectsParams.PARTICLE_END_SIZE,FreezeEffectsParams.PARTICLE_MUZZLE_OFFSET,FreezeEffectsParams.PARTICLE_MUZZLE_RANDOM_OFFSET,this.buffedMode);
battleService.getBattleScene3D().addGraphicEffect(this.graphicEffect);
}
private function createSoundEffect(param1:Object3D) : void {
var local2:Sound3D = Sound3D.create(this.sfxData.shootingSound,FreezeEffectsParams.SOUND_VOLUME);
this.soundEffect = MobileSound3DEffect(this.objectPool.getObject(MobileSound3DEffect));
this.soundEffect.init(local2,param1,0,NUMBER_OF_LOOPS,0,this);
getBattleRunner().getSoundManager().addEffect(this.soundEffect);
}
public function stopEffects() : void {
if(this.graphicEffect != null) {
this.graphicEffect.kill();
this.graphicEffect = null;
this.killSound();
this.muzzleLightEffect.stop();
this.muzzleLightEffect = null;
this.lightEffect.stop();
this.lightEffect = null;
}
}
private function killSound() : void {
if(this.soundEffect != null) {
this.soundEffect.kill();
this.soundEffect = null;
}
}
public function onSoundEffectDestroyed(param1:ISound3DEffect) : void {
if(this.soundEffect == param1) {
this.soundEffect = null;
}
}
public function updateRange(param1:Number) : void {
this.range = param1;
if(this.graphicEffect != null) {
this.graphicEffect.updateRange(param1);
}
}
public function setBuffedMode(param1:Boolean) : void {
this.buffedMode = param1;
if(this.graphicEffect != null) {
this.graphicEffect.setBuffedMode(param1);
}
}
}
}
|
package projects.tanks.client.panel.model.shop.androidspecialoffer.offers.purchaseofupgrades {
public interface IAndroidPurchaseOfUpgradesModelBase {
}
}
|
package alternativa.tanks.view.battlelist.friends {
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
public class FriendsIndicator extends Sprite {
private static var friendsGreenClass:Class = FriendsIndicator_friendsGreenClass;
private static var friendsGreenBitmapData:BitmapData = Bitmap(new friendsGreenClass()).bitmapData;
private static var friendsGreyClass:Class = FriendsIndicator_friendsGreyClass;
private static var friendsGreyBitmapData:BitmapData = Bitmap(new friendsGreyClass()).bitmapData;
private var label:LabelBase = new LabelBase();
private var friendsIcon:Bitmap;
public function FriendsIndicator(param1:Boolean, param2:int, param3:uint) {
super();
this.init(param1,param2,param3);
}
public function setFriendCount(param1:int) : void {
this.label.text = String(param1);
}
public function setAccessable(param1:Boolean) : void {
removeChild(this.friendsIcon);
this.friendsIcon = new Bitmap(param1 ? friendsGreenBitmapData : friendsGreyBitmapData);
addChild(this.friendsIcon);
}
private function init(param1:Boolean, param2:int, param3:uint) : void {
graphics.clear();
graphics.beginFill(16711680,0);
graphics.drawRect(0,0,18,16);
graphics.endFill();
this.friendsIcon = new Bitmap(param1 ? friendsGreenBitmapData : friendsGreyBitmapData);
this.friendsIcon.y = 3;
addChild(this.friendsIcon);
this.label.text = String(param2);
this.label.x = this.friendsIcon.width;
this.label.y = -1;
this.label.color = param3;
addChild(this.label);
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank24.png")]
public class PremiumRankBitmaps_bitmapBigRank24 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank24() {
super();
}
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_10 extends BitmapAsset
{
public function BigRangIcon_rang_10()
{
super();
}
}
}
|
package controls {
[Embed(source="/_assets/assets.swf", symbol="symbol106")]
public class DefaultButton extends ColorButton {
public function DefaultButton() {
super();
setStyle(DEFAULT);
}
}
}
|
package alternativa.tanks.model.donation {
import projects.tanks.client.panel.model.donationalert.user.donation.DonationProfileModelBase;
import projects.tanks.client.panel.model.donationalert.user.donation.IDonationProfileModelBase;
[ModelInfo]
public class DonationProfileModel extends DonationProfileModelBase implements IDonationProfileModelBase {
public function DonationProfileModel() {
super();
}
}
}
|
package forms.userlabel {
import alternativa.osgi.service.display.IDisplay;
import alternativa.types.Long;
import base.DiscreteSprite;
import controls.base.LabelBase;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.system.System;
import forms.ColorConstants;
import forms.ranks.SmallRankIcon;
import projects.tanks.clients.fp10.libraries.tanksservices.model.friends.FriendState;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.UserClanInfo;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.FriendInfoLabelUpdaterEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendsInfoLabelUpdater;
import projects.tanks.clients.fp10.libraries.tanksservices.service.group.IGroupInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.premium.BattleUserPremiumService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.premium.PremiumService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoLabelUpdater;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.UserInfoLabelUpdaterEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import services.contextmenu.IContextMenuService;
public class UserLabel extends Sprite {
[Inject]
public static var userInfoService:IUserInfoService;
[Inject]
public static var friendInfoService:IFriendInfoService;
[Inject]
public static var contextMenuService:IContextMenuService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var premiumService:PremiumService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var groupInfoService:IGroupInfoService;
[Inject]
public static var battlePremiumService:BattleUserPremiumService;
protected static const RANK_ICON_CONT_WIDTH:int = 20;
private static const RANK_ICON_CONT_HEIGHT:int = 18;
protected var shadowContainer:DiscreteSprite = new DiscreteSprite();
protected var _userId:Long;
protected var _uid:String;
protected var _rank:int;
protected var _friendState:FriendState;
protected var _friendInfoUpdater:IFriendsInfoLabelUpdater;
protected var _userInfoUpdater:IUserInfoLabelUpdater;
protected var _uidLabel:LabelBase;
protected var _writeInPublicChat:Boolean;
protected var _writePrivateInChat:Boolean;
protected var _blockUserEnable:Boolean;
protected var _forciblySubscribeFriend:Boolean;
protected var _isInitRank:Boolean;
protected var _isInitUid:Boolean;
protected var _focusOnUserEnabled:Boolean;
protected var _hasPremium:Boolean;
private var _inviteBattleEnable:Boolean;
private var _rankIcon:SmallRankIcon;
private var _online:Boolean;
protected var _self:Boolean;
private var _lastUidColor:uint;
private var _ignoreFriendsColor:Boolean;
private var _additionalText:String = "";
protected var _showClanTag:Boolean = true;
private var _showClanProfile:Boolean = true;
private var _showInviteToClan:Boolean = true;
private var inSameGroup:Boolean = false;
public function UserLabel(param1:Long, param2:Boolean = true) {
super();
if(param1 == null) {
throw Error("UserLabel userId is NULL");
}
this._showClanTag = param2;
this._userId = param1;
this.init();
}
protected function getShadowFilters() : Array {
return null;
}
private function init() : void {
mouseChildren = false;
mouseEnabled = true;
tabEnabled = false;
tabChildren = false;
addChild(this.shadowContainer);
this.shadowContainer.filters = this.getShadowFilters();
this._lastUidColor = ColorConstants.GREEN_LABEL;
this.initSelf();
if(!this._self) {
buttonMode = useHandCursor = true;
}
this.createRankIcon();
this.createAdditionalIcons();
this.createUidLabel();
userInfoService.forciblySubscribe(this._userId);
this._userInfoUpdater = userInfoService.getOrCreateUpdater(this._userId);
this._friendInfoUpdater = friendInfoService.getOrCreateUpdater(this._userId);
this.updateProperties();
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
if(groupInfoService.hasGroups()) {
this.inSameGroup = groupInfoService.isInSameGroup(this._userId);
this.refreshFriendState();
}
}
protected function initSelf() : void {
this._self = userPropertiesService.userId == this._userId;
}
protected function createAdditionalIcons() : void {
}
protected function updateProperties() : void {
if(this._userInfoUpdater.hasData()) {
if(this._self) {
this.setRank(userPropertiesService.rank);
} else {
this.setRank(this._userInfoUpdater.rank);
}
this.setUid(this._userInfoUpdater.uid);
this.updateStatusOnline();
}
this.setFriendState(this._friendInfoUpdater.state);
}
protected function createUidLabel() : void {
this._uidLabel = new LabelBase();
this._uidLabel.x = RANK_ICON_CONT_WIDTH - 2 + this.getAdditionalIconsWidth();
this.shadowContainer.addChild(this._uidLabel);
this._uidLabel.visible = false;
}
protected function getAdditionalIconsWidth() : Number {
return 0;
}
private function createRankIcon() : void {
var local1:Sprite = new Sprite();
local1.graphics.clear();
local1.graphics.beginFill(65535,0);
local1.graphics.drawRect(0,0,RANK_ICON_CONT_WIDTH,RANK_ICON_CONT_HEIGHT);
local1.graphics.endFill();
this._rankIcon = new SmallRankIcon();
local1.addChild(this._rankIcon);
this.shadowContainer.addChild(local1);
this._rankIcon.visible = false;
}
private function onAddedToStage(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
addEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
this.setEvent();
this._userInfoUpdater.incrementVisibleLabelsCounter();
this._friendInfoUpdater.incrementVisibleLabelsCounter();
}
private function onRemoveFromStage(param1:Event) : void {
removeEventListener(Event.REMOVED_FROM_STAGE,this.onRemoveFromStage);
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
this.removeEvent();
this._userInfoUpdater.decrementVisibleLabelsCounter();
this._friendInfoUpdater.decrementVisibleLabelsCounter();
}
private function setEvent() : void {
if(!this.hasEventListener(MouseEvent.CLICK)) {
this.addEventListener(MouseEvent.CLICK,this.onMouseClick);
}
this._userInfoUpdater.addEventListener(UserInfoLabelUpdaterEvent.CHANGE_ONLINE,this.onChangeOnline);
this._userInfoUpdater.addEventListener(UserInfoLabelUpdaterEvent.CHANGE_UID,this.onChangeUid);
this._userInfoUpdater.addEventListener(UserInfoLabelUpdaterEvent.CHANGE_RANK,this.onChangeRank);
premiumService.addEventListener(Event.CHANGE,this.onChangePremiumStatus);
this._friendInfoUpdater.addEventListener(FriendInfoLabelUpdaterEvent.CHANGE_STATE,this.onChangeFriendState);
}
private function removeEvent() : void {
if(this.hasEventListener(MouseEvent.CLICK)) {
this.removeEventListener(MouseEvent.CLICK,this.onMouseClick);
}
this._userInfoUpdater.removeEventListener(UserInfoLabelUpdaterEvent.CHANGE_ONLINE,this.onChangeOnline);
this._userInfoUpdater.removeEventListener(UserInfoLabelUpdaterEvent.CHANGE_UID,this.onChangeUid);
this._userInfoUpdater.removeEventListener(UserInfoLabelUpdaterEvent.CHANGE_RANK,this.onChangeRank);
premiumService.removeEventListener(Event.CHANGE,this.onChangePremiumStatus);
this._friendInfoUpdater.removeEventListener(FriendInfoLabelUpdaterEvent.CHANGE_STATE,this.onChangeFriendState);
}
protected function onMouseClick(param1:MouseEvent) : void {
var local2:Boolean = false;
var local3:Boolean = false;
var local4:Boolean = false;
var local5:Boolean = false;
if(userPropertiesService.userId == this._userId) {
return;
}
if(!this._isInitRank || !this._isInitUid) {
return;
}
if(param1.ctrlKey) {
System.setClipboard(this._uid);
} else {
switch(this._friendState) {
case FriendState.ACCEPTED:
local3 = true;
break;
case FriendState.INCOMING:
local4 = true;
local5 = true;
break;
default:
local2 = true;
}
contextMenuService.show(this._userId,this._rank,this._uid,local2,local3,local4,local5,this._writeInPublicChat,this._writePrivateInChat,this._blockUserEnable,this._inviteBattleEnable,this._focusOnUserEnabled,this._showClanProfile,this._showInviteToClan);
}
}
private function onChangeOnline(param1:UserInfoLabelUpdaterEvent) : void {
this.updateStatusOnline();
}
private function updateStatusOnline() : void {
this._online = this._userInfoUpdater.online;
}
private function onChangeUid(param1:UserInfoLabelUpdaterEvent) : void {
this.setUid(this._userInfoUpdater.uid);
}
protected function setUid(param1:String) : void {
if(!this._isInitUid) {
this._isInitUid = true;
this._uidLabel.visible = true;
}
this._uid = param1;
var local2:String = this.getUidWithClanTag(this._uid);
var local3:String = local2 + this._additionalText;
if(this._uidLabel.text == local3) {
return;
}
this._uidLabel.text = local3;
dispatchEvent(new ChatUpdateEvent(ChatUpdateEvent.UPDATE,true));
}
public function getUidWithClanTag(param1:String) : String {
var local2:UserClanInfo = clanUserInfoService.userClanInfoByUserId(this.userId);
var local3:String = "";
if(this._showClanTag && local2 != null && local2.isInClan) {
local3 = "[" + local2.clanTag + "] ";
}
return local3 + param1;
}
public function setAdditionalText(param1:String) : void {
if(this._additionalText == param1) {
return;
}
this._additionalText = param1;
this.setUid(this._uid);
}
private function onChangeRank(param1:UserInfoLabelUpdaterEvent) : void {
this.setRank(this._userInfoUpdater.rank);
}
private function onChangePremiumStatus(param1:Event = null) : void {
this.updateProperties();
}
protected function setRank(param1:int) : void {
this._rank = param1;
this.updateStatusPremium();
if(!this._isInitRank) {
this._isInitRank = true;
this._rankIcon.init(this._hasPremium,this._rank);
this._rankIcon.visible = true;
} else if(this._hasPremium) {
this._rankIcon.setPremium(this._rank);
} else {
this._rankIcon.setRank(this._rank);
}
this.alignRankIcon();
}
protected function updateStatusPremium() : void {
if(this._self) {
this._hasPremium = premiumService.hasPremium();
} else {
this._hasPremium = battlePremiumService.hasUserPremium(this._userId);
}
}
private function alignRankIcon() : void {
this._rankIcon.x = RANK_ICON_CONT_WIDTH - this._rankIcon.width >> 1;
this._rankIcon.y = RANK_ICON_CONT_HEIGHT - this._rankIcon.height >> 1;
}
private function onChangeFriendState(param1:FriendInfoLabelUpdaterEvent) : void {
this.setFriendState(this._friendInfoUpdater.state);
}
protected function setFriendState(param1:FriendState) : void {
this._friendState = param1;
this.refreshFriendState();
}
protected function refreshFriendState() : void {
if(groupInfoService.hasGroups()) {
if(this.inSameGroup && !this._self) {
this._uidLabel.color = ColorConstants.FRIEND_COLOR;
}
return;
}
if(!this._ignoreFriendsColor) {
if(this._friendState == FriendState.ACCEPTED) {
this._uidLabel.color = ColorConstants.FRIEND_COLOR;
return;
}
this._uidLabel.color = this._lastUidColor;
}
}
public function setUidColor(param1:uint, param2:Boolean = false) : void {
this._lastUidColor = param1;
this._ignoreFriendsColor = param2;
this._uidLabel.color = param1;
this.refreshFriendState();
}
public function get online() : Boolean {
return this._online;
}
public function get userRank() : int {
return this._rank;
}
public function get self() : Boolean {
return this._self;
}
public function get uid() : String {
return this._uid;
}
public function get userId() : Long {
return this._userId;
}
public function get inviteBattleEnable() : Boolean {
return this._inviteBattleEnable;
}
public function set inviteBattleEnable(param1:Boolean) : void {
this._inviteBattleEnable = param1;
}
public function get premium() : Boolean {
return this._hasPremium;
}
public function get showClanProfile() : Boolean {
return this._showClanProfile;
}
public function set showClanProfile(param1:Boolean) : void {
this._showClanProfile = param1;
}
public function get showInviteToClan() : Boolean {
return this._showInviteToClan;
}
public function set showInviteToClan(param1:Boolean) : void {
this._showInviteToClan = param1;
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _889e776d06902fc46f2063fe83990fa6bf81a6b3ad478649e679a4f24415fe62_flash_display_Sprite extends Sprite {
public function _889e776d06902fc46f2063fe83990fa6bf81a6b3ad478649e679a4f24415fe62_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package projects.tanks.client.panel.model.payment.loader {
public interface IShopItemLoaderForAndroidModelBase {
function specialOfferLoaded() : void;
}
}
|
package alternativa.tanks.model.quest.common.gui.greenpanel {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.quest.common.gui.greenpanel.GreenPanelBitmaps_BACKGROUND_PIXEL_BITMAP.png")]
public class GreenPanelBitmaps_BACKGROUND_PIXEL_BITMAP extends BitmapAsset {
public function GreenPanelBitmaps_BACKGROUND_PIXEL_BITMAP() {
super();
}
}
}
|
package alternativa.tanks.gui.foreignclan {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.foreignclan.ForeignClanWindow_bitmapKillsIcon.png")]
public class ForeignClanWindow_bitmapKillsIcon extends BitmapAsset {
public function ForeignClanWindow_bitmapKillsIcon() {
super();
}
}
}
|
package alternativa.tanks.models.tank.ultimate.titan.generator {
import alternativa.math.Vector3;
import alternativa.tanks.models.tank.ultimate.titan.ShieldBeamEffect;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.sfx.ISound3DEffect;
import alternativa.types.Long;
import flash.utils.Dictionary;
public class ShieldGeneratorData {
public var spherePosition:Vector3;
public var resources:TitanUltimateResources;
public var soundEffect:ISound3DEffect;
public var visualEffect:GraphicEffect;
public var rotationAngle:Number;
private var tanksAndBeams:Dictionary = new Dictionary();
public function ShieldGeneratorData(param1:Vector3, param2:TitanUltimateResources, param3:ISound3DEffect, param4:GraphicEffect, param5:Number) {
super();
this.spherePosition = param1;
this.resources = param2;
this.soundEffect = param3;
this.visualEffect = param4;
this.rotationAngle = param5;
}
public function cover(param1:Long) : void {
this.tanksAndBeams[param1] = true;
}
public function addBeam(param1:Long, param2:ShieldBeamEffect) : void {
this.tanksAndBeams[param1] = param2;
}
public function uncover(param1:Long) : void {
var local2:ShieldBeamEffect = this.tanksAndBeams[param1] as ShieldBeamEffect;
if(local2 != null) {
local2.kill();
}
delete this.tanksAndBeams[param1];
}
public function isTankCovered(param1:Long) : Boolean {
return this.tanksAndBeams[param1] != null;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.logging.battlelist {
import alternativa.types.Long;
import flash.events.IEventDispatcher;
import projects.tanks.client.battleservice.BattleMode;
public interface UserBattleSelectActionsService extends IEventDispatcher {
function battleSelected(param1:BattleMode, param2:Long) : void;
function turnOnBattleMode(param1:BattleMode) : void;
function turnOffBattleMode(param1:BattleMode) : void;
function createBattle(param1:BattleMode) : void;
function enterToBattle(param1:BattleMode, param2:Long) : void;
function copyBattleLink(param1:BattleMode, param2:Long) : void;
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_radioexplosionIconClass.png")]
public class DeviceIcons_radioexplosionIconClass extends BitmapAsset {
public function DeviceIcons_radioexplosionIconClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.garageitem.licenseclan {
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 LicenseClanShopItemModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:LicenseClanShopItemModelServer;
private var client:ILicenseClanShopItemModelBase = ILicenseClanShopItemModelBase(this);
private var modelId:Long = Long.getLong(342831337,-415928029);
public function LicenseClanShopItemModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new LicenseClanShopItemModelServer(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.item.discount {
public class DiscountCollector implements IDiscountCollector {
private var discounts:Vector.<DiscountInfo> = new Vector.<DiscountInfo>();
public function DiscountCollector() {
super();
}
public function addDiscount(param1:DiscountInfo) : void {
if(param1.hasDiscount()) {
this.discounts.push(param1);
}
}
public function getDiscountInfoes() : Vector.<DiscountInfo> {
return this.discounts;
}
}
}
|
package projects.tanks.client.panel.model.personaldiscount {
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 PersonalDiscountModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _selectId:Long = Long.getLong(462102347,968889621);
private var _select_lightItemCodec:ICodec;
private var model:IModel;
public function PersonalDiscountModelServer(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._select_lightItemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
}
public function select(param1:IGameObject) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._select_lightItemCodec.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._selectId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.models.weapon.rotation {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class WeaponRotationLimitAdapt implements WeaponRotationLimit {
private var object:IGameObject;
private var impl:WeaponRotationLimit;
public function WeaponRotationLimitAdapt(param1:IGameObject, param2:WeaponRotationLimit) {
super();
this.object = param1;
this.impl = param2;
}
public function getMaxAngle() : Number {
var result:Number = NaN;
try {
Model.object = this.object;
result = Number(this.impl.getMaxAngle());
}
finally {
Model.popObject();
}
return result;
}
public function getMinAngle() : Number {
var result:Number = NaN;
try {
Model.object = this.object;
result = Number(this.impl.getMinAngle());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_piercingCoeffClass.png")]
public class ItemInfoPanelBitmaps_piercingCoeffClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_piercingCoeffClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapons.stream {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class StreamWeaponCommunicationAdapt implements StreamWeaponCommunication {
private var object:IGameObject;
private var impl:StreamWeaponCommunication;
public function StreamWeaponCommunicationAdapt(param1:IGameObject, param2:StreamWeaponCommunication) {
super();
this.object = param1;
this.impl = param2;
}
public function fireStarted(param1:int) : void {
var clientTime:int = param1;
try {
Model.object = this.object;
this.impl.fireStarted(clientTime);
}
finally {
Model.popObject();
}
}
public function fireStopped(param1:int) : void {
var clientTime:int = param1;
try {
Model.object = this.object;
this.impl.fireStopped(clientTime);
}
finally {
Model.popObject();
}
}
public function targetUpdate(param1:int, param2:Vector3, param3:Tank) : void {
var clientTime:int = param1;
var direction:Vector3 = param2;
var target:Tank = param3;
try {
Model.object = this.object;
this.impl.targetUpdate(clientTime,direction,target);
}
finally {
Model.popObject();
}
}
public function targetsUpdateDummy(param1:int, param2:Vector3) : void {
var clientTime:int = param1;
var direction:Vector3 = param2;
try {
Model.object = this.object;
this.impl.targetsUpdateDummy(clientTime,direction);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.model.item.resistance.view {
import alternativa.tanks.gui.device.DeviceButtonSkin;
import alternativa.tanks.gui.shop.shopitems.item.base.ShopButton;
import alternativa.tanks.model.garage.resistance.ResistancesIconsUtils;
import alternativa.tanks.model.item.properties.ItemPropertyValue;
import alternativa.tanks.service.garage.GarageService;
import alternativa.tanks.service.item.ItemService;
import alternativa.tanks.service.resistance.ResistanceService;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.events.MouseEvent;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
public class ResistanceButton extends ShopButton {
[Inject]
public static var itemService:ItemService;
[Inject]
public static var resistanceService:ResistanceService;
[Inject]
public static var garageService:GarageService;
[Inject]
public static var battleInfoService:IBattleInfoService;
private static const unmountHoverIconClass:Class = ResistanceButton_unmountHoverIconClass;
private static const unmountHoverIcon:BitmapData = new unmountHoverIconClass().bitmapData;
private static const mountHoverIconClass:Class = ResistanceButton_mountHoverIconClass;
private static const mountHoverIcon:BitmapData = new mountHoverIconClass().bitmapData;
private static const mountedBGIconClass:Class = ResistanceButton_mountedBGIconClass;
private static const bgWithModule:BitmapData = new mountedBGIconClass().bitmapData;
private static const freeBGIconClass:Class = ResistanceButton_freeBGIconClass;
private static const freeBG:BitmapData = new freeBGIconClass().bitmapData;
private static const lockedIconClass:Class = ResistanceButton_lockedIconClass;
private static const lockedIcon:BitmapData = new lockedIconClass().bitmapData;
private var buttonWithModule:Bitmap = new Bitmap(bgWithModule);
private var freeButton:Bitmap = new Bitmap(freeBG);
private var actionUnmount:Bitmap = new Bitmap(unmountHoverIcon);
private var actionMount:Bitmap = new Bitmap(mountHoverIcon);
public var item:IGameObject;
private var index:int;
protected var deviceImage:Bitmap;
public function ResistanceButton(param1:int) {
super(new DeviceButtonSkin());
this.index = param1;
this.buttonWithModule.visible = false;
addChildAt(this.buttonWithModule,1);
addChildAt(this.freeButton,2);
this.actionUnmount.visible = false;
this.actionUnmount.x = (width - this.actionUnmount.width) / 2;
this.actionUnmount.y = (height - this.actionUnmount.height) / 2;
this.actionMount.visible = false;
this.actionMount.x = (width - this.actionMount.width) / 2;
this.actionMount.y = (height - this.actionMount.height) / 2;
addChildAt(this.actionUnmount,4);
addChildAt(this.actionMount,5);
this.enable();
}
public function getIndex() : int {
return this.index;
}
public function disable() : void {
buttonMode = false;
super.removeEvents();
this.removeEventListener(MouseEvent.CLICK,this.onClick);
this.freeButton.bitmapData = lockedIcon;
}
public function enable() : void {
super.init();
this.addEventListener(MouseEvent.CLICK,this.onClick);
this.freeButton.bitmapData = freeBG;
}
private function onWithoutHover() : void {
this.actionMount.visible = false;
this.actionUnmount.visible = false;
}
private function onHover() : void {
this.actionUnmount.visible = !this.isFree();
this.actionMount.visible = this.isFree();
}
private function updateBG() : void {
this.buttonWithModule.visible = !this.isFree();
this.freeButton.visible = this.isFree();
}
private function onClick(param1:MouseEvent) : void {
var local2:IGameObject = null;
if(this.item != null) {
resistanceService.unmount(this.item);
} else {
local2 = garageService.getView().getSelectedItem();
if(local2 != null) {
if(!garageService.getView().isItemInStore(local2)) {
resistanceService.mount(this.index,local2);
}
}
}
}
override protected function onMouseEvent(param1:MouseEvent) : void {
var local2:IGameObject = null;
if(this.isFree()) {
local2 = garageService.getView().getSelectedItem();
if(local2 == null || Boolean(garageService.getView().isItemInStore(local2))) {
this.disable();
return;
}
this.enable();
}
overState.visible = param1.type == MouseEvent.MOUSE_OVER || param1.type == MouseEvent.MOUSE_DOWN;
normalState.visible = !overState.visible;
if(overState.visible) {
this.onHover();
} else {
this.onWithoutHover();
this.updateBG();
}
}
public function reset() : void {
if(this.item != null) {
if(resistanceService.canBeMount(this.item)) {
this.item = null;
this.setResistanceImage(null);
buttonMode = false;
}
}
}
public function isFree() : Boolean {
return this.item == null;
}
private function setResistanceImage(param1:BitmapData) : void {
if(this.deviceImage != null) {
removeChild(this.deviceImage);
}
this.deviceImage = new Bitmap(param1);
this.deviceImage.x = (width - this.deviceImage.width) / 2;
this.deviceImage.y = (height - this.deviceImage.height) / 2;
this.updateBG();
addChildAt(this.deviceImage,3);
buttonMode = true;
}
public function setDeviceImageFromItem(param1:IGameObject) : void {
var local3:ItemPropertyValue = null;
var local2:Vector.<ItemPropertyValue> = itemService.getProperties(param1);
for each(local3 in local2) {
this.setResistanceImage(ResistancesIconsUtils.getResistanceBigIcon(local3.getProperty()).bitmapData);
}
}
override public function destroy() : void {
this.removeEventListener(MouseEvent.CLICK,this.onClick);
super.destroy();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.map {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import projects.tanks.client.battlefield.models.map.FogParams;
public class CodecFogParams implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_alpha:ICodec;
private var codec_color:ICodec;
private var codec_farLimit:ICodec;
private var codec_nearLimit:ICodec;
public function CodecFogParams() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_alpha = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_color = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_farLimit = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_nearLimit = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:FogParams = new FogParams();
local2.alpha = this.codec_alpha.decode(param1) as Number;
local2.color = this.codec_color.decode(param1) as int;
local2.farLimit = this.codec_farLimit.decode(param1) as Number;
local2.nearLimit = this.codec_nearLimit.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:FogParams = FogParams(param2);
this.codec_alpha.encode(param1,local3.alpha);
this.codec_color.encode(param1,local3.color);
this.codec_farLimit.encode(param1,local3.farLimit);
this.codec_nearLimit.encode(param1,local3.nearLimit);
}
}
}
|
package alternativa.tanks.model.user
{
import alternativa.init.Main;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import flash.utils.Dictionary;
import projects.tanks.client.panel.model.IUserDataModelBase;
import projects.tanks.client.panel.model.UserDataModelBase;
public class UserDataModel extends UserDataModelBase implements IUserDataModelBase, IObjectLoadListener, IUserData
{
private var clientObject:ClientObject;
private var data:Dictionary;
private var _userId:String;
private var _userName:String;
public function UserDataModel()
{
super();
_interfaces.push(IModel);
_interfaces.push(IUserData);
_interfaces.push(IObjectLoadListener);
_interfaces.push(IUserDataModelBase);
this.data = new Dictionary(false);
}
public function objectLoaded(object:ClientObject) : void
{
this.clientObject = object;
}
public function objectUnloaded(object:ClientObject) : void
{
this.clientObject = null;
}
public function initObject(clientObject:ClientObject, uid:String, userId:String) : void
{
this._userId = userId;
this._userName = uid;
}
public function setUserData(clientObject:ClientObject, userId:String, uid:String, index:int) : void
{
var i:int = 0;
this.data[userId] = new UserData(userId,uid,index);
var modelRegister:IModelService = Main.osgi.getService(IModelService) as IModelService;
var listeners:Vector.<IModel> = modelRegister.getModelsByInterface(IUserDataListener);
if(listeners != null)
{
for(i = 0; i < listeners.length; i++)
{
(listeners[i] as IUserDataListener).userDataChanged(userId);
}
}
}
public function getData(userId:String) : UserData
{
var result:UserData = null;
Main.writeToConsole("UserDataModel getData userId: " + userId);
if(this.data[userId] != null)
{
result = this.data[userId];
}
return result;
}
public function get userId() : String
{
return this._userId;
}
public function get userName() : String
{
return this._userName;
}
}
}
|
package alternativa.tanks.models.tank {
import alternativa.tanks.battle.objects.tank.WeaponMount;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class WeaponMountProviderEvents implements WeaponMountProvider {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function WeaponMountProviderEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function createWeaponMount(param1:IGameObject) : WeaponMount {
var result:WeaponMount = null;
var i:int = 0;
var m:WeaponMountProvider = null;
var tankObject:IGameObject = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = WeaponMountProvider(this.impl[i]);
result = m.createWeaponMount(tankObject);
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.panel.model.rankupbonus.alert {
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 RankUpBonusAlertPanelModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:RankUpBonusAlertPanelModelServer;
private var client:IRankUpBonusAlertPanelModelBase = IRankUpBonusAlertPanelModelBase(this);
private var modelId:Long = Long.getLong(1984500447,-1883224146);
private var _showAlertId:Long = Long.getLong(653153520,-1625951208);
private var _showAlert_itemCodec:ICodec;
public function RankUpBonusAlertPanelModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new RankUpBonusAlertPanelModelServer(IModel(this));
this._showAlert_itemCodec = this._protocol.getCodec(new TypeCodecInfo(RankUpBonusAlertItem,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._showAlertId:
this.client.showAlert(RankUpBonusAlertItem(this._showAlert_itemCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIcon_p4 extends BitmapAsset
{
public function RangIcon_p4()
{
super();
}
}
}
|
package alternativa.tanks.service.socialnetwork.vk {
import flash.events.IEventDispatcher;
public interface SNFriendsService extends IEventDispatcher {
function requestFriends() : void;
}
}
|
package alternativa.tanks.models.battlefield
{
import alternativa.console.ConsoleVarFloat;
import alternativa.console.ConsoleVarInt;
import alternativa.console.IConsole;
import alternativa.engine3d.containers.KDContainer;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Light3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Decal;
import alternativa.engine3d.objects.Mesh;
import alternativa.engine3d.objects.SkyBox;
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.osgi.service.debug.IDebugService;
import alternativa.osgi.service.dump.IDumpService;
import alternativa.osgi.service.dump.dumper.IDumper;
import alternativa.osgi.service.focus.IFocusService;
import alternativa.osgi.service.log.LogLevel;
import alternativa.osgi.service.mainContainer.IMainContainerService;
import alternativa.osgi.service.network.INetworkListener;
import alternativa.osgi.service.network.INetworkService;
import alternativa.osgi.service.storage.IStorageService;
import alternativa.physics.Body;
import alternativa.physics.PhysicsScene;
import alternativa.physics.altphysics;
import alternativa.physics.collision.CollisionPrimitive;
import alternativa.physics.collision.IBodyCollisionPredicate;
import alternativa.proplib.PropLibRegistry;
import alternativa.register.ObjectRegister;
import alternativa.register.SpaceInfo;
import alternativa.service.IAddressService;
import alternativa.service.IModelService;
import alternativa.service.ISpaceService;
import alternativa.tanks.battle.Trigger;
import alternativa.tanks.battle.triggers.Triggers;
import alternativa.tanks.bg.IBackgroundService;
import alternativa.tanks.bonuses.IBonus;
import alternativa.tanks.bonuses.IBonusListener;
import alternativa.tanks.camera.FlyCameraController;
import alternativa.tanks.camera.FollowCameraController;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.camera.ICameraController;
import alternativa.tanks.camera.ICameraStateModifier;
import alternativa.tanks.camera.IFollowCameraController;
import alternativa.tanks.camera.ProjectileHitCameraModifier;
import alternativa.tanks.config.Config;
import alternativa.tanks.gui.newyear.ToyLightAnimation;
import alternativa.tanks.model.panel.IBattleSettings;
import alternativa.tanks.model.panel.IPanel;
import alternativa.tanks.model.panel.IPanelListener;
import alternativa.tanks.model.panel.PanelModel;
import alternativa.tanks.models.battlefield.decals.DecalFactory;
import alternativa.tanks.models.battlefield.decals.FadingDecalsRenderer;
import alternativa.tanks.models.battlefield.decals.Queue;
import alternativa.tanks.models.battlefield.decals.RotationState;
import alternativa.tanks.models.battlefield.dust.Dust;
import alternativa.tanks.models.battlefield.gamemode.DayGameMode;
import alternativa.tanks.models.battlefield.gamemode.DefaultGameModel;
import alternativa.tanks.models.battlefield.gamemode.GameModes;
import alternativa.tanks.models.battlefield.gamemode.IGameMode;
import alternativa.tanks.models.battlefield.gui.IBattlefieldGUI;
import alternativa.tanks.models.battlefield.hidableobjects.HidableGraphicObjects;
import alternativa.tanks.models.battlefield.logic.BattleLogicUnits;
import alternativa.tanks.models.battlefield.shadows.BattleShadow;
import alternativa.tanks.models.battlefield.skybox.Object3DRevolver;
import alternativa.tanks.models.effects.common.bonuscommon.BonusCommonModel;
import alternativa.tanks.models.tank.ITank;
import alternativa.tanks.models.tank.ITankEventDispatcher;
import alternativa.tanks.models.tank.ITankEventListener;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.tank.TankEvent;
import alternativa.tanks.models.tank.TankModel;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import alternativa.tanks.services.materialregistry.IMaterialRegistry;
import alternativa.tanks.services.objectpool.IObjectPoolService;
import alternativa.tanks.sfx.IGraphicEffect;
import alternativa.tanks.sfx.ISound3DEffect;
import alternativa.tanks.sfx.ISpecialEffect;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.sfx.SoundOptions;
import alternativa.tanks.sound.ISoundManager;
import alternativa.tanks.sound.SoundManager;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.vehicles.tanks.Tank;
import alternativa.tanks.vehicles.tanks.TankSkin;
import alternativa.utils.DebugPanel;
import com.alternativaplatform.projects.tanks.client.commons.types.Vector3d;
import com.alternativaplatform.projects.tanks.client.models.battlefield.BattleBonus;
import com.alternativaplatform.projects.tanks.client.models.battlefield.BattlefieldModelBase;
import com.alternativaplatform.projects.tanks.client.models.battlefield.BattlefieldResources;
import com.alternativaplatform.projects.tanks.client.models.battlefield.BattlefieldSoundScheme;
import com.alternativaplatform.projects.tanks.client.models.battlefield.IBattlefieldModelBase;
import controls.SuicideIndicator;
import flash.display.BitmapData;
import flash.display.Stage;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.geom.Rectangle;
import flash.geom.Vector3D;
import flash.media.Sound;
import flash.media.SoundTransform;
import flash.net.SharedObject;
import flash.ui.Keyboard;
import flash.utils.Dictionary;
import flash.utils.getTimer;
import scpacker.gui.GTanksLoaderWindow;
import scpacker.gui.IGTanksLoader;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
import scpacker.resource.ResourceType;
import scpacker.resource.ResourceUtil;
import scpacker.resource.listener.ResourceLoaderListener;
import scpacker.test.RenderSystem;
import scpacker.test.anticheat.SpeedHackChecker;
import scpacker.test.spectator.SpectatorCameraController;
import specter.utils.Logger;
use namespace altphysics;
public class BattlefieldModel extends BattlefieldModelBase implements IBattlefieldModelBase, IBattleField, IObjectLoadListener, IBonusListener, INetworkListener, IPanelListener, IBodyCollisionPredicate, IDumper, ITankEventListener
{
private static const MAP_MIPMAP_RESOLUTION:Number = 5.8;
private static const CONSOLE_COMMAND_ID:String = "battle";
private static const PHYSICS_STEP_MILLIS:int = 30;
private static const MAX_FRAMERATE:int = 60;
private static const MIN_FRAMERATE:int = 10;
private static const MAX_FRAME_TIME:int = 200;
private static const ADAPTIVE_FPS_CHANGE_INTERVAL:int = 30;
private static const CAMERA_FLY_TIME:int = 3000;
private static const MAX_TEMPORARY_DECALS:int = 10;
private static const DECAL_FADING_TIME_MS:int = 20000;
private static const _origin3D:Vector3D = new Vector3D();
private static const _direction3D:Vector3D = new Vector3D();
[Embed(source="766.png")]
private static const SNOW_DUST_DATA:Class;
[Embed(source="893.png")]
private static const DUST_DATA:Class;
private var objectPoolService:IObjectPoolService;
private var materialRegistry:IMaterialRegistry;
private var modelsRegister:IModelService;
private var adaptiveFrameCounter:int;
private var adaptiveFpsEnabled:Boolean = false;
private var debugPanel:DebugPanel;
private var tankInterface:TankModel;
private var _soundManager:ISoundManager;
public var bfData:BattlefieldData;
private var suicideIndicator:SuicideIndicator;
private var screenSizeSteps:int = 10;
public var screenSize:int;
private var plugins:Vector.<IBattlefieldPlugin>;
private var pluginCount:int;
private var border:ViewportBorder;
private var deltaSec:Number = 0;
private var debugMode:Boolean;
private var doRender:Boolean;
private var physicsTimeStat:TimeStatistics;
private var logicTimeStat:TimeStatistics;
private var fullTimeStat:TimeStatistics;
private var lastError:Error;
private var uiLockCount:int;
private var cameraUnlockCounter:int;
private var activeCameraController:ICameraController;
private var followCameraController:IFollowCameraController;
private var flyCameraController:FlyCameraController;
private var freeCameraController:SpectatorCameraController;
private var cameraPosition:Vector3;
private var cameraAngles:Vector3;
private var startTime:int;
private var logicTime:int;
public var physicsTime:int;
private var a3dRenderTime:int;
private var gui:IBattlefieldGUI;
private var throwDebugError:Boolean;
private var panelUnlockCounter:int;
private var tankExplosionStartPosition:ConsoleVarInt;
private var tankExplosionVolume:ConsoleVarFloat;
private var muteSound:Boolean;
private var speedHackDetector:SpeedHackChecker;
public var spectatorMode:Boolean;
private var renderSystem:RenderSystem;
public var logicUnits:BattleLogicUnits;
private var lastLogicUnitsUpdate:Number;
private var shadows:BattleShadow;
private var dusts:Dust;
private var decalFactory:DecalFactory;
private const temporaryDecals:Queue = new Queue();
private const allDecals:Dictionary = new Dictionary();
public var fadingDecalRenderer:FadingDecalsRenderer;
public var gameMode:IGameMode;
public var shaft_freq:ConsoleVarFloat;
public var shaft_vel:ConsoleVarFloat;
public var shaft_avel:ConsoleVarFloat;
public var objects2tank:Dictionary;
private var lightings:Vector.<ToyLightAnimation>;
public var hidableObjects:HidableGraphicObjects;
private var skyboxRevolver:Object3DRevolver;
public var animatedTracks:Boolean;
private var updatePhysics:Boolean = true;
private var config:Config;
private var collisionDetector:TanksCollisionDetector;
public var toDestroy:Vector.<Object>;
public var blacklist:Vector.<Object>;
private var loadedList:Vector.<String>;
private var triggers:Triggers;
public var messages:BattlefieldMessages;
public var mapResourceId:String;
public var libs:PropLibRegistry;
public function BattlefieldModel()
{
this.screenSize = this.screenSizeSteps;
this.border = new ViewportBorder();
this.physicsTimeStat = new TimeStatistics();
this.logicTimeStat = new TimeStatistics();
this.fullTimeStat = new TimeStatistics();
this.cameraPosition = new Vector3();
this.cameraAngles = new Vector3();
this.tankExplosionStartPosition = new ConsoleVarInt("tankexpl_soffset",0,0,1000);
this.tankExplosionVolume = new ConsoleVarFloat("tankexpl_svolume",0.4,0,1);
this.lightings = new Vector.<ToyLightAnimation>();
this.hidableObjects = new HidableGraphicObjects();
this.libs = new PropLibRegistry();
super();
_interfaces.push(IModel,IBattleField,IBattlefieldModelBase,IObjectLoadListener,IPanelListener);
this.shaft_freq = new ConsoleVarFloat("shf",0.01,-100,100);
this.shaft_vel = new ConsoleVarFloat("shv",0.05,-100,100);
this.shaft_avel = new ConsoleVarFloat("shav",0.2,-100,100);
this.toDestroy = new Vector.<Object>();
this.blacklist = new Vector.<Object>();
this.objectPoolService = IObjectPoolService(Main.osgi.getService(IObjectPoolService));
this.materialRegistry = IMaterialRegistry(Main.osgi.getService(IMaterialRegistry));
this.modelsRegister = IModelService(Main.osgi.getService(IModelService));
this.logicUnits = new BattleLogicUnits();
ProjectileHitCameraModifier.initVars();
FollowCameraController.effectsEnabled = true;
var console:IConsole = IConsole(Main.osgi.getService(IConsole));
if(console != null)
{
console.addCommandHandler("toggle_debug_textures",this.onToggleTextureDebug);
}
PanelModel(Main.osgi.getService(IPanel)).panelListeners.push(this);
this.triggers = new Triggers();
this.objects2tank = new Dictionary();
}
public static function copyToVector3D(param1:Vector3, param2:Vector3D) : void
{
param2.x = param1.x;
param2.y = param1.y;
param2.z = param1.z;
}
public function bugReportOpened() : void
{
this.changeUILockCount(1);
}
public function bugReportClosed() : void
{
this.changeUILockCount(-1);
}
public function friendsOpened() : void
{
this.changeUILockCount(1);
}
public function friendsClosed() : void
{
this.changeUILockCount(-1);
}
public function settingsOpened() : void
{
this.changeUILockCount(1);
}
public function onCloseGame() : void
{
this.changeUILockCount(1);
}
public function onCloseGameExit() : void
{
this.changeUILockCount(-1);
}
public function settingsCanceled() : void
{
this.changeUILockCount(-1);
}
public function settingsAccepted() : void
{
var key:* = undefined;
var t:TankData = null;
this.changeUILockCount(-1);
if(this.bfData == null)
{
return;
}
var settings:IBattleSettings = this.getBattleSettings();
if(settings != null)
{
this.bfData.skybox.visible = settings.showSkyBox;
this.adaptiveFPS = settings.adaptiveFPS;
if(this.bfData.ambientChannel == null && settings.bgSound || this.bfData.ambientChannel != null && !settings.bgSound)
{
this.toggleAmbientSound();
}
if(settings.fog)
{
this.bfData.viewport.enableFog();
}
else
{
this.bfData.viewport.disableFog();
}
if(settings.useSoftParticle)
{
this.bfData.viewport.enableSoftParticles();
}
else
{
this.bfData.viewport.disableSoftParticles();
}
this.dusts.enabled = settings.dust;
this.gameMode.applyChangesBeforeSettings(settings);
for(key in this.bfData.activeTanks)
{
t = key as TankData;
t.tank.setAnimationTracks(settings.animationTracks);
}
this.animatedTracks = settings.animationTracks;
this.bfData.viewport.enableAmbientShadows(settings.shadowUnderTanks);
}
}
public function connect() : void
{
}
public function disconnect() : void
{
this.removeMainListeners();
this.removeKeyboardListeners();
this._soundManager.stopAllSounds();
}
public function getBattlefieldData() : BattlefieldData
{
return this.bfData;
}
public function initObject(clientObject:ClientObject, battlefieldResources:BattlefieldResources, battlefieldSoundScheme:BattlefieldSoundScheme, idleKickPeriodMsec:int, mapDescriptorResourceId:String, respawnInvulnerabilityPeriodMsec:int, skyboxTextureResourceId:String, spectator:Boolean, gameMode:IGameMode, loadedList:Vector.<String> = null) : void
{
var networkService:INetworkService = null;
var modelService:IModelService = null;
var dumpService:IDumpService = null;
try
{
this.loadedList = loadedList;
this.debugMode = Main.osgi.getService(IDebugService) != null;
this.spectatorMode = spectator;
this.gameMode = gameMode is DefaultGameModel ? new DayGameMode() : gameMode;
this.panelUnlockCounter = 2;
this.throwDebugError = false;
this.tankInterface = Main.osgi.getService(ITank) as TankModel;
networkService = Main.osgi.getService(INetworkService) as INetworkService;
if(networkService != null)
{
networkService.addEventListener(this);
}
modelService = IModelService(Main.osgi.getService(IModelService));
this.gui = Main.osgi.getService(IBattlefieldGUI) as IBattlefieldGUI;
this.bfData = new BattlefieldData();
this.bfData.bfObject = clientObject;
this.bfData.guiContainer = (Main.osgi.getService(IMainContainerService) as IMainContainerService).contentLayer;
this.bfData.respawnInvulnerabilityPeriod = respawnInvulnerabilityPeriodMsec;
this.bfData.idleKickPeriod = idleKickPeriodMsec;
if(skyboxTextureResourceId == "skybox_halloween")
{
battlefieldSoundScheme.ambientSound = "halloween_sound_id";
}
this.initSounds(battlefieldSoundScheme);
this.mapResourceId = mapDescriptorResourceId;
this.initPhysicsAndViewport();
this.initMap(mapDescriptorResourceId,skyboxTextureResourceId);
this.speedHackDetector = new SpeedHackChecker(this);
dumpService = IDumpService(Main.osgi.getService(IDumpService));
if(dumpService != null)
{
dumpService.registerDumper(this);
}
this.startTime = getTimer();
this.logicTime = 0;
this.physicsTime = 0;
this.a3dRenderTime = 0;
}
catch(e:Error)
{
(Main.osgi.getService(IConsole) as IConsole).addLine(e.getStackTrace());
}
}
public function initBonuses(clientObject:ClientObject, bonuses:Array) : void
{
var bonusData:BattleBonus = null;
if(bonuses == null)
{
return;
}
for each(bonusData in bonuses)
{
this.createBonusAndAttach(clientObject.register,bonusData.id,bonusData.objectId,bonusData.position,bonusData.timeFromAppearing,false,clientObject);
}
}
public function addBonus(clientObject:ClientObject, bonusId:String, bonusObjectId:String, position:Vector3d, disappearingTime:int = 21) : void
{
this.createBonusAndAttach(clientObject.register,bonusId,bonusObjectId,position,0,true,clientObject,disappearingTime);
}
public function bonusDropped(clientObject:ClientObject, bonusId:String, bonusObjectId:String, position:Vector3d, timeFromAppearing:int) : void
{
var bonus:IBonus = this.bfData.bonuses[bonusId];
if(bonus == null)
{
bonus = this.createBonusAndAttach(clientObject.register,bonusId,bonusObjectId,position,timeFromAppearing,false,clientObject);
if(bonus == null)
{
return;
}
}
bonus.setRestingState(position.x,position.y,position.z);
}
public function removeBonus(clientObject:ClientObject, bonusId:String) : void
{
if(this.bfData == null)
{
return;
}
var bonus:IBonus = this.bfData.bonuses[bonusId];
if(bonus != null)
{
bonus.setRemovedState();
}
}
public function bonusTaken(clientObject:ClientObject, bonusId:String) : void
{
var sound:Sound3D = null;
var position:Vector3 = null;
if(this.bfData == null)
{
return;
}
var bonus:IBonus = this.bfData.bonuses[bonusId];
if(bonus == null)
{
Logger.info(LogLevel.LOG_ERROR,"BattlefieldModel::bonusTaken(): bonus not found. Bonus id=" + bonusId);
}
else
{
bonus.setTakenState();
if(this.bfData.bonusTakenSound != null)
{
sound = Sound3D.create(this.bfData.bonusTakenSound,SoundOptions.nearRadius,SoundOptions.farRadius,SoundOptions.farDelimiter,0.5);
position = new Vector3();
bonus.readBonusPosition(position);
this.addSound3DEffect(Sound3DEffect.create(this.objectPoolService.objectPool,null,position,sound));
}
}
}
public function onBonusDropped(bonus:IBonus) : void
{
var position:Vector3 = new Vector3();
bonus.readBonusPosition(position);
}
public function onTankCollision(bonus:IBonus) : void
{
if(bonus.isFalling())
{
this.onBonusDropped(bonus);
}
TankModel(Main.osgi.getService(ITank)).mandatoryUpdate();
this.attemptToTakeBonus(this.bfData.bfObject,bonus.bonusId);
}
private function attemptToTakeBonus(bfObject:ClientObject, bonusId:String) : void
{
var localTankData:TankData = this.tankInterface.getTankData(this.bfData.localUser);
var json:Object = new Object();
json.bonus_id = bonusId;
json.real_tank_position = new Vector3d(localTankData.tank.state.pos.x,localTankData.tank.state.pos.y,localTankData.tank.state.pos.z);
Network(Main.osgi.getService(INetworker)).send("battle;attempt_to_take_bonus;" + JSON.stringify(json));
}
public function battleStart(clientObject:ClientObject) : void
{
var i:int = 0;
if(this.plugins != null)
{
for(i = 0; i < this.pluginCount; i++)
{
IBattlefieldPlugin(this.plugins[i]).startBattle();
}
}
}
public function battleFinish(clientObject:ClientObject) : void
{
var key:* = undefined;
var tankData:* = null;
var bonus:IBonus = null;
var i:int = 0;
this.tankInterface.disableUserControls(true);
for(tankData in this.bfData.activeTanks)
{
tankData.tank.title.hideIndicators();
this.tankInterface.stop(tankData);
tankData.enabled = false;
}
this.suicideIndicator.visible = false;
this.tankInterface.resetIdleTimer(true);
for(key in this.bfData.bonuses)
{
bonus = this.bfData.bonuses[key];
bonus.destroy();
delete this.bfData.bonuses[key];
}
if(this.plugins != null)
{
for(i = 0; i < this.pluginCount; i++)
{
IBattlefieldPlugin(this.plugins[i]).finishBattle();
}
}
}
public function battleRestart(clientObject:ClientObject) : void
{
var key:* = undefined;
var i:int = 0;
for(key in this.bfData.activeTanks)
{
this.removeTankFromField(key as TankData);
}
if(this.plugins != null)
{
for(i = 0; i < this.pluginCount; i++)
{
IBattlefieldPlugin(this.plugins[i]).restartBattle();
}
}
}
private function onStageResize(e:Event) : void
{
if(this.messages != null)
{
this.messages.x = 0.5 * Main.stage.stageWidth;
this.messages.y = 40;
}
}
public function objectLoaded(clientObject:ClientObject) : void
{
ResourceUtil.addEventListener(function():void
{
onResourcesReady(clientObject);
});
ResourceUtil.unloadImages(this.loadedList);
}
private function onResourcesReady(clientObject:ClientObject) : void
{
var key:* = undefined;
var t:TankData = null;
var prefix:String = !!Game.local ? "" : "resources/";
this._soundManager = SoundManager.createSoundManager(this.bfData.ambientSound);
var settings:IBattleSettings = this.getBattleSettings();
this.muteSound = settings.muteSound;
if(!this.muteSound && settings.bgSound)
{
this.bfData.ambientChannel = this._soundManager.playSound(this.bfData.ambientSound,0,1000000,new SoundTransform(0.5));
}
this.addMainListeners();
this.addKeyboardListeners();
this.bfData.time = getTimer();
this.onResize(null);
var tankEventDispatcher:ITankEventDispatcher = ITankEventDispatcher(Main.osgi.getService(ITankEventDispatcher));
if(tankEventDispatcher != null)
{
tankEventDispatcher.addTankEventListener(TankEvent.KILLED,this);
tankEventDispatcher.addTankEventListener(TankEvent.SPAWNED,this);
}
if(!this.spectatorMode)
{
Network(Main.osgi.getService(INetworker)).send("battle;get_init_data_local_tank");
}
else
{
BattleController.localTankInited = true;
Network(Main.osgi.getService(INetworker)).send("battle;spectator_user_init");
this.activateSpectatorCamera();
}
if(settings.fog)
{
this.bfData.viewport.enableFog();
}
else
{
this.bfData.viewport.disableFog();
}
if(settings.useSoftParticle)
{
this.bfData.viewport.enableSoftParticles();
}
else
{
this.bfData.viewport.disableSoftParticles();
}
this.dusts.enabled = settings.dust;
this.gameMode.applyChangesBeforeSettings(settings);
for(key in this.bfData.activeTanks)
{
t = key as TankData;
t.tank.setAnimationTracks(settings.animationTracks);
}
this.animatedTracks = settings.animationTracks;
this.bfData.viewport.enableAmbientShadows(settings.shadowUnderTanks);
this.messages = new BattlefieldMessages(3,18,18);
Main.contentUILayer.addChild(this.messages);
Main.stage.addEventListener(Event.RESIZE,this.onStageResize);
this.onStageResize(null);
(Main.osgi.getService(IGTanksLoader) as GTanksLoaderWindow).setFullAndClose(null);
}
public function objectUnloaded(clientObject:ClientObject) : void
{
var b:IBonus = null;
var bgService:IBackgroundService = null;
var o:* = undefined;
ResourceLoaderListener.clearListeners(true);
ResourceUtil.loadImages();
if(this.bfData == null)
{
Logger.info(LogLevel.LOG_ERROR,"BattlefieldModel::objectUnloaded Called more than once");
return;
}
var networkService:INetworkService = INetworkService(Main.osgi.getService(INetworkService));
if(networkService != null)
{
networkService.removeEventListener(this);
}
for(var i:int = 0; i < this.toDestroy.length; i++)
{
o = this.toDestroy[i];
if(o != null)
{
if(this.blacklist.indexOf(o) == -1)
{
o.destroy(true);
o = null;
i++;
}
else
{
this.toDestroy.removeAt(i);
}
}
if(i >= 200)
{
break;
}
}
if(i < 200)
{
this.toDestroy = new Vector.<Object>();
}
Main.debug.unregisterCommand(CONSOLE_COMMAND_ID);
this.materialRegistry.clear();
this.removeMainListeners();
this.removeKeyboardListeners();
this._soundManager.stopAllSounds();
this._soundManager.removeAllEffects();
this.bfData.viewport.camera.view.clear();
this.bfData.viewport.camera.view = null;
this.bfData.viewport.clearContainers();
this.bfData.guiContainer.removeChild(this.bfData.viewport);
IFocusService(Main.osgi.getService(IFocusService)).clearFocus(this.bfData.viewport);
this.bfData.guiContainer.stage.frameRate = MAX_FRAMERATE;
if(this.freeCameraController != null)
{
this.freeCameraController.deactivate();
}
Main.contentUILayer.visible = true;
this.setCameraTarget(null);
this.debugPanel = null;
for each(b in this.bfData.bonuses)
{
b.destroy();
b = null;
}
this.bfData.collisionDetector.destroy();
this.bfData.collisionDetector = null;
this.bfData.physicsScene._staticCD.destroy();
this.bfData.physicsScene._staticCD = null;
this.bfData.physicsScene.destroy();
this.bfData.physicsScene = null;
this.triggers = new Triggers();
this.bfData = null;
this.suicideIndicator = null;
bgService = IBackgroundService(Main.osgi.getService(IBackgroundService));
if(bgService != null)
{
bgService.drawBg();
}
var dumpService:IDumpService = IDumpService(Main.osgi.getService(IDumpService));
if(dumpService != null)
{
dumpService.unregisterDumper(this.dumperName);
}
var storageService:IStorageService = IStorageService(Main.osgi.getService(IStorageService));
storageService.getStorage().data.cameraHeight = this.followCameraController.cameraHeight;
var tankEventDispatcher:ITankEventDispatcher = ITankEventDispatcher(Main.osgi.getService(ITankEventDispatcher));
tankEventDispatcher.removeTankEventListener(TankEvent.KILLED,this);
tankEventDispatcher.removeTankEventListener(TankEvent.SPAWNED,this);
Main.contentUILayer.removeChild(this.messages);
Main.stage.removeEventListener(Event.RESIZE,this.onStageResize);
this.messages = null;
}
public function addGraphicEffect(effect:IGraphicEffect) : void
{
if(effect == null || this.bfData == null)
{
return;
}
this.bfData.graphicEffects[effect] = true;
effect.addToContainer(this.bfData.viewport.getMapContainer());
}
public function addSound3DEffect(effect:ISound3DEffect) : void
{
if(effect != null && !this.muteSound)
{
this._soundManager.addEffect(effect);
}
}
public function setLocalUser(clinetObject:ClientObject) : void
{
if(this.bfData == null)
{
return;
}
this.bfData.localUser = clinetObject;
}
public function addTank(tankData:TankData) : void
{
var i:int = 0;
this.bfData.tanks[tankData.tank] = tankData;
if(tankData.enabled)
{
Logger.debug("addTankToField()");
}
this.addTankToField(tankData);
if(this.plugins != null)
{
for(i = 0; i < this.pluginCount; i++)
{
IBattlefieldPlugin(this.plugins[i]).addUser(tankData.user);
}
}
if(tankData.local)
{
this.updatePanelUnlockCounter();
}
}
public function removeTank(tankData:TankData) : void
{
var i:int = 0;
if(this.bfData == null)
{
return;
}
if(this.bfData.activeTanks[tankData] != null)
{
this.removeTankFromField(tankData);
delete this.bfData.tanks[tankData.tank];
}
if(this.followCameraController.tank == tankData.tank)
{
this.followCameraController.deactivate();
if(this.spectatorMode)
{
this.freeCameraController.playerCamera.unfocus();
}
}
if(this.plugins != null)
{
for(i = 0; i < this.pluginCount; i++)
{
IBattlefieldPlugin(this.plugins[i]).removeUser(tankData.user);
}
}
}
public function onResize(e:Event) : void
{
if(this.bfData == null)
{
return;
}
var scrSize:Number = this.screenSize / this.screenSizeSteps;
var stage:Stage = this.bfData.guiContainer.stage;
var w:Number = stage.stageWidth;
var h:Number = stage.stageHeight;
var sw:int = w * scrSize;
var sh:int = h * scrSize;
this.bfData.viewport.resize(sw,sh);
this.bfData.viewport.x = 0.5 * (w - sw);
this.bfData.viewport.y = 0.5 * (h - sh);
var bgService:IBackgroundService = Main.osgi.getService(IBackgroundService) as IBackgroundService;
if(bgService != null)
{
bgService.drawBg(new Rectangle(0.5 * (w - sw),0.5 * (h - sh),sw,sh));
}
this.bfData.viewport.overlay.graphics.clear();
if(this.screenSize < this.screenSizeSteps)
{
this.border.draw(this.bfData.viewport.overlay.graphics,sw,sh);
}
this.suicideIndicator.x = sw >> 1;
this.suicideIndicator.y = sh >> 1;
}
public function getWidth() : int
{
if(this.bfData.viewport.stage == null)
{
return 1;
}
return this.bfData.viewport.stage.stageWidth * this.screenSize / this.screenSizeSteps;
}
public function getHeight() : int
{
if(this.bfData.viewport.stage == null)
{
return 1;
}
return this.bfData.viewport.stage.stageHeight * this.screenSize / this.screenSizeSteps;
}
public function getDiagonalSquared() : Number
{
return this.getHeight() * this.getHeight() + this.getWidth() * this.getWidth();
}
public function getObjectPool() : ObjectPool
{
return this.objectPoolService.objectPool;
}
public function initFlyCamera(pivotPosition:Vector3, targetDirection:Vector3) : void
{
if(this.activeCameraController == this.freeCameraController)
{
return;
}
this.followCameraController.deactivate();
this.followCameraController.getCameraState(pivotPosition,targetDirection,this.cameraPosition,this.cameraAngles);
this.flyCameraController.init(this.cameraPosition,this.cameraAngles,CAMERA_FLY_TIME);
this.activeCameraController = this.flyCameraController;
}
public function initFollowCamera(pivotPosition:Vector3, targetDirection:Vector3) : void
{
this.followCameraController.activate();
this.followCameraController.setLocked(true);
this.followCameraController.initByTarget(pivotPosition,targetDirection);
this.activeCameraController = this.followCameraController;
this.incCameraUnlockCounter();
}
public function initCameraController(controller:ICameraController) : void
{
this.followCameraController.deactivate();
this.activeCameraController = controller;
TankModel(this.tankInterface).lockControls(true);
}
public function resetFollowCamera() : void
{
if(this.bfData != null && this.bfData.viewport != null)
{
this.bfData.viewport.camera.rotationY = 0;
this.followCameraController.initCameraComponents();
}
}
public function activateFollowCamera() : void
{
this.followCameraController.activate();
this.followCameraController.setLocked(false);
this.activeCameraController = this.followCameraController;
TankModel(this.tankInterface).lockControls(false);
}
public function activateSpectatorCamera() : void
{
if(this.activeCameraController == this.followCameraController)
{
this.followCameraController.deactivate();
}
this.activeCameraController = this.freeCameraController;
this.freeCameraController.activate();
this.freeCameraController.setPositionFromCamera();
TankModel(this.tankInterface).lockControls(true);
}
private function toggleFreeCamera() : void
{
if(this.activeCameraController != this.freeCameraController)
{
if(this.activeCameraController == this.followCameraController)
{
this.followCameraController.deactivate();
}
this.activeCameraController = this.freeCameraController;
this.freeCameraController.activate();
TankModel(this.tankInterface).lockControls(true);
}
else
{
this.freeCameraController.deactivate();
this.followCameraController.activate();
this.followCameraController.setLocked(false);
this.activeCameraController = this.followCameraController;
TankModel(this.tankInterface).lockControls(false);
}
}
public function setCameraTarget(tank:Tank) : void
{
this.followCameraController.tank = tank;
}
public function showSuicideIndicator(time:int) : void
{
this.suicideIndicator.show(time);
}
public function hideSuicideIndicator() : void
{
this.suicideIndicator.visible = false;
}
public function getRespawnInvulnerabilityPeriod() : int
{
return this.getBattlefieldData().respawnInvulnerabilityPeriod;
}
public function removeTankFromField(tankData:TankData) : void
{
var i:int = 0;
if(this.bfData.activeTanks[tankData] == null)
{
return;
}
delete this.bfData.activeTanks[tankData];
tankData.logEvent("Removed from field");
tankData.tank.removeFromContainer();
this.bfData.physicsScene.removeBody(tankData.tank);
this.bfData.collisionDetector.removeBody(tankData.tank);
this.tankInterface.stop(tankData);
this._soundManager.removeEffect(tankData.sounds);
if(this.plugins != null)
{
for(i = 0; i < this.pluginCount; i++)
{
IBattlefieldPlugin(this.plugins[i]).removeUserFromField(tankData.user);
}
}
if(this.followCameraController.tank == tankData.tank)
{
this.followCameraController.deactivate();
}
}
public function considerBodies(body1:Body, body2:Body) : Boolean
{
var tankData:TankData = null;
if(body1.postCollisionPredicate != null && body2.postCollisionPredicate == null)
{
tankData = this.bfData.tanks[body1];
++tankData.tankCollisionCount;
}
else if(body1.postCollisionPredicate == null && body2.postCollisionPredicate != null)
{
tankData = this.bfData.tanks[body2];
++tankData.tankCollisionCount;
}
return false;
}
public function printDebugValue(valueName:String, value:String) : void
{
this.debugPanel.printValue(valueName,value);
}
public function addPlugin(plugin:IBattlefieldPlugin) : void
{
if(this.plugins == null)
{
this.plugins = new Vector.<IBattlefieldPlugin>();
}
if(this.plugins.indexOf(plugin) < 0)
{
var _loc2_:* = this.pluginCount++;
this.plugins[_loc2_] = plugin;
}
}
public function removePlugin(plugin:IBattlefieldPlugin) : void
{
var idx:int = 0;
if(this.plugins != null)
{
idx = this.plugins.indexOf(plugin);
if(idx > -1)
{
this.plugins.splice(idx,1);
--this.pluginCount;
}
}
}
public function get soundManager() : ISoundManager
{
return this._soundManager;
}
public function tankHit(tankData:TankData, direction:Vector3, power:Number) : void
{
}
public function get dumperName() : String
{
return "currbattle";
}
public function dump(params:Vector.<String>) : String
{
var tankData:TankData = null;
var plugin:IBattlefieldPlugin = null;
var active:Boolean = false;
if(this.bfData == null)
{
return "";
}
var str:String = "=== BattlefieldModel dump ===\n";
if(this.plugins != null && this.pluginCount > 0)
{
str += "Plugins list:\n";
for each(plugin in this.plugins)
{
str += " " + plugin.battlefieldPluginName + "\n";
}
str += "End of plugins list\n";
}
str += "Tanks list:\n";
var counter:int = 0;
for each(tankData in this.bfData.tanks)
{
active = this.bfData.activeTanks[tankData] != null;
str += "--- Tank " + counter++ + " ---\n" + "active=" + active + "\n" + tankData.toString() + "\n";
}
str += "End of tanks list\n";
return str + "=== End BattlefieldModel dump ===\n";
}
public function handleTankEvent(eventType:int, tankData:TankData) : void
{
switch(eventType)
{
case TankEvent.SPAWNED:
this.spawnTank(tankData);
break;
case TankEvent.KILLED:
this.killTank(tankData);
}
}
public function addFollowCameraModifier(modifier:ICameraStateModifier) : void
{
this.followCameraController.addModifier(modifier);
}
public function setMuteSound(mute:Boolean) : void
{
var settings:IBattleSettings = null;
var key:* = undefined;
if(this.bfData == null)
{
return;
}
this.muteSound = mute;
if(mute)
{
this._soundManager.stopAllSounds();
this._soundManager.removeAllEffects();
this.bfData.ambientChannel = null;
}
else
{
settings = this.getBattleSettings();
if(settings.bgSound)
{
this.bfData.ambientChannel = this._soundManager.playSound(this.bfData.ambientSound,0,1000000,new SoundTransform(0.5));
}
for(key in this.bfData.activeTanks)
{
this._soundManager.addEffect(TankData(key).sounds);
}
}
}
private function spawnTank(tankData:TankData) : void
{
Logger.debug("spawnTank(" + this.bfData.activeTanks[tankData] + ")");
if(this.bfData.activeTanks[tankData] != null)
{
return;
}
this.addTankToField(tankData);
this._soundManager.addEffect(tankData.sounds);
}
private function killTank(tankData:TankData) : void
{
var key:* = undefined;
var effect:* = null;
var sound3D:Sound3D = null;
var turretMesh:Mesh = null;
this._soundManager.removeEffect(tankData.sounds);
this._soundManager.killEffectsByOwner(tankData.user);
for(effect in this.bfData.graphicEffects)
{
if(effect.owner == tankData.user)
{
effect.kill();
}
}
if(this.bfData.killSound != null)
{
sound3D = Sound3D.create(this.bfData.killSound,SoundOptions.nearRadius,SoundOptions.farRadius,SoundOptions.farDelimiter,this.tankExplosionVolume.value);
turretMesh = tankData.tank.skin.turretMesh;
this.addSound3DEffect(Sound3DEffect.create(this.objectPoolService.objectPool,null,new Vector3(turretMesh.x,turretMesh.y,turretMesh.z),sound3D,0,this.tankExplosionStartPosition.value));
}
if(this.followCameraController.tank == tankData.tank)
{
this.followCameraController.setLocked(true);
}
}
private function initSounds(battlefieldSoundScheme:BattlefieldSoundScheme) : void
{
this.bfData.ambientSound = ResourceUtil.getResource(ResourceType.SOUND,battlefieldSoundScheme.ambientSound).sound as Sound;
this.bfData.bonusTakenSound = ResourceUtil.getResource(ResourceType.SOUND,"bonusTakenSound").sound as Sound;
this.bfData.battleFinishSound = ResourceUtil.getResource(ResourceType.SOUND,"battleFinishSound").sound as Sound;
this.bfData.killSound = ResourceUtil.getResource(ResourceType.SOUND,"killSound").sound as Sound;
}
private function initPhysicsAndViewport() : void
{
var physics:PhysicsScene = new PhysicsScene();
this.bfData.physicsScene = physics;
physics.usePrediction = true;
if(this.gameMode == GameModes.SPACE)
{
if(this.mapResourceId == "map_silence_space")
{
physics.gravity = new Vector3(0,0,-450);
}
else if(this.mapResourceId == "map_satellite")
{
physics.gravity = new Vector3(0,0,-450);
}
else
{
physics.gravity = new Vector3(0,0,-300);
}
}
else
{
physics.gravity = new Vector3(0,0,-1000);
}
physics.collisionIterations = 3;
physics.contactIterations = 3;
physics.maxPenResolutionSpeed = 100;
physics.allowedPenetration = 5;
physics.collisionDetector = this.bfData.collisionDetector = new TanksCollisionDetector();
this.fadingDecalRenderer = new FadingDecalsRenderer(DECAL_FADING_TIME_MS,this);
this.bfData.viewport = new BattleView3D(this.debugMode,this.bfData.collisionDetector,this);
this.shadows = new BattleShadow(this.bfData.viewport);
this.shadows.on();
this.bfData.guiContainer.addChild(this.bfData.viewport);
this.dusts = new Dust(this);
if(this.mapResourceId.indexOf("_winter") != -1)
{
this.dusts.init(new SNOW_DUST_DATA().bitmapData,7000,5000,180,0.75,0.15);
}
else
{
this.dusts.init(new DUST_DATA().bitmapData,7000,5000,180,0.75,0.15);
}
this.suicideIndicator = new SuicideIndicator();
this.bfData.viewport.addChild(this.suicideIndicator);
Main.stage.focus = this.bfData.viewport;
this.cameraUnlockCounter = 0;
this.doRender = false;
this.debugPanel = new DebugPanel();
this.debugPanel.visible = false;
this.followCameraController = new FollowCameraController(Main.stage,this.bfData.collisionDetector,this.bfData.viewport.camera,CollisionGroup.CAMERA);
this.flyCameraController = new FlyCameraController(this.bfData.viewport.camera);
this.freeCameraController = new SpectatorCameraController(this.bfData.viewport.camera);
var settings:IBattleSettings = this.getBattleSettings();
FollowCameraController(this.followCameraController).setDefaultSettings();
var storage:IStorageService = Main.osgi.getService(IStorageService) as IStorageService;
this.screenSize = storage.getStorage().data.screenSize;
if(this.screenSize == 0)
{
this.screenSize = this.screenSizeSteps;
}
var cameraHeight:int = storage.getStorage().data.cameraHeight;
if(cameraHeight != 0)
{
this.followCameraController.cameraHeight = cameraHeight;
}
this.decalFactory = new DecalFactory(this.bfData.collisionDetector);
var stage:Stage = this.bfData.guiContainer.stage;
var w:Number = stage.stageWidth * this.screenSize;
var h:Number = stage.stageHeight * this.screenSize;
this.bfData.viewport.resize(w,h);
Logger.debug("initPhysicsAndViewport()");
}
public function addTrigger(trigger:Trigger) : void
{
this.triggers.add(trigger);
}
public function removeTrigger(trigger:Trigger) : void
{
this.triggers.remove(trigger);
}
private function initMap(mapResourceId:String, skyboxId:String) : void
{
var toLoad:Vector.<String> = new Vector.<String>();
toLoad.push(skyboxId + "_1");
toLoad.push(skyboxId + "_2");
toLoad.push(skyboxId + "_3");
toLoad.push(skyboxId + "_4");
toLoad.push(skyboxId + "_5");
toLoad.push(skyboxId + "_6");
toLoad.push("bonus_box_details");
toLoad.push("bonus_box_lightmap");
ResourceUtil.addEventListener(function():void
{
bfData.skybox = createSkyBox(skyboxId);
bfData.viewport.setSkyBox(bfData.skybox);
mapResourceId = mapResourceId;
config = new Config();
config.load("mapsLibrary.json",mapResourceId);
});
ResourceUtil.loadGraphics(toLoad);
}
public function getConfig() : Config
{
return this.config;
}
public function removeDecal(param1:Decal) : void
{
this.bfData.viewport.removeDecal(param1);
}
public function addDecal(param1:Vector3, param2:Vector3, param3:Number, param4:TextureMaterial, param5:RotationState = null, param6:Boolean = false) : void
{
this.bfData.viewport.addDecal(param1,param2,param3,param4,param5,param6);
}
public function build(mapTree:KDContainer, c:Vector.<CollisionPrimitive>, lights:Vector.<Light3D>, lighting:Vector.<ToyLightAnimation> = null) : void
{
this.lightings = lighting;
this.bfData.viewport._mapContainer = mapTree;
this.bfData.viewport.initLights(lights);
this.collisionDetector = TanksCollisionDetector(this.bfData.physicsScene.collisionDetector);
this.collisionDetector.buildKdTree(c);
this.onMapBuildingComplete(null);
}
private function createSkyBox(skyboxId:String) : SkyBox
{
var obj:Object = ResourceUtil.getResource(ResourceType.IMAGE,skyboxId + "_1");
var part1:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,skyboxId + "_1").bitmapData;
var part2:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,skyboxId + "_2").bitmapData;
var part3:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,skyboxId + "_3").bitmapData;
var part4:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,skyboxId + "_4").bitmapData;
var part5:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,skyboxId + "_5").bitmapData;
var part6:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,skyboxId + "_6").bitmapData;
var skyBox:SkyBox = new SkyBox(200000,new TextureMaterial(part1),new TextureMaterial(part2),new TextureMaterial(part3),new TextureMaterial(part4),new TextureMaterial(part5),new TextureMaterial(part6),0);
this.skyboxRevolver = new Object3DRevolver(skyBox,new Vector3(10,3,0),this.gameMode == GameModes.SPACE ? Number(0.04) : Number(0));
return skyBox;
}
public function raycast(param1:Vector3, param2:Vector3, param3:Dictionary, param4:Camera3D = null) : RayIntersectionData
{
var _loc6_:Object3D = null;
copyToVector3D(param1,_origin3D);
copyToVector3D(param2,_direction3D);
var _loc5_:RayIntersectionData = this.bfData.viewport._mapContainer.intersectRay(_origin3D,_direction3D,param3,param4);
if(_loc5_)
{
_loc6_ = _loc5_.object;
while(_loc6_ != null && !_loc6_.mouseEnabled)
{
_loc6_ = _loc6_.parent;
}
_loc5_.object = _loc6_;
}
return _loc5_;
}
private function onMapBuildingComplete(e:Event) : void
{
this.gui = Main.osgi.getService(IBattlefieldGUI) as IBattlefieldGUI;
this.doRender = true;
this.incCameraUnlockCounter();
this.updatePanelUnlockCounter();
if(this.gameMode != null)
{
this.gameMode.applyChanges(this.bfData.viewport);
}
this.objectLoaded(null);
}
private function addMainListeners() : void
{
if(this.bfData == null)
{
return;
}
this.bfData.guiContainer.addEventListener(Event.ENTER_FRAME,this.loop);
this.bfData.guiContainer.stage.addEventListener(Event.RESIZE,this.onResize);
}
private function removeMainListeners() : void
{
if(this.bfData == null)
{
return;
}
this.bfData.guiContainer.removeEventListener(Event.ENTER_FRAME,this.loop);
this.bfData.guiContainer.stage.removeEventListener(Event.RESIZE,this.onResize);
}
private function addKeyboardListeners() : void
{
if(this.bfData == null)
{
return;
}
this.bfData.guiContainer.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.onKey);
this.bfData.guiContainer.stage.addEventListener(KeyboardEvent.KEY_UP,this.onKey);
}
private function removeKeyboardListeners() : void
{
if(this.bfData == null)
{
return;
}
this.bfData.guiContainer.stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKey);
this.bfData.guiContainer.stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKey);
}
private function updateTimeStat(delta:int, stat:TimeStatistics, timeMessage:String, fpsMessage:String) : void
{
stat.timeAccum += delta;
if(++stat.stepCounter >= stat.numSteps)
{
stat.avrgTime = stat.timeAccum / stat.stepCounter;
stat.avrgFps = 1000 / stat.avrgTime;
stat.stepCounter = 0;
stat.timeAccum = 0;
if(this.debugPanel.visible)
{
this.debugPanel.printValue(timeMessage,stat.avrgTime.toFixed(2));
this.debugPanel.printValue(fpsMessage,stat.avrgFps.toFixed(2));
}
}
}
private function loop(e:Event) : void
{
var la:ToyLightAnimation = null;
var fps:Number = NaN;
var i:int = 0;
var runningTime:int = 0;
var t1:int = getTimer();
var deltaMsec:int = t1 - this.bfData.time;
this.bfData.time = t1;
if(deltaMsec <= 0)
{
return;
}
this.deltaSec = 0.001 * deltaMsec;
if(this.adaptiveFpsEnabled)
{
if(++this.adaptiveFrameCounter == ADAPTIVE_FPS_CHANGE_INTERVAL)
{
this.adaptiveFrameCounter = 0;
if(this.fullTimeStat.avrgFps < Main.stage.frameRate - 1)
{
Main.stage.frameRate = this.fullTimeStat.avrgFps < MIN_FRAMERATE ? Number(Number(MIN_FRAMERATE)) : Number(Number(this.fullTimeStat.avrgFps));
}
else
{
fps = Main.stage.frameRate + 1;
Main.stage.frameRate = fps > MAX_FRAMERATE ? Number(Number(MAX_FRAMERATE)) : Number(Number(fps));
}
if(this.debugPanel.visible)
{
this.debugPanel.printValue("Stage frame rate",Main.stage.frameRate.toFixed(2));
}
}
}
t1 = getTimer();
if(this.updatePhysics)
{
this.runPhysics(PHYSICS_STEP_MILLIS);
}
var t2:int = getTimer();
this.physicsTime += t2 - t1;
t1 = t2;
if(this.activeCameraController != null)
{
this.activeCameraController.update(this.bfData.time,deltaMsec);
}
this.bfData.viewport.camera.calculateAdditionalData();
var t:Number = 1 - (this.bfData.physTime - this.bfData.time) / PHYSICS_STEP_MILLIS;
this.updateTanks(this.bfData.time,deltaMsec,this.deltaSec,t);
if(this.plugins != null)
{
for(i = 0; i < this.pluginCount; i++)
{
IBattlefieldPlugin(this.plugins[i]).tick(this.bfData.time,deltaMsec,this.deltaSec,t);
}
}
for each(la in this.lightings)
{
la.update();
}
this.lastLogicUnitsUpdate = this.bfData.physTime - this.lastLogicUnitsUpdate;
this.logicUnits.update(this.bfData.physTime,deltaMsec);
this.fadingDecalRenderer.render(getTimer(),deltaMsec);
if(this.hidableObjects.isEnabled())
{
this.hidableObjects.render(getTimer(),deltaMsec);
}
if(this.skyboxRevolver != null)
{
this.skyboxRevolver.render(this.bfData.physTime,deltaMsec);
}
this.playSpecialEffects(deltaMsec);
this.updateBonuses(this.bfData.time,deltaMsec,t);
deltaMsec = getTimer() - this.bfData.time;
t2 = getTimer();
this.logicTime += t2 - t1;
t1 = t2;
if(this.doRender)
{
this.bfData.viewport.update();
}
this.dusts.update();
if(this.debugPanel.visible)
{
runningTime = getTimer() - this.startTime;
this.debugPanel.printValue("Running time",runningTime);
this.debugPanel.printValue("Physics time",this.physicsTime,":",Number(this.physicsTime / runningTime).toFixed(4));
this.debugPanel.printValue("Logic time",this.logicTime,":",Number(this.logicTime / runningTime).toFixed(4));
this.debugPanel.printValue("A3D render time",this.a3dRenderTime,":",Number(this.a3dRenderTime / runningTime).toFixed(4));
}
this.messages.update(deltaMsec * 10);
}
private function onAlertButtonPressed(e:Event) : void
{
var spaceService:ISpaceService = null;
var panelObjectId:String = null;
var spaceInfo:SpaceInfo = null;
if(this.debugMode)
{
spaceService = ISpaceService(Main.osgi.getService(ISpaceService));
panelObjectId = "aaa";
spaceInfo = spaceService.getSpaceByObjectId(panelObjectId);
}
var addressService:IAddressService = IAddressService(Main.osgi.getService(IAddressService));
if(addressService != null)
{
addressService.reload();
}
}
private function runPhysics(dt:int) : void
{
var key:* = undefined;
var tankData:* = null;
var time:int = 0;
if(this.bfData.time - this.bfData.physTime > MAX_FRAME_TIME)
{
this.bfData.physTime = this.bfData.time - MAX_FRAME_TIME;
}
if(this.bfData.physTime < this.bfData.time)
{
for(tankData in this.bfData.activeTanks)
{
tankData.tankCollisionCount = 0;
}
while(this.bfData.physTime < this.bfData.time)
{
time = getTimer();
this.bfData.physicsScene.update(dt);
this.bfData.physTime += dt;
this.updateTimeStat(getTimer() - time,this.physicsTimeStat,"Physics avrg time","Physics avrg fps");
if(TankData.localTankData != null && TankData.localTankData.tank != null)
{
this.triggers.check(TankData.localTankData.tank);
}
}
}
}
private function updateTanks(time:int, deltaMillis:int, deltaSec:Number, t:Number) : void
{
var key:* = undefined;
var localTankData:TankData = null;
var camPos:Vector3 = this.bfData.viewport.camera.pos;
for(key in this.bfData.activeTanks)
{
this.tankInterface.update(key as TankData,time,deltaMillis,deltaSec,t,camPos);
}
if(this.bfData.localUser != null)
{
localTankData = this.tankInterface.getTankData(this.bfData.localUser);
if(this.bfData.activeTanks[localTankData] == null)
{
this.tankInterface.update(localTankData,time,deltaMillis,deltaSec,t,camPos);
}
}
}
private function playSpecialEffects(dt:int) : void
{
var camera:GameCamera = this.bfData.viewport.camera;
var effect:ISpecialEffect;
for(var key:* in this.bfData.graphicEffects)
{
effect = key;
if(!effect.play(dt,camera))
{
effect.destroy();
delete this.bfData.graphicEffects[key];
}
}
if(!this.muteSound)
{
this._soundManager.updateSoundEffects(dt,camera);
}
}
private function updateBonuses(time:int, dt:int, t:Number) : void
{
var key:* = undefined;
var bonus:IBonus = null;
for(key in this.bfData.bonuses)
{
bonus = this.bfData.bonuses[key];
if(!bonus.update(time,dt,t))
{
bonus.destroy();
delete this.bfData.bonuses[key];
}
}
}
private function addTankToField(tankData:TankData) : void
{
var skin:TankSkin = null;
var i:int = 0;
Logger.debug("addTankToField()");
try
{
if(this.bfData.activeTanks[tankData] != null)
{
return;
}
this.bfData.activeTanks[tankData] = true;
tankData.tank.addToContainer(this.bfData.viewport.getMapContainer());
tankData.tank.updateSkin(1);
tankData.tank.setAnimationTracks(this.animatedTracks);
tankData.logEvent("Added to field");
this.bfData.physicsScene.addBody(tankData.tank);
this.bfData.collisionDetector.addBody(tankData.tank);
this._soundManager.addEffect(tankData.sounds);
if(this.plugins != null)
{
for(i = 0; i < this.pluginCount; i++)
{
IBattlefieldPlugin(this.plugins[i]).addUserToField(tankData.user);
}
}
if(tankData.tank == this.followCameraController.tank && this.activeCameraController != this.freeCameraController)
{
this.followCameraController.activate();
this.followCameraController.setLocked(false);
this.followCameraController.initCameraComponents();
this.activeCameraController = this.followCameraController;
}
this.dusts.addTank(tankData);
skin = tankData.tank.skin;
this.objects2tank[skin.turretMesh] = tankData.tank;
this.objects2tank[skin.hullMesh] = tankData.tank;
Logger.debug("addTankToField() passed");
}
catch(e:Error)
{
(Main.osgi.getService(IConsole) as IConsole).addLine(e.getStackTrace());
Logger.warn("addTankToField() failed: " + e.getStackTrace());
}
}
private function onKey(e:KeyboardEvent) : void
{
this.tankInterface.resetIdleTimer(false);
if(e.type == KeyboardEvent.KEY_DOWN)
{
this.handleKeyDown(e);
}
}
public function cheatDetected() : void
{
Network(Main.osgi.getService(INetworker)).send("battle;speedhack_detected");
}
private function handleKeyDown(e:KeyboardEvent) : void
{
var tankData:TankData = null;
var camera:Camera3D = null;
switch(e.keyCode)
{
case Keyboard.F5:
this.toggleTextureDebug();
break;
case Keyboard.F6:
FollowCameraController.effectsEnabled = !FollowCameraController.effectsEnabled;
this.gui.logUserAction(null,"Camera effects " + (!!FollowCameraController.effectsEnabled ? "enabled" : "disabled"));
break;
case Keyboard.NUMPAD_ADD:
case 187:
this.setScreenSize(this.screenSize + 1);
break;
case Keyboard.NUMPAD_SUBTRACT:
case 189:
this.setScreenSize(this.screenSize - 1);
break;
case 66:
if(this.debugMode)
{
if(e.ctrlKey && this.bfData != null)
{
for each(tankData in this.bfData.tanks)
{
tankData.tank.showCollisionGeometry = !tankData.tank.showCollisionGeometry;
}
camera = this.bfData.viewport.camera;
camera.debug = !camera.debug;
}
}
}
}
public function isEnableDamageUpEffect() : Boolean
{
return this.getBattleSettings().animationDamage;
}
private function toggleTextureDebug() : Boolean
{
var storage:SharedObject = IStorageService(Main.osgi.getService(IStorageService)).getStorage();
var textureDebug:Boolean = storage.data.textureDebug1;
storage.data.textureDebug1 = !textureDebug;
storage.flush();
return !textureDebug;
}
private function toggleAmbientSound() : void
{
if(this.bfData.ambientChannel != null)
{
this._soundManager.stopSound(this.bfData.ambientChannel);
this.bfData.ambientChannel = null;
}
else
{
this.bfData.ambientChannel = this._soundManager.playSound(this.bfData.ambientSound,0,100000,new SoundTransform(0.5));
}
}
private function setScreenSize(size:int) : void
{
this.screenSize = size > this.screenSizeSteps ? int(int(this.screenSizeSteps)) : (size < 1 ? int(int(1)) : int(int(size)));
var storage:IStorageService = Main.osgi.getService(IStorageService) as IStorageService;
storage.getStorage().data.screenSize = this.screenSize;
this.onResize(null);
}
private function createBonusAndAttach(objectRegister:ObjectRegister, bonusId:String, bonusObjectId:String, position:Vector3d, livingTime:int, isFalling:Boolean, clientObject:ClientObject, disappearingTime:int = 21) : IBonus
{
var bonusObject:ClientObject = clientObject;
if(bonusObject == null)
{
return null;
}
var bonusModel:BonusCommonModel = new BonusCommonModel();
bonusModel.initObject(clientObject,"bonus_box_" + bonusId.split("_")[0],"cords",disappearingTime,"parachute_inner","parachute");
var bonus:IBonus = bonusModel.getBonus(bonusObject,bonusId,livingTime,isFalling);
if(this.bfData == null || this.bfData.bonuses == null)
{
bonus.destroy();
return null;
}
this.bfData.bonuses[bonus.bonusId] = bonus;
bonus.attach(new Vector3(position.x,position.y,position.z),this.bfData.physicsScene,this.bfData.viewport.getMapContainer(),this);
return bonus;
}
private function set adaptiveFPS(value:Boolean) : void
{
if(this.adaptiveFpsEnabled == value)
{
return;
}
this.adaptiveFpsEnabled = value;
if(!this.adaptiveFpsEnabled)
{
this.bfData.guiContainer.stage.frameRate = MAX_FRAMERATE;
}
}
private function getBattleSettings() : IBattleSettings
{
return IBattleSettings(Main.osgi.getService(IBattleSettings));
}
private function changeUILockCount(delta:int) : void
{
this.uiLockCount += delta;
if(this.uiLockCount < 0)
{
this.uiLockCount = 0;
}
}
private function incCameraUnlockCounter() : void
{
this.cameraUnlockCounter += 1;
if(this.cameraUnlockCounter == 2)
{
this.doRender = true;
}
}
private function updatePanelUnlockCounter() : void
{
var modelService:IModelService = null;
var panelModel:IPanel = null;
if(this.panelUnlockCounter == 0)
{
return;
}
--this.panelUnlockCounter;
if(this.panelUnlockCounter == 0)
{
modelService = IModelService(Main.osgi.getService(IModelService));
panelModel = IPanel(modelService.getModelsByInterface(IPanel)[0]);
panelModel.partSelected(4);
}
}
private function onToggleTextureDebug(console:IConsole, params:Array) : void
{
if(this.toggleTextureDebug())
{
console.addLine("Debug textures enabled");
}
else
{
console.addLine("Debug textures disabled");
}
}
}
}
class TimeStatistics
{
public var timeAccum:Number = 0;
public var stepCounter:int;
public var numSteps:int = 10;
public var avrgTime:Number = 0;
public var avrgFps:Number = 100;
function TimeStatistics()
{
super();
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.ricochet {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.weapon.ricochet.RicochetCC;
public class VectorCodecRicochetCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRicochetCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(RicochetCC,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.<RicochetCC> = new Vector.<RicochetCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = RicochetCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:RicochetCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<RicochetCC> = Vector.<RicochetCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package controls.containers {
import flash.display.DisplayObject;
public class HorizontalStackPanel extends StackPanel {
public function HorizontalStackPanel() {
super();
}
override protected function increaseContainerSize(param1:DisplayObject) : void {
var local5:int = 0;
if(items.length < 2) {
height = param1.y + int(param1.height);
width = param1.x + fixWidth(param1);
return;
}
var local2:DisplayObject = items[items.length - 2];
var local3:int = fixWidth(local2);
var local4:int = fixWidth(param1);
local5 = param1.x;
param1.x = local2.x + local3 + getMargin() + local5;
height = Math.max(int(height),param1.y + int(param1.height));
width = local2.x + local3 + getMargin() + local5 + local4;
}
override protected function decreaseContainerSize(param1:int, param2:DisplayObject) : void {
if(param1 <= 0) {
width = 0;
height = 0;
return;
}
if(param1 == items.length) {
height = this.calculateMaxHeight();
width = items[items.length - 1].x - fixWidth(items[items.length - 1]);
return;
}
var local3:int = items[param1].x - param2.x;
var local4:int = param1;
while(local4 < items.length) {
items[local4].x -= local3;
local4++;
}
width = items[items.length - 1].x + fixWidth(items[items.length - 1]);
height = this.calculateMaxHeight();
}
private function calculateMaxHeight() : int {
var local2:DisplayObject = null;
var local1:int = 0;
for each(local2 in items) {
local1 = Math.max(local1,local2.y + local2.height);
}
return local1;
}
}
}
|
package projects.tanks.client.panel.model.shop.description {
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 ShopItemAdditionalDescriptionModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ShopItemAdditionalDescriptionModelServer;
private var client:IShopItemAdditionalDescriptionModelBase = IShopItemAdditionalDescriptionModelBase(this);
private var modelId:Long = Long.getLong(1818598309,-2022254470);
public function ShopItemAdditionalDescriptionModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ShopItemAdditionalDescriptionModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ShopItemAdditionalDescriptionCC,false)));
}
protected function getInitParam() : ShopItemAdditionalDescriptionCC {
return ShopItemAdditionalDescriptionCC(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.engine3d.objects {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Canvas;
import alternativa.engine3d.core.Clipping;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.core.VG;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.Material;
import flash.geom.Matrix;
import flash.geom.Point;
use namespace alternativa3d;
public class SkyBox extends Mesh {
public static const LEFT:String = "left";
public static const RIGHT:String = "right";
public static const BACK:String = "back";
public static const FRONT:String = "front";
public static const BOTTOM:String = "bottom";
public static const TOP:String = "top";
private var leftFace:Face;
private var rightFace:Face;
private var backFace:Face;
private var frontFace:Face;
private var bottomFace:Face;
private var topFace:Face;
public var autoSize:Boolean = true;
public function SkyBox(param1:Number, param2:Material = null, param3:Material = null, param4:Material = null, param5:Material = null, param6:Material = null, param7:Material = null, param8:Number = 0) {
super();
param1 *= 0.5;
var local9:Vertex = this.createVertex(-param1,-param1,param1,param8,param8);
var local10:Vertex = this.createVertex(-param1,-param1,-param1,param8,1 - param8);
var local11:Vertex = this.createVertex(-param1,param1,-param1,1 - param8,1 - param8);
var local12:Vertex = this.createVertex(-param1,param1,param1,1 - param8,param8);
this.leftFace = this.createQuad(local9,local10,local11,local12,param2);
local9 = this.createVertex(param1,param1,param1,param8,param8);
local10 = this.createVertex(param1,param1,-param1,param8,1 - param8);
local11 = this.createVertex(param1,-param1,-param1,1 - param8,1 - param8);
local12 = this.createVertex(param1,-param1,param1,1 - param8,param8);
this.rightFace = this.createQuad(local9,local10,local11,local12,param3);
local9 = this.createVertex(param1,-param1,param1,param8,param8);
local10 = this.createVertex(param1,-param1,-param1,param8,1 - param8);
local11 = this.createVertex(-param1,-param1,-param1,1 - param8,1 - param8);
local12 = this.createVertex(-param1,-param1,param1,1 - param8,param8);
this.backFace = this.createQuad(local9,local10,local11,local12,param4);
local9 = this.createVertex(-param1,param1,param1,param8,param8);
local10 = this.createVertex(-param1,param1,-param1,param8,1 - param8);
local11 = this.createVertex(param1,param1,-param1,1 - param8,1 - param8);
local12 = this.createVertex(param1,param1,param1,1 - param8,param8);
this.frontFace = this.createQuad(local9,local10,local11,local12,param5);
local9 = this.createVertex(-param1,param1,-param1,param8,param8);
local10 = this.createVertex(-param1,-param1,-param1,param8,1 - param8);
local11 = this.createVertex(param1,-param1,-param1,1 - param8,1 - param8);
local12 = this.createVertex(param1,param1,-param1,1 - param8,param8);
this.bottomFace = this.createQuad(local9,local10,local11,local12,param6);
local9 = this.createVertex(-param1,-param1,param1,param8,param8);
local10 = this.createVertex(-param1,param1,param1,param8,1 - param8);
local11 = this.createVertex(param1,param1,param1,1 - param8,1 - param8);
local12 = this.createVertex(param1,-param1,param1,1 - param8,param8);
this.topFace = this.createQuad(local9,local10,local11,local12,param7);
calculateBounds();
calculateFacesNormals(true);
clipping = Clipping.FACE_CLIPPING;
sorting = Sorting.NONE;
shadowMapAlphaThreshold = 100;
}
public function getSide(param1:String) : Face {
switch(param1) {
case LEFT:
return this.leftFace;
case RIGHT:
return this.rightFace;
case BACK:
return this.backFace;
case FRONT:
return this.frontFace;
case BOTTOM:
return this.bottomFace;
case TOP:
return this.topFace;
default:
return null;
}
}
public function transformUV(param1:String, param2:Matrix) : void {
var local4:Wrapper = null;
var local5:Vertex = null;
var local6:Point = null;
var local3:Face = this.getSide(param1);
if(local3 != null) {
local4 = local3.alternativa3d::wrapper;
while(local4 != null) {
local5 = local4.alternativa3d::vertex;
local6 = param2.transformPoint(new Point(local5.u,local5.v));
local5.u = local6.x;
local5.v = local6.y;
local4 = local4.alternativa3d::next;
}
}
}
override public function clone() : Object3D {
var local1:SkyBox = new SkyBox(0);
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
super.clonePropertiesFrom(param1);
var local2:SkyBox = param1 as SkyBox;
var local3:Face = local2.alternativa3d::faceList;
var local4:Face = alternativa3d::faceList;
while(local3 != null) {
if(local3 == local2.leftFace) {
this.leftFace = local4;
} else if(local3 == local2.rightFace) {
this.rightFace = local4;
} else if(local3 == local2.backFace) {
this.backFace = local4;
} else if(local3 == local2.frontFace) {
this.frontFace = local4;
} else if(local3 == local2.bottomFace) {
this.bottomFace = local4;
} else if(local3 == local2.topFace) {
this.topFace = local4;
}
local3 = local3.alternativa3d::next;
local4 = local4.alternativa3d::next;
}
}
private function createVertex(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number) : Vertex {
var local6:Vertex = new Vertex();
local6.alternativa3d::next = alternativa3d::vertexList;
alternativa3d::vertexList = local6;
local6.x = param1;
local6.y = param2;
local6.z = param3;
local6.u = param4;
local6.v = param5;
return local6;
}
private function createQuad(param1:Vertex, param2:Vertex, param3:Vertex, param4:Vertex, param5:Material) : Face {
var local6:Face = new Face();
local6.material = param5;
local6.alternativa3d::next = alternativa3d::faceList;
alternativa3d::faceList = local6;
local6.alternativa3d::wrapper = new Wrapper();
local6.alternativa3d::wrapper.alternativa3d::vertex = param1;
local6.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local6.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = param2;
local6.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local6.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param3;
local6.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::next = new Wrapper();
local6.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = param4;
return local6;
}
override alternativa3d function draw(param1:Camera3D, param2:Canvas) : void {
alternativa3d::culling &= ~3;
super.alternativa3d::draw(param1,param2);
}
override alternativa3d function getVG(param1:Camera3D) : VG {
alternativa3d::culling &= ~3;
return super.alternativa3d::getVG(param1);
}
}
}
|
package alternativa.tanks.gui.friends.list.renderer.background {
import controls.cellrenderer.ButtonState;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Graphics;
public class UserOfflineCellSelected extends ButtonState {
private static var leftIconClass:Class = UserOfflineCellSelected_leftIconClass;
private static var leftIconBitmapData:BitmapData = Bitmap(new leftIconClass()).bitmapData;
private static var centerIconClass:Class = UserOfflineCellSelected_centerIconClass;
private static var centerIconBitmapData:BitmapData = Bitmap(new centerIconClass()).bitmapData;
private static var rightIconClass:Class = UserOfflineCellSelected_rightIconClass;
private static var rightIconBitmapData:BitmapData = Bitmap(new rightIconClass()).bitmapData;
public function UserOfflineCellSelected() {
super();
bmpLeft = leftIconBitmapData;
bmpCenter = centerIconBitmapData;
bmpRight = rightIconBitmapData;
}
override public function draw() : void {
var local1:Graphics = null;
local1 = l.graphics;
local1.clear();
local1.beginBitmapFill(bmpLeft);
local1.drawRect(0,0,5,20);
local1.endFill();
l.x = 0;
l.y = 1;
local1 = c.graphics;
local1.clear();
local1.beginBitmapFill(bmpCenter);
local1.drawRect(0,0,_width - 10,20);
local1.endFill();
c.x = 5;
c.y = 1;
local1 = r.graphics;
local1.clear();
local1.beginBitmapFill(bmpRight);
local1.drawRect(0,0,5,20);
local1.endFill();
r.x = _width - 5;
r.y = 1;
}
}
}
|
package _codec.projects.tanks.client.panel.model.quest.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.TypeCodecInfo;
import alternativa.types.Long;
import projects.tanks.client.panel.model.quest.showing.QuestPrizeInfo;
public class CodecQuestPrizeInfo implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_count:ICodec;
private var codec_name:ICodec;
private var codec_prizeObject:ICodec;
public function CodecQuestPrizeInfo() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_count = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_prizeObject = param1.getCodec(new TypeCodecInfo(Long,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:QuestPrizeInfo = new QuestPrizeInfo();
local2.count = this.codec_count.decode(param1) as int;
local2.name = this.codec_name.decode(param1) as String;
local2.prizeObject = this.codec_prizeObject.decode(param1) as Long;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:QuestPrizeInfo = QuestPrizeInfo(param2);
this.codec_count.encode(param1,local3.count);
this.codec_name.encode(param1,local3.name);
this.codec_prizeObject.encode(param1,local3.prizeObject);
}
}
}
|
package alternativa.resource
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Clipping;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.loaders.Parser3DS;
import alternativa.engine3d.loaders.events.LoaderProgressEvent;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.resource.loaders.BatchTextureLoader;
import alternativa.resource.loaders.TextureInfo;
import alternativa.resource.loaders.events.BatchTextureLoaderErrorEvent;
import flash.display.BitmapData;
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLLoader;
import flash.net.URLLoaderDataFormat;
import flash.net.URLRequest;
public class Tanks3DSResource extends Resource
{
public static const TYPE:int = 9;
private static const LOADING_STATE_TEXTURE_INFO:int = LOADING_STATE_INFO + 1;
private static const LOADING_STATE_TEXTURES:int = LOADING_STATE_INFO + 2;
private static const LOADING_STATE_3DS:int = LOADING_STATE_INFO + 3;
private static const IMAGES_FILE:String = "images.xml";
private static const MODEL_FILE:String = "object.3ds";
public var textures:Object;
public var objects:Vector.<Object3D>;
private var loader:URLLoader;
private var infoLoader:URLLoader;
private var batchTextureLoader:BatchTextureLoader;
public function Tanks3DSResource()
{
super("Танковый ресурс 3DS",false);
}
public function getTextureForObject(objectIdx:int) : BitmapData
{
var mesh:Mesh = this.objects[objectIdx] as Mesh;
if(mesh == null || mesh.alternativa3d::faceList == null)
{
return null;
}
var material:TextureMaterial = mesh.alternativa3d::faceList.material as TextureMaterial;
if(material == null)
{
return null;
}
return this.textures[material.diffuseMapURL];
}
public function getObjectsByName(pattern:RegExp) : Vector.<Object3D>
{
var object:Object3D = null;
var res:Vector.<Object3D> = null;
var len:int = this.objects.length;
for(var i:int = 0; i < len; i++)
{
object = this.objects[i];
if(object.name != null && object.name.match(pattern) != null)
{
if(res == null)
{
res = new Vector.<Object3D>();
}
res.push(object);
}
}
return res;
}
override protected function doClose() : void
{
switch(loadingState)
{
case LOADING_STATE_TEXTURE_INFO:
this.infoLoader.close();
this.destroyInfoLoader();
break;
case LOADING_STATE_TEXTURES:
this.batchTextureLoader.close();
break;
case LOADING_STATE_3DS:
this.loader.close();
}
this.textures = null;
this.batchTextureLoader = null;
this.loader = null;
}
override protected function doUnload() : void
{
var bitmapData:BitmapData = null;
if(this.textures != null)
{
for each(bitmapData in this.textures)
{
bitmapData.dispose();
}
}
}
override protected function loadResourceData() : void
{
this.infoLoader = new URLLoader();
this.infoLoader.addEventListener(Event.OPEN,this.onImagesXMLLoadingOpen);
this.infoLoader.addEventListener(ProgressEvent.PROGRESS,this.onProgress);
this.infoLoader.addEventListener(Event.COMPLETE,this.onImagesXMLLoadingComplete);
this.infoLoader.addEventListener(IOErrorEvent.IO_ERROR,this.onFatalError);
this.infoLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onFatalError);
this.infoLoader.load(new URLRequest(url + IMAGES_FILE));
startTimeoutTimer();
setStatus("Loading images info");
}
private function onImagesXMLLoadingOpen(event:Event) : void
{
loadingState = LOADING_STATE_TEXTURE_INFO;
}
private function onImagesXMLLoadingComplete(e:Event) : void
{
var textureCount:int = 0;
var image:XML = null;
setIdleLoadingState();
var xml:XML = XML(this.infoLoader.data);
this.destroyInfoLoader();
var batch:Object = {};
for each(image in xml.image)
{
textureCount++;
batch[image.@name] = new TextureInfo(image.attribute("new-name"),image.@alpha);
}
if(textureCount > 0)
{
this.batchTextureLoader = new BatchTextureLoader();
this.batchTextureLoader.addEventListener(Event.OPEN,this.onBitmapsLoadingOpen);
this.batchTextureLoader.addEventListener(Event.COMPLETE,this.onBitmapsLoadingComplete);
this.batchTextureLoader.addEventListener(LoaderProgressEvent.LOADER_PROGRESS,this.onProgress);
this.batchTextureLoader.addEventListener(BatchTextureLoaderErrorEvent.LOADER_ERROR,this.onTextureLoadingError);
this.batchTextureLoader.load(url,batch,null);
setStatus("Loading images");
startTimeoutTimer();
}
else
{
this.loadModel();
}
}
private function onBitmapsLoadingOpen(event:Event) : void
{
loadingState = LOADING_STATE_TEXTURES;
}
private function onBitmapsLoadingComplete(e:Event) : void
{
setIdleLoadingState();
setStatus("Images loading complete");
this.textures = this.batchTextureLoader.textures;
this.destroyBatchLoader();
this.loadModel();
}
private function loadModel() : void
{
this.loader = new URLLoader();
this.loader.dataFormat = URLLoaderDataFormat.BINARY;
this.loader.addEventListener(Event.OPEN,this.on3DSLoadingOpen);
this.loader.addEventListener(Event.COMPLETE,this.on3DSLoadingComplete);
this.loader.addEventListener(IOErrorEvent.IO_ERROR,this.onFatalError);
this.loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onFatalError);
this.loader.addEventListener(ProgressEvent.PROGRESS,this.onProgress);
this.loader.load(new URLRequest(url + MODEL_FILE));
setStatus("Loading model");
startTimeoutTimer();
}
private function on3DSLoadingOpen(event:Event) : void
{
loadingState = LOADING_STATE_3DS;
}
private function on3DSLoadingComplete(e:Event) : void
{
var mesh:Mesh = null;
setIdleLoadingState();
setStatus("Model loading complete");
var parser:Parser3DS = new Parser3DS();
parser.parse(this.loader.data);
this.objects = parser.objects;
this.destroyModelLoader();
for(var i:int = 0; i < this.objects.length; i++)
{
mesh = this.objects[i] as Mesh;
if(mesh != null)
{
this.initMesh(mesh);
}
}
completeLoading();
}
private function initMesh(mesh:Mesh) : void
{
mesh.weldVertices(0.001,0.001);
mesh.weldFaces(0.01,0.001,0.01);
mesh.clipping = Clipping.FACE_CLIPPING;
mesh.sorting = Sorting.AVERAGE_Z;
mesh.calculateBounds();
}
private function onFatalError(e:ErrorEvent) : void
{
reportFatalError(e.text);
}
private function onProgress(e:ProgressEvent) : void
{
loadingProgress(e.bytesLoaded,e.bytesTotal);
}
private function onTextureLoadingError(e:ErrorEvent) : void
{
}
private function destroyInfoLoader() : void
{
if(this.infoLoader == null)
{
return;
}
this.infoLoader.removeEventListener(Event.OPEN,this.onImagesXMLLoadingOpen);
this.infoLoader.removeEventListener(ProgressEvent.PROGRESS,this.onProgress);
this.infoLoader.removeEventListener(Event.COMPLETE,this.onImagesXMLLoadingComplete);
this.infoLoader.removeEventListener(IOErrorEvent.IO_ERROR,this.onFatalError);
this.infoLoader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onFatalError);
this.infoLoader = null;
}
private function destroyBatchLoader() : void
{
if(this.batchTextureLoader == null)
{
return;
}
this.batchTextureLoader.removeEventListener(Event.OPEN,this.onBitmapsLoadingOpen);
this.batchTextureLoader.removeEventListener(Event.COMPLETE,this.onBitmapsLoadingComplete);
this.batchTextureLoader.removeEventListener(LoaderProgressEvent.LOADER_PROGRESS,this.onProgress);
this.batchTextureLoader.removeEventListener(BatchTextureLoaderErrorEvent.LOADER_ERROR,this.onTextureLoadingError);
this.batchTextureLoader = null;
}
private function destroyModelLoader() : void
{
if(this.loader == null)
{
return;
}
this.loader.removeEventListener(Event.OPEN,this.on3DSLoadingOpen);
this.loader.removeEventListener(Event.COMPLETE,this.on3DSLoadingComplete);
this.loader.removeEventListener(IOErrorEvent.IO_ERROR,this.onFatalError);
this.loader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onFatalError);
this.loader.removeEventListener(ProgressEvent.PROGRESS,this.onProgress);
this.loader = null;
}
}
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_BG_GRAY_TL.png")]
public dynamic class bres_BG_GRAY_TL extends BitmapData {
public function bres_BG_GRAY_TL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.models.panel.clanpanel {
import alternativa.types.Long;
[ModelInterface]
public interface IClanPanelModel {
function sendInviteToClan(param1:Long) : void;
}
}
|
package alternativa.proplib.types {
public class PropGroup {
public var name:String;
public var props:Vector.<PropData>;
public var groups:Vector.<PropGroup>;
public function PropGroup(name:String) {
super();
this.name = name;
}
public function getPropByName(propName:String) : PropData {
var prop:PropData = null;
if(this.props == null) {
return null;
}
for each(prop in this.props) {
if(prop.name == propName) {
return prop;
}
}
return null;
}
public function getGroupByName(groupName:String) : PropGroup {
var group:PropGroup = null;
if(this.groups == null) {
return null;
}
for each(group in this.groups) {
if(group.name == groupName) {
return group;
}
}
return null;
}
public function addProp(prop:PropData) : void {
if(this.props == null) {
this.props = new Vector.<PropData>();
}
this.props.push(prop);
}
public function addGroup(group:PropGroup) : void {
if(this.groups == null) {
this.groups = new Vector.<PropGroup>();
}
this.groups.push(group);
}
public function traceGroup() : void {
var group:PropGroup = null;
var prop:PropData = null;
trace("=== Group " + this.name + " ===");
if(this.groups != null) {
for each(group in this.groups) {
group.traceGroup();
}
}
if(this.props != null) {
for each(prop in this.props) {
prop.traceProp();
}
}
}
}
}
|
package alternativa.tanks.model.challenge.battlepass.notifier {
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.panel.model.battlepass.purchasenotifier.BattlePassPurchaseNotifierModelBase;
import projects.tanks.client.panel.model.battlepass.purchasenotifier.IBattlePassPurchaseNotifierModelBase;
[ModelInfo]
public class BattlePassPurchaseNotifierModel extends BattlePassPurchaseNotifierModelBase implements IBattlePassPurchaseNotifierModelBase, ObjectLoadListener {
[Inject]
public static var battlePassPurchaseService:BattlePassPurchaseService;
public function BattlePassPurchaseNotifierModel() {
super();
}
public function objectLoaded() : void {
battlePassPurchaseService.setState(getInitParam().purchased);
}
public function battlePassPurchased() : void {
battlePassPurchaseService.setState(true);
}
}
}
|
package alternativa.tanks.gui.tankpreview {
import alternativa.engine3d.containers.BSPContainer;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.MipMapping;
import alternativa.engine3d.core.Object3DContainer;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.View;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.BSP;
import alternativa.engine3d.objects.Decal;
import alternativa.engine3d.objects.Mesh;
import alternativa.tanks.service.garage.GarageService;
import controls.TankWindowInner;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Shape;
import flash.events.Event;
import flash.events.TimerEvent;
import flash.filters.BitmapFilterQuality;
import flash.filters.BlurFilter;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Vector3D;
import flash.utils.Timer;
import forms.TankWindowWithHeader;
import projects.tanks.clients.flash.commons.models.gpu.GPUCapabilities;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
import projects.tanks.clients.flash.resources.tanks.Tank3D;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.disposeBitmapsData;
public class TankPreviewHoliday extends TankWindowWithHeader {
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var garageService:GarageService;
private static const ENTER_FRAME_PRIORITY:Number = -1;
private static const INITIAL_CAMERA_DIRECTION:Number = -150;
private static const WINDOW_MARGIN:int = 11;
private static const SHADOW_ALPHA:Number = 0.7;
private static const SHADOW_BLUR:Number = 13;
private static const SHADOW_RESOLUTION:Number = 2.5;
private static const SHADOW_DIRECTION:Vector3D = new Vector3D(0,0,-1);
private var innerBevel:TankWindowInner;
private var backgroundEraser:Shape;
private var rootContainer:Object3DContainer;
private var hangarContainer:Object3DContainer;
private var cameraContainer:Object3DContainer;
private var camera:Camera3D;
private var stateMachine:TankPreviewStateMachine;
private var tank:Tank3D;
private var loadedPartsCounter:int = 0;
private var backgroundEraserTimer:Timer;
private var shadow:Mesh;
private var _hullMesh:Mesh;
private var bitmapsData:Array;
public function TankPreviewHoliday(param1:Tanks3DSResource) {
super();
this.bitmapsData = [];
setHeaderId(TanksLocale.TEXT_HEADER_YOUR_TANK);
this.init3D();
this.createWindowInnerBevel();
this.addGarageObjectsToScene(param1);
this.createTank();
this.resize(400,300);
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
}
private function init3D() : void {
this.rootContainer = new Object3DContainer();
this.camera = new Camera3D();
this.camera.view = new View(100,100,GPUCapabilities.constrained);
this.camera.view.hideLogo();
addChild(this.camera.view);
this.cameraContainer = new Object3DContainer();
this.rootContainer.addChild(this.cameraContainer);
this.hangarContainer = new BSPContainer();
this.rootContainer.addChild(this.hangarContainer);
this.cameraContainer.addChild(this.camera);
this.cameraContainer.rotationX = garageService.getCameraPitch() * Math.PI / 180;
this.camera.y = garageService.getCameraAltitude();
this.camera.z = garageService.getCameraDistance();
this.camera.fov = garageService.getCameraFieldOfView();
this.cameraContainer.rotationZ = INITIAL_CAMERA_DIRECTION * Math.PI / 180;
if(GPUCapabilities.gpuEnabled) {
this.backgroundEraser = new Shape();
this.backgroundEraser.blendMode = BlendMode.ERASE;
}
}
private function createWindowInnerBevel() : void {
this.innerBevel = new TankWindowInner(0,0,TankWindowInner.TRANSPARENT);
addChild(this.innerBevel);
this.innerBevel.mouseEnabled = true;
}
private function createTank() : void {
this.tank = new Tank3D();
this.tank.z = 120;
this.tank.y = -30;
this.tank.x = 0;
this.rootContainer.addChild(this.tank);
}
private function addGarageObjectsToScene(param1:Tanks3DSResource) : void {
var local4:Mesh = null;
var local5:TextureMaterial = null;
var local6:BSP = null;
var local2:int = int(param1.objects.length);
var local3:int = 0;
while(local3 < local2) {
local4 = param1.objects[local3] as Mesh;
if(local4 != null) {
local5 = TextureMaterial(local4.faceList.material);
local5.texture = param1.getTextureForObject(local3);
local4.setMaterialToAllFaces(local5);
local6 = new BSP();
local6.createTree(local4);
local6.matrix = local4.matrix;
this.hangarContainer.addChild(local6);
}
local3++;
}
}
private function onAddedToStage(param1:Event) : void {
removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
addEventListener(Event.ENTER_FRAME,this.onEnterFrame,false,ENTER_FRAME_PRIORITY);
this.initStateMachine();
if(GPUCapabilities.gpuEnabled) {
this.backgroundEraserTimer = new Timer(1000,1);
this.backgroundEraserTimer.addEventListener(TimerEvent.TIMER_COMPLETE,this.onBackgroundEraserTimerComplete);
this.backgroundEraserTimer.start();
}
}
private function onBackgroundEraserTimerComplete(param1:TimerEvent) : void {
addChild(this.backgroundEraser);
this.backgroundEraserTimer.removeEventListener(TimerEvent.TIMER_COMPLETE,this.onBackgroundEraserTimerComplete);
this.backgroundEraserTimer = null;
}
private function onEnterFrame(param1:Event) : void {
this.stateMachine.updateCurrentState();
this.camera.render();
}
private function initStateMachine() : void {
this.stateMachine = new TankPreviewStateMachine();
var local1:TankPreviewContext = new TankPreviewContext();
var local2:ManualRotationState = new ManualRotationState(this.stateMachine,stage,local1,this.camera,this.cameraContainer);
var local3:RotationDecelerationState = new RotationDecelerationState(this.stateMachine,this.innerBevel,local1,this.cameraContainer);
var local4:IdleState = new IdleState(this.stateMachine,this.innerBevel);
var local5:AutoRotationState = new AutoRotationState(this.stateMachine,this.innerBevel,this.cameraContainer);
this.stateMachine.addTransition(TankPreviewEvent.MOUSE_DOWN,local3,local2);
this.stateMachine.addTransition(TankPreviewEvent.MOUSE_DOWN,local4,local2);
this.stateMachine.addTransition(TankPreviewEvent.MOUSE_DOWN,local5,local2);
this.stateMachine.addTransition(TankPreviewEvent.STOP_MANUAL_ROTATION,local2,local3);
this.stateMachine.addTransition(TankPreviewEvent.ROTATION_STOPPED,local3,local4);
this.stateMachine.addTransition(TankPreviewEvent.IDLE_STATE_TIMEOUT,local4,local5);
this.stateMachine.setCurrentState(local4);
}
public function destroy() : void {
removeEventListener(Event.ENTER_FRAME,this.onEnterFrame);
if(this.backgroundEraserTimer != null) {
this.backgroundEraserTimer.stop();
this.backgroundEraserTimer.removeEventListener(TimerEvent.TIMER_COMPLETE,this.onBackgroundEraserTimerComplete);
this.backgroundEraserTimer = null;
}
this.innerBevel = null;
this.rootContainer = null;
this.cameraContainer = null;
this.camera.view.clear();
this.camera = null;
this.tank.destroy();
this.tank = null;
this.shadow = null;
disposeBitmapsData(this.bitmapsData);
this.bitmapsData = null;
}
public function setHull(param1:Tanks3DSResource) : void {
this._hullMesh = Mesh(param1.objects[0]);
this.tank.setHull(param1);
this.onTankPartLoaded();
}
public function setTurret(param1:Tanks3DSResource) : void {
this.tank.setTurret(param1);
this.onTankPartLoaded();
}
public function setColorMap(param1:BitmapData) : void {
this.tank.setColorMap(param1);
this.onTankPartLoaded();
}
private function onTankPartLoaded() : void {
if(this.loadedPartsCounter < 3) {
++this.loadedPartsCounter;
}
if(this.loadedPartsCounter == 3) {
if(this.shadow != null && Boolean(this.tank.contains(this.shadow))) {
this.tank.removeChild(this.shadow);
}
this.shadow = this.createShadow(this._hullMesh,SHADOW_DIRECTION,SHADOW_RESOLUTION,SHADOW_BLUR,SHADOW_ALPHA);
this.tank.addChildAt(this.shadow,0);
if(!GPUCapabilities.gpuEnabled) {
this.camera.render();
}
}
}
public function resize(param1:Number, param2:Number) : void {
this.width = param1;
this.height = param2;
this.adjustInnerBevel(param1,param2);
this.adjustView3D(param1,param2);
this.adjustBackgroundEraser();
if(!GPUCapabilities.gpuEnabled) {
this.camera.render();
}
}
private function adjustInnerBevel(param1:Number, param2:Number) : void {
this.innerBevel.width = param1 - WINDOW_MARGIN * 2;
this.innerBevel.height = param2 - WINDOW_MARGIN * 2;
this.innerBevel.x = WINDOW_MARGIN;
this.innerBevel.y = WINDOW_MARGIN;
}
private function adjustView3D(param1:Number, param2:Number) : void {
this.camera.view.width = param1 - WINDOW_MARGIN * 2 - 2;
this.camera.view.height = param2 - WINDOW_MARGIN * 2 - 2;
this.camera.view.x = WINDOW_MARGIN;
this.camera.view.y = WINDOW_MARGIN;
}
private function adjustBackgroundEraser() : void {
if(GPUCapabilities.gpuEnabled) {
this.backgroundEraser.x = this.camera.view.x;
this.backgroundEraser.y = this.camera.view.y;
this.backgroundEraser.graphics.clear();
this.backgroundEraser.graphics.beginFill(16711680);
this.backgroundEraser.graphics.drawRect(0,0,this.camera.view.width,this.camera.view.height);
this.backgroundEraser.graphics.endFill();
}
}
private function createShadow(param1:Mesh, param2:Vector3D, param3:Number, param4:int, param5:Number, param6:uint = 0) : Mesh {
var local20:Wrapper = null;
var local21:Vertex = null;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:Number = NaN;
var local25:Decal = null;
param2 = param2.clone();
param2.normalize();
var local7:Number = 1e+22;
var local8:Number = 1e+22;
var local9:Number = -1e+22;
var local10:Number = -1e+22;
var local11:Shape = new Shape();
var local12:Face = param1.faceList;
while(local12 != null) {
local20 = local12.wrapper;
while(local20 != null) {
local21 = local20.vertex;
local22 = -local21.z / param2.z;
local23 = local21.x + param2.x * local22;
local24 = local21.y + param2.y * local22;
if(local23 < local7) {
local7 = local23;
}
if(local23 > local9) {
local9 = local23;
}
if(local24 < local8) {
local8 = local24;
}
if(local24 > local10) {
local10 = local24;
}
if(local20 == local12.wrapper) {
local11.graphics.beginFill(param6);
local11.graphics.moveTo(local23,local24);
} else {
local11.graphics.lineTo(local23,local24);
}
local20 = local20.next;
}
local12 = local12.next;
}
local7 = (Math.floor(local7 / param3) - param4) * param3;
local8 = (Math.floor(local8 / param3) - param4) * param3;
local9 = (Math.ceil(local9 / param3) + param4) * param3;
local10 = (Math.ceil(local10 / param3) + param4) * param3;
var local13:BitmapData = new BitmapData(Math.round((local9 - local7) / param3),Math.round((local10 - local8) / param3),true,0);
this.bitmapsData.push(local13);
local13.draw(local11,new Matrix(1 / param3,0,0,-1 / param3,-local7 / param3,local10 / param3));
local13.applyFilter(local13,local13.rect,new Point(),new BlurFilter(param4,param4,BitmapFilterQuality.MEDIUM));
var local14:TextureMaterial = new TextureMaterial(local13,false,true,MipMapping.PER_PIXEL,param3);
var local15:Mesh = new Mesh();
var local16:Vertex = local15.addVertex(local7,local10,0,0,0);
var local17:Vertex = local15.addVertex(local7,local8,0,0,1);
var local18:Vertex = local15.addVertex(local9,local8,0,1,1);
var local19:Vertex = local15.addVertex(local9,local10,0,1,0);
local15.addQuadFace(local16,local17,local18,local19,local14);
local15.calculateFacesNormals();
local15.calculateBounds();
local15.alpha = param5;
if(GPUCapabilities.gpuEnabled) {
local25 = new Decal();
local25.createGeometry(local15,true);
local25.x = local15.x;
local25.y = local15.y;
local25.z = local15.z;
local25.alpha = local15.alpha;
return local25;
}
return local15;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.map {
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.map.FogParams;
public class VectorCodecFogParamsLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecFogParamsLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(FogParams,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.<FogParams> = new Vector.<FogParams>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = FogParams(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:FogParams = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<FogParams> = Vector.<FogParams>(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.tankslauncershared.dishonestprogressbar {
import mx.core.BitmapAsset;
[Embed(source="/_assets/projects.tanks.clients.tankslauncershared.dishonestprogressbar.LoadingLabel_loadingLabelRuClass.png")]
public class LoadingLabel_loadingLabelRuClass extends BitmapAsset {
public function LoadingLabel_loadingLabelRuClass() {
super();
}
}
}
|
package alternativa.tanks.gui.friends {
public class FriendsWindowState {
public static const ACCEPTED:FriendsWindowState = new FriendsWindowState(0);
public static const INCOMING:FriendsWindowState = new FriendsWindowState(1);
public static const CLAN_MEMBERS:FriendsWindowState = new FriendsWindowState(2);
public static const REFERRALS:FriendsWindowState = new FriendsWindowState(3);
private var _value:int;
public function FriendsWindowState(param1:int) {
super();
this._value = param1;
}
public function get value() : int {
return this._value;
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.guestform {
import flash.display.Bitmap;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.filters.DropShadowFilter;
import flash.text.TextField;
import flash.text.TextFormat;
public class Button extends Sprite {
private var normal:Bitmap;
private var over:Bitmap;
private var button:Sprite;
private var label:TextField;
private var onClickHandler:Function;
public function Button(param1:Bitmap, param2:Bitmap, param3:Function) {
super();
this.onClickHandler = param3;
this.normal = param1;
this.normal.visible = true;
this.over = param2;
this.over.visible = false;
this.label = this.createStartText();
this.label.visible = true;
this.label.filters = [new DropShadowFilter(1,45,10223390,1,2,2,1.5)];
this.button = new Sprite();
this.button.visible = true;
this.button.buttonMode = true;
this.button.useHandCursor = true;
this.button.tabEnabled = false;
this.button.graphics.beginFill(16711680,0);
this.button.graphics.drawRect(this.normal.x,this.normal.y,this.normal.width,this.normal.height);
this.button.addEventListener(MouseEvent.MOUSE_OVER,this.onButtonOver);
this.button.addEventListener(MouseEvent.MOUSE_OUT,this.onButtonOut);
this.button.addEventListener(MouseEvent.MOUSE_DOWN,this.onButtonDown);
this.button.addEventListener(MouseEvent.MOUSE_UP,this.onButtonUp);
this.button.addEventListener(MouseEvent.CLICK,this.onButtonClick);
addChild(this.normal);
addChild(this.over);
addChild(this.button);
addChild(this.label);
}
private function createStartText() : TextField {
var local1:TextField = new TextField();
local1.selectable = false;
local1.multiline = false;
local1.mouseEnabled = false;
local1.autoSize = "center";
local1.antiAliasType = "advanced";
local1.sharpness = 0;
local1.thickness = 0;
local1.defaultTextFormat = new TextFormat("Quadrat",28,1121280,null,null,null,null,null,"center");
local1.embedFonts = true;
local1.x = 105;
local1.y = 3;
local1.text = "START";
return local1;
}
private function onButtonUp(param1:MouseEvent) : void {
this.label.y = 0 + 3;
this.over.y = 0;
}
private function onButtonOver(param1:MouseEvent) : void {
this.normal.alpha = 0;
this.over.visible = true;
}
private function onButtonOut(param1:MouseEvent) : void {
this.label.y = 0 + 3;
this.over.y = 0;
this.normal.alpha = 1;
this.over.visible = false;
}
private function onButtonDown(param1:MouseEvent) : void {
this.label.y = 0 + 3 + 1;
this.over.y = 0 + 1;
}
private function onButtonClick(param1:MouseEvent) : void {
this.label.y = 3;
this.over.y = 0;
this.button.buttonMode = false;
this.button.useHandCursor = false;
this.onClickHandler();
}
public function reposition(param1:int, param2:int) : void {
x = 5 + (param1 - this.button.width) >> 1;
y = 150 + (param2 - this.button.height) >> 1;
}
}
}
|
package alternativa.tanks.gui {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
public class UpgradeIndicator extends Sprite {
private static const m0Class:Class = UpgradeIndicator_m0Class;
private static const m1Class:Class = UpgradeIndicator_m1Class;
private static const m2Class:Class = UpgradeIndicator_m2Class;
private static const m3Class:Class = UpgradeIndicator_m3Class;
private static const modificationBitmapDatas:Vector.<BitmapData> = new Vector.<BitmapData>(4);
modificationBitmapDatas[0] = new m0Class().bitmapData;
modificationBitmapDatas[1] = new m1Class().bitmapData;
modificationBitmapDatas[2] = new m2Class().bitmapData;
modificationBitmapDatas[3] = new m3Class().bitmapData;
public function UpgradeIndicator(param1:int) {
super();
var local2:Bitmap = new Bitmap(modificationBitmapDatas[param1]);
addChild(local2);
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.lootbox {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.shop.lootbox.LootBoxPackageCC;
public class CodecLootBoxPackageCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_count:ICodec;
private var codec_name:ICodec;
public function CodecLootBoxPackageCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_count = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:LootBoxPackageCC = new LootBoxPackageCC();
local2.count = this.codec_count.decode(param1) as int;
local2.name = this.codec_name.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:LootBoxPackageCC = LootBoxPackageCC(param2);
this.codec_count.encode(param1,local3.count);
this.codec_name.encode(param1,local3.name);
}
}
}
|
package projects.tanks.client.garage.prototypes.item.renameitem {
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 RenameModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _renameId:Long = Long.getLong(1667820062,-1874560004);
private var _rename_newNickNameCodec:ICodec;
private var model:IModel;
public function RenameModelServer(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._rename_newNickNameCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function rename(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._rename_newNickNameCodec.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._renameId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.models.battle.rugby {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Quaternion;
import alternativa.math.Vector3;
import alternativa.physics.PhysicsMaterial;
import alternativa.physics.collision.primitives.CollisionSphere;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.bonuses.BonusConst;
import alternativa.tanks.bonuses.BonusObject3DBase;
import alternativa.tanks.bonuses.Cords;
import alternativa.tanks.bonuses.ISpawnableObject;
import alternativa.tanks.bonuses.Parachute;
import alternativa.tanks.bonuses.ParachuteDetachAnimation;
import alternativa.tanks.bonuses.SpawnAnimation;
import alternativa.tanks.models.battle.commonflag.*;
import alternativa.tanks.models.battle.gui.markers.PointIndicatorStateProvider;
import alternativa.tanks.models.controlpoints.hud.KeyPointView;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.utils.TextureMaterialRegistry;
import flash.display.BitmapData;
import org1.osflash.signals.ISignal;
import org1.osflash.signals.Signal;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.battle.pointbased.flag.FlagState;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class Ball extends CommonFlag implements ISpawnableObject, PointIndicatorStateProvider {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var materialRegistry:TextureMaterialRegistry;
public const onDestroy:ISignal = new Signal();
private const BALL_HANDLE_FREQ_X:Number = 0.0005;
private const BALL_HANDLE_FREQ_Y:Number = 0.0003;
private var parachute:Parachute;
private var vec:Vector3 = new Vector3();
private var eulerAngles:Vector3 = new Vector3();
private var parachuteIn:Mesh;
private var parachuteOut:Mesh;
private var cordsMaterial:TextureMaterial;
private var cords:Cords;
private var materials:Vector.<TextureMaterial> = new Vector.<TextureMaterial>();
private var flagWrapper:BonusObject3DBase;
private var radius:Number;
public function Ball(param1:int, param2:Number, param3:Tanks3DSResource, param4:Tanks3DSResource, param5:Tanks3DSResource, param6:TextureResource) {
super(param1,BattleTeam.NONE,NO_POSITION);
skinObject = this.getMeshFromResource(param3);
this.flagWrapper = new BonusObject3DBase();
this.radius = param2;
this.flagWrapper.object = skinObject;
skinObject.calculateBounds();
this.setupCollisionPrimitive(param2);
mountPointOffsetZ = 50;
this.parachuteOut = this.getMeshFromResource(param4);
this.parachuteIn = this.getMeshFromResource(param5);
this.cordsMaterial = materialRegistry.getMaterial(param6.data);
this.materials.push(this.cordsMaterial);
_state = FlagState.EXILED;
}
private static function getMeshFromResource(param1:Tanks3DSResource) : Mesh {
var local2:Mesh = Mesh(param1.objects[0]);
var local3:BitmapData = param1.getTextureForObject(0);
var local4:Mesh = Mesh(local2.clone());
var local5:TextureMaterial = materialRegistry.getMaterial(local3);
local5.resolution = 1;
local4.setMaterialToAllFaces(local5);
return local4;
}
private function setupCollisionPrimitive(param1:Number) : void {
collisionPrimitive = new CollisionSphere(param1,CollisionGroup.TANK,PhysicsMaterial.DEFAULT_MATERIAL);
}
private function getMeshFromResource(param1:Tanks3DSResource) : Mesh {
var local2:Mesh = Mesh(param1.objects[0]);
var local3:BitmapData = param1.getTextureForObject(0);
var local4:Mesh = Mesh(local2.clone());
var local5:TextureMaterial = materialRegistry.getMaterial(local3);
this.materials.push(local5);
local4.setMaterialToAllFaces(local5);
return local4;
}
override protected function initFalling() : void {
this.initParachute();
this.addParachuteToScene();
this.startSpawnAnimation();
}
override public function stopFalling() : void {
super.stopFalling();
if(_state == FlagState.DROPPED) {
this.detachParachute();
}
}
private function detachParachute() : void {
var local1:ParachuteDetachAnimation = null;
if(this.parachute != null) {
local1 = ParachuteDetachAnimation(battleService.getObjectPool().getObject(ParachuteDetachAnimation));
local1.start(this.parachute,this.cords,flyingData.instantSpeed / 2);
this.parachute = null;
this.cords = null;
}
}
private function startSpawnAnimation() : void {
var local1:SpawnAnimation = SpawnAnimation(battleService.getObjectPool().getObject(SpawnAnimation));
local1.start(this);
}
private function addParachuteToScene() : void {
this.parachute.addToScene();
this.cords.addToScene();
}
private function initParachute() : void {
if(this.parachute == null) {
this.parachute = new Parachute(this.parachuteOut,this.parachuteIn);
this.cords = new Cords(Parachute.RADIUS,this.radius,Parachute.NUM_STRAPS,this.cordsMaterial);
this.cords.init(this.flagWrapper,this.parachute);
}
}
override protected function renderImpl(param1:int, param2:int, param3:FlagStatus) : void {
var local4:Quaternion = null;
skinObject.visible = state != FlagState.EXILED;
moveObjects(param3.position);
if(state == FlagState.CARRIED) {
local4 = param3.rotation.clone().normalize();
local4.prepend(Quaternion.createFromAxisAngle(Vector3.X_AXIS,-this.BALL_HANDLE_FREQ_X * param1 * Math.PI));
local4.prepend(Quaternion.createFromAxisAngle(Vector3.Y_AXIS,this.BALL_HANDLE_FREQ_Y * param1 * Math.PI));
local4.prepend(Quaternion.createFromAxisAngle(Vector3.Z_AXIS,0.5 * Math.PI));
local4.getEulerAngles(this.eulerAngles);
skinObject.rotationX = this.eulerAngles.x;
skinObject.rotationY = this.eulerAngles.y;
skinObject.rotationZ = this.eulerAngles.z;
} else {
param3.rotation.normalize().getEulerAngles(this.eulerAngles);
skinObject.rotationX = this.eulerAngles.x;
skinObject.rotationY = this.eulerAngles.y;
skinObject.rotationZ = this.eulerAngles.z;
}
if(this.parachute != null) {
this.vec.copy(param3.position);
this.vec.z += BonusConst.BONUS_OFFSET_Z + BonusConst.PARACHUTE_OFFSET_Z;
this.parachute.setPosition(this.vec);
this.cords.updateVertices();
}
}
override public function dispose() : void {
var local1:TextureMaterial = null;
super.dispose();
for each(local1 in this.materials) {
materialRegistry.releaseMaterial(local1);
}
this.onDestroy.dispatch();
this.onDestroy.removeAll();
if(Boolean(this.parachute)) {
this.parachute.removeFromScene();
this.cords.removeFromScene();
this.parachute = null;
this.cords = null;
}
}
public function addSignal(param1:Function) : void {
this.onDestroy.add(param1);
}
public function removeSignal(param1:Function) : void {
this.onDestroy.remove(param1);
}
override public function setAlpha(param1:Number) : void {
super.setAlpha(param1);
if(Boolean(this.parachute)) {
this.parachute.setAlpha(param1);
this.cords.setAlpha(param1);
}
}
override public function positionChanged(param1:Vector3, param2:Quaternion) : void {
if(_state == FlagState.DROPPED || _state == FlagState.FLYING) {
collisionPrimitive.transform.m03 = param1.x;
collisionPrimitive.transform.m13 = param1.y;
collisionPrimitive.transform.m23 = param1.z;
collisionPrimitive.calculateAABB();
}
lightSource.x = param1.x;
lightSource.y = param1.y;
lightSource.z = param1.z;
}
public function isIndicatorActive(param1:Vector3 = null) : Boolean {
readPosition(this.vec);
return _state == FlagState.DROPPED || _state == FlagState.FLYING && flyingData.isMarked() || param1 != null && _state == FlagState.CARRIED && param1.distanceTo(this.vec) > MARKER_HIDE_DISTANCE && !isLocalCarrier;
}
public function zOffset() : Number {
if(_state == FlagState.CARRIED) {
return 0;
}
return KeyPointView.CIRCLE_ASCENSION;
}
}
}
|
package projects.tanks.client.commons.models.challenge.time {
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 ChallengesTimeModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ChallengesTimeModelServer;
private var client:IChallengesTimeModelBase = IChallengesTimeModelBase(this);
private var modelId:Long = Long.getLong(1891796571,199395138);
public function ChallengesTimeModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ChallengesTimeModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ChallengesTimeCC,false)));
}
protected function getInitParam() : ChallengesTimeCC {
return ChallengesTimeCC(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.engine3d.animation {
import alternativa.engine3d.alternativa3d;
use namespace alternativa3d;
public class AnimationNode {
alternativa3d var _isActive:Boolean = false;
alternativa3d var _parent:AnimationNode;
alternativa3d var controller:AnimationController;
public var speed:Number = 1;
public function AnimationNode() {
super();
}
public function get isActive() : Boolean {
return this.alternativa3d::_isActive && this.alternativa3d::controller != null;
}
public function get parent() : AnimationNode {
return this.alternativa3d::_parent;
}
alternativa3d function update(param1:Number, param2:Number) : void {
}
alternativa3d function setController(param1:AnimationController) : void {
this.alternativa3d::controller = param1;
}
alternativa3d function addNode(param1:AnimationNode) : void {
if(param1.alternativa3d::_parent != null) {
param1.alternativa3d::_parent.alternativa3d::removeNode(param1);
}
param1.alternativa3d::_parent = this;
param1.alternativa3d::setController(this.alternativa3d::controller);
}
alternativa3d function removeNode(param1:AnimationNode) : void {
param1.alternativa3d::setController(null);
param1.alternativa3d::_isActive = false;
param1.alternativa3d::_parent = null;
}
}
}
|
package alternativa.tanks.model.payment.shop.paint {
[ModelInterface]
public interface PaintPackage {
function getName() : String;
function getDescription() : String;
}
}
|
package alternativa.gfx.agal
{
public class SamplerMipMap extends SamplerOption
{
private static const SAMPLER_MIPMAP_SHIFT:uint = 24;
public static const NONE:SamplerMipMap = new SamplerMipMap(0);
public static const NEAREST:SamplerMipMap = new SamplerMipMap(1);
public static const LINEAR:SamplerMipMap = new SamplerMipMap(2);
public function SamplerMipMap(param1:uint)
{
super(param1,SAMPLER_MIPMAP_SHIFT);
}
}
}
|
package projects.tanks.clients.flash.commons.services.validate {
public interface IValidateService {
function isEmailValid(param1:String) : Boolean;
function isValidPromoCode(param1:String) : Boolean;
function isUidValid(param1:String) : Boolean;
function isValidIdentificationStringForRegistration(param1:String) : Boolean;
function isValidIdentificationStringForLogin(param1:String) : Boolean;
function isChinaCardIdValid(param1:String) : Boolean;
function isChinaNameValid(param1:String) : Boolean;
function getForbiddenCharactersCountForRegistration(param1:String) : int;
function getForbiddenLettersCountForRegistration(param1:String) : int;
}
}
|
package projects.tanks.client.commons.models.clienthalt {
public interface IServerHaltModelBase {
function haltServer(param1:int) : void;
}
}
|
package alternativa.tanks.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.weapon.shared.StreamWeaponParticle;
import alternativa.tanks.models.weapon.streamweapon.StreamWeaponGraphicEffect;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class StreamWeaponParticlesPositionProvider extends PooledObject implements Object3DPositionProvider {
private var _streamWeaponGraphicEffect:StreamWeaponGraphicEffect;
private var _defaultPositionProvider:CollisionObject3DPositionProvider;
private var weightDistance:Array = [0.1,0.3,0.5,0.8,0.9,1];
private var weightValue:Array = [0.5,0.8,1,0.5,0.3,0.05];
public function StreamWeaponParticlesPositionProvider(param1:Pool) {
super(param1);
}
public function init(param1:StreamWeaponGraphicEffect, param2:CollisionObject3DPositionProvider) : void {
this._streamWeaponGraphicEffect = param1;
this._defaultPositionProvider = param2;
}
public function initPosition(param1:Object3D) : void {
var local6:Vector.<StreamWeaponParticle> = null;
var local7:int = 0;
var local8:StreamWeaponParticle = null;
var local9:Number = NaN;
var local10:Number = NaN;
var local2:Number = 0;
var local3:Number = 0;
var local4:Number = 0;
var local5:Number = 0;
if(this._streamWeaponGraphicEffect.numParticles == 0) {
this._defaultPositionProvider.initPosition(param1);
} else {
local6 = this._streamWeaponGraphicEffect.particles;
local7 = 0;
while(local7 < this._streamWeaponGraphicEffect.numParticles) {
local8 = local6[local7];
local9 = local8.particleDistance / this._streamWeaponGraphicEffect.range;
local10 = this.getWeight(local9);
local5 += local10;
local2 += local8.x * local10;
local3 += local8.y * local10;
local4 += local8.z * local10;
local7++;
}
local2 /= local5;
local3 /= local5;
local4 /= local5;
param1.x = local2;
param1.y = local3;
param1.z = local4;
}
}
private function getWeight(param1:Number) : Number {
var local3:Number = NaN;
var local2:int = 0;
while(local2 < this.weightDistance.length) {
local3 = Number(this.weightDistance[local2]);
if(local3 >= param1) {
return this.weightValue[local2];
}
local2++;
}
return 0;
}
public function updateObjectPosition(param1:Object3D, param2:GameCamera, param3:int) : void {
this.initPosition(param1);
}
public function destroy() : void {
this._streamWeaponGraphicEffect = null;
this._defaultPositionProvider = null;
}
}
}
|
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_ctfRedPlayerDropBlueflagIcon.png")]
public class ActionOutputLine_ctfRedPlayerDropBlueflagIcon extends BitmapAsset {
public function ActionOutputLine_ctfRedPlayerDropBlueflagIcon() {
super();
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_bitmapLineTableKit.png")]
public class ItemInfoPanelBitmaps_bitmapLineTableKit extends BitmapAsset {
public function ItemInfoPanelBitmaps_bitmapLineTableKit() {
super();
}
}
}
|
package controls.chat
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChatPermissionsLevel_admin extends BitmapAsset
{
public function ChatPermissionsLevel_admin()
{
super();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.