code stringlengths 57 237k |
|---|
package org1.osflash.signals {
public class Slot implements ISlot {
public var _signal:ISignal;
public var _enabled:Boolean = true;
public var _listener:Function;
public var _once:Boolean = false;
public var _priority:int = 0;
public var _params:Array;
public function Slot(param1:Function, param2:ISignal, param3:Boolean = false, param4:int = 0) {
super();
this._listener = param1;
this._once = param3;
this._signal = param2;
this._priority = param4;
this.verifyListener(param1);
}
public function execute0() : void {
if(!this._enabled) {
return;
}
if(this._once) {
this.remove();
}
if(Boolean(this._params) && Boolean(this._params.length)) {
this._listener.apply(null,this._params);
return;
}
this._listener();
}
public function execute1(param1:Object) : void {
if(!this._enabled) {
return;
}
if(this._once) {
this.remove();
}
if(Boolean(this._params) && Boolean(this._params.length)) {
this._listener.apply(null,[param1].concat(this._params));
return;
}
this._listener(param1);
}
public function execute(param1:Array) : void {
if(!this._enabled) {
return;
}
if(this._once) {
this.remove();
}
if(Boolean(this._params) && Boolean(this._params.length)) {
param1 = param1.concat(this._params);
}
var local2:int = int(param1.length);
if(local2 == 0) {
this._listener();
} else if(local2 == 1) {
this._listener(param1[0]);
} else if(local2 == 2) {
this._listener(param1[0],param1[1]);
} else if(local2 == 3) {
this._listener(param1[0],param1[1],param1[2]);
} else {
this._listener.apply(null,param1);
}
}
public function getListener() : Function {
return this._listener;
}
public function setListener(param1:Function) : void {
if(null == param1) {
throw new ArgumentError("Given listener is null.\nDid you want to set enabled to false instead?");
}
this.verifyListener(param1);
this._listener = param1;
}
public function getOnce() : Boolean {
return this._once;
}
public function getPriority() : int {
return this._priority;
}
public function toString() : String {
return "[Slot listener: " + this._listener + ", once: " + this._once + ", priority: " + this._priority + ", enabled: " + this._enabled + "]";
}
public function getEnabled() : Boolean {
return this._enabled;
}
public function setEnabled(param1:Boolean) : void {
this._enabled = param1;
}
public function getParams() : Array {
return this._params;
}
public function setParams(param1:Array) : void {
this._params = param1;
}
public function remove() : void {
this._signal.remove(this._listener);
}
public function verifyListener(param1:Function) : void {
if(null == param1) {
throw new ArgumentError("Given listener is null.");
}
if(null == this._signal) {
throw new Error("Internal signal reference has not been set yet.");
}
}
}
}
|
package {
import flash.display.BitmapData;
[Embed(source="/_assets/IconXP.png")]
public dynamic class IconXP extends BitmapData {
public function IconXP(param1:int = 20, param2:int = 20) {
super(param1,param2);
}
}
}
|
package controls.base
{
import controls.Label;
import flash.events.MouseEvent;
import flash.text.TextFieldAutoSize;
import flash.ui.Mouse;
import flash.ui.MouseCursor;
public class LabelBase extends Label
{
private var _autoSize:String;
private var _correctCursorBehaviour:Boolean;
private var isButtonMode:Boolean = false;
public function LabelBase()
{
super();
sharpness = 40;
thickness = 70;
this._autoSize = super.autoSize;
this._correctCursorBehaviour = true;
}
override public function set autoSize(param1:String) : void
{
super.autoSize = param1;
this._autoSize = super.autoSize;
}
override public function set htmlText(param1:String) : void
{
var _loc2_:Number = NaN;
super.autoSize = this._autoSize;
super.htmlText = param1;
if(super.autoSize == TextFieldAutoSize.CENTER)
{
_loc2_ = super.width;
super.autoSize = TextFieldAutoSize.NONE;
super.width = Math.ceil(_loc2_) + 1;
}
}
public function set buttonMode(param1:Boolean) : void
{
this.isButtonMode = param1;
this.selectable = param1;
}
override public function set selectable(param1:Boolean) : void
{
super.selectable = param1;
this.arrangeEventListeners();
}
public function get correctCursorBehaviour() : Boolean
{
return this._correctCursorBehaviour;
}
public function set correctCursorBehaviour(param1:Boolean) : void
{
this._correctCursorBehaviour = param1;
this.arrangeEventListeners();
}
private function arrangeEventListeners() : void
{
if(super.selectable && this._correctCursorBehaviour)
{
addEventListener(MouseEvent.ROLL_OVER,this.onMouseOver);
addEventListener(MouseEvent.ROLL_OUT,this.onMouseOut);
}
else
{
removeEventListener(MouseEvent.ROLL_OVER,this.onMouseOver);
removeEventListener(MouseEvent.ROLL_OUT,this.onMouseOut);
}
}
private function onMouseOver(param1:MouseEvent) : void
{
Mouse.cursor = !!this.isButtonMode ? MouseCursor.BUTTON : MouseCursor.IBEAM;
}
private function onMouseOut(param1:MouseEvent) : void
{
Mouse.cursor = MouseCursor.AUTO;
}
}
}
|
package alternativa.tanks.models.battlefield
{
public interface IUserStat
{
function getUserName(param1:String) : String;
function getUserRank(param1:String) : int;
function addUserStatListener(param1:IUserStatListener) : void;
function removeUserStatListener(param1:IUserStatListener) : void;
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model.uidcheck {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class UidCheckServiceAdapt implements UidCheckService {
private var object:IGameObject;
private var impl:UidCheckService;
public function UidCheckServiceAdapt(param1:IGameObject, param2:UidCheckService) {
super();
this.object = param1;
this.impl = param2;
}
public function getMaxLength() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getMaxLength());
}
finally {
Model.popObject();
}
return result;
}
public function exist(param1:String, param2:Function) : void {
var uid:String = param1;
var callback:Function = param2;
try {
Model.object = this.object;
this.impl.exist(uid,callback);
}
finally {
Model.popObject();
}
}
public function validate(param1:String, param2:Function) : void {
var uid:String = param1;
var callback:Function = param2;
try {
Model.object = this.object;
this.impl.validate(uid,callback);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.weapons.shell {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.weapons.shell.states.ShellStates;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ShellWeaponCommunicationAdapt implements ShellWeaponCommunication {
private var object:IGameObject;
private var impl:ShellWeaponCommunication;
public function ShellWeaponCommunicationAdapt(param1:IGameObject, param2:ShellWeaponCommunication) {
super();
this.object = param1;
this.impl = param2;
}
public function tryToShoot(param1:int, param2:int, param3:int, param4:Vector3) : void {
var clientTime:int = param1;
var barrelIndex:int = param2;
var shotId:int = param3;
var direction:Vector3 = param4;
try {
Model.object = this.object;
this.impl.tryToShoot(clientTime,barrelIndex,shotId,direction);
}
finally {
Model.popObject();
}
}
public function tryToShootWithTarget(param1:int, param2:int, param3:int, param4:Vector3, param5:Tank, param6:Vector3) : void {
var clientTime:int = param1;
var barrelIndex:int = param2;
var shotId:int = param3;
var direction:Vector3 = param4;
var target:Tank = param5;
var localTargetPoint:Vector3 = param6;
try {
Model.object = this.object;
this.impl.tryToShootWithTarget(clientTime,barrelIndex,shotId,direction,target,localTargetPoint);
}
finally {
Model.popObject();
}
}
public function tryToDummyShoot(param1:int, param2:int) : void {
var clientTime:int = param1;
var barrelIndex:int = param2;
try {
Model.object = this.object;
this.impl.tryToDummyShoot(clientTime,barrelIndex);
}
finally {
Model.popObject();
}
}
public function tryToHit(param1:int, param2:ShellStates, param3:Tank = null) : void {
var shotId:int = param1;
var states:ShellStates = param2;
var target:Tank = param3;
try {
Model.object = this.object;
this.impl.tryToHit(shotId,states,target);
}
finally {
Model.popObject();
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.bonus.showing.items {
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 platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.bonus.showing.items.BonusItemsShowingCC;
public class CodecBonusItemsShowingCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_bonuses:ICodec;
public function CodecBonusItemsShowingCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_bonuses = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(IGameObject,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BonusItemsShowingCC = new BonusItemsShowingCC();
local2.bonuses = this.codec_bonuses.decode(param1) as Vector.<IGameObject>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BonusItemsShowingCC = BonusItemsShowingCC(param2);
this.codec_bonuses.encode(param1,local3.bonuses);
}
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased.rugby.explosion {
public interface IBallExplosionModelBase {
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.base {
public class ShopItemSkins {
public static const RED:RedShopItemSkin = new RedShopItemSkin();
public static const GREY:GreyShopItemSkin = new GreyShopItemSkin();
public static const GREEN:GreenShopItemSkin = new GreenShopItemSkin();
public function ShopItemSkins() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.weapon {
[ModelInterface]
public interface RocketLauncherWeaponProvider {
function remoteWeapon() : RemoteRocketLauncherWeapon;
}
}
|
package projects.tanks.client.garage.models.item.premium {
public class PremiumItemCC {
private var _premiumItem:Boolean;
public function PremiumItemCC(param1:Boolean = false) {
super();
this._premiumItem = param1;
}
public function get premiumItem() : Boolean {
return this._premiumItem;
}
public function set premiumItem(param1:Boolean) : void {
this._premiumItem = param1;
}
public function toString() : String {
var local1:String = "PremiumItemCC [";
local1 += "premiumItem = " + this.premiumItem + " ";
return local1 + "]";
}
}
}
|
package forms.buttons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class MainPanelSpinsButton_normalBtn extends BitmapAsset
{
public function MainPanelSpinsButton_normalBtn()
{
super();
}
}
}
|
package alternativa.tanks.model.bonus.showing.image {
import alternativa.tanks.gui.CongratulationsWindowConfiscate;
import alternativa.tanks.gui.CongratulationsWindowPresent;
import alternativa.tanks.gui.IDestroyWindow;
import alternativa.tanks.model.bonus.showing.info.BonusInfo;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.client.panel.model.bonus.showing.image.BonusImageShowingModelBase;
import projects.tanks.client.panel.model.bonus.showing.image.IBonusImageShowingModelBase;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
[ModelInfo]
public class BonusImageShowingModel extends BonusImageShowingModelBase implements IBonusImageShowingModelBase, ObjectLoadPostListener, ObjectUnloadListener {
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
public function BonusImageShowingModel() {
super();
}
public function objectLoadedPost() : void {
if(Boolean(lobbyLayoutService.isSwitchInProgress()) || lobbyLayoutService.getCurrentState() == LayoutState.BATTLE) {
this.showCongratulationsWindowLater();
} else {
this.createCongratulationsWindow();
}
}
private function showCongratulationsWindowLater() : void {
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,getFunctionWrapper(this.onEndLayoutSwitch));
}
private function onEndLayoutSwitch(param1:LobbyLayoutServiceEvent) : void {
if(param1.state != LayoutState.BATTLE) {
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,getFunctionWrapper(this.onEndLayoutSwitch));
this.createCongratulationsWindow();
}
}
private function createCongratulationsWindow() : void {
var local2:IDestroyWindow = null;
var local1:BonusInfo = BonusInfo(object.adapt(BonusInfo));
if(local1.getImage() == null) {
local2 = new CongratulationsWindowPresent(null,getInitParam().image,local1.getTopText(),local1.getBottomText(),object);
} else {
local2 = new CongratulationsWindowConfiscate(object,getInitParam().image.data,local1.getImage().data,local1.getTopText(),local1.getBottomText());
}
putData(IDestroyWindow,local2);
}
public function objectUnloaded() : void {
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,getFunctionWrapper(this.onEndLayoutSwitch));
var local1:IDestroyWindow = IDestroyWindow(getData(IDestroyWindow));
if(local1 != null) {
local1.destroy();
}
}
}
}
|
package alternativa.tanks.model.item.category {
import projects.tanks.client.commons.types.ItemViewCategoryEnum;
import projects.tanks.client.garage.models.item.view.IItemViewCategoryModelBase;
import projects.tanks.client.garage.models.item.view.ItemViewCategoryModelBase;
[ModelInfo]
public class ItemViewCategoryModel extends ItemViewCategoryModelBase implements IItemViewCategoryModelBase, IItemViewCategory {
public function ItemViewCategoryModel() {
super();
}
public function getViewCategory() : ItemViewCategoryEnum {
return getInitParam().category;
}
public function setCategory(param1:ItemViewCategoryEnum) : void {
getInitParam().category = param1;
}
}
}
|
package projects.tanks.client.panel.model.premiumaccount.alert {
public class PremiumAccountAlertCC {
private var _localRuntimeUser:Boolean;
private var _needShowNotificationCompletionPremium:Boolean;
private var _needShowWelcomeAlert:Boolean;
private var _reminderCompletionPremiumTime:Number;
private var _wasShowAlertForFirstPurchasePremium:Boolean;
private var _wasShowReminderCompletionPremium:Boolean;
public function PremiumAccountAlertCC(param1:Boolean = false, param2:Boolean = false, param3:Boolean = false, param4:Number = 0, param5:Boolean = false, param6:Boolean = false) {
super();
this._localRuntimeUser = param1;
this._needShowNotificationCompletionPremium = param2;
this._needShowWelcomeAlert = param3;
this._reminderCompletionPremiumTime = param4;
this._wasShowAlertForFirstPurchasePremium = param5;
this._wasShowReminderCompletionPremium = param6;
}
public function get localRuntimeUser() : Boolean {
return this._localRuntimeUser;
}
public function set localRuntimeUser(param1:Boolean) : void {
this._localRuntimeUser = param1;
}
public function get needShowNotificationCompletionPremium() : Boolean {
return this._needShowNotificationCompletionPremium;
}
public function set needShowNotificationCompletionPremium(param1:Boolean) : void {
this._needShowNotificationCompletionPremium = param1;
}
public function get needShowWelcomeAlert() : Boolean {
return this._needShowWelcomeAlert;
}
public function set needShowWelcomeAlert(param1:Boolean) : void {
this._needShowWelcomeAlert = param1;
}
public function get reminderCompletionPremiumTime() : Number {
return this._reminderCompletionPremiumTime;
}
public function set reminderCompletionPremiumTime(param1:Number) : void {
this._reminderCompletionPremiumTime = param1;
}
public function get wasShowAlertForFirstPurchasePremium() : Boolean {
return this._wasShowAlertForFirstPurchasePremium;
}
public function set wasShowAlertForFirstPurchasePremium(param1:Boolean) : void {
this._wasShowAlertForFirstPurchasePremium = param1;
}
public function get wasShowReminderCompletionPremium() : Boolean {
return this._wasShowReminderCompletionPremium;
}
public function set wasShowReminderCompletionPremium(param1:Boolean) : void {
this._wasShowReminderCompletionPremium = param1;
}
public function toString() : String {
var local1:String = "PremiumAccountAlertCC [";
local1 += "localRuntimeUser = " + this.localRuntimeUser + " ";
local1 += "needShowNotificationCompletionPremium = " + this.needShowNotificationCompletionPremium + " ";
local1 += "needShowWelcomeAlert = " + this.needShowWelcomeAlert + " ";
local1 += "reminderCompletionPremiumTime = " + this.reminderCompletionPremiumTime + " ";
local1 += "wasShowAlertForFirstPurchasePremium = " + this.wasShowAlertForFirstPurchasePremium + " ";
local1 += "wasShowReminderCompletionPremium = " + this.wasShowReminderCompletionPremium + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.services.initialeffects {
import alternativa.types.Long;
import flash.utils.getTimer;
public class InitialEffectsService implements IInitialEffectsService {
private var initialEffects:Vector.<ClientBattleEffect>;
public function InitialEffectsService() {
super();
}
public function takeInitialEffects(param1:Long) : Vector.<ClientBattleEffect> {
var local2:Vector.<ClientBattleEffect> = null;
var local3:int = 0;
var local4:int = 0;
var local5:ClientBattleEffect = null;
if(this.initialEffects != null) {
local3 = int(this.initialEffects.length);
local4 = 0;
while(local4 < local3) {
local5 = this.initialEffects[local4];
if(local5.userId == param1) {
if(local2 == null) {
local2 = new Vector.<ClientBattleEffect>();
}
local2.push(local5);
var local6:* = local4--;
this.initialEffects[local6] = this.initialEffects[--local3];
this.initialEffects.length = local3;
}
local4++;
}
if(local3 == 0) {
this.initialEffects = null;
}
}
return local2;
}
public function addInitialEffect(param1:Long, param2:int, param3:int, param4:int) : void {
if(this.initialEffects == null) {
this.initialEffects = new Vector.<ClientBattleEffect>();
}
this.initialEffects.push(new ClientBattleEffect(getTimer(),param1,param2,param3,param4));
}
public function removeInitialEffect(param1:Long, param2:int) : void {
var local4:int = 0;
var local3:int = this.indexOfInitialEffect(param1,param2);
if(local3 >= 0) {
local4 = int(this.initialEffects.length);
this.initialEffects[local3] = this.initialEffects[--local4];
this.initialEffects.length = local4;
}
}
private function indexOfInitialEffect(param1:Long, param2:int) : int {
var local3:int = 0;
var local4:int = 0;
var local5:ClientBattleEffect = null;
if(this.initialEffects != null) {
local3 = int(this.initialEffects.length);
local4 = 0;
while(local4 < local3) {
local5 = this.initialEffects[local4];
if(local5.userId == param1 && local5.effectId == param2) {
return local4;
}
local4++;
}
}
return -1;
}
}
}
|
package alternativa.service
{
import alternativa.register.ClientClass;
import flash.utils.Dictionary;
public interface IClassService
{
function createClass(param1:String, param2:ClientClass, param3:String, param4:Array, param5:Array) : ClientClass;
function destroyClass(param1:String) : void;
function getClass(param1:String) : ClientClass;
function get classes() : Dictionary;
function get classList() : Array;
}
}
|
package assets.icons {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol208")]
public dynamic class InputCheckIcon extends MovieClip {
public function InputCheckIcon() {
super();
}
}
}
|
package projects.tanks.clients.flash.commons.models.moveusertoserver {
import projects.tanks.client.commons.models.moveusertoclient.IMoveUserToServerModelBase;
import projects.tanks.client.commons.models.moveusertoclient.MoveUserToServerModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.address.TanksAddressService;
[ModelInfo]
public class MoveUserToServerModel extends MoveUserToServerModelBase implements IMoveUserToServerModelBase {
[Inject]
public static var addressService:TanksAddressService;
public function MoveUserToServerModel() {
super();
}
public function move(param1:int) : void {
addressService.setServer(param1);
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.clanmanagement.ClanProfileWindow_bitmapKillsDeathsIcon.png")]
public class ClanProfileWindow_bitmapKillsDeathsIcon extends BitmapAsset {
public function ClanProfileWindow_bitmapKillsDeathsIcon() {
super();
}
}
}
|
package alternativa.tanks.servermodels.invite {
[ModelInterface]
public interface IInvite {
function checkInvite(param1:String) : void;
}
}
|
package projects.tanks.client.battleselect
{
import scpacker.Base;
public class BattleSelectModelBase extends Base
{
public function BattleSelectModelBase()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.drone {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
public class DroneSFXModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function DroneSFXModelServer(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 platform.client.fp10.core.network.command {
import platform.client.fp10.core.network.ControlChannelContext;
public interface IServerControlCommand {
function execute(param1:ControlChannelContext) : void;
}
}
|
package projects.tanks.client.panel.model
{
public class User
{
public var place:int = 0;
public var callsign:String;
public var achiviments:String;
public var kills:int = 0;
public var deaths:int = 0;
public var ratio:int = 0;
public var rank:int = 0;
public var score:int = 0;
public var wealth:int = 0;
public var rating:Number = 0;
public function User(callsign:String, achiviments:String, score:int, rank:int, place:int, kills:int, deaths:int, ratio:int, wealth:int, rating:int)
{
super();
this.place = place;
this.callsign = callsign;
this.achiviments = achiviments;
this.kills = kills;
this.deaths = deaths;
this.ratio = ratio;
this.rank = rank;
this.score = score;
this.wealth = wealth;
this.rating = rating;
}
}
}
|
package projects.tanks.client.battlefield.models.ultimate.effects.wasp.bomb {
public interface IWaspUltimateBombModelBase {
function bang() : void;
}
}
|
package alternativa.engine3d {
public namespace alternativa3d = "http://alternativaplatform.com/en/alternativa3d";
}
|
package projects.tanks.client.entrance.model.entrance.facebook {
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 FacebookEntranceModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:FacebookEntranceModelServer;
private var client:IFacebookEntranceModelBase = IFacebookEntranceModelBase(this);
private var modelId:Long = Long.getLong(173156618,-1197639698);
public function FacebookEntranceModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new FacebookEntranceModelServer(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.engine3d {
import alternativa.utils.TextureMaterialRegistry;
public interface EffectsMaterialRegistry extends TextureMaterialRegistry {
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.helper {
import flash.utils.Timer;
public class HelperTimer extends Timer {
private var _helper:Helper;
public function HelperTimer(param1:Number, param2:int) {
super(param1,param2);
}
public function get helper() : Helper {
return this._helper;
}
public function set helper(param1:Helper) : void {
this._helper = param1;
}
}
}
|
package alternativa.tanks.model.mobilelootbox {
import projects.tanks.client.panel.model.videoads.containers.IVideoAdsMobileLootBoxModelBase;
import projects.tanks.client.panel.model.videoads.containers.VideoAdsMobileLootBoxModelBase;
[ModelInfo]
public class VideoAdsMobileLootBoxModel extends VideoAdsMobileLootBoxModelBase implements IVideoAdsMobileLootBoxModelBase {
public function VideoAdsMobileLootBoxModel() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.flamethrower
{
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.model.IModel;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.sfx.flame.IFlamethrowerSFXModel;
import alternativa.tanks.models.tank.ITank;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.tank.TankModel;
import alternativa.tanks.models.weapon.IWeaponController;
import alternativa.tanks.models.weapon.WeaponUtils;
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapon.shared.ConicAreaTargetSystem;
import alternativa.tanks.models.weapon.shared.ITargetValidator;
import alternativa.tanks.models.weapon.weakening.IWeaponWeakeningModel;
import alternativa.tanks.sfx.EffectsPair;
import alternativa.tanks.vehicles.tanks.Tank;
import com.alternativaplatform.projects.tanks.client.commons.types.Vector3d;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.flamethrower.FlameThrowerModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.flamethrower.IFlameThrowerModelBase;
import com.reygazu.anticheat.variables.SecureInt;
import flash.utils.Dictionary;
import flash.utils.getTimer;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
import scpacker.tanks.WeaponsManager;
public class FlamethrowerModel extends FlameThrowerModelBase implements IFlameThrowerModelBase, IFlamethrower, IWeaponController
{
private var modelService:IModelService;
private var battlefield:IBattleField;
private var tankInterface:TankModel;
private var commonModel:IWeaponCommonModel;
private var weakeningModel:IWeaponWeakeningModel;
private var active:Boolean;
private var lastUpdateTime:SecureInt;
private var nextTargetCheckTime:SecureInt;
private var targetIds:Array;
private var targetPositions:Array;
private var targetIncarnations:Array;
private var targetDistances:Array;
private var hitPointsTargets:Array;
private var _firingOrigin:Vector3;
private var _gunGlobalDir:Vector3;
private var _xAxis:Vector3;
private var _tmpVector:Vector3;
private var localTankData:TankData;
private var localFlameData:FlamethrowerData;
private var localWeaponCommonData:WeaponCommonData;
private var currentHeat:Number = 0;
private var activeEffects:Dictionary;
private var weaponUtils:WeaponUtils;
private var targetSystem:ConicAreaTargetSystem;
private var targetValidator:ITargetValidator;
public function FlamethrowerModel()
{
this.lastUpdateTime = new SecureInt("lastUpdateTime flame");
this.nextTargetCheckTime = new SecureInt("nextTargetCheckTime flame");
this.targetIds = [];
this.targetPositions = [];
this.targetIncarnations = [];
this.targetDistances = [];
this.hitPointsTargets = [];
this._firingOrigin = new Vector3();
this._gunGlobalDir = new Vector3();
this._xAxis = new Vector3();
this._tmpVector = new Vector3();
this.activeEffects = new Dictionary();
this.weaponUtils = WeaponUtils.getInstance();
this.targetValidator = new FlamethrowerTargetValidator();
super();
_interfaces.push(IModel,IFlameThrowerModelBase,IFlamethrower,IWeaponController);
}
public function initObject(clientObject:ClientObject, coneAngle:Number, coolingSpeed:int, heatingLimit:int, heatingSpeed:int, range:Number, targetDetectionIntervalMsec:int) : void
{
if(this.modelService == null)
{
this.modelService = Main.osgi.getService(IModelService) as IModelService;
this.battlefield = this.modelService.getModelsByInterface(IBattleField)[0] as IBattleField;
this.tankInterface = this.modelService.getModelsByInterface(ITank)[0] as TankModel;
this.commonModel = this.modelService.getModelsByInterface(IWeaponCommonModel)[0] as IWeaponCommonModel;
this.weakeningModel = this.modelService.getModelsByInterface(IWeaponWeakeningModel)[0] as IWeaponWeakeningModel;
}
var data:FlamethrowerData = new FlamethrowerData();
data.coneAngle.value = coneAngle;
data.coolingSpeed.value = coolingSpeed;
data.heatingSpeed.value = heatingSpeed;
data.heatLimit.value = heatingLimit;
data.range.value = range * 100;
data.targetDetectionInterval.value = targetDetectionIntervalMsec;
clientObject.putParams(FlamethrowerModel,data);
}
public function startFire(clientObject:ClientObject, firingTankId:String) : void
{
var firingTankObject:ClientObject = clientObject;
if(firingTankObject == null)
{
return;
}
var firingTankData:TankData = this.tankInterface.getTankData(firingTankObject);
if(firingTankData == null || firingTankData.tank == null || !firingTankData.enabled)
{
return;
}
if(this.tankInterface.localUserData != null)
{
if(firingTankId == this.tankInterface.localUserData.user.id)
{
return;
}
}
this.addFlameEffects(this.commonModel.getCommonData(firingTankData.turret),firingTankData);
}
public function stopFire(clientObject:ClientObject, firingTankId:String) : void
{
this.removeFlameEffects(firingTankId);
}
public function getFlameData(clientObject:ClientObject) : FlamethrowerData
{
return clientObject.getParams(FlamethrowerModel) as FlamethrowerData;
}
public function setLocalUser(localUserData:TankData) : void
{
this.localTankData = localUserData;
this.localFlameData = this.getFlameData(WeaponsManager.getObjectFor(localUserData.turret.id));
this.localWeaponCommonData = this.commonModel.getCommonData(localUserData.turret);
this.lastUpdateTime.value = 0;
this.currentHeat = 0;
this.targetSystem = new ConicAreaTargetSystem(this.localFlameData.range.value,this.localFlameData.coneAngle.value,5,6,this.battlefield.getBattlefieldData().collisionDetector,this.targetValidator);
}
public function clearLocalUser() : void
{
this.localTankData = null;
this.localFlameData = null;
this.localWeaponCommonData = null;
this.targetSystem = null;
}
public function update(time:int, deltaTime:int) : Number
{
var muzzleLocalPos:Vector3 = null;
var barrelLength:Number = NaN;
var len:int = 0;
var i:int = 0;
var target:Tank = null;
var targetData:TankData = null;
var targetPosition:Vector3 = null;
var pos3d:Vector3d = null;
if(!this.active)
{
if(this.currentHeat > 0)
{
this.currentHeat -= 0.001 * (time - this.lastUpdateTime.value) * this.localFlameData.coolingSpeed.value;
if(this.currentHeat < 0)
{
this.currentHeat = 0;
}
}
this.lastUpdateTime.value = time;
return 1 - this.currentHeat / this.localFlameData.heatLimit.value;
}
if(this.currentHeat >= this.localFlameData.heatLimit.value)
{
this.deactivateWeapon(time,true);
return 0;
}
if(time >= this.nextTargetCheckTime.value)
{
muzzleLocalPos = this.localWeaponCommonData.muzzles[0];
this.weaponUtils.calculateGunParams(this.localTankData.tank.skin.turretMesh,muzzleLocalPos,this._tmpVector,this._firingOrigin,this._xAxis,this._gunGlobalDir);
this.targetIds.length = 0;
barrelLength = muzzleLocalPos.y;
this.targetSystem.getTargets(this.localTankData.tank,barrelLength,0.3,this._firingOrigin,this._gunGlobalDir,this._xAxis,this.targetIds,this.targetDistances,this.hitPointsTargets);
len = this.targetIds.length;
if(len > 0)
{
for(i = 0; i < len; i++)
{
target = this.targetIds[i];
targetData = target.tankData;
this.targetIds[i] = targetData.user.id;
this.targetDistances[i] = 0.01 * this.targetDistances[i];
this.targetIncarnations[i] = targetData.incarnation;
targetPosition = target.state.pos;
pos3d = this.targetPositions[i];
if(pos3d == null)
{
pos3d = new Vector3d(targetPosition.x,targetPosition.y,targetPosition.z);
this.targetPositions[i] = pos3d;
}
else
{
pos3d.x = targetPosition.x;
pos3d.y = targetPosition.y;
pos3d.z = targetPosition.z;
}
}
this.targetIncarnations.length = len;
this.targetPositions.length = len;
this.hitCommand(this.localTankData.turret,this.targetIds,this.targetIncarnations,this.targetPositions,this.targetDistances);
}
this.nextTargetCheckTime.value += this.localFlameData.targetDetectionInterval.value;
}
this.currentHeat += 0.001 * (time - this.lastUpdateTime.value) * this.localFlameData.heatingSpeed.value;
this.lastUpdateTime.value = time;
if(this.currentHeat > this.localFlameData.heatLimit.value)
{
return 0;
}
return 1 - this.currentHeat / this.localFlameData.heatLimit.value;
}
private function hitCommand(turret:ClientObject, targetsIds:Array, targetsIncration:Array, targetPositions:Array, targetDistances:Array) : void
{
var js:Object = new Object();
js.targetsIds = targetsIds;
js.targetPositions = targetPositions;
js.targetDistances = targetDistances;
js.tickPeriod = this.localFlameData.targetDetectionInterval.value;
trace(JSON.stringify(js));
Network(Main.osgi.getService(INetworker)).send("battle;fire;" + JSON.stringify(js));
}
private function startFireCommand(turret:ClientObject) : void
{
Network(Main.osgi.getService(INetworker)).send("battle;start_fire");
}
private function stopFireCommand(turret:ClientObject) : void
{
Network(Main.osgi.getService(INetworker)).send("battle;stop_fire");
}
public function activateWeapon(time:int) : void
{
this.active = true;
this.nextTargetCheckTime.value = time + this.localFlameData.targetDetectionInterval.value;
this.lastUpdateTime.value = time;
this.addFlameEffects(this.localWeaponCommonData,this.localTankData);
this.startFireCommand(this.localTankData.turret);
}
public function reset() : void
{
this.currentHeat = 0;
this.nextTargetCheckTime.value = 0;
this.lastUpdateTime.value = getTimer();
}
public function stopEffects(ownerTankData:TankData) : void
{
this.removeFlameEffects(ownerTankData.user.id);
}
public function deactivateWeapon(time:int, sendServerCommand:Boolean) : void
{
this.active = false;
this.nextTargetCheckTime.value = 0;
this.lastUpdateTime.value = time;
this.removeFlameEffects(this.localTankData.user.id);
if(sendServerCommand)
{
this.stopFireCommand(this.localTankData.turret);
}
}
private function addFlameEffects(commonData:WeaponCommonData, tankData:TankData) : void
{
var sfxModel:IFlamethrowerSFXModel = WeaponsManager.getFlamethrowerSFX(tankData.turret);
var effects:EffectsPair = sfxModel.getSpecialEffects(tankData,commonData.muzzles[commonData.currBarrel],tankData.tank.skin.turretMesh,this.weakeningModel);
this.activeEffects[tankData.user.id] = effects;
this.battlefield.addGraphicEffect(effects.graphicEffect);
this.battlefield.addSound3DEffect(effects.soundEffect);
}
private function removeFlameEffects(userId:String) : void
{
var effectsPair:EffectsPair = this.activeEffects[userId];
if(effectsPair != null)
{
delete this.activeEffects[userId];
if(effectsPair.graphicEffect != null)
{
effectsPair.graphicEffect.kill();
}
if(effectsPair.soundEffect != null)
{
effectsPair.soundEffect.kill();
}
if(effectsPair.lightEffect != null && effectsPair.muzzleLightEffect != null)
{
effectsPair.lightEffect.stop();
effectsPair.lightEffect = null;
effectsPair.muzzleLightEffect.stop();
effectsPair.muzzleLightEffect = null;
}
}
}
}
}
|
package controls.scroller.blue
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ScrollSkinBlue_trackTop extends BitmapAsset
{
public function ScrollSkinBlue_trackTop()
{
super();
}
}
}
|
package alternativa.tanks.model.item.item {
import platform.client.fp10.core.resource.types.ImageResource;
[ModelInterface]
public interface IItem {
function getPosition() : int;
function getPreviewResource() : ImageResource;
function getMaxRank() : int;
function getMinRank() : int;
}
}
|
package alternativa.tanks.gui
{
import alternativa.init.Main;
import alternativa.object.ClientObject;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.ImageConst;
import alternativa.tanks.locale.constants.TextConst;
import controls.DefaultButton;
import controls.Label;
import controls.TankWindow;
import controls.TankWindowHeader;
import controls.TankWindowInner;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import flash.geom.Point;
import flash.text.TextFormatAlign;
public class CongratulationsWindowPresent extends Sprite
{
private static var abonBd:BitmapData;
[Embed(source="1194.png")]
private static const bitmapCrys:Class;
private static const crysBd:BitmapData = new bitmapCrys().bitmapData;
[Embed(source="1116.png")]
private static const bitmapCryss:Class;
private static const crys:BitmapData = new bitmapCryss().bitmapData;
public static const CRYSTALS:int = 0;
public static const NOSUPPLIES:int = 1;
public static const DOUBLE_CRYSTALLS:int = 2;
private var window:TankWindow;
private var inner:TankWindowInner;
private var messageTopLabel:Label;
private var messageBottomLabel:Label;
private var presentBitmap:Bitmap;
public var closeButton:DefaultButton;
private var bannerObject:ClientObject;
private var bannerContainer:Sprite;
private var bannerBmp:Bitmap;
private var bannerURL:String;
private var windowWidth:int = 450;
private const windowMargin:int = 12;
private const margin:int = 9;
private const buttonSize:Point = new Point(104,33);
private const space:int = 8;
public function CongratulationsWindowPresent(type:int, bannerObject:ClientObject, numCrystals:int = 0)
{
var messageTop:String = null;
var messageBottom:String = null;
super();
var localeService:ILocaleService = ILocaleService(Main.osgi.getService(ILocaleService));
this.bannerContainer = new Sprite();
this.bannerBmp = new Bitmap();
this.bannerContainer.addChild(this.bannerBmp);
if(type == CRYSTALS)
{
this.presentBitmap = new Bitmap(crysBd);
messageTop = ILocaleService(Main.osgi.getService(ILocaleService)).getText(TextConst.FREE_BONUSES_WINDOW_MESSAGE_TEXT);
messageBottom = TextConst.setVarsInString(ILocaleService(Main.osgi.getService(ILocaleService)).getText(TextConst.FREE_BONUSES_WINDOW_MESSAGE_CRYSTALS_TEXT),numCrystals);
}
else if(type == NOSUPPLIES)
{
this.presentBitmap = new Bitmap(ILocaleService(Main.osgi.getService(ILocaleService)).getImage(ImageConst.CONGRATULATION_WINDOW_TICKET_IMAGE));
messageTop = ILocaleService(Main.osgi.getService(ILocaleService)).getText(TextConst.FREE_BONUSES_WINDOW_MESSAGE_TEXT);
messageBottom = ILocaleService(Main.osgi.getService(ILocaleService)).getText(TextConst.FREE_BONUSES_WINDOW_MESSAGE_NOSUPPLIES_TEXT);
}
else
{
this.presentBitmap = new Bitmap(crys);
messageTop = "";
messageBottom = ILocaleService(Main.osgi.getService(ILocaleService)).getText(TextConst.FREE_BONUSES_WINDOW_MESSAGE_DOUBLECRYSTALLS_TEXT);
}
if(type == 0 || type == 1)
{
this.windowWidth = this.presentBitmap.width + this.windowMargin * 2 + this.margin * 2;
this.window = new TankWindow(this.windowWidth,this.presentBitmap.height);
addChild(this.window);
this.window.headerLang = ILocaleService(Main.osgi.getService(ILocaleService)).getText(TextConst.GUI_LANG);
this.window.header = TankWindowHeader.CONGRATULATIONS;
this.inner = new TankWindowInner(0,0,TankWindowInner.GREEN);
addChild(this.inner);
this.inner.x = this.windowMargin;
this.inner.y = this.windowMargin;
this.messageTopLabel = new Label();
this.messageTopLabel.align = TextFormatAlign.CENTER;
this.messageTopLabel.wordWrap = true;
this.messageTopLabel.multiline = true;
this.messageTopLabel.size = 12;
this.messageTopLabel.text = messageTop;
this.messageTopLabel.color = 5898034;
this.messageTopLabel.x = this.windowMargin * 2;
this.messageTopLabel.y = this.windowMargin * 2;
this.messageTopLabel.width = this.windowWidth - this.windowMargin * 4;
addChild(this.messageTopLabel);
this.presentBitmap.x = this.margin + this.windowMargin;
this.presentBitmap.y = this.messageTopLabel.y + this.messageTopLabel.height - 20;
addChild(this.presentBitmap);
this.messageBottomLabel = new Label();
this.messageBottomLabel.align = TextFormatAlign.CENTER;
this.messageBottomLabel.wordWrap = true;
this.messageBottomLabel.multiline = true;
this.messageBottomLabel.size = 12;
this.messageBottomLabel.color = 5898034;
this.messageBottomLabel.htmlText = messageBottom;
this.messageBottomLabel.x = this.windowMargin * 2;
this.messageBottomLabel.y = this.presentBitmap.y + this.presentBitmap.height - 20;
this.messageBottomLabel.width = this.windowWidth - this.windowMargin * 4;
addChild(this.messageBottomLabel);
this.closeButton = new DefaultButton();
addChild(this.closeButton);
this.closeButton.label = ILocaleService(Main.osgi.getService(ILocaleService)).getText(TextConst.FREE_BONUSES_WINDOW_BUTTON_CLOSE_TEXT);
this.window.height = this.messageBottomLabel.y + this.messageBottomLabel.height + this.closeButton.height + this.margin * 3;
this.closeButton.y = this.window.height - this.margin - 35;
this.closeButton.x = this.window.width - this.closeButton.width >> 1;
this.inner.width = this.window.width - this.windowMargin * 2;
this.inner.height = this.window.height - this.windowMargin - this.margin * 2 - this.buttonSize.y + 2;
}
else
{
this.windowWidth = this.presentBitmap.width * 2 - this.windowMargin * 2 + 5;
this.window = new TankWindow(this.windowWidth,this.presentBitmap.height);
addChild(this.window);
this.window.headerLang = ILocaleService(Main.osgi.getService(ILocaleService)).getText(TextConst.GUI_LANG);
this.window.header = TankWindowHeader.CONGRATULATIONS;
this.inner = new TankWindowInner(0,0,TankWindowInner.GREEN);
addChild(this.inner);
this.inner.x = this.windowMargin;
this.inner.y = this.windowMargin;
this.messageTopLabel = new Label();
this.messageTopLabel.align = TextFormatAlign.LEFT;
this.messageTopLabel.wordWrap = true;
this.messageTopLabel.multiline = true;
this.messageTopLabel.size = 12;
this.messageTopLabel.text = messageTop;
this.messageTopLabel.color = 5898034;
this.messageTopLabel.x = this.windowMargin * 2;
this.messageTopLabel.y = this.windowMargin * 2;
this.messageTopLabel.width = this.windowWidth - this.windowMargin * 4;
addChild(this.messageTopLabel);
this.messageBottomLabel = new Label();
this.messageBottomLabel.align = TextFormatAlign.LEFT;
this.messageBottomLabel.wordWrap = true;
this.messageBottomLabel.multiline = true;
this.messageBottomLabel.size = 12;
this.messageBottomLabel.color = 5898034;
this.messageBottomLabel.htmlText = messageBottom;
this.messageBottomLabel.x = this.windowMargin * 2;
this.messageBottomLabel.y = this.messageTopLabel.y + this.messageTopLabel.height - 7;
this.messageBottomLabel.width = this.windowWidth - this.windowMargin * 4;
addChild(this.messageBottomLabel);
this.presentBitmap.x = this.presentBitmap.width / 2 + this.inner.width / 2 - 25;
this.presentBitmap.y = this.messageBottomLabel.y + this.messageBottomLabel.height + 10;
addChild(this.presentBitmap);
this.closeButton = new DefaultButton();
addChild(this.closeButton);
this.closeButton.label = ILocaleService(Main.osgi.getService(ILocaleService)).getText(TextConst.FREE_BONUSES_WINDOW_BUTTON_CLOSE_TEXT);
this.window.height = this.presentBitmap.y + this.messageBottomLabel.height + this.closeButton.height + this.margin * 3;
this.closeButton.y = this.window.height - this.margin - 35;
this.closeButton.x = this.window.width - this.closeButton.width >> 1;
this.inner.width = this.window.width - this.windowMargin * 2;
this.inner.height = this.window.height - this.windowMargin - this.margin * 2 - this.buttonSize.y + 2;
}
}
}
}
|
package alternativa.tanks.display.usertitle
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ProgressBarSkin_hpLeftBgDmCls extends BitmapAsset
{
public function ProgressBarSkin_hpLeftBgDmCls()
{
super();
}
}
}
|
package projects.tanks.client.tanksservices.model.formatbattle {
public interface IEquipmentConstraintsNamingModelBase {
}
}
|
package alternativa.startup {
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.media.Sound;
import flash.media.SoundLoaderContext;
import flash.net.URLLoader;
import flash.net.URLLoaderDataFormat;
import flash.net.URLRequest;
import flash.utils.ByteArray;
import flash.utils.getDefinitionByName;
public class SoundCacheLoader extends Sound {
private var encodedUrl:String;
private var cacheDirectory:Object;
private var context:SoundLoaderContext;
private var FileClass:Class;
private var FileStreamClass:Class;
private var FileModeClass:Class;
public function SoundCacheLoader() {
super();
if(StartupSettings.isDesktop) {
this.FileClass = getDefinitionByName("flash.filesystem.File") as Class;
this.FileStreamClass = getDefinitionByName("flash.filesystem.FileStream") as Class;
this.FileModeClass = getDefinitionByName("flash.filesystem.FileMode") as Class;
this.cacheDirectory = this.FileClass.applicationStorageDirectory.resolvePath("cache");
if(!this.cacheDirectory.exists) {
this.cacheDirectory.createDirectory();
} else if(!this.cacheDirectory.isDirectory) {
throw new Error("Cannot create directory." + this.cacheDirectory.nativePath + " is already exists.");
}
}
}
override public function load(param1:URLRequest, param2:SoundLoaderContext = null) : void {
if(!StartupSettings.isDesktop || param1 == null) {
super.load(param1,param2);
return;
}
this.context = param2;
this.encodedUrl = URLEncoder.encode(param1.url);
var local3:Object = this.cacheDirectory.resolvePath(this.encodedUrl);
if(local3.exists) {
super.load(new URLRequest(local3.url),param2);
return;
}
var local4:URLLoader = new URLLoader();
local4.dataFormat = URLLoaderDataFormat.BINARY;
local4.addEventListener(Event.COMPLETE,this.onBytesLoaded,false,0,true);
local4.addEventListener(IOErrorEvent.IO_ERROR,this.onIOError,false,0,true);
local4.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onSecurityError,false,0,true);
local4.load(param1);
}
private function onIOError(param1:Event) : void {
dispatchEvent(new IOErrorEvent("SoundCacheLoader: IOError!"));
}
private function onSecurityError(param1:Event) : void {
dispatchEvent(new SecurityErrorEvent("SoundCacheLoader: Security error!"));
}
private function onBytesLoaded(param1:Event) : void {
var e:Event = param1;
var bytes:ByteArray = URLLoader(e.target).data as ByteArray;
var file:Object = new this.FileClass(this.cacheDirectory.resolvePath(this.encodedUrl).nativePath);
var fileStream:Object = new this.FileStreamClass();
try {
fileStream.open(file,this.FileModeClass.WRITE);
fileStream.writeBytes(bytes);
fileStream.close();
}
catch(e:Error) {
dispatchEvent(new IOErrorEvent("SoundCacheLoader error! " + e.message + "url: " + encodedUrl));
}
super.load(new URLRequest(file.url),this.context);
}
}
}
|
package projects.tanks.client.battleservice.model.statistics {
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.Byte;
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 StatisticsModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:StatisticsModelServer;
private var client:IStatisticsModelBase = IStatisticsModelBase(this);
private var modelId:Long = Long.getLong(485575169,-17734339);
private var _fundChangeId:Long = Long.getLong(2027633487,-2104416877);
private var _fundChange_fundCodec:ICodec;
private var _onRankChangedId:Long = Long.getLong(794588440,-1349024015);
private var _onRankChanged_userIdCodec:ICodec;
private var _onRankChanged_newRankCodec:ICodec;
private var _onRankChanged_forceUpRankForNewbiesCodec:ICodec;
private var _resetBattleNameId:Long = Long.getLong(1688328639,-1477155462);
private var _roundFinishId:Long = Long.getLong(1570125867,640719657);
private var _roundFinish_showResultTableCodec:ICodec;
private var _roundFinish_rewardCodec:ICodec;
private var _roundFinish_timeToRestartCodec:ICodec;
private var _roundStartId:Long = Long.getLong(2027560760,1768125684);
private var _roundStart_timeLimitInSecCodec:ICodec;
private var _roundStart_valuableRoundCodec:ICodec;
private var _roundStopId:Long = Long.getLong(1312331174,-81511448);
private var _setBattleNameId:Long = Long.getLong(1481208751,-1671478579);
private var _setBattleName_nameCodec:ICodec;
private var _statusProbablyCheaterChangedId:Long = Long.getLong(844922966,157499169);
private var _statusProbablyCheaterChanged_userIdCodec:ICodec;
private var _statusProbablyCheaterChanged_suspiciousCodec:ICodec;
public function StatisticsModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new StatisticsModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(StatisticsModelCC,false)));
this._fundChange_fundCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._onRankChanged_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._onRankChanged_newRankCodec = this._protocol.getCodec(new TypeCodecInfo(Byte,false));
this._onRankChanged_forceUpRankForNewbiesCodec = this._protocol.getCodec(new TypeCodecInfo(Boolean,false));
this._roundFinish_showResultTableCodec = this._protocol.getCodec(new TypeCodecInfo(Boolean,false));
this._roundFinish_rewardCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(UserReward,false),false,1));
this._roundFinish_timeToRestartCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._roundStart_timeLimitInSecCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._roundStart_valuableRoundCodec = this._protocol.getCodec(new TypeCodecInfo(Boolean,false));
this._setBattleName_nameCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._statusProbablyCheaterChanged_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._statusProbablyCheaterChanged_suspiciousCodec = this._protocol.getCodec(new TypeCodecInfo(Boolean,false));
}
protected function getInitParam() : StatisticsModelCC {
return StatisticsModelCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._fundChangeId:
this.client.fundChange(int(this._fundChange_fundCodec.decode(param2)));
break;
case this._onRankChangedId:
this.client.onRankChanged(Long(this._onRankChanged_userIdCodec.decode(param2)),int(this._onRankChanged_newRankCodec.decode(param2)),Boolean(this._onRankChanged_forceUpRankForNewbiesCodec.decode(param2)));
break;
case this._resetBattleNameId:
this.client.resetBattleName();
break;
case this._roundFinishId:
this.client.roundFinish(Boolean(this._roundFinish_showResultTableCodec.decode(param2)),this._roundFinish_rewardCodec.decode(param2) as Vector.<UserReward>,int(this._roundFinish_timeToRestartCodec.decode(param2)));
break;
case this._roundStartId:
this.client.roundStart(int(this._roundStart_timeLimitInSecCodec.decode(param2)),Boolean(this._roundStart_valuableRoundCodec.decode(param2)));
break;
case this._roundStopId:
this.client.roundStop();
break;
case this._setBattleNameId:
this.client.setBattleName(String(this._setBattleName_nameCodec.decode(param2)));
break;
case this._statusProbablyCheaterChangedId:
this.client.statusProbablyCheaterChanged(Long(this._statusProbablyCheaterChanged_userIdCodec.decode(param2)),Boolean(this._statusProbablyCheaterChanged_suspiciousCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.clients.flash.resources.object3ds {
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
[ModelInterface]
public interface IObject3DS {
function getResource3DS() : Tanks3DSResource;
}
}
|
package controls.cellrenderer {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.cellrenderer.CellNormalSelected_normalCenter.png")]
public class CellNormalSelected_normalCenter extends BitmapAsset {
public function CellNormalSelected_normalCenter() {
super();
}
}
}
|
package projects.tanks.client.garage.models.item.resistance {
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 MountedResistancesModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _mountId:Long = Long.getLong(2114308733,189551230);
private var _mount_indexCodec:ICodec;
private var _mount_resistanceCodec:ICodec;
private var _unmountId:Long = Long.getLong(331161449,244217413);
private var _unmount_resistanceCodec:ICodec;
private var model:IModel;
public function MountedResistancesModelServer(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._mount_indexCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._mount_resistanceCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
this._unmount_resistanceCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
}
public function mount(param1:int, param2:IGameObject) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._mount_indexCodec.encode(this.protocolBuffer,param1);
this._mount_resistanceCodec.encode(this.protocolBuffer,param2);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local3:SpaceCommand = new SpaceCommand(Model.object.id,this._mountId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function unmount(param1:IGameObject) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._unmount_resistanceCodec.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._unmountId,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.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_plasmatorchIconClass.png")]
public class DeviceIcons_plasmatorchIconClass extends BitmapAsset {
public function DeviceIcons_plasmatorchIconClass() {
super();
}
}
}
|
package alternativa.tanks.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class MovingObject3DPositionProvider extends PooledObject implements Object3DPositionProvider {
private var initialPosition:Vector3 = new Vector3();
private var velocity:Vector3 = new Vector3();
private var acceleration:Number;
public function MovingObject3DPositionProvider(param1:Pool) {
super(param1);
}
public function initPosition(param1:Object3D) : void {
param1.x = this.initialPosition.x;
param1.y = this.initialPosition.y;
param1.z = this.initialPosition.z;
}
public function init(param1:Vector3, param2:Vector3, param3:Number) : void {
this.initialPosition.copy(param1);
this.velocity.copy(param2);
this.acceleration = param3;
}
public function updateObjectPosition(param1:Object3D, param2:GameCamera, param3:int) : void {
var local4:Number = 0.001 * param3;
param1.x += this.velocity.x * local4;
param1.y += this.velocity.y * local4;
param1.z += this.velocity.z * local4;
var local5:Number = this.velocity.length();
local5 += this.acceleration * local4;
if(local5 <= 0) {
this.velocity.reset();
} else {
this.velocity.normalize();
this.velocity.scale(local5);
}
}
public function destroy() : void {
recycle();
}
}
}
|
package alternativa.tanks.model.quest.common.notification {
import flash.events.EventDispatcher;
import flash.utils.Dictionary;
import projects.tanks.client.panel.model.quest.QuestTypeEnum;
public class QuestNotifierServiceImpl extends EventDispatcher implements QuestNotifierService {
private var changes:Dictionary;
public function QuestNotifierServiceImpl() {
var local1:QuestTypeEnum = null;
this.changes = new Dictionary();
super();
for each(local1 in QuestTypeEnum.values) {
this.changes[local1] = false;
}
}
public function hasChange(param1:QuestTypeEnum) : Boolean {
return this.changes[param1];
}
public function showChanges(param1:QuestTypeEnum) : void {
this.changes[param1] = true;
this.showNotification(param1);
}
public function changesViewed(param1:QuestTypeEnum) : void {
this.changes[param1] = false;
this.hideNotification(param1);
}
public function isAllChangesViewed() : Boolean {
var local1:Boolean = false;
for each(local1 in this.changes) {
if(local1) {
return false;
}
}
return true;
}
private function showNotification(param1:QuestTypeEnum) : void {
dispatchEvent(new QuestNotificationEvent(QuestNotificationEvent.SHOW_NOTIFICATION,param1));
}
private function hideNotification(param1:QuestTypeEnum = null) : void {
dispatchEvent(new QuestNotificationEvent(QuestNotificationEvent.HIDE_NOTIFICATION,param1));
}
}
}
|
package alternativa.tanks.gui {
import alternativa.osgi.service.locale.ILocaleService;
import controls.TankInput;
import controls.TankWindow;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import controls.base.TankInputBase;
import flash.display.Bitmap;
import flash.events.Event;
import flash.events.FocusEvent;
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.geom.Point;
import flash.utils.Timer;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui.DialogWindow;
public class AntiAddictionWindow extends DialogWindow {
[Inject]
public static var localeService:ILocaleService;
private static const Watches3Hours:Class = AntiAddictionWindow_Watches3Hours;
private static const Watches5Hours:Class = AntiAddictionWindow_Watches5Hours;
private var window:TankWindow;
private var okButton:DefaultButtonBase;
private var closeButton:DefaultButtonBase;
private var descText:LabelBase;
public var realNameInput:TankInputBase;
public var idCardInput:TankInputBase;
private var watches:Bitmap;
public var windowSize:Point;
private var timer:Timer;
private var secondsToWait:int = 60;
public function AntiAddictionWindow(param1:int, param2:Boolean) {
super();
this.windowSize = new Point(392,param2 ? 170 : 270);
this.window = new TankWindow();
this.window.width = this.windowSize.x;
this.window.height = this.windowSize.y;
this.window.headerLang = localeService.getText(TanksLocale.TEXT_GUI_LANG);
this.watches = param1 >= 5 * 60 ? new Watches5Hours() : new Watches3Hours();
this.watches.x = 12;
this.watches.y = 34;
this.window.addChild(this.watches);
this.okButton = new DefaultButtonBase();
this.okButton.width = 115;
this.okButton.height = 30;
this.okButton.x = 150;
this.okButton.y = 220;
this.okButton.label = "确认";
if(!param2) {
this.window.addChild(this.okButton);
}
this.closeButton = new DefaultButtonBase();
this.closeButton.width = 96;
this.closeButton.height = 30;
this.closeButton.x = 280;
this.closeButton.y = param2 ? 120 : 220;
this.closeButton.label = "取消" + " (" + this.secondsToWait + ")";
this.window.addChild(this.closeButton);
this.realNameInput = new TankInputBase();
this.realNameInput.label = "您的真实姓名:";
this.realNameInput.x = 165;
this.realNameInput.y = 30;
this.idCardInput = new TankInputBase();
this.idCardInput.label = "身份证号码:";
this.idCardInput.x = 165;
this.idCardInput.y = 70;
if(!param2) {
this.window.addChild(this.idCardInput);
this.window.addChild(this.realNameInput);
}
this.idCardInput.addEventListener(FocusEvent.FOCUS_OUT,this.validateAddictionID);
this.idCardInput.addEventListener(FocusEvent.FOCUS_IN,this.restoreInput);
this.realNameInput.addEventListener(FocusEvent.FOCUS_OUT,this.validateRealName);
this.realNameInput.addEventListener(FocusEvent.FOCUS_IN,this.restoreInput);
this.descText = new LabelBase();
this.descText.text = param1 >= 5 * 60 ? "您已进入不健康游戏时间，为了您的健康，请您立即下线休息。\n如不下线，您的身体将受到损害，您的收益已降为零，直到您的累计下线时间满5小时后，才能恢复正常。" : "您已经进入疲劳游戏时间，您的游戏收益将降为正常值的50%，为了您的健康，请尽快下线休息，做适当身体活动，合理安排学习生活。";
this.descText.x = param2 ? 80 : 14;
this.descText.y = param2 ? 40 : 120;
this.descText.wordWrap = true;
this.descText.height = 80;
this.descText.width = param2 ? 300 : 370;
this.window.addChild(this.descText);
addChild(this.window);
this.closeButton.enable = false;
this.timer = new Timer(1000);
this.timer.addEventListener(TimerEvent.TIMER,this.onTimer);
this.timer.start();
this.closeButton.addEventListener(MouseEvent.CLICK,this.onCancelClicked);
this.okButton.addEventListener(MouseEvent.CLICK,this.onOkClicked);
dialogService.enqueueDialog(this);
}
private static function trimString(param1:String) : String {
if(param1.charAt(0) == " ") {
param1 = trimString(param1.substring(1));
}
if(param1.charAt(param1.length - 1) == " ") {
param1 = trimString(param1.substring(0,param1.length - 1));
}
return param1;
}
private function onTimer(param1:TimerEvent) : void {
if(--this.secondsToWait < 0) {
this.closeButton.label = "取消";
this.closeButton.enable = true;
this.timer.stop();
} else {
this.closeButton.label = "取消" + " (" + this.secondsToWait + ")";
}
}
private function restoreInput(param1:FocusEvent) : void {
var local2:TankInput = param1.currentTarget as TankInput;
local2.validValue = true;
}
private function validateRealName(param1:FocusEvent) : void {
var local2:RegExp = null;
if(this.realNameInput != null) {
local2 = /^[一-龥]+$/;
this.realNameInput.validValue = Boolean(this.realNameInput.value.match(local2)) || trimString(this.realNameInput.value).length == 0;
}
}
private function validateAddictionID(param1:FocusEvent) : void {
var local2:RegExp = null;
if(this.idCardInput != null) {
local2 = /^\d{17}[0-9xX]$/;
this.idCardInput.validValue = Boolean(this.idCardInput.value.match(local2)) || trimString(this.idCardInput.value).length == 0;
}
}
public function disableButtons() : void {
this.okButton.enable = false;
this.closeButton.enable = false;
}
public function enableButtons() : void {
this.okButton.enable = true;
if(this.secondsToWait < 0) {
this.closeButton.enable = true;
}
}
private function onCancelClicked(param1:Event = null) : void {
this.removeDialog();
}
private function onOkClicked(param1:Event = null) : void {
dispatchEvent(new Event(Event.COMPLETE));
}
public function removeDialog() : void {
dialogService.removeDialog(this);
}
}
}
|
package alternativa.tanks.models.battle.battlefield {
import alternativa.types.Long;
import projects.tanks.client.users.services.chatmoderator.ChatModeratorLevel;
public interface BattleUserInfoService {
function getUserName(param1:Long) : String;
function getUserRank(param1:Long) : int;
function isUserSuspected(param1:Long) : Boolean;
function getChatModeratorLevel(param1:Long) : ChatModeratorLevel;
function hasUserPremium(param1:Long) : Boolean;
function addBattleUserInfoListener(param1:BattleUserInfoListener) : void;
function removeBattleUserInfoListener(param1:BattleUserInfoListener) : void;
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapSmallRank30.png")]
public class DefaultRanksBitmaps_bitmapSmallRank30 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapSmallRank30() {
super();
}
}
}
|
package alternativa.tanks
{
import alternativa.engine3d.containers.ConflictContainer;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.MipMapping;
import alternativa.engine3d.core.Shadow;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.tanks.materials.AnimatedPaintMaterial;
import alternativa.tanks.vehicles.tanks.TrackSkin;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.Shape;
import scpacker.resource.images.ImageResource;
import scpacker.resource.images.MultiframeResourceData;
public class Tank3D extends ConflictContainer
{
private static var defaultColormap:BitmapData;
private var hull:Tank3DPart;
private var turret:Tank3DPart;
private var colormap:BitmapData;
private var animatedColormap:Boolean;
private var multiframeData:MultiframeResourceData;
private var leftTrackSkin:TrackSkin;
private var rightTrackSkin:TrackSkin;
public var shadow:Shadow;
public function Tank3D(hull:Tank3DPart, turret:Tank3DPart, colormap:ImageResource)
{
super();
resolveByAABB = true;
this.setHull(hull);
this.setTurret(turret);
this.setColorMap(colormap);
this.shadow = new Shadow(128,6,100,5000,10000,516,1);
this.shadow.offset = 100;
this.shadow.backFadeRange = 100;
}
private function getDefaultColormap() : BitmapData
{
if(defaultColormap == null)
{
defaultColormap = new BitmapData(1,1,false,6710886);
}
return defaultColormap;
}
public function setColorMap(colormap:ImageResource) : void
{
this.colormap = colormap != null ? colormap.bitmapData as BitmapData : this.getDefaultColormap();
if(this.hull != null)
{
this.hull.animatedPaint = colormap != null ? Boolean(Boolean(colormap.animatedMaterial)) : Boolean(Boolean(false));
}
if(this.turret != null)
{
this.turret.animatedPaint = colormap != null ? Boolean(Boolean(colormap.animatedMaterial)) : Boolean(Boolean(false));
}
this.animatedColormap = colormap != null ? Boolean(Boolean(colormap.animatedMaterial)) : Boolean(Boolean(false));
this.multiframeData = colormap != null ? colormap.multiframeData : null;
this.updatePartTexture(this.hull);
this.updatePartTexture(this.turret);
}
public function setHull(value:Tank3DPart) : void
{
if(this.hull != null)
{
removeChild(this.hull.mesh);
}
if(value == null)
{
return;
}
this.hull = value;
addChild(this.hull.mesh);
this.hull.mesh.x = 0;
this.hull.mesh.y = 0;
this.hull.mesh.z = 0;
this.updatePartTexture(this.hull);
this.updateMountPoint();
this.shadow.addCaster(this.hull.mesh);
}
public function setTurret(value:Tank3DPart) : void
{
if(this.turret != null)
{
removeChild(this.turret.mesh);
}
if(value == null)
{
return;
}
this.turret = value;
addChild(this.turret.mesh);
this.updatePartTexture(this.turret);
this.updateMountPoint();
this.shadow.addCaster(this.turret.mesh);
}
private function updatePartTexture(part:Tank3DPart) : void
{
var material:Material = null;
if(part == null || this.colormap == null)
{
return;
}
var shape:Shape = new Shape();
shape.graphics.beginBitmapFill(this.colormap);
shape.graphics.drawRect(0,0,part.lightmap.width,part.lightmap.height);
var texture:BitmapData = new BitmapData(part.lightmap.width,part.lightmap.height,false,0);
texture.draw(shape);
texture.draw(part.lightmap,null,null,BlendMode.HARDLIGHT);
texture.draw(part.details);
if(this.animatedColormap)
{
material = new AnimatedPaintMaterial(this.colormap,part.lightmap,part.details,this.colormap.width / this.multiframeData.widthFrame,this.colormap.height / this.multiframeData.heigthFrame,this.multiframeData.fps,this.multiframeData.numFrames,1);
}
else
{
material = new TextureMaterial(texture,false,true,MipMapping.PER_PIXEL,part.mesh.calculateResolution(texture.width,texture.height));
}
this.createTrackSkins(part.mesh,material);
part.mesh.setMaterialToAllFaces(material);
}
public function createTrackSkins(param1:Mesh, material:Material) : void
{
var _loc2_:Face = null;
this.leftTrackSkin = new TrackSkin();
this.rightTrackSkin = new TrackSkin();
for each(_loc2_ in param1.faces)
{
if(_loc2_.id == "track" || _loc2_.material.name == "track")
{
this.addFaceToTrackSkin(_loc2_);
}
}
this.leftTrackSkin.init();
this.rightTrackSkin.init();
this.leftTrackSkin.setMaterial(material.clone());
this.rightTrackSkin.setMaterial(material.clone());
}
private function addFaceToTrackSkin(param1:Face) : void
{
var _loc2_:Vertex = param1.vertices[0];
if(_loc2_.x < 0)
{
this.leftTrackSkin.addFace(param1);
}
else
{
this.rightTrackSkin.addFace(param1);
}
}
private function updateMountPoint() : void
{
if(this.hull == null || this.turret == null)
{
return;
}
this.turret.mesh.x = this.hull.turretMountPoint.x;
this.turret.mesh.y = this.hull.turretMountPoint.y;
this.turret.mesh.z = this.hull.turretMountPoint.z;
}
}
}
|
package projects.tanks.client.garage.models.item.view {
public interface IItemViewCategoryModelBase {
}
}
|
package _codec.projects.tanks.client.battlefield.models.inventory.item {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.inventory.item.InventoryItemCC;
public class VectorCodecInventoryItemCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecInventoryItemCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(InventoryItemCC,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.<InventoryItemCC> = new Vector.<InventoryItemCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = InventoryItemCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:InventoryItemCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<InventoryItemCC> = Vector.<InventoryItemCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.battle.facilities {
import alternativa.tanks.materials.AnimatedPaintMaterial;
import alternativa.tanks.materials.PaintMaterial;
import flash.display.BitmapData;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import projects.tanks.clients.flash.commons.models.coloring.IColoring;
public class FacilityMaterialFactory {
public function FacilityMaterialFactory() {
super();
}
internal static function createMaterial(param1:BitmapData, param2:BitmapData, param3:IColoring) : PaintMaterial {
if(param3.isAnimated()) {
return getAnimatedMaterial(param3.getAnimatedColoring(),param1,param2);
}
return new PaintMaterial(param3.getColoring().data.clone(),param1,param2);
}
private static function getAnimatedMaterial(param1:MultiframeTextureResource, param2:BitmapData, param3:BitmapData) : AnimatedPaintMaterial {
var local4:int = int(param1.numFrames);
var local5:Number = Number(param1.fps);
var local6:Number = param1.data.width / param1.frameWidth;
var local7:Number = param1.data.height / param1.frameHeight;
return new AnimatedPaintMaterial(param1.data,param2,param3,local6,local7,local5,local4);
}
}
}
|
package forms.events {
import flash.events.Event;
public class AlertEvent extends Event {
public static const ALERT_BUTTON_PRESSED:String = "CloseAlert";
private var _typeButton:String;
public function AlertEvent(param1:String) {
super(ALERT_BUTTON_PRESSED,true,false);
this._typeButton = param1;
}
public function get typeButton() : String {
return this._typeButton;
}
}
}
|
package alternativa.tanks.help {
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.BubbleHelper;
public class PanelBubbleHelper extends BubbleHelper {
private var A:Number;
private var B:Number;
private var C:Number;
public function PanelBubbleHelper(param1:Number, param2:Number, param3:Number) {
super();
this.A = param1;
this.B = param2;
this.C = param3;
_showLimit = 3;
_targetPoint.y = 25;
}
override public function align(param1:int, param2:int) : void {
if(param1 < 970) {
param1 = 970;
}
_targetPoint.x = int(this.A * (param1 - this.B) + this.C);
doAlign();
}
}
}
|
package controls {
import assets.button.button_def_ACTIVE_CENTER;
import assets.button.button_def_ACTIVE_LEFT;
import assets.button.button_def_ACTIVE_RIGHT;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.filters.DropShadowFilter;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
import fonts.TanksFontService;
public class ButtonXP extends Sprite {
private var bgLeftOFF:BitmapData = new button_def_ACTIVE_LEFT();
private var bgCenterOFF:BitmapData = new button_def_ACTIVE_CENTER();
private var bgRightOFF:BitmapData = new button_def_ACTIVE_RIGHT();
private var bgLeftOVER:BitmapData = new goldButtonLeft_over();
private var bgCenterOVER:BitmapData = new goldButtonCenter_over();
private var bgRightOVER:BitmapData = new goldButtonRight_over();
private var bgLeftDOWN:BitmapData = new goldButtonLeft_pressed();
private var bgCenterDOWN:BitmapData = new goldButtonCenter_pressed();
private var bgRightDOWN:BitmapData = new goldButtonRight_pressed();
private var bgLeftUP:BitmapData = new goldButtonLeft();
private var bgCenterUP:BitmapData = new goldButtonCenter();
private var bgRightUP:BitmapData = new goldButtonRight();
private var bmpL:Bitmap = new Bitmap();
private var bmpC:Bitmap = new Bitmap();
private var bmpR:Bitmap = new Bitmap();
private var icon:Bitmap = new Bitmap(new IconXP());
protected var _label:LabelBase = new LabelBase();
private var _enable:Boolean = true;
private var _width:int;
public function ButtonXP() {
super();
this.configUI();
this.enable = true;
tabEnabled = false;
}
private function configUI() : void {
addChild(this.bmpL);
addChild(this.bmpC);
addChild(this.bmpR);
addChild(this._label);
addChild(this.icon);
this.icon.x = 3;
this.icon.y = 3;
this._label.embedFonts = TanksFontService.isEmbedFonts();
this._label.align = TextFormatAlign.LEFT;
this._label.autoSize = TextFieldAutoSize.LEFT;
this._label.selectable = false;
this._label.x = 24;
this._label.y = 4;
this._label.mouseEnabled = false;
this._label.filters = [new DropShadowFilter(1,45,0,0.7,1,1,1)];
}
public function get label() : String {
return this._label.text;
}
public function set label(param1:String) : void {
this._label.text = param1;
this._width = this._label.textWidth + 33;
this.draw(false);
}
protected function onMouseEvent(param1:MouseEvent) : void {
if(this._enable) {
switch(param1.type) {
case MouseEvent.MOUSE_OVER:
this.setState(2);
this.icon.y = 3;
this._label.y = 4;
break;
case MouseEvent.MOUSE_OUT:
this.setState(1);
this.icon.y = 3;
this._label.y = 4;
break;
case MouseEvent.MOUSE_DOWN:
this.setState(3);
this.icon.y = 4;
this._label.y = 5;
break;
case MouseEvent.MOUSE_UP:
this.setState(1);
this.icon.y = 3;
this._label.y = 4;
}
}
}
protected function addListeners() : void {
this.setState(1);
buttonMode = true;
mouseEnabled = true;
mouseChildren = true;
addEventListener(MouseEvent.MOUSE_OVER,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_OUT,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseEvent);
addEventListener(MouseEvent.MOUSE_UP,this.onMouseEvent);
}
protected function removeListeners() : void {
this.setState(0);
buttonMode = false;
mouseEnabled = false;
mouseChildren = false;
removeEventListener(MouseEvent.MOUSE_OVER,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_OUT,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseEvent);
removeEventListener(MouseEvent.MOUSE_UP,this.onMouseEvent);
}
protected function setState(param1:int = 0) : void {
switch(param1) {
case 0:
this.bmpL.bitmapData = this.bgLeftOFF;
this.bmpC.bitmapData = this.bgCenterOFF;
this.bmpR.bitmapData = this.bgRightOFF;
break;
case 1:
this.bmpL.bitmapData = this.bgLeftUP;
this.bmpC.bitmapData = this.bgCenterUP;
this.bmpR.bitmapData = this.bgRightUP;
break;
case 2:
this.bmpL.bitmapData = this.bgLeftOVER;
this.bmpC.bitmapData = this.bgCenterOVER;
this.bmpR.bitmapData = this.bgRightOVER;
break;
case 3:
this.bmpL.bitmapData = this.bgLeftDOWN;
this.bmpC.bitmapData = this.bgCenterDOWN;
this.bmpR.bitmapData = this.bgRightDOWN;
}
this.draw(param1 == 0);
}
private function draw(param1:Boolean) : void {
this.bmpC.x = this.bmpL.width;
this.bmpC.width = this._width - this.bmpL.width - (param1 ? this.bmpR.width - 1 : this.bmpR.width);
this.bmpR.x = this._width - (param1 ? this.bmpR.width - 1 : this.bmpR.width);
}
public function set enable(param1:Boolean) : void {
this._enable = param1;
if(this._enable) {
this.addListeners();
} else {
this.removeListeners();
}
}
public function get enable() : Boolean {
return this._enable;
}
}
}
|
package controls.chat
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChatPermissionsLevel_event_org extends BitmapAsset
{
public function ChatPermissionsLevel_event_org()
{
super();
}
}
}
|
package projects.tanks.client.battlefield.models.effects.activationsfx {
public class TankEffectSFXCC {
private var _effects:Vector.<EffectSFXRecordCC>;
public function TankEffectSFXCC(param1:Vector.<EffectSFXRecordCC> = null) {
super();
this._effects = param1;
}
public function get effects() : Vector.<EffectSFXRecordCC> {
return this._effects;
}
public function set effects(param1:Vector.<EffectSFXRecordCC>) : void {
this._effects = param1;
}
public function toString() : String {
var local1:String = "TankEffectSFXCC [";
local1 += "effects = " + this.effects + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.item.fitting {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ItemFittingAdapt implements ItemFitting {
private var object:IGameObject;
private var impl:ItemFitting;
public function ItemFittingAdapt(param1:IGameObject, param2:ItemFitting) {
super();
this.object = param1;
this.impl = param2;
}
public function fit() : void {
try {
Model.object = this.object;
this.impl.fit();
}
finally {
Model.popObject();
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.ultimate.effects.dictator {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.ultimate.effects.dictator.DictatorUltimateCC;
public class CodecDictatorUltimateCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_activationSound:ICodec;
private var codec_beam:ICodec;
private var codec_beamScale:ICodec;
private var codec_secondaryBeamScale:ICodec;
private var codec_star:ICodec;
private var codec_wave:ICodec;
private var codec_waveSize:ICodec;
public function CodecDictatorUltimateCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_activationSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_beam = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_beamScale = param1.getCodec(new TypeCodecInfo(Number,false));
this.codec_secondaryBeamScale = param1.getCodec(new TypeCodecInfo(Number,false));
this.codec_star = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_wave = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_waveSize = param1.getCodec(new TypeCodecInfo(Number,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:DictatorUltimateCC = new DictatorUltimateCC();
local2.activationSound = this.codec_activationSound.decode(param1) as SoundResource;
local2.beam = this.codec_beam.decode(param1) as TextureResource;
local2.beamScale = this.codec_beamScale.decode(param1) as Number;
local2.secondaryBeamScale = this.codec_secondaryBeamScale.decode(param1) as Number;
local2.star = this.codec_star.decode(param1) as TextureResource;
local2.wave = this.codec_wave.decode(param1) as TextureResource;
local2.waveSize = this.codec_waveSize.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:DictatorUltimateCC = DictatorUltimateCC(param2);
this.codec_activationSound.encode(param1,local3.activationSound);
this.codec_beam.encode(param1,local3.beam);
this.codec_beamScale.encode(param1,local3.beamScale);
this.codec_secondaryBeamScale.encode(param1,local3.secondaryBeamScale);
this.codec_star.encode(param1,local3.star);
this.codec_wave.encode(param1,local3.wave);
this.codec_waveSize.encode(param1,local3.waveSize);
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.china.partner360platform {
import flash.net.URLRequest;
import flash.net.navigateToURL;
import flash.utils.Dictionary;
import platform.client.core.general.socialnetwork.types.LoginParameters;
import platform.client.fp10.core.service.address.AddressService;
import platform.clients.fp10.libraries.alternativapartners.type.IParametersListener;
import platform.clients.fp10.libraries.alternativapartners.type.IPartner;
import projects.tanks.client.partners.impl.china.partner360platform.IPartner360PlatformModelBase;
import projects.tanks.client.partners.impl.china.partner360platform.Partner360PlatformModelBase;
[ModelInfo]
public class Partner360PlatformModel extends Partner360PlatformModelBase implements IPartner360PlatformModelBase, IPartner {
[Inject]
public static var addressService:AddressService;
private var qid:String;
private var server_id:String;
public function Partner360PlatformModel() {
super();
}
public function getLoginParameters(param1:IParametersListener) : void {
var local2:Dictionary = new Dictionary();
local2["qid"] = addressService.getQueryParameter("qid");
this.qid = local2["qid"];
local2["server_id"] = addressService.getQueryParameter("server_id");
this.server_id = local2["server_id"];
local2["time"] = addressService.getQueryParameter("time");
local2["sign"] = addressService.getQueryParameter("sign");
local2["isAdult"] = addressService.getQueryParameter("isAdult");
param1.onSetParameters(new LoginParameters(local2));
}
public function getFailRedirectUrl() : String {
return "http://game.1360.com/game/tk3d";
}
public function isExternalLoginAllowed() : Boolean {
return false;
}
public function hasPaymentAction() : Boolean {
return true;
}
public function paymentAction() : void {
navigateToURL(new URLRequest("http://pay.game.1360.com/order.html?gkey=tk3d&skey=" + this.server_id + "&sqid=" + this.qid + "&dqid=" + this.qid + "&plat=17419372" + this.server_id),"_blank");
}
public function hasRatings() : Boolean {
return true;
}
}
}
|
package alternativa.tanks.battle.events {
import flash.utils.Dictionary;
public class BattleEventDispatcherImpl implements BattleEventDispatcher {
private var numberProcessingEvents:int;
private var eventListeners:Dictionary = new Dictionary();
private var newListeners:Dictionary = new Dictionary();
private var removedListeners:Dictionary = new Dictionary();
private var dispatchedOnce:Dictionary = new Dictionary();
public function BattleEventDispatcherImpl() {
super();
}
private static function addListener(param1:Dictionary, param2:Class, param3:BattleEventListener) : void {
var local4:Vector.<BattleEventListener> = param1[param2];
if(local4 == null) {
local4 = new Vector.<BattleEventListener>();
param1[param2] = local4;
}
if(local4.indexOf(param3) < 0) {
local4.push(param3);
}
}
private static function removeListener(param1:Dictionary, param2:Class, param3:BattleEventListener) : void {
var local5:int = 0;
var local4:Vector.<BattleEventListener> = param1[param2];
if(local4 != null) {
local5 = int(local4.indexOf(param3));
if(local5 >= 0) {
if(local4.length == 1) {
delete param1[param2];
} else {
local4.splice(local5,1);
}
}
}
}
public function addBattleEventListener(param1:Class, param2:BattleEventListener) : void {
if(this.numberProcessingEvents > 0) {
removeListener(this.removedListeners,param1,param2);
addListener(this.newListeners,param1,param2);
} else {
addListener(this.eventListeners,param1,param2);
}
}
public function removeBattleEventListener(param1:Class, param2:BattleEventListener) : void {
if(this.numberProcessingEvents > 0) {
removeListener(this.newListeners,param1,param2);
addListener(this.removedListeners,param1,param2);
} else {
removeListener(this.eventListeners,param1,param2);
}
}
public function dispatchEvent(param1:Object) : void {
var local4:int = 0;
var local5:int = 0;
++this.numberProcessingEvents;
var local2:Vector.<BattleEventListener> = this.eventListeners[param1.constructor];
if(local2 != null) {
local4 = int(local2.length);
local5 = 0;
while(local5 < local4) {
BattleEventListener(local2[local5]).handleBattleEvent(param1);
local5++;
}
}
--this.numberProcessingEvents;
var local3:IBattleEvent = param1 as IBattleEvent;
if(local3 != null) {
local3.recycle();
}
this.processDeferredActions();
}
public function dispatchEventOnce(param1:Object) : void {
if(!this.dispatchedOnce[param1.constructor]) {
this.dispatchedOnce[param1.constructor] = true;
this.dispatchEvent(param1);
}
}
public function clearDispatchedOnce() : void {
this.dispatchedOnce = new Dictionary();
}
private function processDeferredActions() : void {
var local1:* = undefined;
var local2:int = 0;
var local3:int = 0;
var local4:Class = null;
var local5:Vector.<BattleEventListener> = null;
if(this.numberProcessingEvents > 0) {
return;
}
for(local1 in this.removedListeners) {
local4 = local1;
local5 = this.removedListeners[local1];
delete this.removedListeners[local1];
local3 = int(local5.length);
local2 = 0;
while(local2 < local3) {
removeListener(this.eventListeners,local4,local5[local2]);
local2++;
}
}
for(local1 in this.newListeners) {
local4 = local1;
local5 = this.newListeners[local1];
delete this.newListeners[local1];
local3 = int(local5.length);
local2 = 0;
while(local2 < local3) {
addListener(this.eventListeners,local4,local5[local2]);
local2++;
}
}
}
}
}
|
package alternativa.tanks.models.battlefield.gui.statistics.field
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class CTFScoreIndicator_flagRedClass extends BitmapAsset
{
public function CTFScoreIndicator_flagRedClass()
{
super();
}
}
}
|
package projects.tanks.client.panel.model
{
import scpacker.Base;
public class PanelModelBase extends Base
{
public function PanelModelBase()
{
super();
}
}
}
|
package alternativa.tanks.models.battlefield.effects.graffiti
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class TexturesManager_graffiti_fireball extends BitmapAsset
{
public function TexturesManager_graffiti_fireball()
{
super();
}
}
}
|
package alternativa.tanks.view.timeleftindicator {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.timeleftindicator.GreenTimeLeftIndicator_emptyMarkerClass.png")]
public class GreenTimeLeftIndicator_emptyMarkerClass extends BitmapAsset {
public function GreenTimeLeftIndicator_emptyMarkerClass() {
super();
}
}
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_BG_GREEN_PIXEL.png")]
public dynamic class bres_BG_GREEN_PIXEL extends BitmapData {
public function bres_BG_GREEN_PIXEL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.models.weapon.shotgun.sfx {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ShotgunSFXAdapt implements ShotgunSFX {
private var object:IGameObject;
private var impl:ShotgunSFX;
public function ShotgunSFXAdapt(param1:IGameObject, param2:ShotgunSFX) {
super();
this.object = param1;
this.impl = param2;
}
public function getEffects() : ShotgunEffects {
var result:ShotgunEffects = null;
try {
Model.object = this.object;
result = this.impl.getEffects();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.weapon.rocketlauncher.sfx {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.models.weapon.rocketlauncher.weapon.salvo.aim.AimSoundEffect;
import alternativa.tanks.sfx.AnimatedLightEffect;
import alternativa.tanks.sfx.AnimatedSpriteEffect;
import alternativa.tanks.sfx.MobileSound3DEffect;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.objectpool.ObjectPool;
public class RocketLauncherEffects implements AimSoundEffect {
[Inject]
public static var battleService:BattleService;
private static const EXPLOSION_OFFSET_TO_CAMERA:Number = 110;
private static const EXPLOSION_EFFECT_SIZE:int = 700;
private static const DECAL_RADIUS:Number = 250;
private static const projectionOrigin:Vector3 = new Vector3();
private var sfxData:RocketLauncherSfxData;
private var turret:Object3D;
private var aimingEffect:MobileSound3DEffect;
public function RocketLauncherEffects(param1:RocketLauncherSfxData, param2:Object3D) {
super();
this.sfxData = param1;
this.turret = param2;
}
public function playShotEffect(param1:Vector3, param2:int) : void {
var local3:Sound3D = Sound3D.create(this.sfxData.shotSounds[param2 % this.sfxData.shotSounds.length],0.8);
battleService.addSound3DEffect(Sound3DEffect.create(param1,local3));
}
public function playExplosionEffect(param1:Vector3, param2:Vector3, param3:int) : void {
var local4:ObjectPool = battleService.getObjectPool();
var local5:StaticObject3DPositionProvider = StaticObject3DPositionProvider(local4.getObject(StaticObject3DPositionProvider));
local5.init(param1,EXPLOSION_OFFSET_TO_CAMERA);
var local6:AnimatedSpriteEffect = AnimatedSpriteEffect(local4.getObject(AnimatedSpriteEffect));
var local7:Number = -Math.PI / 4 + Math.random() * Math.PI / 2;
local6.init(EXPLOSION_EFFECT_SIZE,EXPLOSION_EFFECT_SIZE,this.sfxData.explosion,local7,local5);
battleService.addGraphicEffect(local6);
this.createHitMark(param1,param2);
this.createExplosionLightEffect(param1);
var local8:Sound3D = Sound3D.create(this.sfxData.hitSounds[param3 % this.sfxData.hitSounds.length]);
battleService.addSound3DEffect(Sound3DEffect.create(param1,local8));
}
private function createHitMark(param1:Vector3, param2:Vector3) : void {
projectionOrigin.copy(param1).subtract(param2);
battleService.getBattleScene3D().addDecal(param1,projectionOrigin,DECAL_RADIUS,this.sfxData.explosionMark);
}
private function createExplosionLightEffect(param1:Vector3) : void {
var local2:AnimatedLightEffect = AnimatedLightEffect(battleService.getObjectPool().getObject(AnimatedLightEffect));
var local3:StaticObject3DPositionProvider = StaticObject3DPositionProvider(battleService.getObjectPool().getObject(StaticObject3DPositionProvider));
local3.init(param1,EXPLOSION_OFFSET_TO_CAMERA);
local2.init(local3,this.sfxData.explosionLightingAnimation);
battleService.addGraphicEffect(local2);
}
public function createRocketFlightSoundEffect(param1:Mesh, param2:Vector3) : RocketFlightEffect {
var local3:RocketFlightEffect = RocketFlightEffect(battleService.getObjectPool().getObject(RocketFlightEffect));
local3.init(param1,param2,this.sfxData.rocketFlightSound,this.sfxData);
return local3;
}
public function playAimingSoundEffect() : void {
this.killAimingSoundEffect();
var local1:Sound3D = Sound3D.create(this.sfxData.aimingSound);
this.aimingEffect = MobileSound3DEffect(battleService.getObjectPool().getObject(MobileSound3DEffect));
this.aimingEffect.init(local1,this.turret,0,Sound3D.ETERNAL_LOOP);
battleService.addSound3DEffect(this.aimingEffect);
}
public function playTargetLostSoundEffect() : void {
this.killAimingSoundEffect();
var local1:Sound3D = Sound3D.create(this.sfxData.targetLostSound);
this.aimingEffect = MobileSound3DEffect(battleService.getObjectPool().getObject(MobileSound3DEffect));
this.aimingEffect.init(local1,this.turret,0,Sound3D.ETERNAL_LOOP);
battleService.addSound3DEffect(this.aimingEffect);
}
public function playAimingCompleteSoundEffect() : void {
var local1:Sound3D = Sound3D.create(this.sfxData.aimingCompleteSound);
var local2:MobileSound3DEffect = MobileSound3DEffect(battleService.getObjectPool().getObject(MobileSound3DEffect));
local2.init(local1,this.turret);
battleService.addSound3DEffect(local2);
}
public function killAimingSoundEffect() : void {
if(this.aimingEffect != null) {
this.aimingEffect.kill();
this.aimingEffect = null;
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.pointbased {
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.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.battle.pointbased.ClientTeamPoint;
import projects.tanks.client.battlefield.types.Vector3d;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class CodecClientTeamPoint implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_flagBasePosition:ICodec;
private var codec_id:ICodec;
private var codec_teamType:ICodec;
public function CodecClientTeamPoint() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_flagBasePosition = param1.getCodec(new TypeCodecInfo(Vector3d,false));
this.codec_id = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_teamType = param1.getCodec(new EnumCodecInfo(BattleTeam,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ClientTeamPoint = new ClientTeamPoint();
local2.flagBasePosition = this.codec_flagBasePosition.decode(param1) as Vector3d;
local2.id = this.codec_id.decode(param1) as int;
local2.teamType = this.codec_teamType.decode(param1) as BattleTeam;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ClientTeamPoint = ClientTeamPoint(param2);
this.codec_flagBasePosition.encode(param1,local3.flagBasePosition);
this.codec_id.encode(param1,local3.id);
this.codec_teamType.encode(param1,local3.teamType);
}
}
}
|
package projects.tanks.client.battlefield.models.ultimate.effects.titan.generator {
import alternativa.types.Long;
public interface ITitanUltimateGeneratorModelBase {
function coverTank(param1:Long) : void;
function uncoverTank(param1:Long, param2:Boolean) : void;
}
}
|
package alternativa.tanks.gui.clanmanagement {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.clanmanagement.ClanStateButton_ButtonDownCenter.png")]
public class ClanStateButton_ButtonDownCenter extends BitmapAsset {
public function ClanStateButton_ButtonDownCenter() {
super();
}
}
}
|
package alternativa.tanks.models.tank.ultimate.wasp.bomb {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.scene3d.BattleScene3D;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.engine3d.UVFrame;
import alternativa.tanks.models.battle.facilities.BattleFacilities;
import alternativa.tanks.models.battle.facilities.FacilitySphericalZone;
import alternativa.tanks.models.battle.facilities.ICommonFacility;
import alternativa.tanks.models.battle.gui.inventory.InventorySoundService;
import alternativa.tanks.models.battle.meteor.nuclear.NuclearBangEffect;
import alternativa.tanks.models.tank.LocalTankInfoService;
import alternativa.tanks.models.tank.event.TankEntityCreationListener;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.utils.GraphicsUtils;
import alternativa.utils.TextureMaterialRegistry;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import projects.tanks.client.battlefield.models.ultimate.effects.wasp.bomb.IWaspUltimateBombModelBase;
import projects.tanks.client.battlefield.models.ultimate.effects.wasp.bomb.WaspUltimateBombCC;
import projects.tanks.client.battlefield.models.ultimate.effects.wasp.bomb.WaspUltimateBombModelBase;
import projects.tanks.client.battlefield.models.user.tank.TankLogicState;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
[ModelInfo]
public class WaspUltimateBombModel extends WaspUltimateBombModelBase implements IWaspUltimateBombModelBase, ObjectLoadPostListener, ObjectUnloadListener, TankEntityCreationListener {
[Inject]
public static var inventorySoundService:InventorySoundService;
[Inject]
public static var battleService:BattleService;
[Inject]
public static var textureMaterialRegistry:TextureMaterialRegistry;
[Inject]
public static var localTankInfoService:LocalTankInfoService;
private static const DECAL_RADIUS:Number = 1000;
private static const NUKE_BANG_VOLUME:Number = 2;
public function WaspUltimateBombModel() {
super();
}
private static function createUVFrame(param1:TextureMaterial, param2:MultiframeTextureResource) : Vector.<UVFrame> {
return GraphicsUtils.getUVFramesFromTexture(param1.texture,param2.frameWidth,param2.frameHeight,param2.numFrames);
}
public function objectLoadedPost() : void {
this.registerCheckZone();
var local1:WaspBombData = this.createBombData();
putData(WaspBombData,local1);
this.createBombSpawnSound();
this.createCountdownAnimation(local1);
}
private function registerCheckZone() : void {
this.battleFacilities().addCheckZone(object,this.getZoneCenter(),this.sphericalZone().getRadius(),false);
}
private function battleFacilities() : BattleFacilities {
return BattleFacilities(object.space.rootObject.adapt(BattleFacilities));
}
private function getZoneCenter() : Vector3 {
var local1:Vector3 = this.battleFacility().getCenter();
local1.z += this.sphericalZone().getCenterOffsetZ();
return local1;
}
private function battleFacility() : ICommonFacility {
return ICommonFacility(object.adapt(ICommonFacility));
}
private function sphericalZone() : FacilitySphericalZone {
return FacilitySphericalZone(object.adapt(FacilitySphericalZone));
}
private function createBombData() : WaspBombData {
var local1:WaspBombData = new WaspBombData();
if(localTankInfoService.isLocalTankLoaded()) {
local1.localTank = localTankInfoService.getLocalTank();
}
return local1;
}
private function createBombSpawnSound() : void {
var local1:Vector3 = this.battleFacility().getPosition();
var local2:Sound3D = Sound3D.create(getInitParam().bombPlacedSound.sound);
battleService.addSound3DEffect(Sound3DEffect.create(local1,local2));
}
private function createCountdownAnimation(param1:LocalTankPositionProvider) : void {
var local2:WaspUltimateBombCC = getInitParam();
var local3:TextureAnimation = this.createAnimation(local2.countdown);
var local4:TextureAnimation = this.createAnimation(local2.farCountdown);
var local5:Sound3D = Sound3D.create(local2.bombBeepSound.sound);
var local6:ICommonFacility = this.battleFacility();
var local7:WaspUltimateCountdownEffect = WaspUltimateCountdownEffect(battleService.getObjectPool().getObject(WaspUltimateCountdownEffect));
local7.init(local6.getPosition(),this.getZoneCenter(),this.sphericalZone().getRadius(),local2.timeLeft * 0.001,param1,this.isBombHarmlessForLocalTank(),local3,local4,local5);
battleService.getBattleScene3D().addGraphicEffect(local7);
putData(WaspUltimateCountdownEffect,local7);
}
private function createAnimation(param1:MultiframeTextureResource) : TextureAnimation {
var local2:TextureMaterial = textureMaterialRegistry.getMaterial(param1.data);
var local3:Vector.<UVFrame> = createUVFrame(local2,param1);
return new TextureAnimation(local2,local3);
}
private function isBombHarmlessForLocalTank() : Boolean {
var local1:ICommonFacility = null;
var local2:Tank = null;
var local3:BattleTeam = null;
if(localTankInfoService.isLocalTankLoaded()) {
local1 = this.battleFacility();
if(local1.getOwner() != localTankInfoService.getLocalTankObject()) {
local2 = localTankInfoService.getLocalTank();
local3 = local1.getTeam();
return local2.isSameTeam(local3);
}
}
return true;
}
public function onTankEntityCreated(param1:Tank, param2:Boolean, param3:TankLogicState) : void {
var local4:WaspBombData = null;
var local5:WaspUltimateCountdownEffect = null;
if(param2) {
local4 = WaspBombData(getData(WaspBombData));
local4.localTank = param1;
local5 = WaspUltimateCountdownEffect(getData(WaspUltimateCountdownEffect));
local5.isHarmless = this.isBombHarmlessForLocalTank();
}
}
public function bang() : void {
this.stopCountdownEffect();
var local1:WaspUltimateBombCC = getInitParam();
var local2:TextureMaterial = textureMaterialRegistry.getMaterial(local1.nuclearBangFlame.data);
var local3:TextureMaterial = textureMaterialRegistry.getMaterial(local1.nuclearBangLight.data);
var local4:TextureMaterial = textureMaterialRegistry.getMaterial(local1.nuclearBangSmoke.data);
var local5:TextureMaterial = textureMaterialRegistry.getMaterial(local1.nuclearBangWave.data);
var local6:NuclearBangEffect = new NuclearBangEffect(battleService.getObjectPool(),local3,local5,local4,local2);
var local7:BattleScene3D = battleService.getBattleScene3D();
var local8:Vector3 = this.battleFacility().getPosition();
local6.play(local8,local7);
var local9:TextureMaterial = textureMaterialRegistry.getMaterial(local1.craterDecal.data);
var local10:Vector3 = local8.clone().add(Vector3.Z_AXIS.clone().scale(5));
local7.addDecal(local8,local10,DECAL_RADIUS,local9);
var local11:GameCamera = local7.getCamera();
var local12:Sound3D = Sound3D.create(local1.nuclearBangSound.sound);
local12.checkVolume(local11.position,local8,local11.xAxis);
local12.volume = NUKE_BANG_VOLUME;
battleService.addSound3DEffect(Sound3DEffect.create(local8,local12));
}
public function objectUnloaded() : void {
this.battleFacilities().removeCheckZone(object);
this.stopCountdownEffect();
}
private function stopCountdownEffect() : void {
var local1:WaspUltimateCountdownEffect = WaspUltimateCountdownEffect(clearData(WaspUltimateCountdownEffect));
if(local1 != null) {
local1.stop();
}
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.sfx.shoot.gun
{
public interface IGunShootSFXModelBase
{
}
}
|
package projects.tanks.client.garage.models.item.discount {
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 DiscountModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:DiscountModelServer;
private var client:IDiscountModelBase = IDiscountModelBase(this);
private var modelId:Long = Long.getLong(687238537,2002147897);
public function DiscountModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new DiscountModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(DiscountCC,false)));
}
protected function getInitParam() : DiscountCC {
return DiscountCC(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 forms.events {
import flash.events.Event;
public class LoginFormEvent extends Event {
public static const TEXT_CHANGED:String = "LoginChanged";
public static const PLAY_PRESSED:String = "PlayButtonPressed";
public static const RESTORE_PRESSED:String = "RestoreButtonPressed";
public static const SHOW_RULES:String = "ShowRules";
public static const SHOW_TERMS:String = "ShowTerms";
public static const CHANGE_STATE:String = "LoginFormStateChanged";
public function LoginFormEvent(param1:String) {
super(param1,true,false);
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_aimingImpactForceClass.png")]
public class ItemInfoPanelBitmaps_aimingImpactForceClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_aimingImpactForceClass() {
super();
}
}
}
|
package forms.stat
{
import alternativa.init.Main;
import controls.Label;
import controls.Money;
import controls.rangicons.RangIconSmall;
import controls.statassets.ReferalStatLineBackgroundNormal;
import controls.statassets.ReferalStatLineBackgroundSelected;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
public class ReferralStatListRenderer extends StatListRenderer
{
public function ReferralStatListRenderer()
{
super();
}
override protected function myIcon(data:Object) : Sprite
{
var name:Label = null;
var info:Label = null;
var cont:Sprite = new Sprite();
var rangIcon:RangIconSmall = new RangIconSmall(data.rank);
name = new Label();
Main.writeVarsToConsoleChannel("REFERALS MODEL","in renderer name = %1, income = %2",data.callsign,data.income);
if(data.rank > 0)
{
rangIcon.y = 3;
rangIcon.x = 0;
cont.addChild(rangIcon);
}
name.autoSize = TextFieldAutoSize.NONE;
name.height = 18;
name.text = data.callsign;
name.x = 12;
name.width = _width - 72;
cont.addChild(name);
info = new Label();
info.autoSize = TextFieldAutoSize.NONE;
info.align = TextFormatAlign.RIGHT;
info.width = 90;
info.x = _width - 100;
info.text = data.income > -1 ? Money.numToString(data.income,false) : "null";
cont.addChild(info);
return cont;
}
override public function set data(value:Object) : void
{
_data = value;
var nr:DisplayObject = new ReferalStatLineBackgroundNormal();
var sl:DisplayObject = new ReferalStatLineBackgroundSelected();
nicon = this.myIcon(_data);
setStyle("upSkin",nr);
setStyle("downSkin",nr);
setStyle("overSkin",nr);
setStyle("selectedUpSkin",sl);
setStyle("selectedOverSkin",sl);
setStyle("selectedDownSkin",sl);
}
}
}
|
package alternativa.tanks.models.battle.facilities {
import alternativa.math.Vector3;
import alternativa.physics.collision.CollisionDetector;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.physics.CollisionGroup;
import flash.utils.Dictionary;
import platform.client.fp10.core.type.IGameObject;
public class CheckZones {
private var zones:Dictionary = new Dictionary();
private var collisionDetector:CollisionDetector;
public function CheckZones(param1:CollisionDetector) {
super();
this.collisionDetector = param1;
}
public static function checkZoneBordersCrossed(param1:CheckZone, param2:Vector3, param3:Vector3, param4:CollisionDetector = null) : Boolean {
var local5:Boolean = pointInZone(param2,param1) && pointIsReachable(param2,param1,param4);
var local6:Boolean = pointInZone(param3,param1) && pointIsReachable(param3,param1,param4);
return local5 && !local6 || !local5 && local6;
}
private static function pointIsReachable(param1:Vector3, param2:CheckZone, param3:CollisionDetector) : Boolean {
return !param2.checkRaycast || param3 != null && checkRaycast(param2.position,param1,param3);
}
private static function pointInZone(param1:Vector3, param2:CheckZone) : Boolean {
return param1.distanceToSquared(param2.position) <= param2.radiusSqr;
}
private static function checkRaycast(param1:Vector3, param2:Vector3, param3:CollisionDetector) : Boolean {
var local4:Vector3 = param2.clone().subtract(param1);
return !param3.raycastStatic(param1,local4,CollisionGroup.STATIC,1,null,new RayHit());
}
public function remove(param1:IGameObject) : CheckZone {
var local2:CheckZone = this.zones[param1];
delete this.zones[param1];
return local2;
}
public function add(param1:IGameObject, param2:Vector3, param3:Number, param4:Boolean) : CheckZone {
var local5:CheckZone = CheckZone.create(param2,param3,param4);
this.zones[param1] = local5;
return local5;
}
public function addDynamic(param1:IGameObject, param2:Tank, param3:Number, param4:Boolean) : CheckZone {
var local5:CheckZone = CheckZone.createDynamic(param2,param3,param4);
this.zones[param1] = local5;
return local5;
}
public function checkZoneChanged(param1:Vector3, param2:Vector3) : Boolean {
var local3:Object = null;
var local4:CheckZone = null;
for(local3 in this.zones) {
local4 = this.zones[local3];
if(checkZoneBordersCrossed(local4,param1,param2,this.collisionDetector)) {
return true;
}
}
return false;
}
}
}
|
package alternativa.tanks.bonuses {
import alternativa.tanks.animations.AnimatedValue;
import flash.geom.ColorTransform;
public class AnimatedColorTransform implements AnimatedValue {
public const colorTransform:ColorTransform = new ColorTransform();
public function AnimatedColorTransform() {
super();
}
public function setAnimatedValue(param1:Number) : void {
this.colorTransform.redOffset = param1;
this.colorTransform.greenOffset = param1;
this.colorTransform.blueOffset = param1;
}
}
}
|
package alternativa.tanks.ymservice {
public interface YandexMetricaService {
function reachGoal(param1:String) : void;
function reachGoalIfPlayerWasInTutorial(param1:String) : void;
function reachGoalIfPlayerIsNewbie(param1:String) : void;
}
}
|
package alternativa.tanks.controller.commands.goto_ {
import alternativa.tanks.controller.events.showform.ShowLoginFormEvent;
import alternativa.tanks.model.EntranceServerParamsModel;
import alternativa.tanks.model.EntranceUrlParamsModel;
import alternativa.tanks.service.AccountService;
import alternativa.tanks.service.ICaptchaService;
import alternativa.tanks.service.IEntranceServerFacade;
import org.robotlegs.mvcs.Command;
public class GoToLoginCommand extends Command {
[Inject]
public var entranceUrlParamsModel:EntranceUrlParamsModel;
[Inject]
public var accountService:AccountService;
[Inject]
public var serverParamsModel:EntranceServerParamsModel;
[Inject]
public var captchaService:ICaptchaService;
[Inject]
public var serverFacade:IEntranceServerFacade;
public function GoToLoginCommand() {
super();
}
override public function execute() : void {
var local1:Boolean = false;
if(this.serverParamsModel.loginCaptchaEnabled) {
local1 = true;
} else {
local1 = Boolean(this.captchaService.loginCaptchaEnabled);
}
dispatch(new ShowLoginFormEvent(this.entranceUrlParamsModel.passedCallsign || this.accountService.storedUserName,true,local1,this.entranceUrlParamsModel.passedPassword));
}
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_bitmapVampireResistance.png")]
public class ResistancesIcons_bitmapVampireResistance extends BitmapAsset {
public function ResistancesIcons_bitmapVampireResistance() {
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapon.healing {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.battlefield.models.tankparts.weapon.healing.IsisState;
public class CodecIsisState implements ICodec {
public function CodecIsisState() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:IsisState = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = IsisState.OFF;
break;
case 1:
local2 = IsisState.IDLE;
break;
case 2:
local2 = IsisState.HEALING;
break;
case 3:
local2 = IsisState.DAMAGING;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package alternativa.tanks.models.tank.killhandlers {
import platform.client.fp10.core.type.IGameObject;
public interface TankDeathConfirmationHandler {
function handleDeathConfirmation(param1:IGameObject) : void;
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes.braintree {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.payment.modes.braintree.BraintreePaymentCC;
public class CodecBraintreePaymentCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_payPal:ICodec;
public function CodecBraintreePaymentCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_payPal = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BraintreePaymentCC = new BraintreePaymentCC();
local2.payPal = this.codec_payPal.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:BraintreePaymentCC = BraintreePaymentCC(param2);
this.codec_payPal.encode(param1,local3.payPal);
}
}
}
|
package projects.tanks.client.commons.types {
public class ItemCategoryEnum {
public static const WEAPON:ItemCategoryEnum = new ItemCategoryEnum(0,"WEAPON");
public static const ARMOR:ItemCategoryEnum = new ItemCategoryEnum(1,"ARMOR");
public static const PAINT:ItemCategoryEnum = new ItemCategoryEnum(2,"PAINT");
public static const INVENTORY:ItemCategoryEnum = new ItemCategoryEnum(3,"INVENTORY");
public static const PLUGIN:ItemCategoryEnum = new ItemCategoryEnum(4,"PLUGIN");
public static const KIT:ItemCategoryEnum = new ItemCategoryEnum(5,"KIT");
public static const EMBLEM:ItemCategoryEnum = new ItemCategoryEnum(6,"EMBLEM");
public static const CRYSTAL:ItemCategoryEnum = new ItemCategoryEnum(7,"CRYSTAL");
public static const PRESENT:ItemCategoryEnum = new ItemCategoryEnum(8,"PRESENT");
public static const GIVEN_PRESENT:ItemCategoryEnum = new ItemCategoryEnum(9,"GIVEN_PRESENT");
public static const RESISTANCE_MODULE:ItemCategoryEnum = new ItemCategoryEnum(10,"RESISTANCE_MODULE");
public static const DEVICE:ItemCategoryEnum = new ItemCategoryEnum(11,"DEVICE");
public static const LICENSE:ItemCategoryEnum = new ItemCategoryEnum(12,"LICENSE");
public static const CONTAINER:ItemCategoryEnum = new ItemCategoryEnum(13,"CONTAINER");
public static const DRONE:ItemCategoryEnum = new ItemCategoryEnum(14,"DRONE");
public static const SKIN:ItemCategoryEnum = new ItemCategoryEnum(15,"SKIN");
public static const MOBILE_LOOT_BOX:ItemCategoryEnum = new ItemCategoryEnum(16,"MOBILE_LOOT_BOX");
private var _value:int;
private var _name:String;
public function ItemCategoryEnum(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<ItemCategoryEnum> {
var local1:Vector.<ItemCategoryEnum> = new Vector.<ItemCategoryEnum>();
local1.push(WEAPON);
local1.push(ARMOR);
local1.push(PAINT);
local1.push(INVENTORY);
local1.push(PLUGIN);
local1.push(KIT);
local1.push(EMBLEM);
local1.push(CRYSTAL);
local1.push(PRESENT);
local1.push(GIVEN_PRESENT);
local1.push(RESISTANCE_MODULE);
local1.push(DEVICE);
local1.push(LICENSE);
local1.push(CONTAINER);
local1.push(DRONE);
local1.push(SKIN);
local1.push(MOBILE_LOOT_BOX);
return local1;
}
public function toString() : String {
return "ItemCategoryEnum [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package platform.client.fp10.core.network.connection {
public class ConnectionStatus {
public static const IDLE:ConnectionStatus = new ConnectionStatus("IDLE");
public static const CONNECTING:ConnectionStatus = new ConnectionStatus("CONNECTING");
public static const CONNECTED:ConnectionStatus = new ConnectionStatus("CONNECTED");
public static const DISCONNECTED:ConnectionStatus = new ConnectionStatus("DISCONNECTED");
private var _value:String;
public function ConnectionStatus(param1:String) {
super();
this._value = param1;
}
public function toString() : String {
return this._value;
}
}
}
|
package alternativa.tanks.models.weapon.shotgun.aiming {
import alternativa.tanks.models.weapon.shotgun.PelletDirectionCalculator;
import alternativa.tanks.models.weapon.shotgun.ShotgunRicochetTargetingSystem;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ShotgunAimingAdapt implements ShotgunAiming {
private var object:IGameObject;
private var impl:ShotgunAiming;
public function ShotgunAimingAdapt(param1:IGameObject, param2:ShotgunAiming) {
super();
this.object = param1;
this.impl = param2;
}
public function createTargetingSystem() : ShotgunRicochetTargetingSystem {
var result:ShotgunRicochetTargetingSystem = null;
try {
Model.object = this.object;
result = this.impl.createTargetingSystem();
}
finally {
Model.popObject();
}
return result;
}
public function getPelletDirectionCalculator() : PelletDirectionCalculator {
var result:PelletDirectionCalculator = null;
try {
Model.object = this.object;
result = this.impl.getPelletDirectionCalculator();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.sfx.healing
{
public interface IHealingSFXModelBase
{
}
}
|
package alternativa.tanks.model.news
{
import alternativa.init.Main;
import alternativa.tanks.model.panel.IPanel;
import flash.display.DisplayObjectContainer;
import flash.events.Event;
import flash.events.MouseEvent;
public class NewsModel implements INewsModel
{
private var panelModel:IPanel;
private var dialogsLayer:DisplayObjectContainer;
private var window:NewsWindow;
public function NewsModel()
{
super();
this.dialogsLayer = Main.dialogsLayer;
}
public function showNews(items:Vector.<NewsItemServer>) : void
{
var item:NewsItemServer = null;
var _item:NewsItem = null;
this.panelModel = Main.osgi.getService(IPanel) as IPanel;
this.panelModel.blur();
this.window = new NewsWindow();
var news:Array = new Array();
for each(item in items)
{
_item = new NewsItem();
_item.dataText = item.date;
_item.newText = item.text;
_item.iconId = item.iconId;
news.push(_item);
}
this.window.setItems(news);
this.dialogsLayer.addChild(this.window);
Main.stage.addEventListener(Event.RESIZE,this.alignWindow);
this.window.closeBtn.addEventListener(MouseEvent.CLICK,this.closeWindow);
this.alignWindow(null);
}
private function alignWindow(e:Event) : void
{
this.window.x = Math.round((Main.stage.stageWidth - this.window.width) * 0.5);
this.window.y = Math.round((Main.stage.stageHeight - this.window.getHeigth()) * 0.5);
}
private function closeWindow(e:MouseEvent = null) : void
{
this.panelModel.unblur();
this.dialogsLayer.removeChild(this.window);
Main.stage.removeEventListener(Event.RESIZE,this.alignWindow);
}
}
}
|
package alternativa.tanks.model.payment.shop.specialkit {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.shop.enable.paymode.IRestrictionByPayModeModelBase;
import projects.tanks.client.panel.model.shop.enable.paymode.RestrictionByPayModeModelBase;
[ModelInfo]
public class RestrictionByPayModeModel extends RestrictionByPayModeModelBase implements IRestrictionByPayModeModelBase, SinglePayMode {
public function RestrictionByPayModeModel() {
super();
}
public function getPayMode() : IGameObject {
return getInitParam().payMode;
}
}
}
|
package alternativa.tanks.models.weapon {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
public class WeaponUtils {
private static const turretMatrix:Matrix4 = new Matrix4();
private static const localBarrelOrigin:Vector3 = new Vector3();
public function WeaponUtils() {
super();
}
public static function calculateMainGunParams(param1:Object3D, param2:Vector3, param3:AllGlobalGunParams) : void {
turretMatrix.setFromMatrix3D(param1.concatenatedMatrix);
turretMatrix.transformVector(param2,param3.muzzlePosition);
localBarrelOrigin.x = param2.x;
localBarrelOrigin.z = param2.z;
turretMatrix.transformVector(localBarrelOrigin,param3.barrelOrigin);
param3.elevationAxis.x = turretMatrix.m00;
param3.elevationAxis.y = turretMatrix.m10;
param3.elevationAxis.z = turretMatrix.m20;
param3.direction.x = turretMatrix.m01;
param3.direction.y = turretMatrix.m11;
param3.direction.z = turretMatrix.m21;
}
public static function calculateBasicGunParams(param1:Object3D, param2:Vector3, param3:BasicGlobalGunParams) : void {
turretMatrix.setMatrix(param1.x,param1.y,param1.z,param1.rotationX,param1.rotationY,param1.rotationZ);
turretMatrix.transformVector(param2,param3.muzzlePosition);
param3.direction.x = turretMatrix.m01;
param3.direction.y = turretMatrix.m11;
param3.direction.z = turretMatrix.m21;
}
}
}
|
package alternativa.tanks.view.battlelist.modefilter {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.battlelist.modefilter.BattleModeIcons_asIconClass.png")]
public class BattleModeIcons_asIconClass extends BitmapAsset {
public function BattleModeIcons_asIconClass() {
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.pointbased.rugby {
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.battle.pointbased.rugby.RugbyCC;
public class VectorCodecRugbyCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRugbyCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(RugbyCC,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.<RugbyCC> = new Vector.<RugbyCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = RugbyCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:RugbyCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<RugbyCC> = Vector.<RugbyCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p7 extends BitmapAsset
{
public function RangIconNormal_p7()
{
super();
}
}
}
|
package projects.tanks.client.partners.impl.rambler.payment {
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 RamblerPaymentModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _getPaymentTransactionId:Long = Long.getLong(1616445231,-1581045047);
private var _getPaymentTransaction_shopItemIdCodec:ICodec;
private var model:IModel;
public function RamblerPaymentModelServer(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._getPaymentTransaction_shopItemIdCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function getPaymentTransaction(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._getPaymentTransaction_shopItemIdCodec.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._getPaymentTransactionId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIcon_p16 extends BitmapAsset
{
public function RangIcon_p16()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.payment {
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 PaymentModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function PaymentModelServer(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.engine3d.lights {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Canvas;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Light3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
use namespace alternativa3d;
public class SpotLight extends Light3D {
public var attenuationBegin:Number;
public var attenuationEnd:Number;
public var hotspot:Number;
public var falloff:Number;
alternativa3d var localAttenuationBegin:Number;
alternativa3d var localAttenuationEnd:Number;
alternativa3d var localDirectionX:Number;
alternativa3d var localDirectionY:Number;
alternativa3d var localDirectionZ:Number;
alternativa3d var localHotspot:Number;
alternativa3d var localFalloff:Number;
public function SpotLight(param1:uint, param2:Number, param3:Number, param4:Number, param5:Number) {
super();
this.color = param1;
this.attenuationBegin = param2;
this.attenuationEnd = param3;
this.hotspot = param4;
this.falloff = param5;
calculateBounds();
}
public function lookAt(param1:Number, param2:Number, param3:Number) : void {
var local4:Number = NaN;
local4 = param1 - this.x;
var local5:Number = param2 - this.y;
var local6:Number = param3 - this.z;
rotationX = Math.atan2(local6,Math.sqrt(local4 * local4 + local5 * local5)) - Math.PI / 2;
rotationY = 0;
rotationZ = -Math.atan2(local4,local5);
}
override public function clone() : Object3D {
var local1:SpotLight = new SpotLight(color,this.attenuationBegin,this.attenuationEnd,this.hotspot,this.falloff);
local1.clonePropertiesFrom(this);
return local1;
}
override alternativa3d function drawDebug(param1:Camera3D, param2:Canvas) : void {
var local4:Canvas = null;
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
var local8:int = 0;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
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:Number = NaN;
var local30:Number = NaN;
var local31:Number = NaN;
var local32:Number = NaN;
var local33:Number = NaN;
var local34:Number = NaN;
var local35:Number = NaN;
var local36:Number = NaN;
var local37:Number = NaN;
var local38:Number = NaN;
var local39:Number = NaN;
var local40:Number = NaN;
var local41:Number = NaN;
var local42:Number = NaN;
var local43:Number = NaN;
var local44:Number = NaN;
var local45:Number = NaN;
var local46:Number = NaN;
var local47:Number = NaN;
var local48:Number = NaN;
var local3:int = int(param1.alternativa3d::checkInDebug(this));
if(local3 > 0) {
local4 = param2.alternativa3d::getChildCanvas(true,false);
if(Boolean(local3 & Debug.LIGHTS) && alternativa3d::ml > param1.nearClipping) {
local5 = (color >> 16 & 0xFF) * intensity;
local6 = (color >> 8 & 0xFF) * intensity;
local7 = (color & 0xFF) * intensity;
local8 = ((local5 > 255 ? 255 : local5) << 16) + ((local6 > 255 ? 255 : local6) << 8) + (local7 > 255 ? 255 : local7);
local9 = 0;
local10 = alternativa3d::md * param1.alternativa3d::viewSizeX / param1.alternativa3d::focalLength;
local11 = alternativa3d::mh * param1.alternativa3d::viewSizeY / param1.alternativa3d::focalLength;
local12 = Number(alternativa3d::ml);
local13 = alternativa3d::mc * param1.alternativa3d::viewSizeX / param1.alternativa3d::focalLength;
local14 = alternativa3d::mg * param1.alternativa3d::viewSizeY / param1.alternativa3d::focalLength;
local15 = Number(alternativa3d::mk);
local16 = Math.sqrt(local13 * local13 + local14 * local14 + local15 * local15);
local9 += local16;
local13 /= local16;
local14 /= local16;
local15 /= local16;
local17 = alternativa3d::ma * param1.alternativa3d::viewSizeX / param1.alternativa3d::focalLength;
local18 = alternativa3d::me * param1.alternativa3d::viewSizeY / param1.alternativa3d::focalLength;
local19 = Number(alternativa3d::mi);
local9 += Math.sqrt(local17 * local17 + local18 * local18 + local19 * local19);
local20 = local19 * local14 - local18 * local15;
local21 = local17 * local15 - local19 * local13;
local22 = local18 * local13 - local17 * local14;
local16 = Math.sqrt(local20 * local20 + local21 * local21 + local22 * local22);
local20 /= local16;
local21 /= local16;
local22 /= local16;
local17 = alternativa3d::mb * param1.alternativa3d::viewSizeX / param1.alternativa3d::focalLength;
local18 = alternativa3d::mf * param1.alternativa3d::viewSizeY / param1.alternativa3d::focalLength;
local19 = Number(alternativa3d::mj);
local9 += Math.sqrt(local17 * local17 + local18 * local18 + local19 * local19);
local9 /= 3;
local17 = local22 * local14 - local21 * local15;
local18 = local20 * local15 - local22 * local13;
local19 = local21 * local13 - local20 * local14;
local23 = Math.cos(this.hotspot / 2);
local24 = Math.sin(this.hotspot / 2);
local25 = local10 + (local13 * local23 + local17 * local24) * local9 * this.attenuationBegin;
local26 = local11 + (local14 * local23 + local18 * local24) * local9 * this.attenuationBegin;
local27 = local12 + (local15 * local23 + local19 * local24) * local9 * this.attenuationBegin;
local28 = local10 + (local13 * local23 + (local17 + local20) * 0.9 * local24) * local9 * this.attenuationBegin;
local29 = local11 + (local14 * local23 + (local18 + local21) * 0.9 * local24) * local9 * this.attenuationBegin;
local30 = local12 + (local15 * local23 + (local19 + local22) * 0.9 * local24) * local9 * this.attenuationBegin;
local31 = local10 + (local13 * local23 + local20 * local24) * local9 * this.attenuationBegin;
local32 = local11 + (local14 * local23 + local21 * local24) * local9 * this.attenuationBegin;
local33 = local12 + (local15 * local23 + local22 * local24) * local9 * this.attenuationBegin;
local34 = local10 + (local13 * local23 - (local17 - local20) * 0.9 * local24) * local9 * this.attenuationBegin;
local35 = local11 + (local14 * local23 - (local18 - local21) * 0.9 * local24) * local9 * this.attenuationBegin;
local36 = local12 + (local15 * local23 - (local19 - local22) * 0.9 * local24) * local9 * this.attenuationBegin;
local37 = local10 + (local13 * local23 - local17 * local24) * local9 * this.attenuationBegin;
local38 = local11 + (local14 * local23 - local18 * local24) * local9 * this.attenuationBegin;
local39 = local12 + (local15 * local23 - local19 * local24) * local9 * this.attenuationBegin;
local40 = local10 + (local13 * local23 - (local17 + local20) * 0.9 * local24) * local9 * this.attenuationBegin;
local41 = local11 + (local14 * local23 - (local18 + local21) * 0.9 * local24) * local9 * this.attenuationBegin;
local42 = local12 + (local15 * local23 - (local19 + local22) * 0.9 * local24) * local9 * this.attenuationBegin;
local43 = local10 + (local13 * local23 - local20 * local24) * local9 * this.attenuationBegin;
local44 = local11 + (local14 * local23 - local21 * local24) * local9 * this.attenuationBegin;
local45 = local12 + (local15 * local23 - local22 * local24) * local9 * this.attenuationBegin;
local46 = local10 + (local13 * local23 + (local17 - local20) * 0.9 * local24) * local9 * this.attenuationBegin;
local47 = local11 + (local14 * local23 + (local18 - local21) * 0.9 * local24) * local9 * this.attenuationBegin;
local48 = local12 + (local15 * local23 + (local19 - local22) * 0.9 * local24) * local9 * this.attenuationBegin;
if(local27 > param1.nearClipping && local30 > param1.nearClipping && local33 > param1.nearClipping && local36 > param1.nearClipping && local39 > param1.nearClipping && local42 > param1.nearClipping && local45 > param1.nearClipping && local48 > param1.nearClipping) {
local4.alternativa3d::gfx.lineStyle(1,local8);
local4.alternativa3d::gfx.moveTo(local25 * param1.alternativa3d::focalLength / local27,local26 * param1.alternativa3d::focalLength / local27);
local4.alternativa3d::gfx.curveTo(local28 * param1.alternativa3d::focalLength / local30,local29 * param1.alternativa3d::focalLength / local30,local31 * param1.alternativa3d::focalLength / local33,local32 * param1.alternativa3d::focalLength / local33);
local4.alternativa3d::gfx.curveTo(local34 * param1.alternativa3d::focalLength / local36,local35 * param1.alternativa3d::focalLength / local36,local37 * param1.alternativa3d::focalLength / local39,local38 * param1.alternativa3d::focalLength / local39);
local4.alternativa3d::gfx.curveTo(local40 * param1.alternativa3d::focalLength / local42,local41 * param1.alternativa3d::focalLength / local42,local43 * param1.alternativa3d::focalLength / local45,local44 * param1.alternativa3d::focalLength / local45);
local4.alternativa3d::gfx.curveTo(local46 * param1.alternativa3d::focalLength / local48,local47 * param1.alternativa3d::focalLength / local48,local25 * param1.alternativa3d::focalLength / local27,local26 * param1.alternativa3d::focalLength / local27);
local4.alternativa3d::gfx.moveTo(local10 * param1.alternativa3d::focalLength / local12,local11 * param1.alternativa3d::focalLength / local12);
local4.alternativa3d::gfx.lineTo(local25 * param1.alternativa3d::focalLength / local27,local26 * param1.alternativa3d::focalLength / local27);
local4.alternativa3d::gfx.moveTo(local10 * param1.alternativa3d::focalLength / local12,local11 * param1.alternativa3d::focalLength / local12);
local4.alternativa3d::gfx.lineTo(local31 * param1.alternativa3d::focalLength / local33,local32 * param1.alternativa3d::focalLength / local33);
local4.alternativa3d::gfx.moveTo(local10 * param1.alternativa3d::focalLength / local12,local11 * param1.alternativa3d::focalLength / local12);
local4.alternativa3d::gfx.lineTo(local37 * param1.alternativa3d::focalLength / local39,local38 * param1.alternativa3d::focalLength / local39);
local4.alternativa3d::gfx.moveTo(local10 * param1.alternativa3d::focalLength / local12,local11 * param1.alternativa3d::focalLength / local12);
local4.alternativa3d::gfx.lineTo(local43 * param1.alternativa3d::focalLength / local45,local44 * param1.alternativa3d::focalLength / local45);
}
local23 = Math.cos(this.falloff / 2);
local24 = Math.sin(this.falloff / 2);
local25 = local10 + (local13 * local23 + local17 * local24) * local9 * this.attenuationEnd;
local26 = local11 + (local14 * local23 + local18 * local24) * local9 * this.attenuationEnd;
local27 = local12 + (local15 * local23 + local19 * local24) * local9 * this.attenuationEnd;
local28 = local10 + (local13 * local23 + (local17 + local20) * 0.9 * local24) * local9 * this.attenuationEnd;
local29 = local11 + (local14 * local23 + (local18 + local21) * 0.9 * local24) * local9 * this.attenuationEnd;
local30 = local12 + (local15 * local23 + (local19 + local22) * 0.9 * local24) * local9 * this.attenuationEnd;
local31 = local10 + (local13 * local23 + local20 * local24) * local9 * this.attenuationEnd;
local32 = local11 + (local14 * local23 + local21 * local24) * local9 * this.attenuationEnd;
local33 = local12 + (local15 * local23 + local22 * local24) * local9 * this.attenuationEnd;
local34 = local10 + (local13 * local23 - (local17 - local20) * 0.9 * local24) * local9 * this.attenuationEnd;
local35 = local11 + (local14 * local23 - (local18 - local21) * 0.9 * local24) * local9 * this.attenuationEnd;
local36 = local12 + (local15 * local23 - (local19 - local22) * 0.9 * local24) * local9 * this.attenuationEnd;
local37 = local10 + (local13 * local23 - local17 * local24) * local9 * this.attenuationEnd;
local38 = local11 + (local14 * local23 - local18 * local24) * local9 * this.attenuationEnd;
local39 = local12 + (local15 * local23 - local19 * local24) * local9 * this.attenuationEnd;
local40 = local10 + (local13 * local23 - (local17 + local20) * 0.9 * local24) * local9 * this.attenuationEnd;
local41 = local11 + (local14 * local23 - (local18 + local21) * 0.9 * local24) * local9 * this.attenuationEnd;
local42 = local12 + (local15 * local23 - (local19 + local22) * 0.9 * local24) * local9 * this.attenuationEnd;
local43 = local10 + (local13 * local23 - local20 * local24) * local9 * this.attenuationEnd;
local44 = local11 + (local14 * local23 - local21 * local24) * local9 * this.attenuationEnd;
local45 = local12 + (local15 * local23 - local22 * local24) * local9 * this.attenuationEnd;
local46 = local10 + (local13 * local23 + (local17 - local20) * 0.9 * local24) * local9 * this.attenuationEnd;
local47 = local11 + (local14 * local23 + (local18 - local21) * 0.9 * local24) * local9 * this.attenuationEnd;
local48 = local12 + (local15 * local23 + (local19 - local22) * 0.9 * local24) * local9 * this.attenuationEnd;
if(local27 > param1.nearClipping && local30 > param1.nearClipping && local33 > param1.nearClipping && local36 > param1.nearClipping && local39 > param1.nearClipping && local42 > param1.nearClipping && local45 > param1.nearClipping && local48 > param1.nearClipping) {
local4.alternativa3d::gfx.lineStyle(1,local8,0.5);
local4.alternativa3d::gfx.moveTo(local25 * param1.alternativa3d::focalLength / local27,local26 * param1.alternativa3d::focalLength / local27);
local4.alternativa3d::gfx.curveTo(local28 * param1.alternativa3d::focalLength / local30,local29 * param1.alternativa3d::focalLength / local30,local31 * param1.alternativa3d::focalLength / local33,local32 * param1.alternativa3d::focalLength / local33);
local4.alternativa3d::gfx.curveTo(local34 * param1.alternativa3d::focalLength / local36,local35 * param1.alternativa3d::focalLength / local36,local37 * param1.alternativa3d::focalLength / local39,local38 * param1.alternativa3d::focalLength / local39);
local4.alternativa3d::gfx.curveTo(local40 * param1.alternativa3d::focalLength / local42,local41 * param1.alternativa3d::focalLength / local42,local43 * param1.alternativa3d::focalLength / local45,local44 * param1.alternativa3d::focalLength / local45);
local4.alternativa3d::gfx.curveTo(local46 * param1.alternativa3d::focalLength / local48,local47 * param1.alternativa3d::focalLength / local48,local25 * param1.alternativa3d::focalLength / local27,local26 * param1.alternativa3d::focalLength / local27);
local4.alternativa3d::gfx.moveTo(local10 * param1.alternativa3d::focalLength / local12,local11 * param1.alternativa3d::focalLength / local12);
local4.alternativa3d::gfx.lineTo(local25 * param1.alternativa3d::focalLength / local27,local26 * param1.alternativa3d::focalLength / local27);
local4.alternativa3d::gfx.moveTo(local10 * param1.alternativa3d::focalLength / local12,local11 * param1.alternativa3d::focalLength / local12);
local4.alternativa3d::gfx.lineTo(local31 * param1.alternativa3d::focalLength / local33,local32 * param1.alternativa3d::focalLength / local33);
local4.alternativa3d::gfx.moveTo(local10 * param1.alternativa3d::focalLength / local12,local11 * param1.alternativa3d::focalLength / local12);
local4.alternativa3d::gfx.lineTo(local37 * param1.alternativa3d::focalLength / local39,local38 * param1.alternativa3d::focalLength / local39);
local4.alternativa3d::gfx.moveTo(local10 * param1.alternativa3d::focalLength / local12,local11 * param1.alternativa3d::focalLength / local12);
local4.alternativa3d::gfx.lineTo(local43 * param1.alternativa3d::focalLength / local45,local44 * param1.alternativa3d::focalLength / local45);
}
}
if(Boolean(local3 & Debug.BOUNDS)) {
Debug.alternativa3d::drawBounds(param1,local4,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ,10092288);
}
}
}
override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void {
var local5:Vertex = null;
var local3:Number = this.falloff < Math.PI ? Math.sin(this.falloff / 2) * this.attenuationEnd : this.attenuationEnd;
var local4:Number = this.falloff < Math.PI ? 0 : Math.cos(this.falloff / 2) * this.attenuationEnd;
if(param2 != null) {
local5 = alternativa3d::boundVertexList;
local5.x = -local3;
local5.y = -local3;
local5.z = local4;
local5 = local5.alternativa3d::next;
local5.x = local3;
local5.y = -local3;
local5.z = local4;
local5 = local5.alternativa3d::next;
local5.x = -local3;
local5.y = local3;
local5.z = local4;
local5 = local5.alternativa3d::next;
local5.x = local3;
local5.y = local3;
local5.z = local4;
local5 = local5.alternativa3d::next;
local5.x = -local3;
local5.y = -local3;
local5.z = this.attenuationEnd;
local5 = local5.alternativa3d::next;
local5.x = local3;
local5.y = -local3;
local5.z = this.attenuationEnd;
local5 = local5.alternativa3d::next;
local5.x = -local3;
local5.y = local3;
local5.z = this.attenuationEnd;
local5 = local5.alternativa3d::next;
local5.x = local3;
local5.y = local3;
local5.z = this.attenuationEnd;
local5 = alternativa3d::boundVertexList;
while(local5 != null) {
local5.alternativa3d::cameraX = param2.alternativa3d::ma * local5.x + param2.alternativa3d::mb * local5.y + param2.alternativa3d::mc * local5.z + param2.alternativa3d::md;
local5.alternativa3d::cameraY = param2.alternativa3d::me * local5.x + param2.alternativa3d::mf * local5.y + param2.alternativa3d::mg * local5.z + param2.alternativa3d::mh;
local5.alternativa3d::cameraZ = param2.alternativa3d::mi * local5.x + param2.alternativa3d::mj * local5.y + param2.alternativa3d::mk * local5.z + param2.alternativa3d::ml;
if(local5.alternativa3d::cameraX < param1.boundMinX) {
param1.boundMinX = local5.alternativa3d::cameraX;
}
if(local5.alternativa3d::cameraX > param1.boundMaxX) {
param1.boundMaxX = local5.alternativa3d::cameraX;
}
if(local5.alternativa3d::cameraY < param1.boundMinY) {
param1.boundMinY = local5.alternativa3d::cameraY;
}
if(local5.alternativa3d::cameraY > param1.boundMaxY) {
param1.boundMaxY = local5.alternativa3d::cameraY;
}
if(local5.alternativa3d::cameraZ < param1.boundMinZ) {
param1.boundMinZ = local5.alternativa3d::cameraZ;
}
if(local5.alternativa3d::cameraZ > param1.boundMaxZ) {
param1.boundMaxZ = local5.alternativa3d::cameraZ;
}
local5 = local5.alternativa3d::next;
}
} else {
if(-local3 < param1.boundMinX) {
param1.boundMinX = -local3;
}
if(local3 > param1.boundMaxX) {
param1.boundMaxX = local3;
}
if(-local3 < param1.boundMinY) {
param1.boundMinY = -local3;
}
if(local3 > param1.boundMaxY) {
param1.boundMaxY = local3;
}
if(-local4 < param1.boundMinZ) {
param1.boundMinZ = local4;
}
if(this.attenuationEnd > param1.boundMaxZ) {
param1.boundMaxZ = this.attenuationEnd;
}
}
}
}
}
|
package alternativa.tanks.models.battlefield
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BattlefieldModel_SNOW_DUST_DATA extends BitmapAsset
{
public function BattlefieldModel_SNOW_DUST_DATA()
{
super();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.