code
stringlengths 57
237k
|
|---|
package alternativa.tanks.gui.notinclan.dialogs.requests {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.ISourceData;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.SearchInputView;
import alternativa.tanks.gui.notinclan.clanslist.ClanListType;
import alternativa.tanks.gui.notinclan.clanslist.ClansListEvent;
import alternativa.tanks.models.user.ClanUserService;
import alternativa.tanks.models.user.outgoing.IClanUserOutgoingModel;
import flash.events.Event;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class UserOutgoingRequestsDialog extends UserRequestsDialog {
[Inject]
public static var clanUserService:ClanUserService;
[Inject]
public static var localeService:ILocaleService;
private var searchInput:SearchInputView;
public function UserOutgoingRequestsDialog(param1:int) {
this.closeButtonWidth = param1;
var local2:ISourceData = ISourceData(clanUserService.userObject.adapt(ISourceData));
this.searchInput = new SearchInputView(local2,localeService.getText(TanksLocale.TEXT_CLAN_SEND_REQUEST_TO_CLAN),localeService.getText(TanksLocale.TEXT_CLAN_SEND_REQUEST),localeService.getText(TanksLocale.TEXT_CLAN_SEARCH_BLOCKED_HINT),"");
super();
var local3:IClanUserOutgoingModel = clanUserService.userObject.adapt(IClanUserOutgoingModel) as IClanUserOutgoingModel;
clansList.fillClansList(local3.getOutgoingClans(),ClanListType.OUTGOING);
ClansListEvent.getDispatcher().addEventListener(ClansListEvent.OUTGOING + ClansListEvent.ADD,onAddRequest);
ClansListEvent.getDispatcher().addEventListener(ClansListEvent.OUTGOING + ClansListEvent.REMOVE,onCancelRequest);
addChild(this.searchInput);
}
override protected function onResize(param1:Event = null) : void {
heightSearchUnit = this.searchInput.height;
super.onResize(param1);
this.searchInput.width = width - 3 * MARGIN - closeButtonWidth;
this.searchInput.x = MARGIN;
this.searchInput.y = height - this.searchInput.height - MARGIN;
}
override protected function removeEvents() : void {
super.removeEvents();
ClansListEvent.getDispatcher().removeEventListener(ClansListEvent.OUTGOING + ClansListEvent.ADD,onAddRequest);
ClansListEvent.getDispatcher().removeEventListener(ClansListEvent.OUTGOING + ClansListEvent.REMOVE,onCancelRequest);
}
override public function destroy() : void {
this.searchInput.hide();
super.destroy();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank08.png")]
public class PremiumRankBitmaps_bitmapSmallRank08 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank08() {
super();
}
}
}
|
package alternativa.tanks.gui.shop.components.itemscategory {
import alternativa.tanks.gui.shop.components.item.GridItemBase;
import alternativa.types.Long;
import base.DiscreteSprite;
public class ItemsCategoryView extends DiscreteSprite {
private static const GAP:int = 10;
public var headerText:String;
public var descriptionText:String;
public var categoryId:Long;
public var header:ItemsCategoryViewHeader;
public var items:ItemsCategoryViewGrid;
public function ItemsCategoryView(param1:String, param2:String, param3:Long) {
super();
this.headerText = param1;
this.descriptionText = param2;
this.categoryId = param3;
this.init();
}
private function init() : void {
this.header = new ItemsCategoryViewHeader(this.headerText,this.descriptionText);
addChild(this.header);
this.items = new ItemsCategoryViewGrid();
addChild(this.items);
}
public function addItem(param1:GridItemBase) : void {
this.items.addItem(param1);
}
public function render(param1:int) : void {
this.header.render(param1);
this.items.render();
this.items.y = this.header.y + this.header.height + GAP;
}
public function destroy() : void {
this.header = null;
this.items.destroy();
this.items = null;
}
}
}
|
package alternativa.tanks.gui.tables {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.service.item.ItemService;
import assets.Diamond;
import controls.Money;
import controls.base.LabelBase;
import flash.display.Sprite;
import flash.text.TextFormatAlign;
import projects.tanks.client.garage.models.item.kit.KitItem;
public class KitItemInfoRow extends Sprite {
[Inject]
public static var itemService:ItemService;
[Inject]
public static var localeService:ILocaleService;
public function KitItemInfoRow(param1:int, param2:int, param3:KitItem, param4:int, param5:int) {
super();
var local6:int = param2;
this.y = param1;
var local7:LabelBase = new LabelBase();
local7.align = TextFormatAlign.LEFT;
local7.text = itemService.getName(param3.item) + (param3.count <= 1 ? "" : " ×" + String(param3.count));
local7.x = param4;
addChild(local7);
var local8:Diamond = new Diamond();
local8.x = local6 - local7.x - local8.width;
addChild(local8);
local8.y = param5;
var local9:int = itemService.getPriceWithoutDiscount(param3.item) * param3.count;
var local10:LabelBase = new LabelBase();
local10.align = TextFormatAlign.RIGHT;
local10.text = Money.numToString(local9,false);
local10.x = local8.x - local10.width - 1;
addChild(local10);
}
}
}
|
package projects.tanks.client.panel.model.garage.availableupgrades {
public interface IAvailableUpgradesModelBase {
function updateAvailableUpgrade(param1:Vector.<AvailableUpgradeItem>) : void;
}
}
|
package controls.buttons.h30px {
import controls.buttons.FixedHeightRectangleSkin;
public class GreenMediumButtonSkin extends H30ButtonSkin {
public static const leftUpClass:Class = GreenMediumButtonSkin_leftUpClass;
public static const middleUpClass:Class = GreenMediumButtonSkin_middleUpClass;
public static const rightUpClass:Class = GreenMediumButtonSkin_rightUpClass;
private static const leftOverClass:Class = GreenMediumButtonSkin_leftOverClass;
private static const middleOverClass:Class = GreenMediumButtonSkin_middleOverClass;
private static const rightOverClass:Class = GreenMediumButtonSkin_rightOverClass;
public static const leftDownClass:Class = GreenMediumButtonSkin_leftDownClass;
public static const middleDownClass:Class = GreenMediumButtonSkin_middleDownClass;
public static const rightDownClass:Class = GreenMediumButtonSkin_rightDownClass;
public function GreenMediumButtonSkin() {
super(createStateSkin(leftUpClass,middleUpClass,rightUpClass),createStateSkin(leftOverClass,middleOverClass,rightOverClass),createStateSkin(leftDownClass,middleDownClass,rightDownClass));
}
private static function createStateSkin(param1:Class, param2:Class, param3:Class) : FixedHeightRectangleSkin {
return new FixedHeightRectangleSkin(param1,param2,param3);
}
}
}
|
package alternativa.tanks.models.battle.gui.group {
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.battlefield.models.battle.gui.group.IMatchmakingGroupInfoModelBase;
import projects.tanks.client.battlefield.models.battle.gui.group.MatchmakingGroupInfoModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.group.IGroupInfoService;
[ModelInfo]
public class MatchmakingGroupInfoModel extends MatchmakingGroupInfoModelBase implements IMatchmakingGroupInfoModelBase, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var groupInfoService:IGroupInfoService;
public function MatchmakingGroupInfoModel() {
super();
}
public function objectLoaded() : void {
var local1:* = undefined;
groupInfoService.setHasGroups(getInitParam().hasGroups);
for each(local1 in getInitParam().groupUserIds) {
groupInfoService.addGroupUser(local1);
}
}
public function objectUnloaded() : void {
groupInfoService.setHasGroups(false);
}
}
}
|
package alternativa.tanks.gui.category {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.category.ItemCategoryButton_kitIconClass.png")]
public class ItemCategoryButton_kitIconClass extends BitmapAsset {
public function ItemCategoryButton_kitIconClass() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.healing {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.ISound3DEffect;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundTransform;
import projects.tanks.client.battlefield.models.tankparts.weapon.healing.IsisState;
public class HealingGunSoundEffect extends PooledObject implements ISound3DEffect {
private static const NUM_LOOPS:int = 100000;
private static const NEAR_RADIUS:Number = 1000;
private static const FAR_RADIUS:Number = 2000;
private static const FAR_DELIMITER:Number = 2;
private static const BASE_VOLUME:Number = 1;
private static const MP3_BEGINNING_GAP:int = 200;
private static const position:Vector3 = new Vector3();
private var sfxData:HealingGunSFXData;
private var object:Object3D;
private var _type:IsisState;
private var _enabled:Boolean;
private var dead:Boolean;
private var currentSound3D:Sound3D;
private var soundChannel:SoundChannel;
public function HealingGunSoundEffect(param1:Pool) {
super(param1);
}
public function init(param1:HealingGunSFXData, param2:Object3D) : void {
this.sfxData = param1;
this.object = param2;
this._type = IsisState.OFF;
this.dead = false;
this._enabled = false;
}
public function set type(param1:IsisState) : void {
if(this._type != param1) {
this._type = param1;
this.changeSound();
}
}
public function set enabled(param1:Boolean) : void {
if(this._enabled != param1) {
this._enabled = param1;
if(!this._enabled) {
this.currentSound3D.stop();
this.soundChannel = null;
}
}
}
public function play(param1:int, param2:GameCamera) : void {
if(!this.dead) {
if(this.soundChannel == null) {
this.soundChannel = this.currentSound3D.play(MP3_BEGINNING_GAP,NUM_LOOPS);
}
position.x = this.object.x;
position.y = this.object.y;
position.z = this.object.z;
this.currentSound3D.checkVolume(param2.position,position,param2.xAxis);
}
}
public function readPosition(param1:Vector3) : void {
param1.x = this.object.x;
param1.y = this.object.y;
param1.z = this.object.z;
}
public function destroy() : void {
if(this.currentSound3D != null) {
Sound3D.destroy(this.currentSound3D);
this.currentSound3D = null;
this.soundChannel = null;
}
this.sfxData = null;
this.object = null;
recycle();
}
public function get numSounds() : int {
return this.dead ? 0 : 1;
}
public function kill() : void {
this.dead = true;
}
private function changeSound() : void {
var local1:SoundTransform = null;
if(this.soundChannel != null) {
local1 = this.soundChannel.soundTransform;
this.soundChannel = null;
}
if(this.currentSound3D != null) {
Sound3D.destroy(this.currentSound3D);
}
var local2:Sound = this.getSound();
this.currentSound3D = Sound3D.create(local2,BASE_VOLUME,NEAR_RADIUS,FAR_RADIUS,FAR_DELIMITER);
if(local1 != null) {
this.soundChannel = this.currentSound3D.play(MP3_BEGINNING_GAP,NUM_LOOPS);
if(this.soundChannel != null) {
this.soundChannel.soundTransform = local1;
}
}
}
private function getSound() : Sound {
switch(this._type) {
case IsisState.IDLE:
return this.sfxData.idleSound;
case IsisState.HEALING:
return this.sfxData.healSound;
case IsisState.DAMAGING:
return this.sfxData.damageSound;
default:
throw new Error();
}
}
}
}
|
package controls.base {
import controls.Label;
import flash.events.MouseEvent;
import flash.text.TextFieldAutoSize;
import flash.ui.Mouse;
import flash.ui.MouseCursor;
import utils.FontParamsUtil;
public class LabelBase extends Label {
private var _autoSize:String;
private var _correctCursorBehaviour:Boolean;
public function LabelBase() {
super();
sharpness = FontParamsUtil.SHARPNESS_LABEL_BASE;
thickness = FontParamsUtil.THICKNESS_LABEL_BASE;
this._autoSize = super.autoSize;
this._correctCursorBehaviour = true;
}
override public function set autoSize(value:String) : void {
super.autoSize = value;
this._autoSize = super.autoSize;
}
override public function set htmlText(value:String) : void {
var autoWidth:Number = NaN;
super.autoSize = this._autoSize;
super.htmlText = value;
if(super.autoSize == TextFieldAutoSize.CENTER) {
autoWidth = super.width;
super.autoSize = TextFieldAutoSize.NONE;
super.width = Math.ceil(autoWidth) + 1;
}
}
override public function set selectable(value:Boolean) : void {
super.selectable = value;
this.arrangeEventListeners();
}
public function get correctCursorBehaviour() : Boolean {
return this._correctCursorBehaviour;
}
public function set correctCursorBehaviour(value:Boolean) : void {
this._correctCursorBehaviour = value;
this.arrangeEventListeners();
}
private function arrangeEventListeners() : void {
if(super.selectable && this._correctCursorBehaviour) {
addEventListener(MouseEvent.MOUSE_OVER,this.onMouseOver);
addEventListener(MouseEvent.MOUSE_OUT,this.onMouseOut);
} else {
removeEventListener(MouseEvent.MOUSE_OVER,this.onMouseOver);
removeEventListener(MouseEvent.MOUSE_OUT,this.onMouseOut);
}
}
private function onMouseOver(event:MouseEvent) : void {
Mouse.cursor = MouseCursor.IBEAM;
}
private function onMouseOut(event:MouseEvent) : void {
Mouse.cursor = MouseCursor.AUTO;
}
}
}
|
package scpacker.test
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class UpdateRankLabel_bitmapCrystal extends BitmapAsset
{
public function UpdateRankLabel_bitmapCrystal()
{
super();
}
}
}
|
package projects.tanks.client.battleselect.types
{
public class BattleClient
{
public var battleId:String;
public var mapId:String;
public var name:String;
public var type:String;
public var team:Boolean;
public var countRedPeople:int;
public var countBluePeople:int;
public var countPeople:int;
public var maxPeople:int;
public var minRank:int;
public var maxRank:int;
public var paid:Boolean;
public function BattleClient()
{
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory.readytouse {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.readytouse.LightPillarEffect_barClass.png")]
public class LightPillarEffect_barClass extends BitmapAsset {
public function LightPillarEffect_barClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.garage.resistance {
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 ResistancesListModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ResistancesListModelServer(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 assets.windowinner.bitmaps {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.windowinner.bitmaps.WindowInnerBottom.png")]
public class WindowInnerBottom extends BitmapData {
public function WindowInnerBottom(param1:int, param2:int, param3:Boolean = true, param4:uint = 0) {
super(param1,param2,param3,param4);
}
}
}
|
package alternativa.tanks.controller.commands {
import alternativa.tanks.controller.events.AccountLoginEvent;
import alternativa.tanks.service.IEntranceServerFacade;
import org.robotlegs.mvcs.Command;
public class AccountLoginCommand extends Command {
[Inject]
public var entranceGateway:IEntranceServerFacade;
[Inject]
public var loginEvent:AccountLoginEvent;
public function AccountLoginCommand() {
super();
}
override public function execute() : void {
this.entranceGateway.loginByHash(this.loginEvent.hash);
}
}
}
|
package alternativa.tanks.help
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
public class StoreListHelper extends BubbleHelper
{
public function StoreListHelper()
{
super();
var localeService:ILocaleService = ILocaleService(Main.osgi.getService(ILocaleService));
text = localeService.getText(TextConst.HELP_GARAGE_STORE_LIST_HELPER_TEXT);
arrowLehgth = int(localeService.getText(TextConst.HELP_GARAGE_STORE_LIST_HELPER_ARROW_LENGTH));
arrowAlign = HelperAlign.MIDDLE_RIGHT;
_showLimit = 3;
}
}
}
|
package projects.tanks.client.battlefield.models.statistics {
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 MemoryStatisticsModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _collectId:Long = Long.getLong(1179706893,-899812627);
private var _collect_gpuEnabledCodec:ICodec;
private var _collect_totalMemoryKBCodec:ICodec;
private var model:IModel;
public function MemoryStatisticsModelServer(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._collect_gpuEnabledCodec = this.protocol.getCodec(new TypeCodecInfo(Boolean,false));
this._collect_totalMemoryKBCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
}
public function collect(param1:Boolean, param2:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._collect_gpuEnabledCodec.encode(this.protocolBuffer,param1);
this._collect_totalMemoryKBCodec.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._collectId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package org.osflash.signals {
public interface IDispatcher {
function dispatch(... rest) : void;
}
}
|
package projects.tanks.clients.flash.commons.services.payment.event {
import flash.events.Event;
import platform.client.fp10.core.type.IGameObject;
public class PaymentLoadWithShopItemEvent extends Event {
public static const LOAD_PAYMENT:String = "PAYMENT_SERVICE_LOAD_WITH_SHOP_ITEM";
private var _shopItem:IGameObject;
public function PaymentLoadWithShopItemEvent(param1:IGameObject) {
super(LOAD_PAYMENT);
this._shopItem = param1;
}
public function get shopItem() : IGameObject {
return this._shopItem;
}
}
}
|
package alternativa.tanks.view.forms {
import alternativa.osgi.service.locale.ILocaleService;
import controls.TankWindow;
import controls.base.DefaultButtonBase;
import fl.controls.UIScrollBar;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.text.AntiAliasType;
import flash.text.GridFitType;
import flash.text.TextField;
import flash.text.TextFormat;
import fonts.TanksFontService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import utils.FontParamsUtil;
public class ViewText extends Sprite {
[Inject]
public var localeService:ILocaleService;
private var output:TextField;
private var format:TextFormat;
private var scrollBar:UIScrollBar = new UIScrollBar();
public var closeButton:DefaultButtonBase = new DefaultButtonBase();
public function ViewText() {
super();
}
[PostConstruct]
public function postConstruct() : void {
var local1:TankWindow = new TankWindow(400,500);
addChild(local1);
this.format = TanksFontService.getTextFormat(13);
this.output = new TextField();
addChild(this.output);
this.output.background = false;
this.output.multiline = true;
this.output.wordWrap = true;
this.output.x = 35;
this.output.y = 35;
this.output.width = 315;
this.output.height = 375;
this.output.embedFonts = TanksFontService.isEmbedFonts();
this.output.antiAliasType = AntiAliasType.ADVANCED;
this.output.gridFitType = GridFitType.SUBPIXEL;
this.output.sharpness = FontParamsUtil.SHARPNESS_LABEL_BASE;
this.output.thickness = FontParamsUtil.THICKNESS_LABEL_BASE;
this.output.defaultTextFormat = this.format;
addChild(this.scrollBar);
this.scrollBar.move(this.output.x + this.output.width,this.output.y);
this.scrollBar.setSize(this.scrollBar.width,this.output.height);
this.scrollBar.scrollTarget = this.output;
addChild(this.closeButton);
this.closeButton.x = 148;
this.closeButton.y = 435;
this.closeButton.label = "123123Close";
this.closeButton.label = this.localeService.getText(TanksLocale.TEXT_ALERT_ANSWER_OK);
this.closeButton.addEventListener(MouseEvent.CLICK,this.hide);
stage.addEventListener(Event.RESIZE,this.onResize);
this.onResize(null);
}
private function onResize(param1:Event) : void {
this.x = int((stage.stageWidth - this.width) / 2);
this.y = int((stage.stageHeight - this.height) / 2);
}
private function hide(param1:MouseEvent) : void {
this.closeButton.removeEventListener(MouseEvent.CLICK,this.hide);
stage.removeEventListener(Event.RESIZE,this.onResize);
this.visible = false;
parent.removeChild(this);
}
public function set text(param1:String) : void {
this.output.htmlText = param1;
this.scrollBar.update();
if(this.scrollBar.maxScrollPosition == 0) {
this.scrollBar.visible = false;
}
}
override public function get width() : Number {
return 400;
}
override public function get height() : Number {
return 500;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.logging.garage {
import flash.events.IEventDispatcher;
import platform.client.fp10.core.type.IGameObject;
public interface UserGarageActionsService extends IEventDispatcher {
function selectItem(param1:IGameObject) : void;
function equipItem(param1:IGameObject) : void;
function unmountItem(param1:IGameObject) : void;
function buyItem(param1:IGameObject) : void;
function buyItemModification(param1:IGameObject) : void;
function upgradeItem(param1:IGameObject) : void;
function chooseItemCount(param1:IGameObject) : void;
function notEnoughCrystalsForBuying(param1:IGameObject) : void;
function purchaseAccepted(param1:IGameObject) : void;
function purchaseDeclined(param1:IGameObject) : void;
}
}
|
package projects.tanks.client.partners.impl.odnoklassniki {
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 OdnoklassnikiInternalLoginModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function OdnoklassnikiInternalLoginModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model {
import alternativa.types.Long;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.users.model.friends.FriendsModelBase;
import projects.tanks.client.users.model.friends.IFriendsModelBase;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.FriendActionServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.FriendActionServiceUidEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendActionService;
[ModelInfo]
public class FriendsModel extends FriendsModelBase implements IFriendsModelBase, ObjectLoadListener, ObjectUnloadListener, IFriends {
[Inject]
public static var friendsActionService:IFriendActionService;
public function FriendsModel() {
super();
}
public function objectLoaded() : void {
if(IFriends(object.adapt(IFriends)).isLocal()) {
friendsActionService.addEventListener(FriendActionServiceEvent.ACCEPT,getFunctionWrapper(this.onAccept));
friendsActionService.addEventListener(FriendActionServiceEvent.ADD,getFunctionWrapper(this.onAdd));
friendsActionService.addEventListener(FriendActionServiceUidEvent.ADD,getFunctionWrapper(this.onAddByUid));
friendsActionService.addEventListener(FriendActionServiceEvent.BREAK_OFF,getFunctionWrapper(this.onBreakItOff));
friendsActionService.addEventListener(FriendActionServiceEvent.REJECT,getFunctionWrapper(this.onReject));
friendsActionService.addEventListener(FriendActionServiceEvent.REJECT_ALL_INCOMING,getFunctionWrapper(this.onRejectAllIncoming));
}
}
private function onAccept(param1:FriendActionServiceEvent) : void {
server.accept(param1.userId);
}
private function onAddByUid(param1:FriendActionServiceUidEvent) : void {
server.addByUid(param1.uid);
}
private function onAdd(param1:FriendActionServiceEvent) : void {
server.add(param1.userId);
}
private function onBreakItOff(param1:FriendActionServiceEvent) : void {
server.breakItOff(param1.userId);
}
private function onReject(param1:FriendActionServiceEvent) : void {
server.reject(param1.userId);
}
private function onRejectAllIncoming(param1:FriendActionServiceEvent) : void {
server.rejectAll();
}
public function objectUnloaded() : void {
if(IFriends(object.adapt(IFriends)).isLocal()) {
friendsActionService.removeEventListener(FriendActionServiceEvent.ACCEPT,getFunctionWrapper(this.onAccept));
friendsActionService.removeEventListener(FriendActionServiceEvent.ADD,getFunctionWrapper(this.onAdd));
friendsActionService.removeEventListener(FriendActionServiceUidEvent.ADD,getFunctionWrapper(this.onAddByUid));
friendsActionService.removeEventListener(FriendActionServiceEvent.BREAK_OFF,getFunctionWrapper(this.onBreakItOff));
friendsActionService.removeEventListener(FriendActionServiceEvent.REJECT,getFunctionWrapper(this.onReject));
friendsActionService.removeEventListener(FriendActionServiceEvent.REJECT_ALL_INCOMING,getFunctionWrapper(this.onRejectAllIncoming));
}
}
public function isLocal() : Boolean {
return getInitParam().local;
}
public function alreadyInAcceptedFriends(param1:String) : void {
friendsActionService.alreadyInAcceptedFriends(param1);
}
public function alreadyInIncomingFriends(param1:String, param2:Long) : void {
friendsActionService.alreadyInIncomingFriends(param1,param2);
}
public function alreadyInOutgoingFriends(param1:String) : void {
friendsActionService.alreadyInOutgoingFriends(param1);
}
public function yourAcceptedLimitExceeded() : void {
friendsActionService.yourAcceptedLimitExceeded();
}
public function acceptedLimitExceeded(param1:String) : void {
friendsActionService.acceptedLimitExceeded(param1);
}
public function incomingLimitExceeded() : void {
friendsActionService.incomingLimitExceeded();
}
public function acceptSuccess(param1:Long) : void {
friendsActionService.requestAccepted(param1);
}
}
}
|
package alternativa.gfx.agal {
public class SamplerSpecial extends SamplerOption {
private static const SAMPLER_SPECIAL_SHIFT:uint = 16;
public static const CENTROID:SamplerSpecial = new SamplerSpecial(1);
public static const SINGLE:SamplerSpecial = new SamplerSpecial(2);
public static const IGNORESAMPLER:SamplerSpecial = new SamplerSpecial(4);
public function SamplerSpecial(param1:int) {
super(param1,SAMPLER_SPECIAL_SHIFT);
}
override public function apply(param1:int) : int {
return param1 | uint(mask) << uint(flag);
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _550d270e9aa6e5a15204aabf084b662ed3d0942e2a28bab885b127239aafb537_flash_display_Sprite extends Sprite {
public function _550d270e9aa6e5a15204aabf084b662ed3d0942e2a28bab885b127239aafb537_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package alternativa.tanks.sound
{
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.ISound3DEffect;
import flash.events.Event;
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundTransform;
import flash.utils.Dictionary;
public class SoundManager implements ISoundManager
{
private var maxDistanceSqr:Number;
private var maxSounds:int = 10;
private var maxSounds3D:int = 20;
private var effects:Vector.<SoundEffectData>;
private var numEffects:int;
private var sounds:Dictionary;
private var numSounds:int;
private var _position:Vector3;
private var sortingStack:Vector.<int>;
public function SoundManager()
{
this.effects = new Vector.<SoundEffectData>();
this.sounds = new Dictionary();
this._position = new Vector3();
this.sortingStack = new Vector.<int>();
super();
}
public static function createSoundManager(testSound:Sound) : ISoundManager
{
var channel:SoundChannel = testSound.play(0,1,new SoundTransform(0));
if(channel != null)
{
channel.stop();
return new SoundManager();
}
return new DummySoundManager();
}
public function set maxDistance(value:Number) : void
{
this.maxDistanceSqr = value * value;
}
public function playSound(sound:Sound, startTime:int = 0, loops:int = 0, soundTransform:SoundTransform = null) : SoundChannel
{
if(this.numSounds == this.maxSounds || sound == null)
{
return null;
}
var channel:SoundChannel = sound.play(startTime,loops,soundTransform);
if(channel == null)
{
return null;
}
this.addSoundChannel(channel);
return channel;
}
public function stopSound(channel:SoundChannel) : void
{
if(channel == null || this.sounds[channel] == null)
{
return;
}
this.removeSoundChannel(channel);
}
public function stopAllSounds() : void
{
var channel:* = undefined;
for(channel in this.sounds)
{
this.removeSoundChannel(channel as SoundChannel);
}
}
public function addEffect(effect:ISound3DEffect) : void
{
if(this.getEffectIndex(effect) > -1)
{
return;
}
effect.enabled = true;
this.effects.push(SoundEffectData.create(0,effect));
++this.numEffects;
}
public function removeEffect(effect:ISound3DEffect) : void
{
var data:SoundEffectData = null;
for(var i:int = 0; i < this.numEffects; i++)
{
data = this.effects[i];
if(data.effect == effect)
{
effect.destroy();
SoundEffectData.destroy(data);
this.effects.splice(i,1);
--this.numEffects;
return;
}
}
}
public function removeAllEffects() : void
{
var data:SoundEffectData = null;
while(this.effects.length > 0)
{
data = this.effects.pop();
data.effect.destroy();
SoundEffectData.destroy(data);
}
this.numEffects = 0;
}
public function updateSoundEffects(millis:int, camera:GameCamera) : void
{
var data:SoundEffectData = null;
var i:int = 0;
var numSounds:int = 0;
if(this.numEffects == 0)
{
return;
}
this.sortEffects(camera.pos);
var num:int = 0;
for(i = 0; i < this.numEffects; i++)
{
data = this.effects[i];
numSounds = data.effect.numSounds;
if(numSounds == 0)
{
data.effect.destroy();
SoundEffectData.destroy(data);
this.effects.splice(i,1);
--this.numEffects;
i--;
}
else
{
if(data.distanceSqr > this.maxDistanceSqr || num + numSounds > this.maxSounds3D)
{
break;
}
data.effect.enabled = true;
data.effect.play(millis,camera);
num += numSounds;
}
}
while(i < this.numEffects)
{
data = this.effects[i];
data.effect.enabled = false;
if(data.effect.numSounds == 0)
{
data.effect.destroy();
SoundEffectData.destroy(data);
this.effects.splice(i,1);
--this.numEffects;
i--;
}
i++;
}
}
public function killEffectsByOwner(owner:ClientObject) : void
{
var soundEffectData:SoundEffectData = null;
var effect:ISound3DEffect = null;
for(var i:int = 0; i < this.numEffects; i++)
{
soundEffectData = this.effects[i];
effect = soundEffectData.effect;
if(effect.owner == owner)
{
effect.kill();
}
}
}
private function addSoundChannel(channel:SoundChannel) : void
{
channel.addEventListener(Event.SOUND_COMPLETE,this.onSoundComplete);
this.sounds[channel] = true;
++this.numSounds;
}
private function removeSoundChannel(channel:SoundChannel) : void
{
channel.stop();
channel.removeEventListener(Event.SOUND_COMPLETE,this.onSoundComplete);
delete this.sounds[channel];
--this.numSounds;
}
private function onSoundComplete(e:Event) : void
{
this.stopSound(e.target as SoundChannel);
}
private function getEffectIndex(effect:ISound3DEffect) : int
{
for(var i:int = 0; i < this.numEffects; i++)
{
if(SoundEffectData(this.effects[i]).effect == effect)
{
return i;
}
}
return -1;
}
private function sortEffects(cameraPos:Vector3) : void
{
var i:int = 0;
var j:int = 0;
var sortingStackIndex:int = 0;
var sortingMedian:Number = NaN;
var data:SoundEffectData = null;
var sortingLeft:SoundEffectData = null;
var sortingRight:SoundEffectData = null;
var dx:Number = NaN;
var dy:Number = NaN;
var dz:Number = NaN;
var left:int = 0;
var right:int = this.numEffects - 1;
for(i = 0; i < this.numEffects; i++)
{
data = this.effects[i];
data.effect.readPosition(this._position);
dx = cameraPos.x - this._position.x;
dy = cameraPos.y - this._position.y;
dz = cameraPos.z - this._position.z;
data.distanceSqr = dx * dx + dy * dy + dz * dz;
}
if(this.numEffects == 1)
{
return;
}
this.sortingStack[0] = left;
this.sortingStack[1] = right;
sortingStackIndex = 2;
while(sortingStackIndex > 0)
{
j = right = this.sortingStack[--sortingStackIndex];
sortingMedian = SoundEffectData(this.effects[right + (i = int(this.sortingStack[--sortingStackIndex])) >> 1]).distanceSqr;
do
{
while((sortingLeft = this.effects[i]).distanceSqr < sortingMedian)
{
i++;
}
while((sortingRight = this.effects[j]).distanceSqr > sortingMedian)
{
j--;
}
if(i <= j)
{
var _loc14_:* = i++;
this.effects[_loc14_] = sortingRight;
var _loc15_:* = j--;
this.effects[_loc15_] = sortingLeft;
}
}
while(i <= j);
if(left < j)
{
_loc14_ = sortingStackIndex++;
this.sortingStack[_loc14_] = left;
_loc15_ = sortingStackIndex++;
this.sortingStack[_loc15_] = j;
}
if(i < right)
{
_loc14_ = sortingStackIndex++;
this.sortingStack[_loc14_] = i;
_loc15_ = sortingStackIndex++;
this.sortingStack[_loc15_] = right;
}
}
}
}
}
import alternativa.tanks.sfx.ISound3DEffect;
class SoundEffectData
{
private static var pool:Vector.<SoundEffectData> = new Vector.<SoundEffectData>();
private static var numObjects:int;
public var distanceSqr:Number;
public var effect:ISound3DEffect;
function SoundEffectData(distanceSqr:Number, effect:ISound3DEffect)
{
super();
this.distanceSqr = distanceSqr;
this.effect = effect;
}
public static function create(distanceSqr:Number, effect:ISound3DEffect) : SoundEffectData
{
var data:SoundEffectData = null;
if(numObjects > 0)
{
data = pool[--numObjects];
pool[numObjects] = null;
data.distanceSqr = distanceSqr;
data.effect = effect;
return data;
}
return new SoundEffectData(distanceSqr,effect);
}
public static function destroy(data:SoundEffectData) : void
{
data.effect = null;
var _loc2_:* = numObjects++;
pool[_loc2_] = data;
}
}
|
package {
import flash.display.MovieClip;
[Embed(source="/_assets/assets.swf", symbol="symbol100")]
public dynamic class SliderThumb_downSkin extends MovieClip {
public function SliderThumb_downSkin() {
super();
}
}
}
|
package alternativa.tanks.models.tank.armor {
import projects.tanks.client.battlefield.models.tankparts.armor.simple.ISimpleArmorModelBase;
import projects.tanks.client.battlefield.models.tankparts.armor.simple.SimpleArmorModelBase;
[ModelInfo]
public class SimpleArmorModel extends SimpleArmorModelBase implements ISimpleArmorModelBase, Armor {
public function SimpleArmorModel() {
super();
}
public function getMaxHealth() : int {
return getInitParam().maxHealth;
}
}
}
|
package projects.tanks.client.battlefield.models.bonus.battle.goldbonus {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.bonus.battle.bonusregions.BonusRegionData;
public interface IGoldBonusesModelBase {
function hideDropZone(param1:BonusRegionData) : void;
function notificationBonus(param1:IGameObject, param2:BonusRegionData) : void;
function notificationBonusContainsUid(param1:IGameObject, param2:String, param3:BonusRegionData) : void;
}
}
|
package alternativa.tanks.models.sfx
{
import alternativa.engine3d.lights.OmniLight;
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.sfx.IGraphicEffect;
import alternativa.tanks.sfx.Object3DPositionProvider;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
public final class AnimatedLightEffect extends PooledObject implements IGraphicEffect
{
public static const DEFAULT_MAX_DISTANCE:Number = 99999;
private var light:OmniLight;
private var positionProvider:Object3DPositionProvider;
private var animation:LightAnimation;
private var currentTime:int;
private var timeToLive:int;
private var looped:Boolean;
private var alive:Boolean;
private var maxDistance:Number;
private var fadeDistance:Number;
private var position:Vector3;
private var container:Scene3DContainer;
public function AnimatedLightEffect(param1:ObjectPool)
{
this.position = new Vector3();
super(param1);
this.light = new OmniLight(0,0,0);
}
public function init(param1:Object3DPositionProvider, param2:LightAnimation, param3:Number = 99999, param4:Boolean = false) : void
{
this.initFromTime(param1,param2.getLiveTime(),param2,param3,param4);
}
public function initFromTime(param1:Object3DPositionProvider, param2:int, param3:LightAnimation, param4:Number = 99999, param5:Boolean = false) : void
{
this.positionProvider = param1;
this.timeToLive = param2;
this.currentTime = 0;
this.animation = param3;
this.looped = param5;
this.alive = true;
this.maxDistance = param4;
this.fadeDistance = param4 / 4 * 3;
}
public function addToContainer(param1:Scene3DContainer) : void
{
this.container = param1;
param1.addChild(this.light);
}
public function play(param1:int, param2:GameCamera) : Boolean
{
var _loc3_:Number = NaN;
var _loc4_:Number = NaN;
if(this.alive)
{
if(this.animation == null)
{
return false;
}
this.animation.updateByTime(this.light,this.currentTime,this.timeToLive);
this.positionProvider.updateObjectPosition(this.light,param2,param1);
this.currentTime += param1;
if(this.currentTime > this.timeToLive)
{
if(this.looped)
{
this.currentTime %= this.timeToLive;
}
else
{
this.alive = false;
}
}
this.position.x = this.light.x;
this.position.y = this.light.y;
this.position.z = this.light.z;
_loc3_ = Vector3.distanceBetween(this.position,param2.pos);
if(_loc3_ > this.fadeDistance)
{
_loc4_ = 1 - (_loc3_ - this.fadeDistance) / (this.maxDistance - this.fadeDistance);
this.light.intensity *= _loc4_;
this.light.visible = _loc3_ < this.maxDistance;
}
return this.alive;
}
return false;
}
public function destroy() : void
{
this.container.removeChild(this.light);
this.container = null;
this.animation = null;
this.positionProvider.destroy();
this.positionProvider = null;
}
public function kill() : void
{
this.alive = false;
}
public function get owner() : ClientObject
{
return null;
}
}
}
|
package alternativa.tanks.models.battlefield.effects.graffiti
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class TexturesManager_graffiti_default extends BitmapAsset
{
public function TexturesManager_graffiti_default()
{
super();
}
}
}
|
package alternativa.utils {
public class Properties {
private var data:Object;
public function Properties(param1:Object = null) {
super();
this.data = param1 || {};
}
public function getProperty(param1:String) : String {
return this.data[param1];
}
public function getPropertyDef(param1:String, param2:String) : String {
return this.data[param1] || param2;
}
public function setProperty(param1:String, param2:String) : void {
if(!param2) {
throw new ArgumentError("Empty values are not allowed");
}
this.data[param1] = param2;
}
public function removeProperty(param1:String) : void {
delete this.data[param1];
}
public function get propertyNames() : Vector.<String> {
var local2:String = null;
var local1:Vector.<String> = new Vector.<String>();
for(local2 in this.data) {
local1.push(local2);
}
return local1;
}
public function toString() : String {
var local2:String = null;
var local1:* = "";
for(local2 in this.data) {
if(local1) {
local1 += ", ";
}
local1 += local2 + ": " + this.data[local2];
}
return "[Properties " + local1 + "]";
}
}
}
|
package controls.cellrenderer {
import flash.display.Graphics;
public class CellRendererDefault extends ButtonState {
public function CellRendererDefault() {
super();
}
override public function draw() : void {
var local1:Graphics = null;
local1 = l.graphics;
local1.clear();
local1.beginBitmapFill(bmpLeft);
local1.drawRect(0,0,5,20);
local1.endFill();
l.x = 0;
l.y = 0;
local1 = c.graphics;
local1.clear();
local1.beginBitmapFill(bmpCenter);
local1.drawRect(0,0,_width - 10,20);
local1.endFill();
c.x = 5;
c.y = 0;
local1 = r.graphics;
local1.clear();
local1.beginBitmapFill(bmpRight);
local1.drawRect(0,0,5,20);
local1.endFill();
r.x = _width - 5;
r.y = 0;
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.healing.struct
{
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.healing.IsisActionType;
public class IsisAction
{
public var shooterId:String;
public var targetId:String;
public var type:IsisActionType;
public function IsisAction()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.lootboxandpaintkit {
import platform.client.fp10.core.resource.types.ImageResource;
public class LootboxAndPaintCC {
private var _button:ImageResource;
private var _buttonOver:ImageResource;
private var _crystalCount:int;
private var _lootBoxPreview:ImageResource;
private var _lootboxCount:int;
private var _paintPreview:ImageResource;
public function LootboxAndPaintCC(param1:ImageResource = null, param2:ImageResource = null, param3:int = 0, param4:ImageResource = null, param5:int = 0, param6:ImageResource = null) {
super();
this._button = param1;
this._buttonOver = param2;
this._crystalCount = param3;
this._lootBoxPreview = param4;
this._lootboxCount = param5;
this._paintPreview = param6;
}
public function get button() : ImageResource {
return this._button;
}
public function set button(param1:ImageResource) : void {
this._button = param1;
}
public function get buttonOver() : ImageResource {
return this._buttonOver;
}
public function set buttonOver(param1:ImageResource) : void {
this._buttonOver = param1;
}
public function get crystalCount() : int {
return this._crystalCount;
}
public function set crystalCount(param1:int) : void {
this._crystalCount = param1;
}
public function get lootBoxPreview() : ImageResource {
return this._lootBoxPreview;
}
public function set lootBoxPreview(param1:ImageResource) : void {
this._lootBoxPreview = param1;
}
public function get lootboxCount() : int {
return this._lootboxCount;
}
public function set lootboxCount(param1:int) : void {
this._lootboxCount = param1;
}
public function get paintPreview() : ImageResource {
return this._paintPreview;
}
public function set paintPreview(param1:ImageResource) : void {
this._paintPreview = param1;
}
public function toString() : String {
var local1:String = "LootboxAndPaintCC [";
local1 += "button = " + this.button + " ";
local1 += "buttonOver = " + this.buttonOver + " ";
local1 += "crystalCount = " + this.crystalCount + " ";
local1 += "lootBoxPreview = " + this.lootBoxPreview + " ";
local1 += "lootboxCount = " + this.lootboxCount + " ";
local1 += "paintPreview = " + this.paintPreview + " ";
return local1 + "]";
}
}
}
|
package assets.input {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.input.InputRight.png")]
public class InputRight extends BitmapData {
public function InputRight(param1:int, param2:int, param3:Boolean = true, param4:uint = 0) {
super(param1,param2,param3,param4);
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.effects.activationsfx {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.effects.activationsfx.EffectSFXRecordCC;
import projects.tanks.client.battlefield.models.effects.activationsfx.TankEffectSFXCC;
public class CodecTankEffectSFXCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_effects:ICodec;
public function CodecTankEffectSFXCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_effects = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(EffectSFXRecordCC,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:TankEffectSFXCC = new TankEffectSFXCC();
local2.effects = this.codec_effects.decode(param1) as Vector.<EffectSFXRecordCC>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:TankEffectSFXCC = TankEffectSFXCC(param2);
this.codec_effects.encode(param1,local3.effects);
}
}
}
|
package projects.tanks.client.clans.clan.permissions {
public interface IClanPermissionsModelBase {
function updateActions(param1:Vector.<ClanAction>) : void;
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangsIcon_p27 extends BitmapAsset
{
public function RangsIcon_p27()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.healing {
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import projects.tanks.client.battlefield.models.tankparts.weapon.healing.IsisState;
public interface HealingGunEffects {
function init(param1:Object3D, param2:Vector3) : void;
function setLocalEffectsType(param1:IsisState, param2:Tank = null, param3:Vector3 = null) : void;
function setRemoteEffectsType(param1:IsisState, param2:Tank = null, param3:Vector3 = null) : void;
function stopEffects() : void;
function setBuffedMode(param1:Boolean) : void;
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.base {
import flash.display.BitmapData;
public class ButtonItemSkin {
public var overState:BitmapData;
public var normalState:BitmapData;
public function ButtonItemSkin() {
super();
}
}
}
|
package alternativa.tanks.gui.friends.list.renderer.background {
import controls.cellrenderer.ButtonState;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Graphics;
public class FriendCellSelected extends ButtonState {
private static var leftIconClass:Class = FriendCellSelected_leftIconClass;
private static var leftIconBitmapData:BitmapData = Bitmap(new leftIconClass()).bitmapData;
private static var centerIconClass:Class = FriendCellSelected_centerIconClass;
private static var centerIconBitmapData:BitmapData = Bitmap(new centerIconClass()).bitmapData;
private static var rightIconClass:Class = FriendCellSelected_rightIconClass;
private static var rightIconBitmapData:BitmapData = Bitmap(new rightIconClass()).bitmapData;
public function FriendCellSelected() {
super();
bmpLeft = leftIconBitmapData;
bmpCenter = centerIconBitmapData;
bmpRight = rightIconBitmapData;
}
override public function draw() : void {
var local1:Graphics = null;
local1 = l.graphics;
local1.clear();
local1.beginBitmapFill(bmpLeft);
local1.drawRect(0,0,5,20);
local1.endFill();
l.x = 0;
l.y = 0;
local1 = c.graphics;
local1.clear();
local1.beginBitmapFill(bmpCenter);
local1.drawRect(0,0,_width - 10,20);
local1.endFill();
c.x = 5;
c.y = 0;
local1 = r.graphics;
local1.clear();
local1.beginBitmapFill(bmpRight);
local1.drawRect(0,0,5,20);
local1.endFill();
r.x = _width - 5;
r.y = 0;
}
}
}
|
package alternativa.tanks.models.weapon.angles.verticals {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class VerticalAnglesEvents implements VerticalAngles {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function VerticalAnglesEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getAngleUp() : Number {
var result:Number = NaN;
var i:int = 0;
var m:VerticalAngles = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = VerticalAngles(this.impl[i]);
result = Number(m.getAngleUp());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getAngleDown() : Number {
var result:Number = NaN;
var i:int = 0;
var m:VerticalAngles = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = VerticalAngles(this.impl[i]);
result = Number(m.getAngleDown());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package utils.tweener.core
{
import utils.tweener.TweenLite;
public class TweenCore
{
public static const version:Number = 1.693;
protected static var _classInitted:Boolean;
protected var _delay:Number;
protected var _hasUpdate:Boolean;
protected var _rawPrevTime:Number = -1;
public var vars:Object;
public var active:Boolean;
public var gc:Boolean;
public var initted:Boolean;
public var timeline:SimpleTimeline;
public var cachedStartTime:Number;
public var cachedTime:Number;
public var cachedTotalTime:Number;
public var cachedDuration:Number;
public var cachedTotalDuration:Number;
public var cachedTimeScale:Number;
public var cachedPauseTime:Number;
public var cachedReversed:Boolean;
public var nextNode:TweenCore;
public var prevNode:TweenCore;
public var cachedOrphan:Boolean;
public var cacheIsDirty:Boolean;
public var cachedPaused:Boolean;
public var data:Object;
public function TweenCore(param1:Number = 0, param2:Object = null)
{
super();
this.vars = param2 != null ? param2 : {};
if(this.vars.isGSVars)
{
this.vars = this.vars.vars;
}
this.cachedDuration = this.cachedTotalDuration = param1;
this._delay = !!Boolean(this.vars.delay) ? Number(Number(Number(Number(this.vars.delay)))) : Number(Number(Number(0)));
this.cachedTimeScale = !!Boolean(this.vars.timeScale) ? Number(Number(Number(Number(this.vars.timeScale)))) : Number(Number(Number(1)));
this.active = Boolean(param1 == 0 && this._delay == 0 && this.vars.immediateRender != false);
this.cachedTotalTime = this.cachedTime = 0;
this.data = this.vars.data;
if(!_classInitted)
{
if(!isNaN(TweenLite.rootFrame))
{
return;
}
TweenLite.initClass();
_classInitted = true;
}
var _loc3_:SimpleTimeline = this.vars.timeline is SimpleTimeline ? this.vars.timeline : (!!Boolean(this.vars.useFrames) ? TweenLite.rootFramesTimeline : TweenLite.rootTimeline);
_loc3_.insert(this,_loc3_.cachedTotalTime);
if(this.vars.reversed)
{
this.cachedReversed = true;
}
if(this.vars.paused)
{
this.paused = true;
}
}
public function play() : void
{
this.reversed = false;
this.paused = false;
}
public function pause() : void
{
this.paused = true;
}
public function resume() : void
{
this.paused = false;
}
public function restart(param1:Boolean = false, param2:Boolean = true) : void
{
this.reversed = false;
this.paused = false;
this.setTotalTime(!!param1 ? Number(Number(Number(-this._delay))) : Number(Number(Number(0))),param2);
}
public function reverse(param1:Boolean = true) : void
{
this.reversed = true;
if(param1)
{
this.paused = false;
}
else if(this.gc)
{
this.setEnabled(true,false);
}
}
public function renderTime(param1:Number, param2:Boolean = false, param3:Boolean = false) : void
{
}
public function complete(param1:Boolean = false, param2:Boolean = false) : void
{
if(!param1)
{
this.renderTime(this.totalDuration,param2,false);
return;
}
if(this.timeline.autoRemoveChildren)
{
this.setEnabled(false,false);
}
else
{
this.active = false;
}
if(!param2)
{
if(this.vars.onComplete && this.cachedTotalTime >= this.cachedTotalDuration && !this.cachedReversed)
{
this.vars.onComplete.apply(null,this.vars.onCompleteParams);
}
else if(this.cachedReversed && this.cachedTotalTime == 0 && this.vars.onReverseComplete)
{
this.vars.onReverseComplete.apply(null,this.vars.onReverseCompleteParams);
}
}
}
public function invalidate() : void
{
}
public function setEnabled(param1:Boolean, param2:Boolean = false) : Boolean
{
this.gc = !param1;
if(param1)
{
this.active = Boolean(!this.cachedPaused && this.cachedTotalTime > 0 && this.cachedTotalTime < this.cachedTotalDuration);
if(!param2 && this.cachedOrphan)
{
this.timeline.insert(this,this.cachedStartTime - this._delay);
}
}
else
{
this.active = false;
if(!param2 && !this.cachedOrphan)
{
this.timeline.remove(this,true);
}
}
return false;
}
public function kill() : void
{
this.setEnabled(false,false);
}
protected function setDirtyCache(param1:Boolean = true) : void
{
var _loc2_:TweenCore = !!param1 ? this : this.timeline;
while(_loc2_)
{
_loc2_.cacheIsDirty = true;
_loc2_ = _loc2_.timeline;
}
}
protected function setTotalTime(param1:Number, param2:Boolean = false) : void
{
var _loc3_:Number = NaN;
var _loc4_:Number = NaN;
if(this.timeline)
{
_loc3_ = !!this.cachedPaused ? Number(Number(Number(this.cachedPauseTime))) : Number(Number(Number(this.timeline.cachedTotalTime)));
if(this.cachedReversed)
{
_loc4_ = !!this.cacheIsDirty ? Number(Number(Number(this.totalDuration))) : Number(Number(Number(this.cachedTotalDuration)));
this.cachedStartTime = _loc3_ - (_loc4_ - param1) / this.cachedTimeScale;
}
else
{
this.cachedStartTime = _loc3_ - param1 / this.cachedTimeScale;
}
if(!this.timeline.cacheIsDirty)
{
this.setDirtyCache(false);
}
if(this.cachedTotalTime != param1)
{
this.renderTime(param1,param2,false);
}
}
}
public function get delay() : Number
{
return this._delay;
}
public function set delay(param1:Number) : void
{
this.startTime += param1 - this._delay;
this._delay = param1;
}
public function get duration() : Number
{
return this.cachedDuration;
}
public function set duration(param1:Number) : void
{
var _loc2_:Number = param1 / this.cachedDuration;
this.cachedDuration = this.cachedTotalDuration = param1;
this.setDirtyCache(true);
if(this.active && !this.cachedPaused && param1 != 0)
{
this.setTotalTime(this.cachedTotalTime * _loc2_,true);
}
}
public function get totalDuration() : Number
{
return this.cachedTotalDuration;
}
public function set totalDuration(param1:Number) : void
{
this.duration = param1;
}
public function get currentTime() : Number
{
return this.cachedTime;
}
public function set currentTime(param1:Number) : void
{
this.setTotalTime(param1,false);
}
public function get totalTime() : Number
{
return this.cachedTotalTime;
}
public function set totalTime(param1:Number) : void
{
this.setTotalTime(param1,false);
}
public function get startTime() : Number
{
return this.cachedStartTime;
}
public function set startTime(param1:Number) : void
{
if(this.timeline != null && (param1 != this.cachedStartTime || this.gc))
{
this.timeline.insert(this,param1 - this._delay);
}
else
{
this.cachedStartTime = param1;
}
}
public function get reversed() : Boolean
{
return this.cachedReversed;
}
public function set reversed(param1:Boolean) : void
{
if(param1 != this.cachedReversed)
{
this.cachedReversed = param1;
this.setTotalTime(this.cachedTotalTime,true);
}
}
public function get paused() : Boolean
{
return this.cachedPaused;
}
public function set paused(param1:Boolean) : void
{
if(param1 != this.cachedPaused && this.timeline)
{
if(param1)
{
this.cachedPauseTime = this.timeline.rawTime;
}
else
{
this.cachedStartTime += this.timeline.rawTime - this.cachedPauseTime;
this.cachedPauseTime = NaN;
this.setDirtyCache(false);
}
this.cachedPaused = param1;
this.active = Boolean(!this.cachedPaused && this.cachedTotalTime > 0 && this.cachedTotalTime < this.cachedTotalDuration);
}
if(!param1 && this.gc)
{
this.setEnabled(true,false);
}
}
}
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_HEADER_RED_PIXEL.png")]
public dynamic class bres_HEADER_RED_PIXEL extends BitmapData {
public function bres_HEADER_RED_PIXEL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package projects.tanks.client.entrance.model.entrance.logging {
public class RegistrationUXScreen {
public static const MAIN:RegistrationUXScreen = new RegistrationUXScreen(0,"MAIN");
public static const VK:RegistrationUXScreen = new RegistrationUXScreen(1,"VK");
public static const FACEBOOK:RegistrationUXScreen = new RegistrationUXScreen(2,"FACEBOOK");
public static const GOOGLE:RegistrationUXScreen = new RegistrationUXScreen(3,"GOOGLE");
public static const PARTNER:RegistrationUXScreen = new RegistrationUXScreen(4,"PARTNER");
public static const LOGIN:RegistrationUXScreen = new RegistrationUXScreen(5,"LOGIN");
public static const SITE:RegistrationUXScreen = new RegistrationUXScreen(6,"SITE");
public static const TUTORIAL:RegistrationUXScreen = new RegistrationUXScreen(7,"TUTORIAL");
public static const STANDALONE:RegistrationUXScreen = new RegistrationUXScreen(8,"STANDALONE");
private var _value:int;
private var _name:String;
public function RegistrationUXScreen(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<RegistrationUXScreen> {
var local1:Vector.<RegistrationUXScreen> = new Vector.<RegistrationUXScreen>();
local1.push(MAIN);
local1.push(VK);
local1.push(FACEBOOK);
local1.push(GOOGLE);
local1.push(PARTNER);
local1.push(LOGIN);
local1.push(SITE);
local1.push(TUTORIAL);
local1.push(STANDALONE);
return local1;
}
public function toString() : String {
return "RegistrationUXScreen [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.model.payment.shop.specialkit {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.shop.specialkit.SpecialKitPackageCC;
public class SpecialKitPackageEvents implements SpecialKitPackage {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function SpecialKitPackageEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getCrystalsAmount() : int {
var result:int = 0;
var i:int = 0;
var m:SpecialKitPackage = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpecialKitPackage(this.impl[i]);
result = int(m.getCrystalsAmount());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getPremiumDurationInDays() : int {
var result:int = 0;
var i:int = 0;
var m:SpecialKitPackage = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpecialKitPackage(this.impl[i]);
result = int(m.getPremiumDurationInDays());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getEverySupplyAmount() : int {
var result:int = 0;
var i:int = 0;
var m:SpecialKitPackage = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpecialKitPackage(this.impl[i]);
result = int(m.getEverySupplyAmount());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getGoldAmount() : int {
var result:int = 0;
var i:int = 0;
var m:SpecialKitPackage = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpecialKitPackage(this.impl[i]);
result = int(m.getGoldAmount());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function hasAdditionalItem() : Boolean {
var result:Boolean = false;
var i:int = 0;
var m:SpecialKitPackage = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpecialKitPackage(this.impl[i]);
result = Boolean(m.hasAdditionalItem());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getItemsCount() : int {
var result:int = 0;
var i:int = 0;
var m:SpecialKitPackage = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpecialKitPackage(this.impl[i]);
result = int(m.getItemsCount());
i++;
}
}
finally {
Model.popObject();
}
return result;
}
public function getPackageData() : SpecialKitPackageCC {
var result:SpecialKitPackageCC = null;
var i:int = 0;
var m:SpecialKitPackage = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = SpecialKitPackage(this.impl[i]);
result = m.getPackageData();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.model.quest.common.gui.greenpanel {
import flash.display.BitmapData;
import utils.FlipBitmapDataUtils;
public class GreenPanelBitmaps {
private static const LEFT_TOP_CORNER_BITMAP:Class = GreenPanelBitmaps_LEFT_TOP_CORNER_BITMAP;
public static const LEFT_TOP_CORNER_BITMAP_DATA:BitmapData = new LEFT_TOP_CORNER_BITMAP().bitmapData;
public static const RIGHT_TOP_CORNER_BITMAP_DATA:BitmapData = FlipBitmapDataUtils.flipH(LEFT_TOP_CORNER_BITMAP_DATA);
private static const TOP_LINE_BITMAP:Class = GreenPanelBitmaps_TOP_LINE_BITMAP;
public static const TOP_LINE_BITMAP_DATA:BitmapData = new TOP_LINE_BITMAP().bitmapData;
public static const BOTTOM_LINE_BITMAP_DATA:BitmapData = FlipBitmapDataUtils.flipW(TOP_LINE_BITMAP_DATA);
private static const LEFT_LINE_BITMAP:Class = GreenPanelBitmaps_LEFT_LINE_BITMAP;
public static const LEFT_LINE_BITMAP_DATA:BitmapData = new LEFT_LINE_BITMAP().bitmapData;
public static const RIGHT_LINE_BITMAP_DATA:BitmapData = FlipBitmapDataUtils.flipH(LEFT_LINE_BITMAP_DATA);
private static const BACKGROUND_PIXEL_BITMAP:Class = GreenPanelBitmaps_BACKGROUND_PIXEL_BITMAP;
public static const BACKGROUND_PIXEL_BITMAP_DATA:BitmapData = new BACKGROUND_PIXEL_BITMAP().bitmapData;
private static const LEFT_BOTTOM_CORNER_BITMAP:Class = GreenPanelBitmaps_LEFT_BOTTOM_CORNER_BITMAP;
public static const LEFT_BOTTOM_CORNER_BITMAP_DATA:BitmapData = new LEFT_BOTTOM_CORNER_BITMAP().bitmapData;
public static const RIGHT_BOTTOM_CORNER_BITMAP_DATA:BitmapData = FlipBitmapDataUtils.flipH(LEFT_BOTTOM_CORNER_BITMAP_DATA);
public function GreenPanelBitmaps() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.twins {
import alternativa.math.Vector3;
import alternativa.physics.Body;
[ModelInterface]
public interface TwinsWeaponCallback {
function onShot(param1:int, param2:int, param3:int, param4:Vector3) : void;
function onDummyShot(param1:int, param2:int) : void;
function onTargetHit(param1:int, param2:Body, param3:Vector3) : void;
function onStaticHit(param1:int, param2:Vector3) : void;
}
}
|
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 ScalingObject3DPositionProvider extends PooledObject implements Object3DPositionProvider {
private var initialPosition:Vector3 = new Vector3();
private var velocity:Vector3 = new Vector3();
private var scaleVelocity:Number;
public function ScalingObject3DPositionProvider(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;
param1.scaleX = 1;
param1.scaleY = 1;
param1.scaleZ = 1;
}
public function init(param1:Vector3, param2:Vector3, param3:Number) : void {
this.initialPosition.copy(param1);
this.velocity.copy(param2);
this.scaleVelocity = 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;
param1.scaleX += this.scaleVelocity;
param1.scaleY += this.scaleVelocity;
param1.scaleZ += this.scaleVelocity;
}
public function destroy() : void {
recycle();
}
}
}
|
package platform.client.fp10.core.service.errormessage.errors {
public interface ErrorType {
function getMessage() : String;
}
}
|
package _codec.projects.tanks.client.entrance.model.entrance.clienthalt {
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.entrance.model.entrance.clienthalt.ServerHaltEntranceCC;
public class CodecServerHaltEntranceCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_serverHalt:ICodec;
public function CodecServerHaltEntranceCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_serverHalt = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ServerHaltEntranceCC = new ServerHaltEntranceCC();
local2.serverHalt = this.codec_serverHalt.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:ServerHaltEntranceCC = ServerHaltEntranceCC(param2);
this.codec_serverHalt.encode(param1,local3.serverHalt);
}
}
}
|
package assets.resultwindow {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.resultwindow.bres_BG_GRAY_PIXEL.png")]
public dynamic class bres_BG_GRAY_PIXEL extends BitmapData {
public function bres_BG_GRAY_PIXEL(param1:int = 4, param2:int = 4) {
super(param1,param2);
}
}
}
|
package alternativa.tanks.model.referals
{
public interface IReferals
{
function getReferalsData() : void;
}
}
|
package alternativa.tanks.model.challenge
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChallengeCongratulationWindow_metallicBitmap extends BitmapAsset
{
public function ChallengeCongratulationWindow_metallicBitmap()
{
super();
}
}
}
|
package alternativa.tanks.help
{
import alternativa.init.Main;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.locale.constants.TextConst;
public class LockedMapsHelper extends BubbleHelper
{
public function LockedMapsHelper()
{
super();
var localeService:ILocaleService = ILocaleService(Main.osgi.getService(ILocaleService));
text = localeService.getText(TextConst.HELP_BATTLE_SELECT_LOCKED_MAP_HELPER_TEXT);
arrowLehgth = int(localeService.getText(TextConst.HELP_BATTLE_SELECT_LOCKED_MAP_HELPER_ARROW_LENGTH));
arrowAlign = HelperAlign.MIDDLE_LEFT;
_showLimit = 5;
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.clientlayoutkit.entity {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.shop.clientlayoutkit.entity.BundleImage;
public class VectorCodecBundleImageLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBundleImageLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BundleImage,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<BundleImage> = new Vector.<BundleImage>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BundleImage(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BundleImage = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BundleImage> = Vector.<BundleImage>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.weapon.artillery.sfx {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.engine3d.EffectsMaterialRegistry;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.sfx.lighting.LightingSfx;
import alternativa.tanks.sfx.LightAnimation;
import alternativa.tanks.utils.GraphicsUtils;
import flash.media.Sound;
import platform.client.fp10.core.type.AutoClosable;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapons.artillery.sfx.ArtillerySfxCC;
public class ArtillerySfxData implements AutoClosable {
[Inject]
public static var materialRegistry:EffectsMaterialRegistry;
public var explosion:TextureAnimation;
public var smoke:TextureAnimation;
public var trail:TextureMaterial;
public var stream:TextureMaterial;
public var flame:TextureMaterial;
public var explosionMarkMaterial:TextureMaterial;
public var shotLightAnimation:LightAnimation;
public var hitLightAnimation:LightAnimation;
public var explosionSound:Sound;
public var reloadSound:Sound;
public var flyBySound:Sound;
public var chargingSound:Sound;
public var shotSounds:Vector.<Sound>;
public var farShotSound:Sound;
public function ArtillerySfxData(param1:IGameObject, param2:ArtillerySfxCC, param3:LightingSfx) {
super();
this.explosion = GraphicsUtils.getTextureAnimationFromResource(materialRegistry,param2.explosionTexture);
this.smoke = GraphicsUtils.getTextureAnimationFromResource(materialRegistry,param2.smokeTexture);
this.trail = materialRegistry.getMaterial(param2.trailTexture.data);
this.stream = materialRegistry.getMaterial(param2.streamTexture.data);
this.flame = materialRegistry.getMaterial(param2.flameTexture.data);
this.explosionMarkMaterial = materialRegistry.getMaterial(param2.markTexture.data);
this.shotLightAnimation = param3.createAnimation("shot");
this.hitLightAnimation = param3.createAnimation("hit");
this.explosionSound = param2.explosionSound.sound;
this.reloadSound = param2.reloadSound.sound;
this.flyBySound = param2.flyBySound.sound;
this.chargingSound = param2.chargingSound.sound;
this.shotSounds = Vector.<Sound>([param2.shot1Sound.sound,param2.shot2Sound.sound,param2.shot3Sound.sound,param2.shot4Sound.sound]);
this.farShotSound = param2.farShotSound.sound;
}
public function close() : void {
materialRegistry.releaseMaterial(this.explosion.material);
materialRegistry.releaseMaterial(this.smoke.material);
materialRegistry.releaseMaterial(this.trail);
materialRegistry.releaseMaterial(this.stream);
materialRegistry.releaseMaterial(this.flame);
materialRegistry.releaseMaterial(this.explosionMarkMaterial);
this.hitLightAnimation = null;
this.shotLightAnimation = null;
var local1:int = 0;
while(local1 < this.shotSounds.length) {
this.shotSounds[local1] = null;
local1++;
}
this.chargingSound = null;
this.explosionSound = null;
this.reloadSound = null;
this.flyBySound = null;
this.farShotSound = null;
}
}
}
|
package projects.tanks.client.panel.model.payment.modes {
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 PaymentModeModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function PaymentModeModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.upgradeable.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.upgradeable.types.GaragePropertyParams;
public class VectorCodecGaragePropertyParamsLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecGaragePropertyParamsLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(GaragePropertyParams,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.<GaragePropertyParams> = new Vector.<GaragePropertyParams>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = GaragePropertyParams(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:GaragePropertyParams = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<GaragePropertyParams> = Vector.<GaragePropertyParams>(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.controlpoints {
import alternativa.types.Long;
import flash.utils.Dictionary;
public class PointOccupationBuffer {
private var buffer:Dictionary = new Dictionary();
public function PointOccupationBuffer() {
super();
}
public function add(param1:Long, param2:int) : void {
this.buffer[param1] = param2;
}
public function remove(param1:Long) : void {
delete this.buffer[param1];
}
public function takeTankPointId(param1:Long) : int {
var local2:int = 0;
if(this.buffer[param1] != undefined) {
local2 = int(this.buffer[param1]);
delete this.buffer[param1];
return local2;
}
return -1;
}
}
}
|
package alternativa.tanks.models.weapon.thunder {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IThunderSFXModelAdapt implements IThunderSFXModel {
private var object:IGameObject;
private var impl:IThunderSFXModel;
public function IThunderSFXModelAdapt(param1:IGameObject, param2:IThunderSFXModel) {
super();
this.object = param1;
this.impl = param2;
}
public function getEffects() : IThunderEffects {
var result:IThunderEffects = null;
try {
Model.object = this.object;
result = this.impl.getEffects();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.model.payment.modes {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.payment.types.PaymentRequestUrl;
public class PayUrlEvents implements PayUrl {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function PayUrlEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function forceGoToUrl(param1:PaymentRequestUrl) : void {
var i:int = 0;
var m:PayUrl = null;
var url:PaymentRequestUrl = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayUrl(this.impl[i]);
m.forceGoToUrl(url);
i++;
}
}
finally {
Model.popObject();
}
}
public function forceGoToOrderedUrl(param1:PaymentRequestUrl) : void {
var i:int = 0;
var m:PayUrl = null;
var url:PaymentRequestUrl = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = PayUrl(this.impl[i]);
m.forceGoToOrderedUrl(url);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.engine3d.animation {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.animation.keys.TransformKey;
import alternativa.engine3d.core.Object3D;
import flash.geom.Vector3D;
use namespace alternativa3d;
public class AnimationState {
public var useCount:int = 0;
public var transform:TransformKey = new TransformKey();
public var transformWeightSum:Number = 0;
public var numbers:Object = new Object();
public var numberWeightSums:Object = new Object();
public function AnimationState() {
super();
}
public function reset() : void {
var local1:String = null;
this.transformWeightSum = 0;
for(local1 in this.numbers) {
delete this.numbers[local1];
delete this.numberWeightSums[local1];
}
}
public function addWeightedTransform(param1:TransformKey, param2:Number) : void {
this.transformWeightSum += param2;
this.transform.interpolate(this.transform,param1,param2 / this.transformWeightSum);
}
public function addWeightedNumber(param1:String, param2:Number, param3:Number) : void {
var local5:Number = NaN;
var local4:Number = Number(this.numberWeightSums[param1]);
if(local4 == local4) {
local4 += param3;
param3 /= local4;
local5 = Number(this.numbers[param1]);
this.numbers[param1] = (1 - param3) * local5 + param3 * param2;
this.numberWeightSums[param1] = local4;
} else {
this.numbers[param1] = param2;
this.numberWeightSums[param1] = param3;
}
}
public function apply(param1:Object3D) : void {
var local2:Number = NaN;
var local3:Number = NaN;
var local4:String = null;
if(this.transformWeightSum > 0) {
param1.x = this.transform.alternativa3d::x;
param1.y = this.transform.alternativa3d::y;
param1.z = this.transform.alternativa3d::z;
this.setEulerAngles(this.transform.alternativa3d::rotation,param1);
param1.scaleX = this.transform.alternativa3d::scaleX;
param1.scaleY = this.transform.alternativa3d::scaleY;
param1.scaleZ = this.transform.alternativa3d::scaleZ;
}
for(local4 in this.numbers) {
switch(local4) {
case "x":
local2 = Number(this.numberWeightSums["x"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.x = (1 - local3) * param1.x + local3 * this.numbers["x"];
break;
case "y":
local2 = Number(this.numberWeightSums["y"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.y = (1 - local3) * param1.y + local3 * this.numbers["y"];
break;
case "z":
local2 = Number(this.numberWeightSums["z"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.z = (1 - local3) * param1.z + local3 * this.numbers["z"];
break;
case "rotationX":
local2 = Number(this.numberWeightSums["rotationX"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.rotationX = (1 - local3) * param1.rotationX + local3 * this.numbers["rotationX"];
break;
case "rotationY":
local2 = Number(this.numberWeightSums["rotationY"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.rotationY = (1 - local3) * param1.rotationY + local3 * this.numbers["rotationY"];
break;
case "rotationZ":
local2 = Number(this.numberWeightSums["rotationZ"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.rotationZ = (1 - local3) * param1.rotationZ + local3 * this.numbers["rotationZ"];
break;
case "scaleX":
local2 = Number(this.numberWeightSums["scaleX"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.scaleX = (1 - local3) * param1.scaleX + local3 * this.numbers["scaleX"];
break;
case "scaleY":
local2 = Number(this.numberWeightSums["scaleY"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.scaleY = (1 - local3) * param1.scaleY + local3 * this.numbers["scaleY"];
break;
case "scaleZ":
local2 = Number(this.numberWeightSums["scaleZ"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.scaleZ = (1 - local3) * param1.scaleZ + local3 * this.numbers["scaleZ"];
break;
default:
param1[local4] = this.numbers[local4];
break;
}
}
}
public function applyObject(param1:Object) : void {
var local2:Number = NaN;
var local3:Number = NaN;
var local4:String = null;
if(this.transformWeightSum > 0) {
param1.x = this.transform.alternativa3d::x;
param1.y = this.transform.alternativa3d::y;
param1.z = this.transform.alternativa3d::z;
this.setEulerAnglesObject(this.transform.alternativa3d::rotation,param1);
param1.scaleX = this.transform.alternativa3d::scaleX;
param1.scaleY = this.transform.alternativa3d::scaleY;
param1.scaleZ = this.transform.alternativa3d::scaleZ;
}
for(local4 in this.numbers) {
switch(local4) {
case "x":
local2 = Number(this.numberWeightSums["x"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.x = (1 - local3) * param1.x + local3 * this.numbers["x"];
break;
case "y":
local2 = Number(this.numberWeightSums["y"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.y = (1 - local3) * param1.y + local3 * this.numbers["y"];
break;
case "z":
local2 = Number(this.numberWeightSums["z"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.z = (1 - local3) * param1.z + local3 * this.numbers["z"];
break;
case "rotationX":
local2 = Number(this.numberWeightSums["rotationX"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.rotationX = (1 - local3) * param1.rotationX + local3 * this.numbers["rotationX"];
break;
case "rotationY":
local2 = Number(this.numberWeightSums["rotationY"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.rotationY = (1 - local3) * param1.rotationY + local3 * this.numbers["rotationY"];
break;
case "rotationZ":
local2 = Number(this.numberWeightSums["rotationZ"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.rotationZ = (1 - local3) * param1.rotationZ + local3 * this.numbers["rotationZ"];
break;
case "scaleX":
local2 = Number(this.numberWeightSums["scaleX"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.scaleX = (1 - local3) * param1.scaleX + local3 * this.numbers["scaleX"];
break;
case "scaleY":
local2 = Number(this.numberWeightSums["scaleY"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.scaleY = (1 - local3) * param1.scaleY + local3 * this.numbers["scaleY"];
break;
case "scaleZ":
local2 = Number(this.numberWeightSums["scaleZ"]);
local3 = local2 / (local2 + this.transformWeightSum);
param1.scaleZ = (1 - local3) * param1.scaleZ + local3 * this.numbers["scaleZ"];
break;
default:
param1[local4] = this.numbers[local4];
break;
}
}
}
private function setEulerAngles(param1:Vector3D, param2:Object3D) : void {
var local3:Number = 2 * param1.x * param1.x;
var local4:Number = 2 * param1.y * param1.y;
var local5:Number = 2 * param1.z * param1.z;
var local6:Number = 2 * param1.x * param1.y;
var local7:Number = 2 * param1.y * param1.z;
var local8:Number = 2 * param1.z * param1.x;
var local9:Number = 2 * param1.w * param1.x;
var local10:Number = 2 * param1.w * param1.y;
var local11:Number = 2 * param1.w * param1.z;
var local12:Number = 1 - local4 - local5;
var local13:Number = local6 - local11;
var local14:Number = local6 + local11;
var local15:Number = 1 - local3 - local5;
var local16:Number = local8 - local10;
var local17:Number = local7 + local9;
var local18:Number = 1 - local3 - local4;
if(-1 < local16 && local16 < 1) {
param2.rotationX = Math.atan2(local17,local18);
param2.rotationY = -Math.asin(local16);
param2.rotationZ = Math.atan2(local14,local12);
} else {
param2.rotationX = 0;
param2.rotationY = local16 <= -1 ? Math.PI : -Math.PI;
param2.rotationY *= 0.5;
param2.rotationZ = Math.atan2(-local13,local15);
}
}
private function setEulerAnglesObject(param1:Vector3D, param2:Object) : void {
var local3:Number = 2 * param1.x * param1.x;
var local4:Number = 2 * param1.y * param1.y;
var local5:Number = 2 * param1.z * param1.z;
var local6:Number = 2 * param1.x * param1.y;
var local7:Number = 2 * param1.y * param1.z;
var local8:Number = 2 * param1.z * param1.x;
var local9:Number = 2 * param1.w * param1.x;
var local10:Number = 2 * param1.w * param1.y;
var local11:Number = 2 * param1.w * param1.z;
var local12:Number = 1 - local4 - local5;
var local13:Number = local6 - local11;
var local14:Number = local6 + local11;
var local15:Number = 1 - local3 - local5;
var local16:Number = local8 - local10;
var local17:Number = local7 + local9;
var local18:Number = 1 - local3 - local4;
if(-1 < local16 && local16 < 1) {
param2.rotationX = Math.atan2(local17,local18);
param2.rotationY = -Math.asin(local16);
param2.rotationZ = Math.atan2(local14,local12);
} else {
param2.rotationX = 0;
param2.rotationY = local16 <= -1 ? Math.PI : -Math.PI;
param2.rotationY *= 0.5;
param2.rotationZ = Math.atan2(-local13,local15);
}
}
}
}
|
package alternativa.tanks.view.battleinfo {
import alternativa.types.Long;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.BattleCreateParameters;
import projects.tanks.client.battleservice.model.types.BattleSuspicionLevel;
public class BattleInfoBaseParams {
public var battle:IGameObject;
public var createParams:BattleCreateParameters;
public var battleUrl:String;
public var mapName:String;
public var customName:String;
public var endTime:int;
public var roundStarted:Boolean;
public var matchmakingMark:Boolean;
public var previewResource:ImageResource;
public var suspicionLevel:BattleSuspicionLevel;
public var friends:int;
public var userToInfo:UserToInfoMap = new UserToInfoMap();
public function BattleInfoBaseParams() {
super();
}
public function get battleId() : Long {
return this.battle.id;
}
}
}
|
package controls.numeric {
import flash.events.TimerEvent;
import flash.utils.Timer;
import flash.utils.clearInterval;
import flash.utils.setInterval;
public class TimerStepper {
private static const CHANGE_COUNTER_VALUE:int = 7;
private static const DEFAULT_INTERVAL_DURATION:int = 75;
private static const STEPS:Vector.<int> = new <int>[1,5,10,20,50,100,200,500];
private var stepUnit:Number;
private var timer:Timer;
private var intervalId:int;
private var intervalCounter:int;
private var stepper:INumericStepper;
private var stepIndex:int;
public function TimerStepper(param1:INumericStepper, param2:Number = 1) {
super();
this.stepper = param1;
this.stepUnit = param2;
this.timer = new Timer(500,1);
this.timer.addEventListener(TimerEvent.TIMER_COMPLETE,this.onTimerComplete);
}
public function start() : void {
this.timer.reset();
this.timer.start();
}
public function stop() : void {
this.timer.stop();
clearInterval(this.intervalId);
}
private function onTimerComplete(param1:TimerEvent) : void {
this.intervalCounter = 0;
this.stepIndex = 0;
this.intervalId = setInterval(this.changeCounterByTime,DEFAULT_INTERVAL_DURATION);
}
private function changeCounterByTime() : void {
var local1:Number = this.stepper.getValue() + this.stepper.getButtonStatus() * this.getStep();
++this.intervalCounter;
if(this.intervalCounter >= CHANGE_COUNTER_VALUE && this.stepIndex + 1 < STEPS.length && local1 % this.getStepByIndex(this.stepIndex + 1) < this.stepUnit) {
this.intervalCounter = 0;
++this.stepIndex;
}
this.stepper.setValue(local1,true);
}
private function getStep() : Number {
return this.getStepByIndex(this.stepIndex);
}
public function setStep(param1:Number) : void {
this.stepUnit = param1;
}
private function getStepByIndex(param1:int) : Number {
return STEPS[param1] * this.stepUnit;
}
}
}
|
package platform.client.core.general.spaces.loading.dispatcher.types {
import platform.client.core.general.spaces.loading.modelconstructors.ModelData;
import platform.client.fp10.core.type.IGameObject;
public class ObjectsData {
private var _modelsData:Vector.<ModelData>;
private var _objects:Vector.<IGameObject>;
public function ObjectsData(param1:Vector.<ModelData> = null, param2:Vector.<IGameObject> = null) {
super();
this._modelsData = param1;
this._objects = param2;
}
public function get modelsData() : Vector.<ModelData> {
return this._modelsData;
}
public function set modelsData(param1:Vector.<ModelData>) : void {
this._modelsData = param1;
}
public function get objects() : Vector.<IGameObject> {
return this._objects;
}
public function set objects(param1:Vector.<IGameObject>) : void {
this._objects = param1;
}
public function toString() : String {
var local1:String = "ObjectsData [";
local1 += "modelsData = " + this.modelsData + " ";
local1 += "objects = " + this.objects + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.loader
{
import alternativa.init.TanksServicesActivator;
import alternativa.osgi.service.console.IConsoleService;
import alternativa.osgi.service.focus.IFocusListener;
import alternativa.osgi.service.loader.ILoaderService;
import alternativa.osgi.service.loader.ILoadingProgressListener;
import alternativa.osgi.service.mainContainer.IMainContainerService;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObjectContainer;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.TimerEvent;
import flash.text.TextField;
import flash.utils.Dictionary;
import flash.utils.Timer;
public class LoaderWindow extends Sprite implements ILoadingProgressListener, ILoaderWindowService, IFocusListener
{
[Embed(source="1185.png")]
private static const bitmapWindowSmall:Class;
private static const windowBitmapSmall:BitmapData = new bitmapWindowSmall().bitmapData;
[Embed(source="1118.png")]
private static const bitmapWindowMedium:Class;
private static const windowBitmapMedium:BitmapData = new bitmapWindowMedium().bitmapData;
[Embed(source="1106.png")]
private static const bitmapWindowBig:Class;
private static const windowBitmapBig:BitmapData = new bitmapWindowBig().bitmapData;
private var console:IConsoleService;
private var layer:DisplayObjectContainer;
private var windowBmp:Bitmap;
private var showTimer:Timer;
private var hideTimer:Timer;
private var showDelay:int = 1000;
private var hideDelay:int = 10000;
private var resourcesId:Array;
private var lock:Boolean = false;
private const SIZE_SMALL:String = "SizeSmall";
private const SIZE_MEDIUM:String = "SizeMedium";
private const SIZE_BIG:String = "SizeBig";
private var size:String;
private var batchByProcess:Dictionary;
private var processesForBatch:Dictionary;
private var processesWithoutBatch:Dictionary;
private var batchBlocks:Dictionary;
private var processBlocksList:Array;
private var progressSlots:Array;
private const slotsNum:int = 4;
public function LoaderWindow()
{
var i:int = 0;
i = 0;
var slot:Bitmap = null;
super();
this.size = this.SIZE_SMALL;
this.layer = (TanksServicesActivator.osgi.getService(IMainContainerService) as IMainContainerService).systemUILayer;
this.console = TanksServicesActivator.osgi.getService(IConsoleService) as IConsoleService;
this.resourcesId = new Array();
this.batchByProcess = new Dictionary();
this.processesForBatch = new Dictionary();
this.processesWithoutBatch = new Dictionary();
this.batchBlocks = new Dictionary();
this.processBlocksList = new Array();
this.progressSlots = new Array();
this.windowBmp = new Bitmap(windowBitmapSmall);
addChild(this.windowBmp);
for(i = 0; i < this.slotsNum; i++)
{
slot = new Bitmap(ProgressBar.barBd);
addChild(slot);
slot.x = 17;
slot.y = 50 + i * 37;
if(i != 0)
{
slot.visible = false;
}
slot.visible = false;
this.progressSlots.push(slot);
}
this.showTimer = new Timer(this.showDelay,1);
this.hideTimer = new Timer(this.hideDelay,1);
this.showTimer.addEventListener(TimerEvent.TIMER_COMPLETE,this.onShowTimerComplemete);
this.hideTimer.addEventListener(TimerEvent.TIMER_COMPLETE,this.onHideTimerComplemete);
(TanksServicesActivator.osgi.getService(ILoaderService) as ILoaderService).loadingProgress.addEventListener(this);
}
private function setSize(value:String) : void
{
var i:int = 0;
var slot:Bitmap = null;
this.size = value;
switch(value)
{
case this.SIZE_SMALL:
this.windowBmp.bitmapData = windowBitmapSmall;
for(i = 0; i < this.slotsNum; i++)
{
slot = this.progressSlots[i] as Bitmap;
if(i == 0)
{
slot.visible = true;
}
else
{
slot.visible = false;
}
}
break;
case this.SIZE_MEDIUM:
this.windowBmp.bitmapData = windowBitmapMedium;
for(i = 0; i < this.slotsNum; i++)
{
slot = this.progressSlots[i] as Bitmap;
if(i < 2)
{
slot.visible = true;
}
else
{
slot.visible = false;
}
}
break;
case this.SIZE_BIG:
this.windowBmp.bitmapData = windowBitmapBig;
for(i = 0; i < this.slotsNum; i++)
{
slot = this.progressSlots[i] as Bitmap;
slot.visible = true;
}
}
}
private function redraw() : void
{
var processBlock:ProcessBlock = null;
var i:int = 0;
var l:int = this.processBlocksList.length;
if(l > 1)
{
if(this.processBlocksList.length == 2)
{
this.setSize(this.SIZE_MEDIUM);
for(i = 0; i < this.processBlocksList.length; i++)
{
processBlock = this.processBlocksList[i] as ProcessBlock;
processBlock.y = 35 + i * 37;
}
}
else
{
this.setSize(this.SIZE_BIG);
for(i = 0; i < this.processBlocksList.length; i++)
{
processBlock = this.processBlocksList[i] as ProcessBlock;
processBlock.y = 35 + i * 37;
}
}
}
else
{
this.setSize(this.SIZE_SMALL);
processBlock = this.processBlocksList[0] as ProcessBlock;
if(processBlock != null)
{
processBlock.y = 35;
}
}
}
private function addProgress(processId:Object) : ProcessBlock
{
var batchBlock:ProcessBlock = null;
this.console.writeToConsoleChannel("LOADER WINDOW","addProgress batchId: %1",processId);
if(this.batchBlocks[processId] == null)
{
batchBlock = new ProcessBlock(processId);
addChild(batchBlock);
this.batchBlocks[processId] = batchBlock;
this.processBlocksList.push(batchBlock);
batchBlock.x = 17;
this.redraw();
}
return batchBlock;
}
private function removeProgress(processId:Object) : void
{
var index:int = 0;
this.console.writeToConsoleChannel("LOADER WINDOW","removeProgress batchId: %1",processId);
var batchBlock:ProcessBlock = this.batchBlocks[processId];
if(batchBlock != null)
{
if(contains(batchBlock))
{
removeChild(batchBlock);
}
delete this.batchBlocks[processId];
index = this.processBlocksList.indexOf(batchBlock);
if(index != -1)
{
this.processBlocksList.splice(index,1);
}
this.redraw();
}
}
private function addProgressWithoutBatch(processId:Object) : ProcessBlock
{
var processBlock:ProcessBlock = null;
this.console.writeToConsoleChannel("LOADER WINDOW","addProgressWithoutBatch processId: %1",processId);
if(this.processesWithoutBatch[processId] == null)
{
processBlock = new ProcessBlock(processId);
addChild(processBlock);
this.processesWithoutBatch[processId] = processBlock;
this.processBlocksList.push(processBlock);
processBlock.x = 17;
this.redraw();
}
return processBlock;
}
private function removeProgressWithoutBatch(processId:Object) : void
{
var index:int = 0;
this.console.writeToConsoleChannel("LOADER WINDOW","removeProgressWithoutBatch processId: %1",processId);
var processBlock:ProcessBlock = this.processesWithoutBatch[processId];
if(processBlock != null)
{
if(contains(processBlock))
{
removeChild(processBlock);
}
delete this.processesWithoutBatch[processId];
index = this.processBlocksList.indexOf(processBlock);
if(index != -1)
{
this.processBlocksList.splice(index,1);
}
this.redraw();
}
}
public function focusIn(focusedObject:Object) : void
{
}
public function focusOut(exfocusedObject:Object) : void
{
}
public function deactivate() : void
{
if(!this.lock)
{
this.hideLoaderWindow();
this.lockLoaderWindow();
}
}
public function activate() : void
{
if(this.lock)
{
this.unlockLoaderWindow();
}
}
public function processStarted(processId:Object) : void
{
this.console.writeToConsoleChannel("LOADER WINDOW","processStarted processId: %1",processId);
var batchId:int = this.batchByProcess[processId] != null ? int(int(this.batchByProcess[processId])) : int(int(-1));
if(batchId != -1)
{
if(this.batchBlocks[batchId] == null)
{
this.addProgress(batchId);
}
}
else if(this.processesWithoutBatch[processId] == null)
{
this.addProgressWithoutBatch(processId);
}
this.hideTimer.stop();
if(this.resourcesId.indexOf(processId) == -1)
{
this.resourcesId.push(processId);
}
if(!this.lock && !this.showTimer.running && !this.layer.contains(this))
{
this.showTimer.reset();
this.showTimer.start();
}
}
public function processStoped(processId:Object) : void
{
var currentBatchProcesses:Array = null;
var index:int = 0;
this.console.writeToConsoleChannel("LOADER WINDOW","processStoped processId: %1",processId);
var batchId:int = this.batchByProcess[processId] != null ? int(int(this.batchByProcess[processId])) : int(int(-1));
if(batchId != -1)
{
currentBatchProcesses = this.processesForBatch[batchId] as Array;
index = currentBatchProcesses.indexOf(processId);
if(index != -1)
{
currentBatchProcesses.splice(index,1);
if(currentBatchProcesses.length == 0)
{
this.processesForBatch[batchId] = null;
this.removeProgress(batchId);
}
}
}
else
{
this.removeProgressWithoutBatch(processId);
}
index = this.resourcesId.indexOf(processId);
if(index != -1)
{
this.resourcesId.splice(index,1);
}
if(this.resourcesId.length == 0)
{
this.console.writeToConsoleChannel("LOADER WINDOW"," all processes completed");
if(this.showTimer.running)
{
this.showTimer.stop();
}
else if(!this.hideTimer.running)
{
if(!this.lock)
{
this.hideTimer.reset();
this.hideTimer.start();
}
}
else if(this.lock)
{
this.hideTimer.stop();
}
}
}
public function changeStatus(processId:Object, value:String) : void
{
var processBlock:ProcessBlock = null;
var statusLabel:TextField = null;
var s:String = null;
this.console.writeToConsoleChannel("LOADER WINDOW","changeStatus processId: %1, value: %2",processId,value);
var batchId:int = this.batchByProcess[processId] != null ? int(int(this.batchByProcess[processId])) : int(int(-1));
if(batchId != -1)
{
processBlock = this.batchBlocks[batchId] as ProcessBlock;
}
else
{
processBlock = this.processesWithoutBatch[processId] as ProcessBlock;
}
if(processBlock != null)
{
statusLabel = processBlock.statusLabel;
if(statusLabel != null)
{
if(value.length > 100)
{
s = value.slice(0,99) + "...";
}
else
{
s = value;
}
statusLabel.text = value;
}
}
}
public function changeProgress(processId:Object, value:Number) : void
{
var processBlock:ProcessBlock = null;
this.console.writeToConsoleChannel("LOADER WINDOW","changeProgress processId: %1, value: %2",processId,value);
var batchId:int = this.batchByProcess[processId] != null ? int(int(this.batchByProcess[processId])) : int(int(-1));
if(batchId != -1)
{
processBlock = this.batchBlocks[batchId] as ProcessBlock;
}
else
{
processBlock = this.processesWithoutBatch[processId] as ProcessBlock;
}
this.console.writeToConsoleChannel("LOADER WINDOW"," processBlock: %1",processBlock);
if(processBlock != null)
{
this.console.writeToConsoleChannel("LOADER WINDOW"," processBlock processId: %1",processBlock.processId);
processBlock.progressBar.progress = value;
}
}
public function setBatchIdForProcess(batchId:int, processId:Object) : void
{
this.console.writeToConsoleChannel("LOADER WINDOW","setBatchIdForProcess batchId: %1, processId: %2",batchId,processId);
this.batchByProcess[processId] = batchId;
if(this.processesForBatch[batchId] == null)
{
this.processesForBatch[batchId] = new Array();
}
(this.processesForBatch[batchId] as Array).push(processId);
}
public function showLoaderWindow() : void
{
this.onShowTimerComplemete();
}
public function hideLoaderWindow() : void
{
this.showTimer.stop();
this.onHideTimerComplemete();
}
public function lockLoaderWindow() : void
{
this.console.writeToConsoleChannel("LOADER WINDOW","lockLoaderWindow");
if(!this.lock)
{
this.lock = true;
this.showTimer.stop();
this.hideTimer.stop();
}
}
public function unlockLoaderWindow() : void
{
this.console.writeToConsoleChannel("LOADER WINDOW","unlockLoaderWindow");
if(this.lock)
{
this.lock = false;
}
}
private function onShowTimerComplemete(e:TimerEvent = null) : void
{
this.showTimer.stop();
this.show();
}
private function onHideTimerComplemete(e:TimerEvent = null) : void
{
this.hideTimer.stop();
this.hide();
}
private function show() : void
{
if(!this.layer.contains(this))
{
this.layer.addChild(this);
Game._stage.addEventListener(Event.RESIZE,this.align);
this.align();
}
}
private function hide() : void
{
if(this.layer.contains(this))
{
Game._stage.removeEventListener(Event.RESIZE,this.align);
this.layer.removeChild(this);
}
}
private function align(e:Event = null) : void
{
this.x = Game._stage.stageWidth - this.width >>> 1;
this.y = Game._stage.stageHeight - this.height >>> 1;
}
}
}
|
package projects.tanks.client.garage.models.item.resistance {
public interface IMountedResistancesModelBase {
}
}
|
package alternativa.tanks.models.battlefield.effects.levelup.rangs
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class BigRangIcon_rang_20 extends BitmapAsset
{
public function BigRangIcon_rang_20()
{
super();
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_smokyCritClass.png")]
public class ItemInfoPanelBitmaps_smokyCritClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_smokyCritClass() {
super();
}
}
}
|
package alternativa.tanks.service.temporaryitem {
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.TimerEvent;
import flash.utils.Timer;
import flash.utils.getTimer;
import platform.client.fp10.core.type.IGameObject;
public class ItemTimer extends EventDispatcher {
private var _item:IGameObject;
private var _timer:Timer;
private var _startTimeInMSec:Number;
private var _remainingTimeInSec:int;
public function ItemTimer(param1:IGameObject, param2:int) {
super();
this._item = param1;
this._remainingTimeInSec = param2;
this._startTimeInMSec = getTimer();
this._timer = new Timer(1000);
this._timer.addEventListener(TimerEvent.TIMER,this.onTimer);
this._timer.start();
}
private function onTimer(param1:TimerEvent) : void {
var local2:int = (getTimer() - this._startTimeInMSec) / 1000;
if(local2 > this._remainingTimeInSec) {
dispatchEvent(new Event(Event.COMPLETE));
this._timer.stop();
this.destroy();
}
}
public function destroy() : void {
if(this._timer != null) {
this._timer.removeEventListener(TimerEvent.TIMER,this.onTimer);
this._timer.stop();
this._timer = null;
}
}
public function get item() : IGameObject {
return this._item;
}
public function get currentTimeRemainingMSec() : Number {
return this._remainingTimeInSec * 1000 - (getTimer() - this._startTimeInMSec);
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.gearscore {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class BattleGearScoreModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BattleGearScoreModelServer;
private var client:IBattleGearScoreModelBase = IBattleGearScoreModelBase(this);
private var modelId:Long = Long.getLong(1135202411,-1956043623);
private var _setGearScoreId:Long = Long.getLong(1064176503,81422397);
private var _setGearScore_scoreCodec:ICodec;
public function BattleGearScoreModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BattleGearScoreModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(BattleGearScoreCC,false)));
this._setGearScore_scoreCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
protected function getInitParam() : BattleGearScoreCC {
return BattleGearScoreCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._setGearScoreId:
this.client.setGearScore(int(this._setGearScore_scoreCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIconNormal_p23 extends BitmapAsset
{
public function RangIconNormal_p23()
{
super();
}
}
}
|
package alternativa.tanks.view.battleinfo.team {
import alternativa.tanks.view.battleinfo.BattleInfoBaseParams;
import projects.tanks.client.battleselect.model.battle.entrance.user.BattleInfoUser;
public class BattleInfoTeamParams extends BattleInfoBaseParams {
public var usersRed:Vector.<BattleInfoUser> = new Vector.<BattleInfoUser>();
public var usersBlue:Vector.<BattleInfoUser> = new Vector.<BattleInfoUser>();
public var scoreRed:int;
public var scoreBlue:int;
public function BattleInfoTeamParams() {
super();
}
}
}
|
package alternativa.osgi.service.command.impl {
public class InvalidCommandFormatError extends Error {
public function InvalidCommandFormatError(param1:String) {
super("Command invalid format: " + param1);
}
}
}
|
package alternativa.startup {
import flash.utils.ByteArray;
import mx.utils.Base64Encoder;
public class URLEncoder {
public function URLEncoder() {
super();
}
public static function encode(param1:String) : String {
var local2:Base64Encoder = new Base64Encoder();
local2.insertNewLines = false;
var local3:ByteArray = new ByteArray();
local3.writeUTFBytes(param1);
local2.encodeUTFBytes(local3.toString());
return local2.toString();
}
}
}
|
package alternativa.tanks.models.weapon.smoky.sfx {
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.sfx.LightAnimation;
import flash.media.Sound;
public class SmokySFXData {
public var muzzleFlashMaterial:TextureMaterial;
public var explosionAnimation:TextureAnimation;
public var criticalHitAnimation:TextureAnimation;
public var explosionMarkMaterial:TextureMaterial;
public var shotSound:Sound;
public var explosionSound:Sound;
public var explosionSize:Number;
public var criticalHitSize:int;
public var shotLightAnimation:LightAnimation;
public var hitLightAnimation:LightAnimation;
public function SmokySFXData() {
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.challenge.rewarding {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.challenge.rewarding.ChallengeRewardsCC;
import projects.tanks.client.panel.model.challenge.rewarding.Tier;
public class CodecChallengeRewardsCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_tiers:ICodec;
public function CodecChallengeRewardsCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_tiers = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(Tier,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ChallengeRewardsCC = new ChallengeRewardsCC();
local2.tiers = this.codec_tiers.decode(param1) as Vector.<Tier>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ChallengeRewardsCC = ChallengeRewardsCC(param2);
this.codec_tiers.encode(param1,local3.tiers);
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.common {
public interface IWeaponCommonModelBase {
function setBuffed(param1:Boolean, param2:Number) : void;
}
}
|
package projects.tanks.client.chat.models.chat.chat {
import projects.tanks.client.chat.types.ChatMessage;
public interface IChatModelBase {
function cleanUsersMessages(param1:String) : void;
function showMessages(param1:Vector.<ChatMessage>) : void;
function updateTypingSpeedAntifloodParams(param1:int, param2:int) : void;
}
}
|
package alternativa.tanks.controllers.battlecreate {
import flash.events.Event;
import projects.tanks.client.battleservice.BattleCreateParameters;
public class CreateBattleEvent extends Event {
public static const CREATE_BATTLE:String = "CreateBattleEvent.CREATE_BATTLE";
public var battleCreateParams:BattleCreateParameters;
public function CreateBattleEvent(param1:BattleCreateParameters) {
super(CREATE_BATTLE);
this.battleCreateParams = param1;
}
}
}
|
package projects.tanks.client.battlefield.models.battle.gui.group {
import alternativa.types.Long;
public class MatchmakingGroupInfoCC {
private var _groupUserIds:Vector.<Long>;
private var _hasGroups:Boolean;
public function MatchmakingGroupInfoCC(param1:Vector.<Long> = null, param2:Boolean = false) {
super();
this._groupUserIds = param1;
this._hasGroups = param2;
}
public function get groupUserIds() : Vector.<Long> {
return this._groupUserIds;
}
public function set groupUserIds(param1:Vector.<Long>) : void {
this._groupUserIds = param1;
}
public function get hasGroups() : Boolean {
return this._hasGroups;
}
public function set hasGroups(param1:Boolean) : void {
this._hasGroups = param1;
}
public function toString() : String {
var local1:String = "MatchmakingGroupInfoCC [";
local1 += "groupUserIds = " + this.groupUserIds + " ";
local1 += "hasGroups = " + this.hasGroups + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.model.payment.shop.kitviewresource {
import flash.display.BitmapData;
[ModelInterface]
public interface KitViewResource {
function getButtonKitImage() : BitmapData;
function getButtonKitOverImage() : BitmapData;
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_backIconClass.png")]
public class ItemInfoPanelBitmaps_backIconClass extends BitmapAsset {
public function ItemInfoPanelBitmaps_backIconClass() {
super();
}
}
}
|
package alternativa.engine3d.core
{
import alternativa.gfx.agal.VertexShader;
public class ShadowCasterVertexShader extends VertexShader
{
public function ShadowCasterVertexShader()
{
super();
dp4(vt0.x,va0,vc[0]);
dp4(vt0.y,va0,vc[1]);
dp4(vt0.zw,va0,vc[2]);
mul(vt0.xy,vt0,vc[3]);
add(vt0.xy,vt0,vc[4]);
mov(op.xyz,vt0);
mov(op.w,vc[3]);
mov(v0,vt0);
}
}
}
|
package alternativa.tanks.controllers.battlelist {
import alternativa.tanks.controllers.BattleSelectVectorUtil;
import alternativa.tanks.service.battlecreate.IBattleCreateFormService;
import alternativa.tanks.service.battleinfo.IBattleInfoFormService;
import alternativa.tanks.view.battleinfo.BattleInfoBaseParams;
import alternativa.tanks.view.battlelist.BattleListView;
import alternativa.tanks.view.battlelist.IBattleListView;
import alternativa.types.Long;
import flash.events.Event;
import flash.events.EventDispatcher;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.BattleMode;
import projects.tanks.client.battleservice.model.types.BattleSuspicionLevel;
import projects.tanks.clients.fp10.libraries.tanksservices.service.address.TanksAddressService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.address.events.BattleChangedAddressEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.address.events.TanksAddressEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.battlelist.UserBattleSelectActionsService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.premium.PremiumService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.probattle.IUserProBattleService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.probattle.ProBattleEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.servername.ServerNumberToLocaleServerService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.UserPropertiesServiceEvent;
public class BattleListController extends EventDispatcher implements IBattleListViewControllerCallback {
[Inject]
public static var battleInfoFormService:IBattleInfoFormService;
[Inject]
public static var addressService:TanksAddressService;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var serverNameService:ServerNumberToLocaleServerService;
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var battleSelectActionsService:UserBattleSelectActionsService;
[Inject]
public static var userProBattleService:IUserProBattleService;
[Inject]
public static var premiumService:PremiumService;
[Inject]
public static var battleCreateFormService:IBattleCreateFormService;
private static var lastShownItemId:Long;
private static const MODE_FILTER:String = "BATTLE_LIST_MODE_FILTER";
private static const DEFAULT_MODE:BattleMode = BattleMode.TDM;
private var filteredMode:BattleMode;
private var _view:IBattleListView;
private var _selectedItem:IGameObject;
private var _allItems:Vector.<BattleListItemParams>;
private var _itemsAwaitPacketJoinSuccess:Array;
private var _isItemsPacketJoinSuccess:Boolean;
public function BattleListController() {
super();
this._view = new BattleListView();
this._allItems = new Vector.<BattleListItemParams>();
this._itemsAwaitPacketJoinSuccess = new Array();
this._view.setCallBack(this);
this.setFilterBattleModeFormStorage();
}
private static function getModeFromStorage() : BattleMode {
var local1:* = storageService.getStorage().data[MODE_FILTER];
return local1 == null ? DEFAULT_MODE : BattleMode.values[local1];
}
private static function storeMode(param1:BattleMode) : void {
storageService.getStorage().data[MODE_FILTER] = param1.value;
}
private function setFilterBattleModeFormStorage() : void {
this.filteredMode = getModeFromStorage();
this._view.lockFilter(this.filteredMode);
}
public function destroy() : void {
this.removeEvents();
this._view.destroy();
this._view = null;
this._selectedItem = null;
this._allItems = null;
this._itemsAwaitPacketJoinSuccess = null;
this._isItemsPacketJoinSuccess = false;
lastShownItemId = null;
}
public function showForm() : void {
this._view.show(this.filteredMode);
this.setEvents();
}
private function setEvents() : void {
addressService.addEventListener(TanksAddressEvent.BATTLE_CHANGED,this.onBattleChanged);
userPropertiesService.addEventListener(UserPropertiesServiceEvent.UPDATE_RANK,this.onUpdateRank);
userProBattleService.addEventListener(ProBattleEvent.OVER,this.onAbonementOver);
premiumService.addEventListener(Event.CHANGE,this.onPremiumChange);
}
private function onPremiumChange(param1:Event) : void {
this.updateCreateBattleButton();
}
private function onAbonementOver(param1:ProBattleEvent) : void {
this.updateCreateBattleButton();
}
private function updateCreateBattleButton() : void {
var local1:Boolean = Boolean(premiumService.hasPremium()) || Boolean(userProBattleService.hasAbonement());
if(!local1) {
battleCreateFormService.hideForm();
}
this._view.setBattleCreationEnabled(local1);
}
private function onUpdateRank(param1:UserPropertiesServiceEvent) : void {
this._view.updateAccessibleItems();
}
private function onBattleChanged(param1:BattleChangedAddressEvent) : void {
if(!serverNameService.isLocalServer()) {
return;
}
var local2:Long = param1.getBattleId();
if(local2 == null) {
this.resetSelectedItem();
} else {
this.selectBattleItemById(local2);
}
}
private function selectBattleItemById(param1:Long) : void {
var local2:BattleListItemParams = this.findBattleListItem(param1);
if(local2 == null) {
this.resetSelectedItem();
dispatchEvent(new BattleByURLNotFoundEvent(BattleByURLNotFoundEvent.BATTLE_BY_URL_NOT_FOUND,param1));
} else if(local2.params.battle != this._selectedItem) {
this.selectBattleItem(local2.params.battle,true,true);
}
}
private function findBattleListItem(param1:Long) : BattleListItemParams {
var local2:BattleListItemParams = null;
var local3:int = int(this._allItems.length);
var local4:int = 0;
while(local4 < local3) {
if(this._allItems[local4].params.battle.id == param1) {
local2 = this._allItems[local4];
break;
}
local4++;
}
return local2;
}
public function selectBattleItemFromServer(param1:IGameObject) : void {
if(param1 == null) {
this.resetSelectedItem();
} else {
this.selectBattleItem(param1,true,false);
}
}
private function selectBattleItem(param1:IGameObject, param2:Boolean, param3:Boolean) : void {
var local4:BattleListItemParams = null;
this._selectedItem = param1;
if(param2) {
if(this._view.getItemIndex(param1.id) < 0) {
local4 = BattleSelectVectorUtil.findElementInVector(this._allItems,param1.id);
if(local4 != null) {
this._view.createItem(local4,true);
if(local4 == battleInfoFormService.getSelectedBattle()) {
battleInfoFormService.showLastShowedForm();
}
}
}
this._view.setSelect(this._selectedItem.id);
}
if(param3) {
dispatchEvent(new BattleSelectedEvent(BattleSelectedEvent.BATTLE_SELECTED,this._selectedItem));
}
if(lastShownItemId == this._selectedItem.id) {
battleInfoFormService.showLastShowedForm();
}
lastShownItemId = this._selectedItem.id;
}
public function onBattleListItemClick(param1:IGameObject) : void {
this.selectBattleItem(param1,false,true);
}
public function resetBattleButtonState() : void {
this._view.setBattleButtonEnabled(true);
}
public function onBattleListItemChange(param1:IGameObject) : void {
if(this._selectedItem != null) {
if(this._selectedItem != param1) {
this.selectBattleItem(param1,false,true);
}
} else {
this.selectBattleItem(param1,false,true);
}
}
private function resetSelectedItem() : void {
if(this._selectedItem != null) {
this._selectedItem = null;
this._view.resetSelectedItem();
}
}
public function hideForm() : void {
this.removeEvents();
this._view.hide();
}
private function removeEvents() : void {
addressService.removeEventListener(TanksAddressEvent.BATTLE_CHANGED,this.onBattleChanged);
userPropertiesService.removeEventListener(UserPropertiesServiceEvent.UPDATE_RANK,this.onUpdateRank);
userProBattleService.removeEventListener(ProBattleEvent.OVER,this.onAbonementOver);
premiumService.removeEventListener(Event.CHANGE,this.onPremiumChange);
}
public function battleItemRecord(param1:BattleInfoBaseParams) : void {
var local2:BattleListItemParams = new BattleListItemParams(param1);
if(this._isItemsPacketJoinSuccess) {
this._allItems.push(local2);
if(this.isVisibleItem(local2.createParams.battleMode)) {
this._view.createItem(local2,true);
}
} else {
this._itemsAwaitPacketJoinSuccess.push(local2);
}
}
private function isVisibleItem(param1:BattleMode) : Boolean {
return param1 == this.filteredMode;
}
public function removeBattle(param1:Long) : void {
this._view.removeItem(param1);
BattleSelectVectorUtil.deleteElementInVector(this._allItems,param1);
BattleSelectVectorUtil.deleteElementInArray(this._itemsAwaitPacketJoinSuccess,param1);
}
public function onShowCreateBattleFormButtonClick() : void {
this.resetSelectedItem();
dispatchEvent(new CreateBattleClickEvent());
}
public function updateSuspicious(param1:Long, param2:BattleSuspicionLevel) : void {
this._view.updateSuspicious(param1,param2);
}
public function updateUsersCount(param1:Long) : void {
this._view.updateUsersCount(param1);
}
public function updateBattleName(param1:Long) : void {
this._view.updateBattleName(param1);
}
public function swapTeams(param1:Long) : void {
this._view.swapTeams(param1);
}
public function battleItemsPacketJoinSuccess() : void {
var local2:BattleListItemParams = null;
var local3:int = 0;
var local4:BattleListItemParams = null;
var local5:BattleListItemParams = null;
var local6:Long = null;
this._isItemsPacketJoinSuccess = true;
var local1:int = int(this._itemsAwaitPacketJoinSuccess.length);
if(local1 != 0) {
this._itemsAwaitPacketJoinSuccess.sortOn(["currentBattle","suspicionLevel","accessible","friends","id"],[Array.NUMERIC | Array.DESCENDING,Array.NUMERIC | Array.DESCENDING,Array.DESCENDING,Array.NUMERIC | Array.DESCENDING,Array.NUMERIC | Array.DESCENDING]);
local2 = this.getRecommendedFriendsBattle();
local3 = 0;
while(local3 < local1) {
local4 = this._itemsAwaitPacketJoinSuccess[local3];
this._allItems.push(local4);
if(this.isVisibleItem(local4.params.createParams.battleMode)) {
this._view.createItem(local4,false);
}
local3++;
}
this._view.sortBattleList();
}
this._itemsAwaitPacketJoinSuccess.length = 0;
this._view.resize();
if(lastShownItemId != null) {
local5 = this.findBattleListItem(lastShownItemId);
if(local5 != null) {
local2 = BattleSelectVectorUtil.findElementInVector(this._allItems,local5.id);
}
}
if(Boolean(addressService.hasBattle()) && this._selectedItem == null) {
local6 = addressService.getBattleId();
this.selectBattleItemById(local6);
} else if(local2 != null) {
this.selectBattleItem(local2.params.battle,true,true);
}
}
private function getRecommendedFriendsBattle() : BattleListItemParams {
var local5:BattleListItemParams = null;
var local1:BattleListItemParams = this._itemsAwaitPacketJoinSuccess[0];
var local2:int = this.getFreePlaces(local1);
var local3:uint = this._itemsAwaitPacketJoinSuccess.length;
var local4:int = 0;
while(local4 < local3) {
local5 = this._itemsAwaitPacketJoinSuccess[local4];
if(local5.params.friends > local1.params.friends && this.getFreePlaces(local5) > local2) {
local1 = local5;
}
local4++;
}
return local1;
}
private function getFreePlaces(param1:BattleListItemParams) : int {
var local2:int = param1.params.createParams.maxPeopleCount;
if(param1.isDM) {
return local2 - param1.dmParams.users.length;
}
return local2 * 2 - param1.teamParams.usersBlue.length - param1.teamParams.usersRed.length;
}
public function onBattleModeChange(param1:BattleMode, param2:Boolean) : void {
if(this.filteredMode != param1) {
this.hideBattleByType(this.filteredMode);
battleSelectActionsService.turnOffBattleMode(this.filteredMode);
this.showBattleByType(param1);
battleSelectActionsService.turnOnBattleMode(param1);
this._view.unPressFilter(this.filteredMode);
this._view.unLockFilter(this.filteredMode);
this.filteredMode = param1;
storeMode(this.filteredMode);
this._view.lockFilter(this.filteredMode);
}
}
private function showBattleByType(param1:BattleMode) : void {
var local2:int = 0;
var local3:int = int(this._allItems.length);
var local4:int = 0;
while(local4 < local3) {
if(this._allItems[local4].params.createParams.battleMode == param1) {
this._view.createItem(this._allItems[local4],false);
local2++;
}
local4++;
}
if(local2 != 0) {
this._view.sortBattleList();
if(this._selectedItem != null) {
this.selectBattleItem(this._selectedItem,true,false);
}
this._view.resize();
}
}
private function hideBattleByType(param1:BattleMode) : void {
var local2:int = 0;
var local3:int = int(this._allItems.length);
var local4:int = 0;
while(local4 < local3) {
if(this._allItems[local4].params.createParams.battleMode == param1) {
this._view.removeItem(this._allItems[local4].id);
local2++;
}
local4++;
}
if(local2 != 0) {
this._view.resize();
}
if(this._selectedItem != null) {
if(this._view.getItemIndex(this._selectedItem.id) == -1) {
this.resetSelectedItem();
}
}
}
public function onBackToMatchmakingClick() : void {
lobbyLayoutService.showMatchmaking();
}
}
}
|
package _codec.projects.tanks.client.panel.model.kitoffer.log {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.EnumCodecInfo;
import projects.tanks.client.panel.model.kitoffer.log.KitOfferAction;
public class VectorCodecKitOfferActionLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecKitOfferActionLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(KitOfferAction,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<KitOfferAction> = new Vector.<KitOfferAction>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = KitOfferAction(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:KitOfferAction = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<KitOfferAction> = Vector.<KitOfferAction>(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.engine3d.loaders {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.engine3d.materials.FillMaterial;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import flash.geom.Matrix;
import flash.geom.Vector3D;
import flash.utils.ByteArray;
import flash.utils.Endian;
use namespace alternativa3d;
public class Parser3DS {
private static const CHUNK_MAIN:int = 19789;
private static const CHUNK_VERSION:int = 2;
private static const CHUNK_SCENE:int = 15677;
private static const CHUNK_ANIMATION:int = 45056;
private static const CHUNK_OBJECT:int = 16384;
private static const CHUNK_TRIMESH:int = 16640;
private static const CHUNK_VERTICES:int = 16656;
private static const CHUNK_FACES:int = 16672;
private static const CHUNK_FACESMATERIAL:int = 16688;
private static const CHUNK_FACESSMOOTH:int = 16720;
private static const CHUNK_MAPPINGCOORDS:int = 16704;
private static const CHUNK_TRANSFORMATION:int = 16736;
private static const CHUNK_MATERIAL:int = 45055;
private var data:ByteArray;
private var objectDatas:Object;
private var animationDatas:Array;
private var materialDatas:Object;
public var objects:Vector.<Object3D>;
public var parents:Vector.<Object3D>;
public var materials:Vector.<Material>;
public var textureMaterials:Vector.<TextureMaterial>;
public function Parser3DS() {
super();
}
public function getObjectByName(param1:String) : Object3D {
var local2:Object3D = null;
for each(local2 in this.objects) {
if(local2.name == param1) {
return local2;
}
}
return null;
}
public function parse(param1:ByteArray, param2:String = "", param3:Number = 1) : void {
if(param1.bytesAvailable < 6) {
return;
}
this.data = param1;
param1.endian = Endian.LITTLE_ENDIAN;
this.parse3DSChunk(param1.position,param1.bytesAvailable);
this.objects = new Vector.<Object3D>();
this.parents = new Vector.<Object3D>();
this.materials = new Vector.<Material>();
this.textureMaterials = new Vector.<TextureMaterial>();
this.buildContent(param2,param3);
param1 = null;
this.objectDatas = null;
this.animationDatas = null;
this.materialDatas = null;
}
private function readChunkInfo(param1:int) : ChunkInfo {
this.data.position = param1;
var local2:ChunkInfo = new ChunkInfo();
local2.id = this.data.readUnsignedShort();
local2.size = this.data.readUnsignedInt();
local2.dataSize = local2.size - 6;
local2.dataPosition = this.data.position;
local2.nextChunkPosition = param1 + local2.size;
return local2;
}
private function parse3DSChunk(param1:int, param2:int) : void {
if(param2 < 6) {
return;
}
var local3:ChunkInfo = this.readChunkInfo(param1);
this.data.position = param1;
switch(local3.id) {
case CHUNK_MAIN:
this.parseMainChunk(local3.dataPosition,local3.dataSize);
}
this.parse3DSChunk(local3.nextChunkPosition,param2 - local3.size);
}
private function parseMainChunk(param1:int, param2:int) : void {
if(param2 < 6) {
return;
}
var local3:ChunkInfo = this.readChunkInfo(param1);
switch(local3.id) {
case CHUNK_VERSION:
break;
case CHUNK_SCENE:
this.parse3DChunk(local3.dataPosition,local3.dataSize);
break;
case CHUNK_ANIMATION:
this.parseAnimationChunk(local3.dataPosition,local3.dataSize);
}
this.parseMainChunk(local3.nextChunkPosition,param2 - local3.size);
}
private function parse3DChunk(param1:int, param2:int) : void {
var local3:ChunkInfo = null;
var local4:MaterialData = null;
while(param2 >= 6) {
local3 = this.readChunkInfo(param1);
switch(local3.id) {
case CHUNK_MATERIAL:
local4 = new MaterialData();
this.parseMaterialChunk(local4,local3.dataPosition,local3.dataSize);
break;
case CHUNK_OBJECT:
this.parseObject(local3);
break;
}
param1 = local3.nextChunkPosition;
param2 -= local3.size;
}
}
private function parseObject(param1:ChunkInfo) : void {
if(this.objectDatas == null) {
this.objectDatas = new Object();
}
var local2:ObjectData = new ObjectData();
local2.name = this.getString(param1.dataPosition);
this.objectDatas[local2.name] = local2;
var local3:int = local2.name.length + 1;
this.parseObjectChunk(local2,param1.dataPosition + local3,param1.dataSize - local3);
}
private function parseObjectChunk(param1:ObjectData, param2:int, param3:int) : void {
if(param3 < 6) {
return;
}
var local4:ChunkInfo = this.readChunkInfo(param2);
switch(local4.id) {
case CHUNK_TRIMESH:
this.parseMeshChunk(param1,local4.dataPosition,local4.dataSize);
break;
case 17920:
case 18176:
}
this.parseObjectChunk(param1,local4.nextChunkPosition,param3 - local4.size);
}
private function parseMeshChunk(param1:ObjectData, param2:int, param3:int) : void {
if(param3 < 6) {
return;
}
var local4:ChunkInfo = this.readChunkInfo(param2);
switch(local4.id) {
case CHUNK_VERTICES:
this.parseVertices(param1);
break;
case CHUNK_MAPPINGCOORDS:
this.parseUVs(param1);
break;
case CHUNK_TRANSFORMATION:
this.parseMatrix(param1);
break;
case CHUNK_FACES:
this.parseFaces(param1,local4);
}
this.parseMeshChunk(param1,local4.nextChunkPosition,param3 - local4.size);
}
private function parseVertices(param1:ObjectData) : void {
var local2:int = int(this.data.readUnsignedShort());
param1.vertices = new Vector.<Number>();
var local3:int = 0;
var local4:int = 0;
while(local3 < local2) {
var local5:* = local4++;
param1.vertices[local5] = this.data.readFloat();
var local6:* = local4++;
param1.vertices[local6] = this.data.readFloat();
var local7:* = local4++;
param1.vertices[local7] = this.data.readFloat();
local3++;
}
}
private function parseUVs(param1:ObjectData) : void {
var local2:int = int(this.data.readUnsignedShort());
param1.uvs = new Vector.<Number>();
var local3:int = 0;
var local4:int = 0;
while(local3 < local2) {
var local5:* = local4++;
param1.uvs[local5] = this.data.readFloat();
var local6:* = local4++;
param1.uvs[local6] = this.data.readFloat();
local3++;
}
}
private function parseMatrix(param1:ObjectData) : void {
param1.a = this.data.readFloat();
param1.e = this.data.readFloat();
param1.i = this.data.readFloat();
param1.b = this.data.readFloat();
param1.f = this.data.readFloat();
param1.j = this.data.readFloat();
param1.c = this.data.readFloat();
param1.g = this.data.readFloat();
param1.k = this.data.readFloat();
param1.d = this.data.readFloat();
param1.h = this.data.readFloat();
param1.l = this.data.readFloat();
}
private function parseFaces(param1:ObjectData, param2:ChunkInfo) : void {
var local3:int = int(this.data.readUnsignedShort());
param1.faces = new Vector.<int>(local3 * 3);
param1.smoothingGroups = new Vector.<uint>(local3);
var local4:int = 0;
var local5:int = 0;
while(local4 < local3) {
var local7:* = local5++;
param1.faces[local7] = this.data.readUnsignedShort();
var local8:* = local5++;
param1.faces[local8] = this.data.readUnsignedShort();
var local9:* = local5++;
param1.faces[local9] = this.data.readUnsignedShort();
this.data.position += 2;
local4++;
}
var local6:int = 2 + 8 * local3;
this.parseFacesChunk(param1,param2.dataPosition + local6,param2.dataSize - local6);
}
private function parseFacesChunk(param1:ObjectData, param2:int, param3:int) : void {
if(param3 < 6) {
return;
}
var local4:ChunkInfo = this.readChunkInfo(param2);
switch(local4.id) {
case CHUNK_FACESMATERIAL:
this.parseSurface(param1);
break;
case CHUNK_FACESSMOOTH:
this.parseSmoothingGroups(param1);
}
this.parseFacesChunk(param1,local4.nextChunkPosition,param3 - local4.size);
}
private function parseSurface(param1:ObjectData) : void {
if(param1.surfaces == null) {
param1.surfaces = new Object();
}
var local2:Vector.<int> = new Vector.<int>();
param1.surfaces[this.getString(this.data.position)] = local2;
var local3:int = int(this.data.readUnsignedShort());
var local4:int = 0;
while(local4 < local3) {
local2[local4] = this.data.readUnsignedShort();
local4++;
}
}
private function parseSmoothingGroups(param1:ObjectData) : void {
var local2:int = param1.faces.length / 3;
var local3:int = 0;
while(local3 < local2) {
param1.smoothingGroups[local3] = this.data.readUnsignedInt();
local3++;
}
}
private function parseAnimationChunk(param1:int, param2:int) : void {
var local3:ChunkInfo = null;
var local4:AnimationData = null;
while(param2 >= 6) {
local3 = this.readChunkInfo(param1);
switch(local3.id) {
case 45057:
case 45058:
case 45059:
case 45060:
case 45061:
case 45062:
case 45063:
if(this.animationDatas == null) {
this.animationDatas = new Array();
}
local4 = new AnimationData();
this.animationDatas.push(local4);
this.parseObjectAnimationChunk(local4,local3.dataPosition,local3.dataSize);
break;
case 45064:
break;
}
param1 = local3.nextChunkPosition;
param2 -= local3.size;
}
}
private function parseObjectAnimationChunk(param1:AnimationData, param2:int, param3:int) : void {
if(param3 < 6) {
return;
}
var local4:ChunkInfo = this.readChunkInfo(param2);
switch(local4.id) {
case 45072:
param1.objectName = this.getString(this.data.position);
this.data.position += 4;
param1.parentIndex = this.data.readUnsignedShort();
break;
case 45073:
param1.objectName = this.getString(this.data.position);
break;
case 45075:
param1.pivot = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
break;
case 45088:
this.data.position += 20;
param1.position = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
break;
case 45089:
this.data.position += 20;
param1.rotation = this.getRotationFrom3DSAngleAxis(this.data.readFloat(),this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
break;
case 45090:
this.data.position += 20;
param1.scale = new Vector3D(this.data.readFloat(),this.data.readFloat(),this.data.readFloat());
}
this.parseObjectAnimationChunk(param1,local4.nextChunkPosition,param3 - local4.size);
}
private function parseMaterialChunk(param1:MaterialData, param2:int, param3:int) : void {
if(param3 < 6) {
return;
}
var local4:ChunkInfo = this.readChunkInfo(param2);
switch(local4.id) {
case 40960:
this.parseMaterialName(param1);
break;
case 40976:
break;
case 40992:
this.data.position = local4.dataPosition + 6;
param1.color = (this.data.readUnsignedByte() << 16) + (this.data.readUnsignedByte() << 8) + this.data.readUnsignedByte();
break;
case 41008:
break;
case 41024:
this.data.position = local4.dataPosition + 6;
param1.glossiness = this.data.readUnsignedShort();
break;
case 41025:
this.data.position = local4.dataPosition + 6;
param1.specular = this.data.readUnsignedShort();
break;
case 41040:
this.data.position = local4.dataPosition + 6;
param1.transparency = this.data.readUnsignedShort();
break;
case 41472:
param1.diffuseMap = new MapData();
this.parseMapChunk(param1.name,param1.diffuseMap,local4.dataPosition,local4.dataSize);
break;
case 41786:
break;
case 41488:
param1.opacityMap = new MapData();
this.parseMapChunk(param1.name,param1.opacityMap,local4.dataPosition,local4.dataSize);
break;
case 41520:
case 41788:
case 41476:
case 41789:
case 41504:
}
this.parseMaterialChunk(param1,local4.nextChunkPosition,param3 - local4.size);
}
private function parseMaterialName(param1:MaterialData) : void {
if(this.materialDatas == null) {
this.materialDatas = new Object();
}
param1.name = this.getString(this.data.position);
this.materialDatas[param1.name] = param1;
}
private function parseMapChunk(param1:String, param2:MapData, param3:int, param4:int) : void {
if(param4 < 6) {
return;
}
var local5:ChunkInfo = this.readChunkInfo(param3);
switch(local5.id) {
case 41728:
param2.filename = this.getString(local5.dataPosition).toLowerCase();
break;
case 41809:
break;
case 41812:
param2.scaleU = this.data.readFloat();
break;
case 41814:
param2.scaleV = this.data.readFloat();
break;
case 41816:
param2.offsetU = this.data.readFloat();
break;
case 41818:
param2.offsetV = this.data.readFloat();
break;
case 41820:
param2.rotation = this.data.readFloat();
}
this.parseMapChunk(param1,param2,local5.nextChunkPosition,param4 - local5.size);
}
private function buildContent(param1:String, param2:Number) : void {
var local3:String = null;
var local4:String = null;
var local5:ObjectData = null;
var local6:Object3D = null;
var local7:MaterialData = null;
var local8:MapData = null;
var local9:Matrix = null;
var local10:Number = NaN;
var local11:TextureMaterial = null;
var local12:FillMaterial = null;
var local13:int = 0;
var local14:int = 0;
var local15:AnimationData = null;
var local16:int = 0;
var local17:int = 0;
var local18:AnimationData = null;
var local19:ObjectData = null;
var local20:String = null;
for(local3 in this.materialDatas) {
local7 = this.materialDatas[local3];
local8 = local7.diffuseMap;
if(local8 != null) {
local9 = new Matrix();
local10 = local8.rotation * Math.PI / 180;
local9.translate(-local8.offsetU,local8.offsetV);
local9.translate(-0.5,-0.5);
local9.rotate(-local10);
local9.scale(local8.scaleU,local8.scaleV);
local9.translate(0.5,0.5);
local7.matrix = local9;
local11 = new TextureMaterial();
local11.name = local3;
local11.diffuseMapURL = param1 + local8.filename;
local11.opacityMapURL = local7.opacityMap != null ? param1 + local7.opacityMap.filename : null;
local7.material = local11;
local11.name = local7.name;
this.textureMaterials.push(local11);
} else {
local12 = new FillMaterial(local7.color);
local7.material = local12;
local12.name = local7.name;
}
this.materials.push(local7.material);
}
if(this.animationDatas != null) {
if(this.objectDatas != null) {
local14 = int(this.animationDatas.length);
local13 = 0;
while(local13 < local14) {
local15 = this.animationDatas[local13];
local4 = local15.objectName;
local5 = this.objectDatas[local4];
if(local5 != null) {
local16 = local13 + 1;
local17 = 1;
while(local16 < local14) {
local18 = this.animationDatas[local16];
if(!local18.isInstance && local4 == local18.objectName) {
local19 = new ObjectData();
local20 = local4 + local17++;
local19.name = local20;
this.objectDatas[local20] = local19;
local18.objectName = local20;
local19.vertices = local5.vertices;
local19.uvs = local5.uvs;
local19.faces = local5.faces;
local19.smoothingGroups = local5.smoothingGroups;
local19.surfaces = local5.surfaces;
local19.a = local5.a;
local19.b = local5.b;
local19.c = local5.c;
local19.d = local5.d;
local19.e = local5.e;
local19.f = local5.f;
local19.g = local5.g;
local19.h = local5.h;
local19.i = local5.i;
local19.j = local5.j;
local19.k = local5.k;
local19.l = local5.l;
}
local16++;
}
}
if(local5 != null && local5.vertices != null) {
local6 = new Mesh();
this.buildMesh(local6 as Mesh,local5,local15,param2);
} else {
local6 = new Object3D();
}
local6.name = local4;
local15.object = local6;
if(local15.position != null) {
local6.x = local15.position.x * param2;
local6.y = local15.position.y * param2;
local6.z = local15.position.z * param2;
}
if(local15.rotation != null) {
local6.rotationX = local15.rotation.x;
local6.rotationY = local15.rotation.y;
local6.rotationZ = local15.rotation.z;
}
if(local15.scale != null) {
local6.scaleX = local15.scale.x;
local6.scaleY = local15.scale.y;
local6.scaleZ = local15.scale.z;
}
local13++;
}
local13 = 0;
while(local13 < local14) {
local15 = this.animationDatas[local13];
this.objects.push(local15.object);
this.parents.push(local15.parentIndex == 65535 ? null : AnimationData(this.animationDatas[local15.parentIndex]).object);
local13++;
}
}
} else {
for(local4 in this.objectDatas) {
local5 = this.objectDatas[local4];
if(local5.vertices != null) {
local6 = new Mesh();
local6.name = local4;
this.buildMesh(local6 as Mesh,local5,null,param2);
this.objects.push(local6);
this.parents.push(null);
}
}
}
}
private function buildMesh(param1:Mesh, param2:ObjectData, param3:AnimationData, param4:Number) : void {
var local9:int = 0;
var local10:int = 0;
var local11:Face = null;
var local12:Vertex = null;
var local14:int = 0;
var 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:Boolean = false;
var local29:Number = NaN;
var local30:Number = NaN;
var local31:Number = NaN;
var local32:Face = null;
var local33:String = null;
var local34:Vector.<int> = null;
var local35:MaterialData = null;
var local36:Material = null;
var local37:Wrapper = null;
var local38:Number = NaN;
var local39:Number = NaN;
var local5:Vector.<Vertex> = new Vector.<Vertex>();
var local6:Vector.<Face> = new Vector.<Face>();
var local7:int = 0;
var local8:int = 0;
var local13:Boolean = false;
if(param3 != null) {
local15 = param2.a;
local16 = param2.b;
local17 = param2.c;
local18 = param2.d;
local19 = param2.e;
local20 = param2.f;
local21 = param2.g;
local22 = param2.h;
local23 = param2.i;
local24 = param2.j;
local25 = param2.k;
local26 = param2.l;
local27 = 1 / (-local17 * local20 * local23 + local16 * local21 * local23 + local17 * local19 * local24 - local15 * local21 * local24 - local16 * local19 * local25 + local15 * local20 * local25);
param2.a = (-local21 * local24 + local20 * local25) * local27;
param2.b = (local17 * local24 - local16 * local25) * local27;
param2.c = (-local17 * local20 + local16 * local21) * local27;
param2.d = (local18 * local21 * local24 - local17 * local22 * local24 - local18 * local20 * local25 + local16 * local22 * local25 + local17 * local20 * local26 - local16 * local21 * local26) * local27;
param2.e = (local21 * local23 - local19 * local25) * local27;
param2.f = (-local17 * local23 + local15 * local25) * local27;
param2.g = (local17 * local19 - local15 * local21) * local27;
param2.h = (local17 * local22 * local23 - local18 * local21 * local23 + local18 * local19 * local25 - local15 * local22 * local25 - local17 * local19 * local26 + local15 * local21 * local26) * local27;
param2.i = (-local20 * local23 + local19 * local24) * local27;
param2.j = (local16 * local23 - local15 * local24) * local27;
param2.k = (-local16 * local19 + local15 * local20) * local27;
param2.l = (local18 * local20 * local23 - local16 * local22 * local23 - local18 * local19 * local24 + local15 * local22 * local24 + local16 * local19 * local26 - local15 * local20 * local26) * local27;
if(param3.pivot != null) {
param2.d -= param3.pivot.x;
param2.h -= param3.pivot.y;
param2.l -= param3.pivot.z;
}
local13 = true;
}
if(param2.vertices != null) {
local28 = param2.uvs != null && param2.uvs.length > 0;
local9 = 0;
local10 = 0;
local14 = int(param2.vertices.length);
while(local9 < local14) {
local12 = new Vertex();
if(local13) {
local29 = param2.vertices[local9++];
local30 = param2.vertices[local9++];
local31 = param2.vertices[local9++];
local12.x = param2.a * local29 + param2.b * local30 + param2.c * local31 + param2.d;
local12.y = param2.e * local29 + param2.f * local30 + param2.g * local31 + param2.h;
local12.z = param2.i * local29 + param2.j * local30 + param2.k * local31 + param2.l;
} else {
local12.x = param2.vertices[local9++];
local12.y = param2.vertices[local9++];
local12.z = param2.vertices[local9++];
}
local12.x *= param4;
local12.y *= param4;
local12.z *= param4;
if(local28) {
local12.u = param2.uvs[local10++];
local12.v = 1 - param2.uvs[local10++];
}
local12.alternativa3d::transformId = -1;
var local40:* = local7++;
local5[local40] = local12;
local12.alternativa3d::next = param1.alternativa3d::vertexList;
param1.alternativa3d::vertexList = local12;
}
}
if(param2.faces != null) {
local9 = 0;
local10 = 0;
local14 = int(param2.faces.length);
while(local9 < local14) {
local11 = new Face();
local11.alternativa3d::wrapper = new Wrapper();
local11.alternativa3d::wrapper.alternativa3d::next = new Wrapper();
local11.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next = new Wrapper();
local11.alternativa3d::wrapper.alternativa3d::vertex = local5[param2.faces[local9++]];
local11.alternativa3d::wrapper.alternativa3d::next.alternativa3d::vertex = local5[param2.faces[local9++]];
local11.alternativa3d::wrapper.alternativa3d::next.alternativa3d::next.alternativa3d::vertex = local5[param2.faces[local9++]];
local11.smoothingGroups = param2.smoothingGroups[local10++];
local40 = local8++;
local6[local40] = local11;
if(local32 != null) {
local32.alternativa3d::next = local11;
} else {
param1.alternativa3d::faceList = local11;
}
local32 = local11;
}
}
if(param2.surfaces != null) {
for(local33 in param2.surfaces) {
local34 = param2.surfaces[local33];
local35 = this.materialDatas[local33];
local36 = local35.material;
local9 = 0;
while(local9 < local34.length) {
local11 = local6[local34[local9]];
local11.material = local36;
if(local35.matrix != null) {
local37 = local11.alternativa3d::wrapper;
while(local37 != null) {
local12 = local37.alternativa3d::vertex;
if(local12.alternativa3d::transformId < 0) {
local38 = local12.u;
local39 = local12.v;
local12.u = local35.matrix.a * local38 + local35.matrix.b * local39 + local35.matrix.tx;
local12.v = local35.matrix.c * local38 + local35.matrix.d * local39 + local35.matrix.ty;
local12.alternativa3d::transformId = 0;
}
local37 = local37.alternativa3d::next;
}
}
local9++;
}
}
}
param1.calculateFacesNormals(true);
param1.calculateBounds();
}
private function getString(param1:int) : String {
var local2:int = 0;
this.data.position = param1;
var local3:String = "";
while(true) {
local2 = this.data.readByte();
if(local2 == 0) {
break;
}
local3 += String.fromCharCode(local2);
}
return local3;
}
private function getRotationFrom3DSAngleAxis(param1:Number, param2:Number, param3:Number, param4:Number) : Vector3D {
var local10:Number = NaN;
var local5:Vector3D = new Vector3D();
var local6:Number = Math.sin(param1);
var local7:Number = Math.cos(param1);
var local8:Number = 1 - local7;
var local9:Number = param2 * param4 * local8 + param3 * local6;
if(local9 >= 1) {
local10 = param1 / 2;
local5.z = -2 * Math.atan2(param2 * Math.sin(local10),Math.cos(local10));
local5.y = -Math.PI / 2;
local5.x = 0;
return local5;
}
if(local9 <= -1) {
local10 = param1 / 2;
local5.z = 2 * Math.atan2(param2 * Math.sin(local10),Math.cos(local10));
local5.y = Math.PI / 2;
local5.x = 0;
return local5;
}
local5.z = -Math.atan2(param4 * local6 - param2 * param3 * local8,1 - (param4 * param4 + param3 * param3) * local8);
local5.y = -Math.asin(param2 * param4 * local8 + param3 * local6);
local5.x = -Math.atan2(param2 * local6 - param4 * param3 * local8,1 - (param2 * param2 + param3 * param3) * local8);
return local5;
}
}
}
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.Material;
import flash.geom.Matrix;
import flash.geom.Vector3D;
class MaterialData {
public var name:String;
public var color:int;
public var specular:int;
public var glossiness:int;
public var transparency:int;
public var diffuseMap:MapData;
public var opacityMap:MapData;
public var matrix:Matrix;
public var material:Material;
public function MaterialData() {
super();
}
}
class MapData {
public var filename:String;
public var scaleU:Number = 1;
public var scaleV:Number = 1;
public var offsetU:Number = 0;
public var offsetV:Number = 0;
public var rotation:Number = 0;
public function MapData() {
super();
}
}
class ObjectData {
public var name:String;
public var vertices:Vector.<Number>;
public var uvs:Vector.<Number>;
public var faces:Vector.<int>;
public var smoothingGroups:Vector.<uint>;
public var surfaces:Object;
public var a:Number;
public var b:Number;
public var c:Number;
public var d:Number;
public var e:Number;
public var f:Number;
public var g:Number;
public var h:Number;
public var i:Number;
public var j:Number;
public var k:Number;
public var l:Number;
public function ObjectData() {
super();
}
}
class AnimationData {
public var objectName:String;
public var object:Object3D;
public var parentIndex:int;
public var pivot:Vector3D;
public var position:Vector3D;
public var rotation:Vector3D;
public var scale:Vector3D;
public var isInstance:Boolean;
public function AnimationData() {
super();
}
}
class ChunkInfo {
public var id:int;
public var size:int;
public var dataSize:int;
public var dataPosition:int;
public var nextChunkPosition:int;
public function ChunkInfo() {
super();
}
}
|
package alternativa.tanks.model.garage.resistance {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.garage.resistance.ResistancesIcons_bitmapRailResistance_x2.png")]
public class ResistancesIcons_bitmapRailResistance_x2 extends BitmapAsset {
public function ResistancesIcons_bitmapRailResistance_x2() {
super();
}
}
}
|
package alternativa.tanks.models.statistics {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleservice.model.statistics.UserReward;
public class IStatisticRoundAdapt implements IStatisticRound {
private var object:IGameObject;
private var impl:IStatisticRound;
public function IStatisticRoundAdapt(param1:IGameObject, param2:IStatisticRound) {
super();
this.object = param1;
this.impl = param2;
}
public function roundStart() : void {
try {
Model.object = this.object;
this.impl.roundStart();
}
finally {
Model.popObject();
}
}
public function roundFinish(param1:Boolean, param2:Boolean, param3:int, param4:Vector.<UserReward>) : void {
var matchBattle:Boolean = param1;
var needShowScore:Boolean = param2;
var timeToRestart:int = param3;
var reward:Vector.<UserReward> = param4;
try {
Model.object = this.object;
this.impl.roundFinish(matchBattle,needShowScore,timeToRestart,reward);
}
finally {
Model.popObject();
}
}
public function roundStop() : void {
try {
Model.object = this.object;
this.impl.roundStop();
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.battle.scene3d {
import alternativa.engine3d.containers.KDContainer;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Decal;
import alternativa.math.Vector3;
import alternativa.physics.collision.CollisionDetector;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.*;
import alternativa.tanks.physics.CollisionGroup;
import flash.geom.Vector3D;
public class DecalFactory {
private static const ANGLE_LIMIT:Number = 85 * Math.PI / 180;
private static const rayHit:RayHit = new RayHit();
private static const direction:Vector3 = new Vector3();
private static const right:Vector3 = new Vector3();
private static const up:Vector3 = new Vector3();
private static const normal:Vector3 = new Vector3();
private static const origins:Vector.<Vector3> = Vector.<Vector3>([new Vector3(),new Vector3(),new Vector3(),new Vector3(),new Vector3()]);
private static const position3D:Vector3D = new Vector3D();
private static const normal3D:Vector3D = new Vector3D();
private var collisionDetector:CollisionDetector;
public function DecalFactory(param1:CollisionDetector) {
super();
this.collisionDetector = param1;
}
public function createDecal(param1:Vector3, param2:Vector3, param3:Number, param4:TextureMaterial, param5:KDContainer, param6:RotationState) : Decal {
var local8:Vector3 = null;
var local9:Number = NaN;
direction.diff(param1,param2);
var local7:Number = direction.length() + 200;
direction.normalize();
right.cross2(direction,Vector3.Z_AXIS).normalize();
up.cross2(right,direction);
Vector3(origins[4]).copy(param2);
Vector3(origins[0]).copy(param2).addScaled(50,right);
Vector3(origins[1]).copy(param2).addScaled(50,up);
Vector3(origins[2]).copy(param2).addScaled(-50,right);
Vector3(origins[3]).copy(param2).addScaled(-50,up);
normal.reset(0,0,0);
for each(local8 in origins) {
if(this.collisionDetector.raycastStatic(local8,direction,CollisionGroup.STATIC,local7,null,rayHit)) {
normal.add(rayHit.normal);
}
}
normal.normalize();
BattleUtils.copyToVector3D(param1,position3D);
BattleUtils.copyToVector3D(normal,normal3D);
local9 = this.getRotation(param6);
return param5.createDecal(position3D,normal3D,param3,local9,ANGLE_LIMIT,300,param4);
}
private function getRotation(param1:RotationState) : Number {
switch(param1) {
case RotationState.WITHOUT_ROTATION:
return 0;
default:
return Math.random() * 2 * Math.PI;
}
}
}
}
|
package alternativa.tanks.models.tank.killhandlers {
import platform.client.fp10.core.type.IGameObject;
public interface TankDieHandler {
function handleTankDie(param1:IGameObject, param2:int) : void;
}
}
|
package projects.tanks.client.panel.model.shop.lootbox {
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 LootBoxPackageModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function LootBoxPackageModelServer(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.resource {
import flash.utils.ByteArray;
public interface IResourceSerializationListener {
function onSerializationComplete(param1:Resource, param2:ByteArray) : void;
}
}
|
package controls.rangicons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class RangIcon_p9 extends BitmapAsset
{
public function RangIcon_p9()
{
super();
}
}
}
|
package {
import flash.display.Sprite;
import flash.system.Security;
[ExcludeClass]
public class _86b13dc487d81c3a17b36d48983f2b5b5ca5c9ee21ec208b0c42383f10e0b934_flash_display_Sprite extends Sprite {
public function _86b13dc487d81c3a17b36d48983f2b5b5ca5c9ee21ec208b0c42383f10e0b934_flash_display_Sprite() {
super();
}
public function allowDomainInRSL(... rest) : void {
Security.allowDomain.apply(null,rest);
}
public function allowInsecureDomainInRSL(... rest) : void {
Security.allowInsecureDomain.apply(null,rest);
}
}
}
|
package alternativa.tanks.models.tank.hullcommon {
import flash.display.BitmapData;
import flash.media.Sound;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.TextureResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.armor.common.HullCommonCC;
public class HullCommonAdapt implements HullCommon {
private var object:IGameObject;
private var impl:HullCommon;
public function HullCommonAdapt(param1:IGameObject, param2:HullCommon) {
super();
this.object = param1;
this.impl = param2;
}
public function getCC() : HullCommonCC {
var result:HullCommonCC = null;
try {
Model.object = this.object;
result = this.impl.getCC();
}
finally {
Model.popObject();
}
return result;
}
public function getDeadColoring() : TextureResource {
var result:TextureResource = null;
try {
Model.object = this.object;
result = this.impl.getDeadColoring();
}
finally {
Model.popObject();
}
return result;
}
public function getMass() : Number {
var result:Number = NaN;
try {
Model.object = this.object;
result = this.impl.getMass();
}
finally {
Model.popObject();
}
return result;
}
public function setTankObject(param1:IGameObject) : void {
var tank:IGameObject = param1;
try {
Model.object = this.object;
this.impl.setTankObject(tank);
}
finally {
Model.popObject();
}
}
public function getTankObject() : IGameObject {
var result:IGameObject = null;
try {
Model.object = this.object;
result = this.impl.getTankObject();
}
finally {
Model.popObject();
}
return result;
}
public function getStunEffectTexture() : BitmapData {
var result:BitmapData = null;
try {
Model.object = this.object;
result = this.impl.getStunEffectTexture();
}
finally {
Model.popObject();
}
return result;
}
public function getStunSound() : Sound {
var result:Sound = null;
try {
Model.object = this.object;
result = this.impl.getStunSound();
}
finally {
Model.popObject();
}
return result;
}
public function getUltimateIconIndex() : int {
var result:int = 0;
try {
Model.object = this.object;
result = this.impl.getUltimateIconIndex();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.panel.model.quest.notifier {
public interface IQuestNotifierModelBase {
function completedDailyQuest() : void;
function completedWeeklyQuests() : void;
function newInDailyQuests() : void;
function newInWeeklyQuests() : void;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.