code
stringlengths 57
237k
|
|---|
package alternativa.tanks.gui.shop.shopitems.item.garageitem {
import alternativa.tanks.gui.shop.shopitems.item.AbstractGarageItemShopItemButton;
import alternativa.tanks.model.payment.shop.paint.PaintPackage;
import platform.client.fp10.core.type.IGameObject;
public class PaintPackageButton extends AbstractGarageItemShopItemButton {
public function PaintPackageButton(param1:IGameObject) {
super(param1);
}
override protected function getNameLabelValue(param1:IGameObject) : String {
return PaintPackage(param1.adapt(PaintPackage)).getName();
}
}
}
|
package platform.client.core.general.pushnotification.impl.model {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import flash.utils.ByteArray;
import platform.client.core.general.pushnotification.api.NotificationClientPlatform;
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 FirebasePushNotificationPanelUserProfileModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _storeTokenId:Long = Long.getLong(1272774525,-863530729);
private var _storeToken_platformCodec:ICodec;
private var _storeToken_tokenCodec:ICodec;
private var model:IModel;
public function FirebasePushNotificationPanelUserProfileModelServer(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._storeToken_platformCodec = this.protocol.getCodec(new EnumCodecInfo(NotificationClientPlatform,false));
this._storeToken_tokenCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function storeToken(param1:NotificationClientPlatform, param2:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._storeToken_platformCodec.encode(this.protocolBuffer,param1);
this._storeToken_tokenCodec.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._storeTokenId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.model.panel {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.startup.StartupSettings;
import alternativa.tanks.gui.panel.MainPanel;
import alternativa.tanks.help.ButtonBarHelper;
import alternativa.tanks.help.FriendsHelper;
import alternativa.tanks.help.MainMenuHelper;
import alternativa.tanks.help.MoneyHelper;
import alternativa.tanks.help.RankBarHelper;
import alternativa.tanks.help.RankHelper;
import alternativa.tanks.help.ScoreHelper;
import alternativa.tanks.service.achievement.IAchievementService;
import alternativa.tanks.service.clan.ClanPanelNotificationService;
import alternativa.tanks.service.fps.FPSService;
import alternativa.tanks.service.fps.FPSServiceImpl;
import alternativa.tanks.service.panel.IPanelView;
import alternativa.tanks.service.payment.IPaymentService;
import alternativa.tanks.service.settings.keybinding.GameActionEnum;
import alternativa.tanks.service.settings.keybinding.KeysBindingService;
import alternativa.tanks.tracker.ITrackerService;
import flash.display.InteractiveObject;
import flash.events.FullScreenEvent;
import flash.events.KeyboardEvent;
import flash.geom.Point;
import flash.text.TextField;
import flash.text.TextFieldType;
import flash.ui.Keyboard;
import forms.events.MainButtonBarEvents;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.clients.fp10.libraries.alternativapartners.service.IPartnerService;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.client.panel.model.panel.IPanelModelBase;
import projects.tanks.client.panel.model.panel.PanelModelBase;
import projects.tanks.clients.flash.commons.services.layout.event.LobbyLayoutServiceEvent;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.AlertServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.BattleInfoServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.dialogwindowdispatcher.IDialogWindowsDispatcherService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenStateService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.IHelpService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.gamescreen.UserChangeGameScreenService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.AlertUtils;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.KeyUpListenerPriority;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.removeDisplayObject;
[ModelInfo]
public class PanelModel extends PanelModelBase implements IPanelModelBase, ObjectLoadListener, ObjectLoadPostListener, ObjectUnloadListener {
[Inject]
public static var panelView:IPanelView;
[Inject]
public static var display:IDisplay;
[Inject]
public static var helpService:IHelpService;
[Inject]
public static var trackerService:ITrackerService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
[Inject]
public static var achievementService:IAchievementService;
[Inject]
public static var partnerService:IPartnerService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var paymentService:IPaymentService;
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var fullscreenService:FullscreenService;
[Inject]
public static var fullscreenStateService:FullscreenStateService;
[Inject]
public static var userInfoService:IUserInfoService;
[Inject]
public static var paymentDisplayService:PaymentDisplayService;
[Inject]
public static var userChangeGameScreenService:UserChangeGameScreenService;
[Inject]
public static var keysBindingService:KeysBindingService;
[Inject]
public static var dialogWindowsDispatcherService:IDialogWindowsDispatcherService;
[Inject]
public static var clanPanelNotificationService:ClanPanelNotificationService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
private static const HELPER_GROUP_KEY:String = "PanelModel";
private static const HELPER_CHANGE_SERVER:int = 11;
private static const GA_CATEGORY:String = "lobby";
private static const HELPER_RANK:int = 1;
private static const HELPER_RANK_BAR:int = 2;
private static const HELPER_MAIN_MENU:int = 5;
private static const HELPER_BUTTON_BAR:int = 6;
private static const HELPER_MONEY:int = 7;
private static const HELPER_FRIENDS:int = 11;
private static const HELPER_SCORE:int = 10;
private static const HELPER_RATING:int = 100;
private static const SMALL_BUTTON_WIDTH:int = 26;
private static const SMALL_BUTTONS_COUNT:int = 4;
private static const BUTTON_BAR_HELPER_B_COEFF:int = 43;
private static const BUTTON_BAR_OFFSET:int = 4;
private static const FRIENDS_BUTTON_OFFSET:int = 6;
private static const DAILY_QUEST_BUTTON_WIDTH:int = 36;
private static const MONEY_HELPER_OFFSET:int = 225;
private static const MAIN_MENU_HELPER_OFFSET:int = 320;
private static const RATING_HELPER_OFFSET:int = 30;
private static const RANK_BAR_WIDTH:int = 631;
private var panel:MainPanel;
private var destinationsState:String;
public function PanelModel() {
super();
}
private static function removeGarageAchievement() : void {
if(!lobbyLayoutService.inBattle()) {
achievementService.removeGarageButtonAchievement();
}
}
private static function closeButtonPressed() : void {
if(lobbyLayoutService.inBattle()) {
if(lobbyLayoutService.getCurrentState() == LayoutState.BATTLE) {
lobbyLayoutService.exitFromBattle();
} else {
lobbyLayoutService.returnToBattle();
}
} else {
lobbyLayoutService.exitFromGame();
}
}
private static function showHelpers() : void {
helpService.showHelp();
panelView.unlock();
}
private static function onKeyUp(param1:KeyboardEvent) : void {
if(AlertUtils.isCancelKey(param1.keyCode) && !lobbyLayoutService.isSwitchInProgress()) {
param1.stopImmediatePropagation();
closeButtonPressed();
}
if(isFullscreenHotKey(param1.keyCode)) {
fullscreenService.switchFullscreen();
}
}
private static function isFullscreenHotKey(param1:uint) : Boolean {
var local3:InteractiveObject = null;
var local2:GameActionEnum = keysBindingService.getBindingAction(param1);
if(param1 == Keyboard.F11) {
return true;
}
if(local2 == GameActionEnum.FULL_SCREEN) {
local3 = display.stage.focus;
if(local3 is TextField) {
return TextField(local3).type != TextFieldType.INPUT;
}
return true;
}
return false;
}
public function objectLoaded() : void {
panelView.setPanel();
this.panel = panelView.getPanel();
display.systemUILayer.addChild(this.panel);
this.addListeners();
if(this.shouldHideButton()) {
this.panel.buttonBar.closeButton.hide();
}
if(fullscreenService.isAvailable()) {
this.panel.buttonBar.fullScreenButton.isActivateFullscreen = !fullscreenStateService.isFullscreen();
} else {
this.panel.buttonBar.fullScreenButton.hide();
this.panel.buttonBar.draw();
}
this.updateNavigationLock(null);
trackerService.trackPageView(GA_CATEGORY);
trackerService.trackEventAfter(GA_CATEGORY,"lobbyLoaded","initTracker");
FPSServiceImpl(OSGi.getInstance().getService(FPSService)).start();
}
public function objectLoadedPost() : void {
achievementService.setGarageBuyButtonTargetPoint(new Point(0,0));
this.initHelpers();
}
private function initHelpers() : void {
var local1:int = this.getClanButtonWidth();
var local2:RankBarHelper = new RankBarHelper(0.5,RANK_BAR_WIDTH,60);
var local3:int = !!userPropertiesService.isQuestsAvailableByRank() ? DAILY_QUEST_BUTTON_WIDTH : 0;
var local4:MainMenuHelper = new MainMenuHelper(1,RANK_BAR_WIDTH,MAIN_MENU_HELPER_OFFSET);
var local5:MoneyHelper = new MoneyHelper(1,RANK_BAR_WIDTH + local3 + local1,MONEY_HELPER_OFFSET);
var local6:ScoreHelper = new ScoreHelper();
var local7:RankHelper = new RankHelper();
var local8:int = SMALL_BUTTON_WIDTH * SMALL_BUTTONS_COUNT + (SMALL_BUTTON_WIDTH >> 2) + BUTTON_BAR_OFFSET + FRIENDS_BUTTON_OFFSET;
var local9:FriendsHelper = new FriendsHelper(1,BUTTON_BAR_HELPER_B_COEFF,-local8);
var local10:ButtonBarHelper = new ButtonBarHelper(1,BUTTON_BAR_HELPER_B_COEFF,-BUTTON_BAR_OFFSET,partnerService.isRunningInsidePartnerEnvironment(),fullscreenService.isAvailable());
helpService.registerHelper(HELPER_GROUP_KEY,HELPER_RANK,local7,true);
helpService.registerHelper(HELPER_GROUP_KEY,HELPER_RANK_BAR,local2,true);
helpService.registerHelper(HELPER_GROUP_KEY,HELPER_SCORE,local6,true);
helpService.registerHelper(HELPER_GROUP_KEY,HELPER_MAIN_MENU,local4,true);
helpService.registerHelper(HELPER_GROUP_KEY,HELPER_BUTTON_BAR,local10,true);
if(paymentService.isEnabled()) {
helpService.registerHelper(HELPER_GROUP_KEY,HELPER_MONEY,local5,true);
}
helpService.registerHelper(HELPER_GROUP_KEY,HELPER_FRIENDS,local9,true);
}
private function getClanButtonWidth() : int {
return this.panel.buttonBar.clanButton.visible ? int(this.panel.buttonBar.clanButton.width) : 0;
}
public function objectUnloaded() : void {
this.panel.destroy();
this.panel.buttonBar.removeEventListener(MainButtonBarEvents.PANEL_BUTTON_PRESSED,getFunctionWrapper(this.onButtonBarButtonClick));
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.BEGIN_LAYOUT_SWITCH,this.updateNavigationLock);
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.updateNavigationLock);
battleInfoService.removeEventListener(BattleInfoServiceEvent.BATTLE_UNLOAD,this.onBattleUnload);
battleInfoService.removeEventListener(BattleInfoServiceEvent.BATTLE_LOAD,this.onBattleLoad);
display.stage.removeEventListener(KeyboardEvent.KEY_UP,getFunctionWrapper(onKeyUp));
if(fullscreenService.isAvailable()) {
display.stage.removeEventListener(FullScreenEvent.FULL_SCREEN,this.onFullscreen);
display.stage.removeEventListener(FullScreenEvent.FULL_SCREEN_INTERACTIVE_ACCEPTED,this.onFullscreen);
}
achievementService.hideAllBubbles(false);
this.hidePanel();
}
private function hidePanel() : void {
this.panel.hide();
removeDisplayObject(this.panel);
}
private function addListeners() : void {
this.panel.buttonBar.addEventListener(MainButtonBarEvents.PANEL_BUTTON_PRESSED,getFunctionWrapper(this.onButtonBarButtonClick));
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.BEGIN_LAYOUT_SWITCH,this.updateNavigationLock);
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.updateNavigationLock);
battleInfoService.addEventListener(BattleInfoServiceEvent.BATTLE_UNLOAD,this.onBattleUnload);
battleInfoService.addEventListener(BattleInfoServiceEvent.BATTLE_LOAD,this.onBattleLoad);
display.stage.addEventListener(KeyboardEvent.KEY_UP,getFunctionWrapper(onKeyUp),false,KeyUpListenerPriority.PANEL);
if(fullscreenService.isAvailable()) {
display.stage.addEventListener(FullScreenEvent.FULL_SCREEN,this.onFullscreen);
display.stage.addEventListener(FullScreenEvent.FULL_SCREEN_INTERACTIVE_ACCEPTED,this.onFullscreen);
}
}
private function onButtonBarButtonClick(param1:MainButtonBarEvents) : void {
achievementService.hideAllBubbles(false);
trackerService.trackEvent(GA_CATEGORY,"panel",param1.typeButton);
this.destinationsState = param1.typeButton;
if(Boolean(lobbyLayoutService.inBattle()) && this.buttonChangeLayout(param1.typeButton) && !battleInfoService.isSpectatorMode() && !(Boolean(lobbyLayoutService.inBattle()) && Boolean(dialogWindowsDispatcherService.isOpen()))) {
this.showExitFromBattleAlert();
} else {
this.changeState();
}
}
private function buttonChangeLayout(param1:String) : Boolean {
if(Boolean(clanUserInfoService.clanMember) && param1 == MainButtonBarEvents.CLAN) {
return true;
}
return [MainButtonBarEvents.BATTLE].indexOf(param1) >= 0;
}
private function showExitFromBattleAlert() : void {
var local1:String = this.getTextForExitFromBattleAlert();
alertService.showAlert(local1,Vector.<String>([localeService.getText(TanksLocale.TEXT_ALERT_ANSWER_YES),localeService.getText(TanksLocale.TEXT_ALERT_ANSWER_NO)]));
alertService.addEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onQuitBattleDialogButtonPressed);
}
private function getTextForExitFromBattleAlert() : String {
if(!userInfoService.isOffer()) {
return localeService.getText(TanksLocale.TEXT_FRIENDS_EXIT_FROM_BATTLE_ALERT);
}
return localeService.getText(TanksLocale.TEXT_FRIENDS_EXIT_FROM_BATTLE_ALERT) + "\n" + localeService.getText(TanksLocale.TEXT_POSTFIX_OFFER_EXIT_BATTLE);
}
private function onQuitBattleDialogButtonPressed(param1:AlertServiceEvent) : void {
var local2:LayoutState = null;
alertService.removeEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,this.onQuitBattleDialogButtonPressed);
if(param1.typeButton == localeService.getText(TanksLocale.TEXT_ALERT_ANSWER_YES)) {
local2 = this.getStateByDestination();
if(local2 == LayoutState.MATCHMAKING) {
lobbyLayoutService.exitFromBattleWithoutNotify();
} else {
lobbyLayoutService.exitFromBattleToState(local2);
}
}
}
private function getStateByDestination() : LayoutState {
switch(this.destinationsState) {
case MainButtonBarEvents.GARAGE:
return LayoutState.GARAGE;
case MainButtonBarEvents.CLAN:
return LayoutState.CLAN;
default:
return LayoutState.MATCHMAKING;
}
}
private function changeState() : void {
switch(this.destinationsState) {
case MainButtonBarEvents.BATTLE:
this.lockMainPanel();
lobbyLayoutService.showBattleLobby();
this.panel.buttonBar.battlesButton.enable = true;
break;
case MainButtonBarEvents.GARAGE:
this.lockMainPanel();
if(Boolean(lobbyLayoutService.inBattle()) && lobbyLayoutService.getCurrentState() == LayoutState.GARAGE) {
lobbyLayoutService.returnToBattle();
} else if(Boolean(lobbyLayoutService.inBattle()) && Boolean(battleInfoService.enterGarageCausesExitBattle)) {
lobbyLayoutService.exitFromBattleToGarageThroughAlert();
} else {
lobbyLayoutService.showGarage();
}
removeGarageAchievement();
break;
case MainButtonBarEvents.CLAN:
if(clanUserInfoService.clanMember) {
this.lockMainPanel();
lobbyLayoutService.showClan();
}
break;
case MainButtonBarEvents.SHOP:
paymentDisplayService.openPayment();
break;
case MainButtonBarEvents.HELP:
showHelpers();
break;
case MainButtonBarEvents.CLOSE:
closeButtonPressed();
break;
case MainButtonBarEvents.FULL_SCREEN:
fullscreenService.switchFullscreen();
}
}
private function onFullscreen(param1:FullScreenEvent) : void {
this.panel.buttonBar.fullScreenButton.isActivateFullscreen = !param1.fullScreen;
}
private function updateNavigationLock(param1:LobbyLayoutServiceEvent) : void {
if(lobbyLayoutService.isSwitchInProgress()) {
this.lockMainPanel();
} else {
this.unlockMainPanel();
}
this.setButtonState(lobbyLayoutService.getCurrentState());
}
private function onBattleLoad(param1:BattleInfoServiceEvent) : void {
lobbyLayoutService.addEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.onEndLayoutSwitchInBattle);
if(partnerService.isRunningInsidePartnerEnvironment()) {
this.panel.buttonBar.closeButton.show();
}
}
private function onBattleUnload(param1:BattleInfoServiceEvent) : void {
lobbyLayoutService.removeEventListener(LobbyLayoutServiceEvent.END_LAYOUT_SWITCH,this.onEndLayoutSwitchInBattle);
if(this.shouldHideButton()) {
this.panel.buttonBar.closeButton.hide();
}
this.panel.buttonBar.closeButton.changeOnCloseButton();
}
private function onEndLayoutSwitchInBattle(param1:LobbyLayoutServiceEvent) : void {
if(param1.state == LayoutState.BATTLE) {
this.panel.buttonBar.closeButton.changeOnCloseButton();
} else {
this.panel.buttonBar.closeButton.changeOnBackButton();
}
}
private function lockMainPanel() : void {
this.panel.mouseEnabled = false;
this.panel.mouseChildren = false;
}
private function unlockMainPanel() : void {
this.panel.mouseEnabled = true;
this.panel.mouseChildren = true;
}
private function setButtonState(param1:LayoutState, param2:Boolean = true) : void {
if(param2) {
this.panel.buttonBar.battlesButton.selected = false;
this.panel.buttonBar.garageButton.selected = false;
}
switch(param1) {
case LayoutState.BATTLE:
this.panel.buttonBar.battlesButton.enable = true;
this.panel.buttonBar.garageButton.enable = true;
break;
case LayoutState.BATTLE_SELECT:
case LayoutState.MATCHMAKING:
this.panel.buttonBar.battlesButton.enable = false;
this.panel.buttonBar.garageButton.enable = true;
this.panel.buttonBar.clanButton.enable = true;
break;
case LayoutState.GARAGE:
this.panel.buttonBar.garageButton.enable = false;
this.panel.buttonBar.battlesButton.enable = true;
this.panel.buttonBar.clanButton.enable = true;
break;
case LayoutState.CLAN:
this.panel.buttonBar.clanButton.enable = false;
this.panel.buttonBar.battlesButton.enable = true;
this.panel.buttonBar.garageButton.enable = true;
}
}
private function shouldHideButton() : Boolean {
return Boolean(partnerService.isRunningInsidePartnerEnvironment()) && !StartupSettings.isDesktop;
}
}
}
|
package controls.resultassets {
import assets.resultwindow.bres_BG_BLUE_PIXEL;
import assets.resultwindow.bres_BG_BLUE_TL;
public class ResultWindowBlue extends ResultWindowBase {
public function ResultWindowBlue() {
super();
tl = new bres_BG_BLUE_TL(1,1);
px = new bres_BG_BLUE_PIXEL(1,1);
}
}
}
|
package alternativa.tanks.view.battleinfo.renderer {
import controls.cellrenderer.ButtonState;
public class BattleInfoRedUserListRenderer extends BattleInfoUserListRenderer {
private var style:ButtonState = new CellRed();
public function BattleInfoRedUserListRenderer() {
super();
}
override public function getCurrentStyle() : ButtonState {
return this.style;
}
}
}
|
package platform.client.fp10.core.resource.types {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Loader;
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLLoaderDataFormat;
import flash.net.URLRequest;
import flash.utils.ByteArray;
import mx.graphics.codec.PNGEncoder;
import platform.client.fp10.core.resource.IResourceLoadingListener;
import platform.client.fp10.core.resource.IResourceSerializationListener;
import platform.client.fp10.core.resource.Resource;
import platform.client.fp10.core.resource.ResourceFlags;
import platform.client.fp10.core.resource.ResourceInfo;
import platform.client.fp10.core.resource.SafeURLLoader;
import platform.client.fp10.core.service.localstorage.IResourceLocalStorage;
public class ImageResource extends Resource {
[Inject]
public static var resourceLocalStorage:IResourceLocalStorage;
private static const IMAGE_FILE:String = "image.tnk";
private static const BINARY_VERSION:int = 1;
private var loader:SafeURLLoader;
private var _data:BitmapData;
public function ImageResource(param1:ResourceInfo) {
super(param1);
}
public function get data() : BitmapData {
return this._data;
}
override public function get description() : String {
return "Image";
}
override public function loadBytes(param1:ByteArray, param2:IResourceLoadingListener) : Boolean {
if(param1.bytesAvailable < 2 || param1.readByte() != BINARY_VERSION) {
return false;
}
this.listener = param2;
var local3:int = param1.readInt();
var local4:ByteArray = new ByteArray();
param1.readBytes(local4,param1.position,local3);
this.loadImage(param1);
return true;
}
override public function serialize(param1:IResourceSerializationListener) : void {
var local2:ByteArray = new ByteArray();
local2.writeByte(BINARY_VERSION);
var local3:ByteArray = new PNGEncoder().encode(this._data);
local2.writeInt(local3.length);
local2.writeBytes(local3);
param1.onSerializationComplete(this,local2);
}
override public function load(param1:String, param2:IResourceLoadingListener) : void {
super.load(param1,param2);
this.loadImageBytes();
}
override protected function doReload() : void {
this.loader.close();
this.loadImageBytes();
}
override protected function createDummyData() : Boolean {
this._data = new StubBitmapData(16711680);
return true;
}
protected function getImageFileName() : String {
return IMAGE_FILE;
}
private function loadImageBytes() : void {
this.loader = this.createLoader();
this.loader.load(new URLRequest(baseUrl + this.getImageFileName()));
startTimeoutTracking();
status = "Image requested";
}
private function onLoadingComplete(param1:Event) : void {
stopTimeoutTracking();
this.loadImage(param1.target.data);
}
private function loadImage(param1:ByteArray) : void {
var local2:Loader = new Loader();
local2.contentLoaderInfo.addEventListener(Event.COMPLETE,this.completeLoadImage);
local2.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadingError);
local2.loadBytes(param1);
}
private function completeLoadImage(param1:Event) : void {
this._data = Bitmap(param1.target.content).bitmapData;
this.completeLoading();
}
override protected function completeLoading() : void {
super.completeLoading();
this.loader = null;
baseUrl = null;
}
private function onLoadingOpen(param1:Event) : void {
updateLastActivityTime();
listener.onResourceLoadingStart(this);
}
private function onLoadingError(param1:ErrorEvent) : void {
stopTimeoutTracking();
this._data = new StubBitmapData(16711680);
setFlags(ResourceFlags.LOADED);
baseUrl = null;
listener.onResourceLoadingError(this,param1.toString());
}
private function onLoadingProgress(param1:ProgressEvent) : void {
updateLastActivityTime();
}
private function createLoader() : SafeURLLoader {
var local1:SafeURLLoader = new SafeURLLoader();
local1.dataFormat = URLLoaderDataFormat.BINARY;
local1.addEventListener(Event.OPEN,this.onLoadingOpen);
local1.addEventListener(ProgressEvent.PROGRESS,this.onLoadingProgress);
local1.addEventListener(Event.COMPLETE,this.onLoadingComplete);
local1.addEventListener(IOErrorEvent.IO_ERROR,this.onLoadingError);
local1.addEventListener(SecurityErrorEvent.SECURITY_ERROR,this.onLoadingError);
return local1;
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.common.stream {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.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;
import projects.tanks.client.battlefield.models.tankparts.weapons.common.TargetPosition;
import projects.tanks.client.battlefield.types.Vector3d;
public class StreamWeaponCommunicationModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _startFireId:Long = Long.getLong(1600977732,-1971270444);
private var _startFire_clientTimeCodec:ICodec;
private var _stopFireId:Long = Long.getLong(779639549,-508617372);
private var _stopFire_clientTimeCodec:ICodec;
private var _updateTargetsId:Long = Long.getLong(1983735305,-731019411);
private var _updateTargets_clientTimeCodec:ICodec;
private var _updateTargets_directionCodec:ICodec;
private var _updateTargets_targetsCodec:ICodec;
private var _updateTargetsDummyId:Long = Long.getLong(116946402,65284411);
private var _updateTargetsDummy_clientTimeCodec:ICodec;
private var _updateTargetsDummy_directionCodec:ICodec;
private var model:IModel;
public function StreamWeaponCommunicationModelServer(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._startFire_clientTimeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._stopFire_clientTimeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._updateTargets_clientTimeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._updateTargets_directionCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._updateTargets_targetsCodec = this.protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(TargetPosition,false),false,1));
this._updateTargetsDummy_clientTimeCodec = this.protocol.getCodec(new TypeCodecInfo(int,false));
this._updateTargetsDummy_directionCodec = this.protocol.getCodec(new TypeCodecInfo(Vector3d,false));
}
public function startFire(param1:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._startFire_clientTimeCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._startFireId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function stopFire(param1:int) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._stopFire_clientTimeCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._stopFireId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function updateTargets(param1:int, param2:Vector3d, param3:Vector.<TargetPosition>) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._updateTargets_clientTimeCodec.encode(this.protocolBuffer,param1);
this._updateTargets_directionCodec.encode(this.protocolBuffer,param2);
this._updateTargets_targetsCodec.encode(this.protocolBuffer,param3);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local4:SpaceCommand = new SpaceCommand(Model.object.id,this._updateTargetsId,this.protocolBuffer);
var local5:IGameObject = Model.object;
var local6:ISpace = local5.space;
local6.commandSender.sendCommand(local4);
this.protocolBuffer.optionalMap.clear();
}
public function updateTargetsDummy(param1:int, param2:Vector3d) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._updateTargetsDummy_clientTimeCodec.encode(this.protocolBuffer,param1);
this._updateTargetsDummy_directionCodec.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._updateTargetsDummyId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.gui.shop.shopitems.item.crystalitem {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.shop.shopitems.item.crystalitem.CrystalPackageItemIcons_premiumClass.png")]
public class CrystalPackageItemIcons_premiumClass extends BitmapAsset {
public function CrystalPackageItemIcons_premiumClass() {
super();
}
}
}
|
package projects.tanks.client.chat.models.chat.chat {
import projects.tanks.client.users.services.chatmoderator.ChatModeratorLevel;
public class ChatCC {
private var _admin:Boolean;
private var _antifloodEnabled:Boolean;
private var _bufferSize:int;
private var _channels:Vector.<String>;
private var _chatEnabled:Boolean;
private var _chatModeratorLevel:ChatModeratorLevel;
private var _linksWhiteList:Vector.<String>;
private var _minChar:int;
private var _minWord:int;
private var _privateMessagesEnabled:Boolean;
private var _selfName:String;
private var _showLinks:Boolean;
private var _typingSpeedAntifloodEnabled:Boolean;
public function ChatCC(param1:Boolean = false, param2:Boolean = false, param3:int = 0, param4:Vector.<String> = null, param5:Boolean = false, param6:ChatModeratorLevel = null, param7:Vector.<String> = null, param8:int = 0, param9:int = 0, param10:Boolean = false, param11:String = null, param12:Boolean = false, param13:Boolean = false) {
super();
this._admin = param1;
this._antifloodEnabled = param2;
this._bufferSize = param3;
this._channels = param4;
this._chatEnabled = param5;
this._chatModeratorLevel = param6;
this._linksWhiteList = param7;
this._minChar = param8;
this._minWord = param9;
this._privateMessagesEnabled = param10;
this._selfName = param11;
this._showLinks = param12;
this._typingSpeedAntifloodEnabled = param13;
}
public function get admin() : Boolean {
return this._admin;
}
public function set admin(param1:Boolean) : void {
this._admin = param1;
}
public function get antifloodEnabled() : Boolean {
return this._antifloodEnabled;
}
public function set antifloodEnabled(param1:Boolean) : void {
this._antifloodEnabled = param1;
}
public function get bufferSize() : int {
return this._bufferSize;
}
public function set bufferSize(param1:int) : void {
this._bufferSize = param1;
}
public function get channels() : Vector.<String> {
return this._channels;
}
public function set channels(param1:Vector.<String>) : void {
this._channels = param1;
}
public function get chatEnabled() : Boolean {
return this._chatEnabled;
}
public function set chatEnabled(param1:Boolean) : void {
this._chatEnabled = param1;
}
public function get chatModeratorLevel() : ChatModeratorLevel {
return this._chatModeratorLevel;
}
public function set chatModeratorLevel(param1:ChatModeratorLevel) : void {
this._chatModeratorLevel = param1;
}
public function get linksWhiteList() : Vector.<String> {
return this._linksWhiteList;
}
public function set linksWhiteList(param1:Vector.<String>) : void {
this._linksWhiteList = param1;
}
public function get minChar() : int {
return this._minChar;
}
public function set minChar(param1:int) : void {
this._minChar = param1;
}
public function get minWord() : int {
return this._minWord;
}
public function set minWord(param1:int) : void {
this._minWord = param1;
}
public function get privateMessagesEnabled() : Boolean {
return this._privateMessagesEnabled;
}
public function set privateMessagesEnabled(param1:Boolean) : void {
this._privateMessagesEnabled = param1;
}
public function get selfName() : String {
return this._selfName;
}
public function set selfName(param1:String) : void {
this._selfName = param1;
}
public function get showLinks() : Boolean {
return this._showLinks;
}
public function set showLinks(param1:Boolean) : void {
this._showLinks = param1;
}
public function get typingSpeedAntifloodEnabled() : Boolean {
return this._typingSpeedAntifloodEnabled;
}
public function set typingSpeedAntifloodEnabled(param1:Boolean) : void {
this._typingSpeedAntifloodEnabled = param1;
}
public function toString() : String {
var local1:String = "ChatCC [";
local1 += "admin = " + this.admin + " ";
local1 += "antifloodEnabled = " + this.antifloodEnabled + " ";
local1 += "bufferSize = " + this.bufferSize + " ";
local1 += "channels = " + this.channels + " ";
local1 += "chatEnabled = " + this.chatEnabled + " ";
local1 += "chatModeratorLevel = " + this.chatModeratorLevel + " ";
local1 += "linksWhiteList = " + this.linksWhiteList + " ";
local1 += "minChar = " + this.minChar + " ";
local1 += "minWord = " + this.minWord + " ";
local1 += "privateMessagesEnabled = " + this.privateMessagesEnabled + " ";
local1 += "selfName = " + this.selfName + " ";
local1 += "showLinks = " + this.showLinks + " ";
local1 += "typingSpeedAntifloodEnabled = " + this.typingSpeedAntifloodEnabled + " ";
return local1 + "]";
}
}
}
|
package platform.client.fp10.core.network.connection {
import flash.utils.ByteArray;
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
public interface IProtectionContext {
function wrap(param1:IDataOutput, param2:ByteArray) : void;
function unwrap(param1:ByteArray, param2:IDataInput) : void;
function reset() : void;
}
}
|
package _codec.projects.tanks.client.battleselect.model.battle.param {
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.battleselect.model.battle.param.BattleParamInfoCC;
public class VectorCodecBattleParamInfoCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecBattleParamInfoCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(BattleParamInfoCC,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.<BattleParamInfoCC> = new Vector.<BattleParamInfoCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = BattleParamInfoCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:BattleParamInfoCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<BattleParamInfoCC> = Vector.<BattleParamInfoCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.clients.fp10.TanksLauncherErrorScreen {
import flash.display.BitmapData;
import flash.display.Shape;
import flash.display.Sprite;
public class TankBackground extends Sprite {
private static const bitmapBg:Class = TankBackground_bitmapBg;
private var bgBitmap:BitmapData = new bitmapBg().bitmapData;
private var bg:Shape;
public function TankBackground() {
super();
this.bg = new Shape();
addChild(this.bg);
}
public function redraw(stageWidth:int, stageHeight:int) : void {
this.bg.graphics.clear();
this.bg.graphics.beginBitmapFill(this.bgBitmap);
this.bg.graphics.drawRect(0,0,stageWidth,stageHeight);
}
}
}
|
package alternativa.tanks.models.battle.battlefield.mine {
import alternativa.math.Matrix3;
import alternativa.math.Vector3;
import alternativa.osgi.service.console.variables.ConsoleVarFloat;
import alternativa.osgi.service.console.variables.ConsoleVarInt;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.camera.ICameraStateModifier;
import alternativa.tanks.camera.IFollowCameraController;
public class MineExplosionCameraEffect implements ICameraStateModifier {
private static var amplitude:ConsoleVarFloat;
private static var yawAmplitude:ConsoleVarFloat;
private static var rollAmplitude:ConsoleVarFloat;
private static var duration:ConsoleVarInt;
private static var m1:Matrix3 = new Matrix3();
private static var m2:Matrix3 = new Matrix3();
private static var axis:Vector3 = new Vector3();
private var sign:int;
private var time:int;
private var tank:Tank;
public function MineExplosionCameraEffect() {
super();
}
public static function initVars() : void {
amplitude = new ConsoleVarFloat("minecam_ampl",0,-10000,10000);
yawAmplitude = new ConsoleVarFloat("minecam_yaw",-0.02,-10,10);
rollAmplitude = new ConsoleVarFloat("minecam_roll",0.03,-10,10);
duration = new ConsoleVarInt("minecam_time",800,0,10000);
}
public function update(param1:int, param2:int, param3:Vector3, param4:Vector3) : Boolean {
if(param1 - this.time > duration.value) {
return false;
}
return true;
}
public function onAddedToController(param1:IFollowCameraController) : void {
}
public function destroy() : void {
}
}
}
|
package alternativa.tanks.model.entrancealert {
import alternativa.tanks.gui.EntranceAlertWindow;
import platform.client.fp10.core.resource.types.LocalizedImageResource;
import projects.tanks.client.panel.model.alerts.entrancealert.EntranceAlertModelBase;
import projects.tanks.client.panel.model.alerts.entrancealert.IEntranceAlertModelBase;
[ModelInfo]
public class EntranceAlertModel extends EntranceAlertModelBase implements IEntranceAlertModelBase {
public function EntranceAlertModel() {
super();
}
public function showAlert(param1:LocalizedImageResource, param2:String, param3:String) : void {
new EntranceAlertWindow(param1,param2,param3);
}
}
}
|
package projects.tanks.client.battlefield.models.battle.cp {
public class ControlPointState {
public static const RED:ControlPointState = new ControlPointState(0,"RED");
public static const BLUE:ControlPointState = new ControlPointState(1,"BLUE");
public static const NEUTRAL:ControlPointState = new ControlPointState(2,"NEUTRAL");
private var _value:int;
private var _name:String;
public function ControlPointState(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<ControlPointState> {
var local1:Vector.<ControlPointState> = new Vector.<ControlPointState>();
local1.push(RED);
local1.push(BLUE);
local1.push(NEUTRAL);
return local1;
}
public function toString() : String {
return "ControlPointState [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package projects.tanks.client.garage.models.shopabonement {
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 ShopAbonementModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ShopAbonementModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.controller.events {
import flash.events.Event;
public class PartnersEvent extends Event {
public static const START_REGISTRATION:String = "PartnersEvent.START_REGISTRATION";
public static const START_LOGIN:String = "PartnersEvent.START_LOGIN";
public function PartnersEvent(param1:String) {
super(param1);
}
override public function clone() : Event {
return new PartnersEvent(this.type);
}
}
}
|
package alternativa.engine3d.core {
public class MipMapping {
public static const NONE:int = 0;
public static const OBJECT_DISTANCE:int = 1;
public static const PER_PIXEL:int = 2;
public function MipMapping() {
super();
}
}
}
|
package alternativa.tanks.model.item.premium {
import projects.tanks.client.garage.models.item.premium.IPremiumItemModelBase;
import projects.tanks.client.garage.models.item.premium.PremiumItemModelBase;
[ModelInfo]
public class PremiumItemModel extends PremiumItemModelBase implements IPremiumItemModelBase, PremiumItem {
public function PremiumItemModel() {
super();
}
public function isPremiumItem() : Boolean {
return getInitParam().premiumItem;
}
}
}
|
package _codec.projects.tanks.client.panel.model.quest {
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.quest.QuestTypeEnum;
public class VectorCodecQuestTypeEnumLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecQuestTypeEnumLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(QuestTypeEnum,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.<QuestTypeEnum> = new Vector.<QuestTypeEnum>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = QuestTypeEnum(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:QuestTypeEnum = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<QuestTypeEnum> = Vector.<QuestTypeEnum>(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.battle.objects.tank.controllers {
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.utils.BitMask;
import alternativa.tanks.utils.MathUtils;
import platform.client.fp10.core.type.AutoClosable;
public class ChassisController implements AutoClosable {
public static const BIT_FORWARD:int = 0;
public static const BIT_BACK:int = 1;
public static const BIT_LEFT:int = 2;
public static const BIT_RIGHT:int = 3;
public static const BIT_REVERSE_TURN:int = 4;
protected var controlState:int;
protected var turnSpeedNumber:int;
protected var appliedControlState:int;
private var tank:Tank;
private var lockMask:BitMask = new BitMask();
protected var listener:ChassisControlListener;
public function ChassisController(param1:Tank, param2:ChassisControlListener) {
super();
this.tank = param1;
this.listener = param2;
}
private function isNotLocked() : Boolean {
return this.lockMask.isEmpty();
}
public function lock(param1:int) : void {
var local2:Boolean = this.isNotLocked();
this.lockMask.setBits(param1);
if(local2 && !this.isNotLocked()) {
this.applyControlState(0,0);
}
}
public function unlock(param1:int) : void {
var local2:Boolean = this.isNotLocked();
this.lockMask.clearBits(param1);
if(this.isNotLocked() && !local2) {
this.applyControlState(this.controlState,this.turnSpeedNumber);
}
}
public function getControlState() : int {
return this.isNotLocked() ? this.controlState : 0;
}
public function setControlState(param1:int, param2:int) : void {
this.controlState = param1;
this.turnSpeedNumber = param2;
if(this.isNotLocked()) {
this.applyControlState(param1,param2);
}
}
private function applyControlState(param1:int, param2:int) : void {
var local3:int = this.appliedControlState;
this.appliedControlState = param1;
var local4:int = MathUtils.getBitValue(param1,BIT_FORWARD) - MathUtils.getBitValue(param1,BIT_BACK);
var local5:Number = MathUtils.getBitValue(param1,BIT_LEFT) - MathUtils.getBitValue(param1,BIT_RIGHT);
var local6:Boolean = MathUtils.getBitValue(param1,BIT_REVERSE_TURN) == 1;
this.tank.setMovementParams(local4,local5,param2,local6);
if(local3 != this.appliedControlState) {
this.onAppliedControlStateChanged(this.appliedControlState);
}
}
protected function onAppliedControlStateChanged(param1:int) : void {
this.listener.onChassisControlChanged(param1,false);
}
protected function getTank() : Tank {
return this.tank;
}
[Obfuscation(rename="false")]
public function close() : void {
this.tank = null;
}
}
}
|
package alternativa.tanks.models.tank {
public interface IWeaponController {
function activateWeapon() : void;
function deactivateWeapon() : void;
function lockWeapon(param1:int, param2:Boolean) : void;
function unlockWeapon(param1:int) : void;
}
}
|
package _codec.projects.tanks.client.panel.model.premiumaccount.alert {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import projects.tanks.client.panel.model.premiumaccount.alert.PremiumAccountAlertCC;
public class CodecPremiumAccountAlertCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_localRuntimeUser:ICodec;
private var codec_needShowNotificationCompletionPremium:ICodec;
private var codec_needShowWelcomeAlert:ICodec;
private var codec_reminderCompletionPremiumTime:ICodec;
private var codec_wasShowAlertForFirstPurchasePremium:ICodec;
private var codec_wasShowReminderCompletionPremium:ICodec;
public function CodecPremiumAccountAlertCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_localRuntimeUser = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_needShowNotificationCompletionPremium = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_needShowWelcomeAlert = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_reminderCompletionPremiumTime = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_wasShowAlertForFirstPurchasePremium = param1.getCodec(new TypeCodecInfo(Boolean,false));
this.codec_wasShowReminderCompletionPremium = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:PremiumAccountAlertCC = new PremiumAccountAlertCC();
local2.localRuntimeUser = this.codec_localRuntimeUser.decode(param1) as Boolean;
local2.needShowNotificationCompletionPremium = this.codec_needShowNotificationCompletionPremium.decode(param1) as Boolean;
local2.needShowWelcomeAlert = this.codec_needShowWelcomeAlert.decode(param1) as Boolean;
local2.reminderCompletionPremiumTime = this.codec_reminderCompletionPremiumTime.decode(param1) as Number;
local2.wasShowAlertForFirstPurchasePremium = this.codec_wasShowAlertForFirstPurchasePremium.decode(param1) as Boolean;
local2.wasShowReminderCompletionPremium = this.codec_wasShowReminderCompletionPremium.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:PremiumAccountAlertCC = PremiumAccountAlertCC(param2);
this.codec_localRuntimeUser.encode(param1,local3.localRuntimeUser);
this.codec_needShowNotificationCompletionPremium.encode(param1,local3.needShowNotificationCompletionPremium);
this.codec_needShowWelcomeAlert.encode(param1,local3.needShowWelcomeAlert);
this.codec_reminderCompletionPremiumTime.encode(param1,local3.reminderCompletionPremiumTime);
this.codec_wasShowAlertForFirstPurchasePremium.encode(param1,local3.wasShowAlertForFirstPurchasePremium);
this.codec_wasShowReminderCompletionPremium.encode(param1,local3.wasShowReminderCompletionPremium);
}
}
}
|
package alternativa.tanks.models.clan.info {
import flash.events.EventDispatcher;
public class ClanInfoDelayed extends EventDispatcher {
private static var _instance:ClanInfoDelayed;
public static const EVENT_PREFIX:String = "ClanInfoDelayed.";
public function ClanInfoDelayed() {
super();
if(_instance != null) {
throw new Error("More than one instance created!");
}
}
public static function getInstance() : ClanInfoDelayed {
if(_instance == null) {
_instance = new ClanInfoDelayed();
}
return _instance;
}
}
}
|
package controls {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.TankWindowInner_topRightClass.png")]
public class TankWindowInner_topRightClass extends BitmapAsset {
public function TankWindowInner_topRightClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.battle.battlefield.mine {
import alternativa.types.Long;
public interface IBattleMinesModelBase {
function activateMine(param1:Long) : void;
function explodeMine(param1:Long, param2:Long, param3:Boolean) : void;
function putMine(param1:Long, param2:Number, param3:Number, param4:Number, param5:Long) : void;
function removeAllMines(param1:Long) : void;
function removeMines(param1:Long, param2:Vector.<Long>) : void;
}
}
|
package _codec.projects.tanks.client.battlefield.models.battle.jgr.killstreak {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.SoundResource;
import projects.tanks.client.battlefield.models.battle.jgr.killstreak.KillStreakItem;
public class CodecKillStreakItem implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_count:ICodec;
private var codec_messageToBoss:ICodec;
private var codec_messageToVictims:ICodec;
private var codec_sound:ICodec;
public function CodecKillStreakItem() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_count = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_messageToBoss = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_messageToVictims = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_sound = param1.getCodec(new TypeCodecInfo(SoundResource,true));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:KillStreakItem = new KillStreakItem();
local2.count = this.codec_count.decode(param1) as int;
local2.messageToBoss = this.codec_messageToBoss.decode(param1) as String;
local2.messageToVictims = this.codec_messageToVictims.decode(param1) as String;
local2.sound = this.codec_sound.decode(param1) as SoundResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:KillStreakItem = KillStreakItem(param2);
this.codec_count.encode(param1,local3.count);
this.codec_messageToBoss.encode(param1,local3.messageToBoss);
this.codec_messageToVictims.encode(param1,local3.messageToVictims);
this.codec_sound.encode(param1,local3.sound);
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.messages {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.messages.ActionOutputLine_cpPointNeutralBlueIcon.png")]
public class ActionOutputLine_cpPointNeutralBlueIcon extends BitmapAsset {
public function ActionOutputLine_cpPointNeutralBlueIcon() {
super();
}
}
}
|
package alternativa.tanks.bonuses {
public class BonusConst {
public static const BONUS_HALF_SIZE:Number = 75;
public static const COS_ONE_DEGREE:Number = Math.cos(Math.PI / 180);
public static const PARACHUTE_OFFSET_Z:Number = 50;
public static const BONUS_OFFSET_Z:Number = 450;
public static const ANGULAR_SPEED_Z:Number = 0.1;
public static const BOUND_SPHERE_RADIUS:Number = Math.sqrt(2) * BONUS_HALF_SIZE * 1.6;
public function BonusConst() {
super();
}
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ItemInfoPanel_bitmapUpgradeTableCenter extends BitmapAsset
{
public function ItemInfoPanel_bitmapUpgradeTableCenter()
{
super();
}
}
}
|
package alternativa.tanks.physics {
public class CollisionGroup {
public static const TANK:int = 1;
public static const ACTIVE_TRACK:int = 2;
public static const INACTIVE_TRACK:int = 4;
public static const WEAPON:int = 8;
public static const STATIC:int = 16;
public static const BONUS_WITH_TANK:int = 64;
public function CollisionGroup() {
super();
}
}
}
|
package projects.tanks.client.battleselect.model.matchmaking.queue {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
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 MatchmakingQueueModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _registerId:Long = Long.getLong(383549676,-1867263584);
private var _register_modeCodec:ICodec;
private var _unregisterId:Long = Long.getLong(775927952,732992519);
private var model:IModel;
public function MatchmakingQueueModelServer(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._register_modeCodec = this.protocol.getCodec(new EnumCodecInfo(MatchmakingMode,false));
}
public function register(param1:MatchmakingMode) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._register_modeCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._registerId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function unregister() : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local1:SpaceCommand = new SpaceCommand(Model.object.id,this._unregisterId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.model.chat {
public interface ShowChat {
function setShowChat(param1:Boolean) : void;
}
}
|
package projects.tanks.client.panel.model.quest.daily.type.bonus {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class BonusCatchDailyQuestModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BonusCatchDailyQuestModelServer;
private var client:IBonusCatchDailyQuestModelBase = IBonusCatchDailyQuestModelBase(this);
private var modelId:Long = Long.getLong(170908502,1988359357);
public function BonusCatchDailyQuestModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BonusCatchDailyQuestModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes.terminal {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.panel.model.payment.modes.terminal.TerminalInstance;
public class CodecTerminalInstance implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_image:ICodec;
private var codec_url:ICodec;
public function CodecTerminalInstance() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_image = param1.getCodec(new TypeCodecInfo(ImageResource,false));
this.codec_url = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:TerminalInstance = new TerminalInstance();
local2.image = this.codec_image.decode(param1) as ImageResource;
local2.url = this.codec_url.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:TerminalInstance = TerminalInstance(param2);
this.codec_image.encode(param1,local3.image);
this.codec_url.encode(param1,local3.url);
}
}
}
|
package platform.clients.fp10.libraries.alternativapartners.type {
import platform.client.core.general.socialnetwork.types.LoginParameters;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IParametersListenerAdapt implements IParametersListener {
private var object:IGameObject;
private var impl:IParametersListener;
public function IParametersListenerAdapt(param1:IGameObject, param2:IParametersListener) {
super();
this.object = param1;
this.impl = param2;
}
public function onSetParameters(param1:LoginParameters) : void {
var parameters:LoginParameters = param1;
try {
Model.object = this.object;
this.impl.onSetParameters(parameters);
}
finally {
Model.popObject();
}
}
public function onFailSetParameters() : void {
try {
Model.object = this.object;
this.impl.onFailSetParameters();
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.models.tank.pause {
[ModelInterface]
public interface ITankPause {
function enablePause() : void;
function disablePause() : void;
function resetIdleKickTime() : void;
}
}
|
package _codec.projects.tanks.client.tanksservices.model.rankloader {
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.tanksservices.model.rankloader.RankLoaderCC;
public class VectorCodecRankLoaderCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRankLoaderCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(RankLoaderCC,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.<RankLoaderCC> = new Vector.<RankLoaderCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = RankLoaderCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:RankLoaderCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<RankLoaderCC> = Vector.<RankLoaderCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank07.png")]
public class PremiumRankBitmaps_bitmapBigRank07 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank07() {
super();
}
}
}
|
package alternativa.tanks.model.shop.items.crystallitem
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class CrystalPackageItemIcons_crystalBlueClass extends BitmapAsset
{
public function CrystalPackageItemIcons_crystalBlueClass()
{
super();
}
}
}
|
package controls.scroller.red {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.scroller.red.ScrollSkinRed_track.png")]
public class ScrollSkinRed_track extends BitmapAsset {
public function ScrollSkinRed_track() {
super();
}
}
}
|
package projects.tanks.client.panel.model.mobilequest.quest {
import alternativa.types.Long;
public class MobileQuestCC {
private var _countSteps:int;
private var _rewards:Vector.<MobileQuestReward>;
private var _skipStepShopItemId:Long;
public function MobileQuestCC(param1:int = 0, param2:Vector.<MobileQuestReward> = null, param3:Long = null) {
super();
this._countSteps = param1;
this._rewards = param2;
this._skipStepShopItemId = param3;
}
public function get countSteps() : int {
return this._countSteps;
}
public function set countSteps(param1:int) : void {
this._countSteps = param1;
}
public function get rewards() : Vector.<MobileQuestReward> {
return this._rewards;
}
public function set rewards(param1:Vector.<MobileQuestReward>) : void {
this._rewards = param1;
}
public function get skipStepShopItemId() : Long {
return this._skipStepShopItemId;
}
public function set skipStepShopItemId(param1:Long) : void {
this._skipStepShopItemId = param1;
}
public function toString() : String {
var local1:String = "MobileQuestCC [";
local1 += "countSteps = " + this.countSteps + " ";
local1 += "rewards = " + this.rewards + " ";
local1 += "skipStepShopItemId = " + this.skipStepShopItemId + " ";
return local1 + "]";
}
}
}
|
package alternativa.resource
{
import flash.display.BitmapData;
public class StubBitmapData extends BitmapData
{
private static const SIZE:int = 20;
public function StubBitmapData(color:uint)
{
super(SIZE,SIZE,false,0);
this.init(color);
}
private function init(color:uint) : void
{
var j:int = 0;
for(var i:int = 0; i < SIZE; i++)
{
for(j = 0; j < SIZE; j += 2)
{
setPixel(!!Boolean(i % 2) ? int(int(j)) : int(int(j + 1)),i,color);
}
}
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.terminator.sfx {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class TerminatorSFXModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:TerminatorSFXModelServer;
private var client:ITerminatorSFXModelBase = ITerminatorSFXModelBase(this);
private var modelId:Long = Long.getLong(1446106501,1517097209);
public function TerminatorSFXModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new TerminatorSFXModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(TerminatorSFXCC,false)));
}
protected function getInitParam() : TerminatorSFXCC {
return TerminatorSFXCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.garage.models.item.present {
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 PresentItemModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function PresentItemModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.models.weapon.snowman
{
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.physics.Body;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.service.IModelService;
import alternativa.tanks.models.battlefield.BattlefieldData;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.sfx.shoot.snowman.SnowmanSFXData;
import alternativa.tanks.models.sfx.shoot.snowman.SnowmanSFXModel;
import alternativa.tanks.models.tank.ITank;
import alternativa.tanks.models.tank.TankData;
import alternativa.tanks.models.tank.TankModel;
import alternativa.tanks.models.weapon.IWeaponController;
import alternativa.tanks.models.weapon.WeaponUtils;
import alternativa.tanks.models.weapon.common.HitInfo;
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapon.common.WeaponCommonModel;
import alternativa.tanks.models.weapon.shared.CommonTargetEvaluator;
import alternativa.tanks.models.weapon.shared.CommonTargetSystem;
import alternativa.tanks.models.weapon.shared.shot.ShotData;
import alternativa.tanks.models.weapon.weakening.IWeaponWeakeningModel;
import alternativa.tanks.physics.CollisionGroup;
import alternativa.tanks.physics.TanksCollisionDetector;
import com.alternativaplatform.projects.tanks.client.commons.types.Vector3d;
import com.reygazu.anticheat.variables.SecureInt;
import flash.utils.Dictionary;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
import scpacker.tanks.WeaponsManager;
public class SnowmanModel implements IObjectLoadListener, ISnowmanShotListener, IWeaponController
{
private var _triggerPressed:Boolean;
private var shotId:int;
private var activeShots:Dictionary;
private var localTankData:TankData;
private var localShotData:ShotData;
private var localWeaponCommonData:WeaponCommonData;
private var modelService:IModelService;
private var battlefieldModel:IBattleField;
private var tankModel:TankModel;
private var weaponCommonModel:WeaponCommonModel;
private var weaponWeakeningModel:IWeaponWeakeningModel;
private var targetSystem:CommonTargetSystem;
private var hitInfo:HitInfo;
private var weaponUtils:WeaponUtils;
private var nextReadyTime:SecureInt;
private var currentTime:SecureInt;
private var _dirToTarget:Vector3;
private var _barrelOrigin:Vector3;
private var _gunDirGlobal:Vector3;
private var _xAxis:Vector3;
private var _hitPosGlobal:Vector3;
private var _hitPosLocal:Vector3;
private var _muzzlePosGlobal:Vector3;
private var _hitPos:Vector3;
private var _hitPos3d:Vector3d;
private var _tankPos3d:Vector3d;
private var _dirToTarget3d:Vector3d;
private var intersection:RayIntersection;
private var targetEvaluator:CommonTargetEvaluator;
private var maxTargetingDistance:Number = 100000;
public function SnowmanModel()
{
this.activeShots = new Dictionary();
this.hitInfo = new HitInfo();
this.weaponUtils = WeaponUtils.getInstance();
this.nextReadyTime = new SecureInt("twins nextReadyTime");
this.currentTime = new SecureInt("twins currentTime");
this._dirToTarget = new Vector3();
this._barrelOrigin = new Vector3();
this._gunDirGlobal = new Vector3();
this._xAxis = new Vector3();
this._hitPosGlobal = new Vector3();
this._hitPosLocal = new Vector3();
this._muzzlePosGlobal = new Vector3();
this._hitPos = new Vector3();
this._hitPos3d = new Vector3d(0,0,0);
this._tankPos3d = new Vector3d(0,0,0);
this._dirToTarget3d = new Vector3d(0,0,0);
this.intersection = new RayIntersection();
super();
}
public function objectLoaded(clientObject:ClientObject) : void
{
this.cacheInterfaces();
}
public function objectUnloaded(clientObject:ClientObject) : void
{
var playerShots:Dictionary = null;
var shot:SnowmanShot = null;
for each(playerShots in this.activeShots)
{
for each(shot in playerShots)
{
shot.kill();
}
}
this.activeShots = new Dictionary();
}
public function initObject(clientObject:ClientObject, chargeRadius:Number, distance:Number, speed:Number) : void
{
var data:SnowmanGunData = new SnowmanGunData();
data.shotSpeed = speed * 100;
data.shotRange = distance * 100;
data.shotRadius = chargeRadius * 100;
clientObject.putParams(SnowmanModel,data);
}
public function fire(clientObject:ClientObject, firingTankId:String, shotId:int, dirToTarget:Vector3d) : void
{
var firingTankObject:ClientObject = null;
var firingTankData:TankData = null;
var commonData:WeaponCommonData = null;
this.objectLoaded(null);
try
{
firingTankObject = BattleController.activeTanks[firingTankId];
if(firingTankObject == null)
{
return;
}
if(this.tankModel.localUserData != null)
{
if(firingTankId == this.tankModel.localUserData.user.id)
{
return;
}
}
firingTankData = this.tankModel.getTankData(firingTankObject);
if(firingTankData.tank == null)
{
return;
}
commonData = this.weaponCommonModel.getCommonData(firingTankData.turret);
this.weaponUtils.calculateGunParamsAux(firingTankData.tank.skin.turretMesh,commonData.muzzles[0],this._muzzlePosGlobal,this._gunDirGlobal);
this.weaponCommonModel.createShotEffects(firingTankData.turret,firingTankData.tank,0,this._muzzlePosGlobal,this._gunDirGlobal);
if(shotId > -1)
{
this._dirToTarget.x = dirToTarget.x;
this._dirToTarget.y = dirToTarget.y;
this._dirToTarget.z = dirToTarget.z;
this.createShot(false,shotId,firingTankData,this._muzzlePosGlobal,this._dirToTarget);
}
}
catch(e:Error)
{
}
}
public function hit(clientObject:ClientObject, firingTankId:String, shotId:int, affectedPoint:Vector3d, affectedTankId:String, weakeningCoeff:Number) : void
{
var firingTankData:TankData = null;
var shot:SnowmanShot = null;
var affectedTankObject:ClientObject = null;
var affectedTankData:TankData = null;
var commonData:WeaponCommonData = null;
var firingTankObject:ClientObject = BattleController.activeTanks[firingTankId];
if(firingTankObject == null || this.tankModel == null)
{
return;
}
try
{
firingTankData = this.tankModel.getTankData(firingTankObject);
}
catch(e:Error)
{
return;
}
if(firingTankData.tank == null)
{
return;
}
var tankShots:Dictionary = this.activeShots[firingTankId];
if(tankShots != null)
{
shot = tankShots[shotId];
if(shot != null)
{
this.removeShot(shot);
shot.kill();
}
}
if(affectedPoint == null || isNaN(affectedPoint.x) || isNaN(affectedPoint.y))
{
return;
}
this._hitPos.x = affectedPoint.x;
this._hitPos.y = affectedPoint.y;
this._hitPos.z = affectedPoint.z;
if(affectedTankId != null)
{
affectedTankObject = BattleController.activeTanks[affectedTankId];
if(affectedTankObject == null)
{
return;
}
affectedTankData = this.tankModel.getTankData(affectedTankObject);
if(affectedTankData.tank == null)
{
return;
}
this.weaponCommonModel.createExplosionEffects(firingTankData.turret,this.battlefieldModel.getBattlefieldData().viewport.camera,true,this._hitPos,this._gunDirGlobal,affectedTankData,weakeningCoeff);
commonData = this.weaponCommonModel.getCommonData(firingTankData.turret);
this.battlefieldModel.tankHit(affectedTankData,this._gunDirGlobal,weakeningCoeff * commonData.impactCoeff);
}
else
{
this.weaponCommonModel.createExplosionEffects(firingTankData.turret,this.battlefieldModel.getBattlefieldData().viewport.camera,false,this._hitPos,null,null,weakeningCoeff);
}
}
public function setLocalUser(localUserData:TankData) : void
{
this.objectLoaded(null);
this.localTankData = localUserData;
this.localShotData = WeaponsManager.shotDatas[localUserData.turret.id];
this.localWeaponCommonData = this.weaponCommonModel.getCommonData(localUserData.turret);
this.targetEvaluator = CommonTargetEvaluator.create(this.localTankData,this.localShotData,this.battlefieldModel,this.weaponWeakeningModel,this.modelService);
this.targetSystem = new CommonTargetSystem(this.maxTargetingDistance,this.localShotData.autoAimingAngleUp.value,this.localShotData.numRaysUp.value,this.localShotData.autoAimingAngleDown.value,this.localShotData.numRaysDown.value,this.battlefieldModel.getBattlefieldData().collisionDetector,this.targetEvaluator);
}
public function clearLocalUser() : void
{
this.localTankData = null;
this.localShotData = null;
this.localWeaponCommonData = null;
this.targetSystem = null;
this.targetEvaluator = null;
}
public function update(time:int, deltaTime:int) : Number
{
this.currentTime.value = time;
if(!this._triggerPressed || this.currentTime.value < this.nextReadyTime.value)
{
if(this.currentTime.value < this.nextReadyTime.value)
{
return 1 + (this.currentTime.value - this.nextReadyTime.value) / this.localShotData.reloadMsec.value;
}
return 1;
}
this.nextReadyTime.value = this.currentTime.value + this.localShotData.reloadMsec.value;
var bfData:BattlefieldData = this.battlefieldModel.getBattlefieldData();
var collisionDetector:TanksCollisionDetector = TanksCollisionDetector(bfData.physicsScene.collisionDetector);
var muzzlePosLocal:Vector3 = this.localWeaponCommonData.muzzles[0];
this.weaponUtils.calculateGunParams(this.localTankData.tank.skin.turretMesh,muzzlePosLocal,this._muzzlePosGlobal,this._barrelOrigin,this._xAxis,this._gunDirGlobal);
var canFire:Boolean = !collisionDetector.intersectRay(this._barrelOrigin,this._gunDirGlobal,CollisionGroup.STATIC,muzzlePosLocal.y,null,this.intersection);
this.weaponCommonModel.createShotEffects(this.localTankData.turret,this.localTankData.tank,this.localWeaponCommonData.currBarrel,this._muzzlePosGlobal,this._gunDirGlobal);
var realShotId:int = -1;
if(canFire)
{
if(this.targetSystem.getTarget(this._muzzlePosGlobal,this._gunDirGlobal,this._xAxis,this.localTankData.tank,this.hitInfo))
{
this._dirToTarget.vCopy(this.hitInfo.direction);
}
else
{
this._dirToTarget.vCopy(this._gunDirGlobal);
}
this._dirToTarget3d.x = this._dirToTarget.x;
this._dirToTarget3d.y = this._dirToTarget.y;
this._dirToTarget3d.z = this._dirToTarget.z;
realShotId = this.shotId;
this.createShot(true,this.shotId,this.localTankData,this._muzzlePosGlobal,this._dirToTarget);
++this.shotId;
}
this.fireCommand(this.localTankData.turret,this.localWeaponCommonData.currBarrel,realShotId,this._dirToTarget3d);
this.localWeaponCommonData.currBarrel = 0;
return 0;
}
private function fireCommand(turr:ClientObject, currBarrel:int, realShotId:int, _dirToTarget3d:Vector3d) : void
{
var js:Object = new Object();
js.realShotId = realShotId;
js.dirToTarget = _dirToTarget3d;
js.reloadTime = this.localShotData.reloadMsec.value;
Network(Main.osgi.getService(INetworker)).send("battle;start_fire;" + JSON.stringify(js));
}
public function activateWeapon(time:int) : void
{
this._triggerPressed = true;
}
public function deactivateWeapon(time:int, sendServerCommand:Boolean) : void
{
this._triggerPressed = false;
}
public function reset() : void
{
this._triggerPressed = false;
this.nextReadyTime.value = 0;
}
public function stopEffects(tankData:TankData) : void
{
}
public function snowShotDissolved(shot:SnowmanShot) : void
{
this.removeShot(shot);
}
public function snowShotHit(shot:SnowmanShot, hitPoint:Vector3, hitDir:Vector3, body:Body) : void
{
var key:* = undefined;
var td:* = null;
var v:Vector3 = null;
this.removeShot(shot);
var affectedTankData:TankData = null;
if(body != null)
{
for(td in this.battlefieldModel.getBattlefieldData().activeTanks)
{
if(body == td.tank)
{
this._hitPosGlobal.vDiff(hitPoint,body.state.pos);
body.baseMatrix.transformVectorInverse(this._hitPosGlobal,this._hitPosLocal);
this._hitPos3d.x = this._hitPosLocal.x;
this._hitPos3d.y = this._hitPosLocal.y;
this._hitPos3d.z = this._hitPosLocal.z;
affectedTankData = td;
break;
}
}
}
else
{
this._hitPos3d.x = hitPoint.x;
this._hitPos3d.y = hitPoint.y;
this._hitPos3d.z = hitPoint.z;
}
var distance:Number = 0.01 * shot.totalDistance;
var weakeingCoeff:Number = this.weaponWeakeningModel.getImpactCoeff(shot.shooterData.turret,distance);
this.weaponCommonModel.createExplosionEffects(shot.shooterData.turret,this.battlefieldModel.getBattlefieldData().viewport.camera,false,hitPoint,hitDir,affectedTankData,weakeingCoeff);
if(affectedTankData != null)
{
v = affectedTankData.tank.state.pos;
this._tankPos3d.x = v.x;
this._tankPos3d.y = v.y;
this._tankPos3d.z = v.z;
this.hitCommand(shot.shooterData.turret,shot.shotId,this._hitPos3d,affectedTankData.user.id,affectedTankData.incarnation,this._tankPos3d,distance);
}
else
{
this.hitCommand(shot.shooterData.turret,shot.shotId,this._hitPos3d,null,-1,null,distance);
}
}
private function hitCommand(turrObj:ClientObject, shotId:int, hitPos:Vector3d, affectedTankId:String, incr:int, tankPos:Vector3d, distance:int) : void
{
var js:Object = new Object();
js.shotId = shotId;
js.hitPos = hitPos;
js.victimId = affectedTankId;
js.incr = incr;
js.tankPos = tankPos;
js.distance = distance;
js.reloadTime = this.localShotData.reloadMsec.value;
Network(Main.osgi.getService(INetworker)).send("battle;fire;" + JSON.stringify(js));
}
private function getWeaponData(clientObject:ClientObject) : SnowmanGunData
{
return clientObject.getParams(SnowmanModel) as SnowmanGunData;
}
private function removeShot(shot:SnowmanShot) : void
{
var tankShots:Dictionary = this.activeShots[shot.shooterData.user.id];
if(tankShots != null)
{
delete tankShots[shot.shotId];
}
}
private function createShot(active:Boolean, shotId:int, tankData:TankData, muzzleGlobalPos:Vector3, dirToTarget:Vector3) : void
{
var data:SnowmanGunData = this.getWeaponData(tankData.turret);
var tankShots:Dictionary = this.activeShots[tankData.user.id];
if(tankShots == null)
{
this.activeShots[tankData.user.id] = tankShots = new Dictionary();
}
var bfData:BattlefieldData = this.battlefieldModel.getBattlefieldData();
var plasmaShootSfx:SnowmanSFXModel = WeaponsManager.getSnowmanSFX(WeaponsManager.getObjectFor(tankData.turret.id));
var plasmaData:SnowmanSFXData = plasmaShootSfx.getSnowmanSFXData(tankData.turret);
var shot:SnowmanShot = SnowmanShot.getShot();
shot.init(shotId,active,data,muzzleGlobalPos,dirToTarget,tankData,this,plasmaData,bfData.physicsScene.collisionDetector,this.weaponWeakeningModel);
tankShots[shotId] = shot;
this.battlefieldModel.addGraphicEffect(shot);
}
private function cacheInterfaces() : void
{
if(this.modelService == null)
{
this.modelService = IModelService(Main.osgi.getService(IModelService));
this.battlefieldModel = IBattleField(this.modelService.getModelsByInterface(IBattleField)[0]);
this.tankModel = Main.osgi.getService(ITank) as TankModel;
this.weaponCommonModel = Main.osgi.getService(IWeaponCommonModel) as WeaponCommonModel;
this.weaponWeakeningModel = IWeaponWeakeningModel(this.modelService.getModelsByInterface(IWeaponWeakeningModel)[0]);
}
}
}
}
|
package projects.tanks.client.partners.osgi {
import _codec.projects.tanks.client.partners.impl.asiasoft.CodecAsiasoftLoginCC;
import _codec.projects.tanks.client.partners.impl.asiasoft.VectorCodecAsiasoftLoginCCLevel1;
import _codec.projects.tanks.client.partners.impl.odnoklassniki.CodecOdnoklassnikiUrlParams;
import _codec.projects.tanks.client.partners.impl.odnoklassniki.VectorCodecOdnoklassnikiUrlParamsLevel1;
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.client.partners.impl.asiasoft.AsiasoftLoginCC;
import projects.tanks.client.partners.impl.odnoklassniki.OdnoklassnikiUrlParams;
public class Activator implements IBundleActivator {
public static var osgi:OSGi;
public function Activator() {
super();
}
public function start(param1:OSGi) : void {
var local4:ICodec = null;
osgi = param1;
var local2:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local2.register(Long.getLong(207007060,1485489233),Long.getLong(341705782,434846708));
local2.register(Long.getLong(207007060,1485489233),Long.getLong(1221568909,812989734));
local2.register(Long.getLong(1386392731,192355220),Long.getLong(890493454,-1969693338));
local2.register(Long.getLong(1386392731,192355220),Long.getLong(710462738,-568001163));
local2.register(Long.getLong(1051840655,1324649819),Long.getLong(344321414,-2112933510));
local2.register(Long.getLong(698539894,1283037116),Long.getLong(10593173,209532726));
local2.register(Long.getLong(1215969521,1635618100),Long.getLong(885983582,663395758));
local2.register(Long.getLong(588118997,-1972708299),Long.getLong(418477357,1914357093));
local2.register(Long.getLong(922991279,696481140),Long.getLong(1973287099,901106954));
local2.register(Long.getLong(1273864280,-1855777834),Long.getLong(801007651,-1207089136));
local2.register(Long.getLong(723546009,-53480122),Long.getLong(47453348,912731532));
local2.register(Long.getLong(982237961,270527442),Long.getLong(780155353,1879122584));
var local3:IProtocol = IProtocol(osgi.getService(IProtocol));
local4 = new CodecAsiasoftLoginCC();
local3.registerCodec(new TypeCodecInfo(AsiasoftLoginCC,false),local4);
local3.registerCodec(new TypeCodecInfo(AsiasoftLoginCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecOdnoklassnikiUrlParams();
local3.registerCodec(new EnumCodecInfo(OdnoklassnikiUrlParams,false),local4);
local3.registerCodec(new EnumCodecInfo(OdnoklassnikiUrlParams,true),new OptionalCodecDecorator(local4));
local4 = new VectorCodecAsiasoftLoginCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(AsiasoftLoginCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(AsiasoftLoginCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecAsiasoftLoginCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(AsiasoftLoginCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(AsiasoftLoginCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecOdnoklassnikiUrlParamsLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(OdnoklassnikiUrlParams,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(OdnoklassnikiUrlParams,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecOdnoklassnikiUrlParamsLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(OdnoklassnikiUrlParams,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(OdnoklassnikiUrlParams,true),true,1),new OptionalCodecDecorator(local4));
}
public function stop(param1:OSGi) : void {
}
}
}
|
package projects.tanks.client.tanksservices.model.ads {
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 AdShowModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _logAdShowId:Long = Long.getLong(351351762,-24219482);
private var _logAdShow_durationCodec:ICodec;
private var _logAdShow_providerCodec:ICodec;
private var _logAdShow_originCodec:ICodec;
private var model:IModel;
public function AdShowModelServer(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._logAdShow_durationCodec = this.protocol.getCodec(new TypeCodecInfo(Number,false));
this._logAdShow_providerCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._logAdShow_originCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function logAdShow(param1:Number, param2:String, param3:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._logAdShow_durationCodec.encode(this.protocolBuffer,param1);
this._logAdShow_providerCodec.encode(this.protocolBuffer,param2);
this._logAdShow_originCodec.encode(this.protocolBuffer,param3);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local4:SpaceCommand = new SpaceCommand(Model.object.id,this._logAdShowId,this.protocolBuffer);
var local5:IGameObject = Model.object;
var local6:ISpace = local5.space;
local6.commandSender.sendCommand(local4);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.model.coin {
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.panel.model.coin.CoinInfoModelBase;
import projects.tanks.client.panel.model.coin.ICoinInfoModelBase;
[ModelInfo]
public class CoinInfoModel extends CoinInfoModelBase implements ICoinInfoModelBase, ObjectLoadListener {
[Inject]
public static var coinInfoService:CoinInfoService;
public function CoinInfoModel() {
super();
}
public function objectLoaded() : void {
coinInfoService.enabled = getInitParam().enabled;
coinInfoService.setCoins(getInitParam().coins);
}
public function setCoins(param1:int) : void {
coinInfoService.setCoins(param1);
}
public function changeBy(param1:int) : void {
coinInfoService.changeBy(param1);
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_dropGreen.png")]
public class MakeUp_dropGreen extends BitmapAsset {
public function MakeUp_dropGreen() {
super();
}
}
}
|
package org.osflash.signals.natives {
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.IEventDispatcher;
[DefaultProperty("eventClass")]
public class NativeSignal implements INativeSignalOwner {
protected var _target:IEventDispatcher;
protected var _eventType:String;
protected var _eventClass:Class;
protected var listenerBoxes:Array;
public function NativeSignal(target:IEventDispatcher = null, eventType:String = "", eventClass:Class = null) {
super();
this.listenerBoxes = [];
this.target = target;
this.eventType = eventType;
this.eventClass = eventClass;
}
public function get eventType() : String {
return this._eventType;
}
public function set eventType(value:String) : void {
this._eventType = value;
}
public function get eventClass() : Class {
return this._eventClass;
}
public function set eventClass(value:Class) : void {
this._eventClass = value || Event;
}
public function get valueClasses() : Array {
return [this._eventClass];
}
public function set valueClasses(value:Array) : void {
this.eventClass = Boolean(value) ? value[0] : null;
}
public function get numListeners() : uint {
return this.listenerBoxes.length;
}
public function get target() : IEventDispatcher {
return this._target;
}
public function set target(value:IEventDispatcher) : void {
if(value == this._target) {
return;
}
this.removeAll();
this._target = value;
}
public function add(listener:Function) : Function {
return this.addWithPriority(listener);
}
public function addWithPriority(listener:Function, priority:int = 0) : Function {
this.registerListener(listener,false,priority);
return listener;
}
public function addOnce(listener:Function) : Function {
return this.addOnceWithPriority(listener);
}
public function addOnceWithPriority(listener:Function, priority:int = 0) : Function {
this.registerListener(listener,true,priority);
return listener;
}
public function remove(listener:Function) : Function {
var listenerIndex:int = this.indexOfListener(listener);
if(listenerIndex == -1) {
return listener;
}
var listenerBox:Object = this.listenerBoxes.splice(listenerIndex,1)[0];
this._target.removeEventListener(this._eventType,listenerBox.execute);
return listener;
}
public function removeAll() : void {
for(var i:int = int(this.listenerBoxes.length); Boolean(i--); ) {
this.remove(this.listenerBoxes[i].listener as Function);
}
}
public function dispatch(event:Event) : Boolean {
if(!(event is this._eventClass)) {
throw new ArgumentError("Event object " + event + " is not an instance of " + this._eventClass + ".");
}
if(event.type != this._eventType) {
throw new ArgumentError("Event object has incorrect type. Expected <" + this._eventType + "> but was <" + event.type + ">.");
}
return this._target.dispatchEvent(event);
}
protected function registerListener(listener:Function, once:Boolean = false, priority:int = 0) : void {
var prevListenerIndex:int;
var listenerBox:Object;
var prevlistenerBox:Object = null;
var signal:NativeSignal = null;
if(listener.length != 1) {
throw new ArgumentError("Listener for native event must declare exactly 1 argument.");
}
prevListenerIndex = this.indexOfListener(listener);
if(prevListenerIndex >= 0) {
prevlistenerBox = this.listenerBoxes[prevListenerIndex];
if(Boolean(prevlistenerBox.once) && !once) {
throw new IllegalOperationError("You cannot addOnce() then add() the same listener without removing the relationship first.");
}
if(!prevlistenerBox.once && once) {
throw new IllegalOperationError("You cannot add() then addOnce() the same listener without removing the relationship first.");
}
return;
}
listenerBox = {
"listener":listener,
"once":once,
"execute":listener
};
if(once) {
signal = this;
listenerBox.execute = function(event:Event):void {
signal.remove(listener);
listener(event);
};
}
this.listenerBoxes[this.listenerBoxes.length] = listenerBox;
this._target.addEventListener(this._eventType,listenerBox.execute,false,priority);
}
protected function indexOfListener(listener:Function) : int {
for(var i:int = int(this.listenerBoxes.length); Boolean(i--); ) {
if(this.listenerBoxes[i].listener == listener) {
return i;
}
}
return -1;
}
}
}
|
package alternativa.tanks.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.ItemInfoPanelBitmaps_bitmapDroneBonusRadius.png")]
public class ItemInfoPanelBitmaps_bitmapDroneBonusRadius extends BitmapAsset {
public function ItemInfoPanelBitmaps_bitmapDroneBonusRadius() {
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.drone {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.SoundResource;
import projects.tanks.client.battlefield.models.drone.DroneSFXCC;
public class CodecDroneSFXCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_activationSound:ICodec;
public function CodecDroneSFXCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_activationSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:DroneSFXCC = new DroneSFXCC();
local2.activationSound = this.codec_activationSound.decode(param1) as SoundResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:DroneSFXCC = DroneSFXCC(param2);
this.codec_activationSound.encode(param1,local3.activationSound);
}
}
}
|
package alternativa.tanks.help {
import alternativa.osgi.service.locale.ILocaleService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.BubbleHelper;
import projects.tanks.clients.fp10.libraries.tanksservices.service.helper.HelperAlign;
public class SwitchingItemCategoriesHelper extends BubbleHelper {
[Inject]
public static var localeService:ILocaleService;
public function SwitchingItemCategoriesHelper() {
super();
text = localeService.getText(TanksLocale.TEXT_GARAGE_HELPER_SWITCHING_ITEM_CATEGORIES);
arrowLehgth = 48;
arrowAlign = HelperAlign.MIDDLE_RIGHT;
_showLimit = 3;
}
}
}
|
package alternativa.tanks.models.battle.rugby {
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Decal;
import alternativa.engine3d.objects.Mesh;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.LogicUnit;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.events.BattleRestartEvent;
import alternativa.tanks.battle.events.TankAddedToBattleEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.battle.assault.IndicatorStateAdapter;
import alternativa.tanks.models.battle.battlefield.BattleModel;
import alternativa.tanks.models.battle.battlefield.BattleType;
import alternativa.tanks.models.battle.commonflag.CommonFlag;
import alternativa.tanks.models.battle.commonflag.FlagNotification;
import alternativa.tanks.models.battle.commonflag.ICommonFlagModeModel;
import alternativa.tanks.models.battle.commonflag.IFlagModeInitilizer;
import alternativa.tanks.models.battle.commonflag.MarkersUtils;
import alternativa.tanks.models.battle.ctf.FlagMessage;
import alternativa.tanks.models.battle.gui.BattlefieldGUI;
import alternativa.tanks.models.battle.gui.gui.statistics.field.score.ctf.flagindicator.FlagIndicator;
import alternativa.tanks.models.battle.gui.gui.statistics.messages.UserAction;
import alternativa.utils.TextureMaterialRegistry;
import flash.utils.getTimer;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.battle.pointbased.ClientTeamPoint;
import projects.tanks.client.battlefield.models.battle.pointbased.flag.ClientFlag;
import projects.tanks.client.battlefield.models.battle.pointbased.flag.FlagState;
import projects.tanks.client.battlefield.models.battle.pointbased.rugby.IRugbyModelBase;
import projects.tanks.client.battlefield.models.battle.pointbased.rugby.RugbyCC;
import projects.tanks.client.battlefield.models.battle.pointbased.rugby.RugbyModelBase;
import projects.tanks.client.battlefield.types.Vector3d;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
[ModelInfo]
public class RugbyModel extends RugbyModelBase implements IRugbyModelBase, IFlagModeInitilizer, FlagNotification, ObjectLoadListener, ObjectUnloadListener, BattleModel, LogicUnit {
[Inject]
public static var materialRegistry:TextureMaterialRegistry;
[Inject]
public static var battleService:BattleService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var battleInfoService:IBattleInfoService;
private var ballSpawnZones:Vector.<Mesh>;
private var ballSpawnZoneMaterial:TextureMaterial;
private var guiModel:BattlefieldGUI;
private var messages:RugbyMessages = new RugbyMessages();
private var battleEventSupport:BattleEventSupport;
private var ball:Ball;
private var nextNotificationTime:int;
public function RugbyModel() {
super();
this.battleEventSupport = new BattleEventSupport(battleEventDispatcher);
this.battleEventSupport.addEventHandler(BattleFinishEvent,this.onBattleFinish);
this.battleEventSupport.addEventHandler(BattleRestartEvent,this.onBattleRestart);
this.battleEventSupport.addEventHandler(TankAddedToBattleEvent,this.onTankAddedToBattle);
}
private static function createBallSpawnZone(param1:Vector3d, param2:TextureMaterial) : Mesh {
var local3:Decal = null;
local3 = new Decal();
var local4:Number = 500;
var local5:Vertex = local3.addVertex(-local4,local4,0,0,0);
var local6:Vertex = local3.addVertex(-local4,-local4,0,0,1);
var local7:Vertex = local3.addVertex(local4,-local4,0,1,1);
var local8:Vertex = local3.addVertex(local4,local4,0,1,0);
local3.addQuadFace(local5,local6,local7,local8,param2);
local3.calculateFacesNormals();
local3.calculateVerticesNormals();
local3.x = param1.x;
local3.y = param1.y;
local3.z = param1.z + 0.001;
battleService.getBattleScene3D().addObject(local3);
return local3;
}
public function objectLoaded() : void {
this.guiModel = BattlefieldGUI(object.adapt(BattlefieldGUI));
this.battleEventSupport.activateHandlers();
}
private function onTankAddedToBattle(param1:TankAddedToBattleEvent) : void {
if(param1.tank.getUser().id == this.ball.carrierId) {
this.ball.setRemoteCarrier(this.ball.carrierId,param1.tank);
this.initHudIndicator();
}
}
private function initHudIndicator() : void {
var local1:BattleTeam = null;
if(this.ball.state == FlagState.CARRIED) {
local1 = this.ball.carrier.teamType;
this.guiModel.setIndicatorState(local1,FlagIndicator.STATE_BLINK);
this.guiModel.setIndicatorState(this.oppositeTeam(local1),FlagIndicator.STATE_DEFAULT);
} else {
this.guiModel.setBothIndicatorsState(FlagIndicator.STATE_DEFAULT,FlagIndicator.STATE_DEFAULT);
}
}
public function objectUnloaded() : void {
var local1:Mesh = null;
this.battleEventSupport.deactivateHandlers();
for each(local1 in this.ballSpawnZones) {
battleService.getBattleScene3D().removeObject(local1);
}
materialRegistry.releaseMaterial(this.ballSpawnZoneMaterial);
this.ballSpawnZones = null;
this.ballSpawnZoneMaterial = null;
this.ball = null;
battleService.getBattleRunner().removeLogicUnit(this);
}
public function init(param1:Vector.<ClientFlag>, param2:Vector.<ClientTeamPoint>) : void {
var local5:ClientTeamPoint = null;
var local6:ClientFlag = null;
var local7:IndicatorStateAdapter = null;
var local3:ICommonFlagModeModel = ICommonFlagModeModel(object.adapt(ICommonFlagModeModel));
var local4:RugbyCC = getInitParam();
this.ballSpawnZones = new Vector.<Mesh>();
this.ballSpawnZoneMaterial = materialRegistry.getMaterial(local4.ballSpawnZone.data);
for each(local5 in param2) {
local7 = new IndicatorStateAdapter(Vector3.fromVector3d(local5.flagBasePosition));
if(local5.id == -1) {
local3.createBasePoint(local5,local4.blueGoalModel);
MarkersUtils.createMarkers(BattleTeam.BLUE,local4.blueBallMarker.data,local4.bigBlueBallMarker.data,local7);
} else if(local5.id == -2) {
local3.createBasePoint(local5,local4.redGoalModel);
MarkersUtils.createMarkers(BattleTeam.RED,local4.redBallMarker.data,local4.bigRedBallMarker.data,local7);
} else {
this.ballSpawnZones.push(createBallSpawnZone(local5.flagBasePosition,this.ballSpawnZoneMaterial));
local3.addMineProtectedZone(Vector3.fromVector3d(local5.flagBasePosition));
}
}
local6 = param1[0];
this.ball = new Ball(local6.flagId,local4.ballRadius,local4.ballModel,local4.parachuteResource,local4.parachuteInnerResource,local4.cordResource);
MarkersUtils.createMarkers(null,local4.greenBallMarker.data,local4.bigGreenBallMarker.data,this.ball);
local3.initFlag(this.ball,local6);
}
public function guiShowFlagDropped(param1:CommonFlag) : void {
this.guiModel.setBothIndicatorsState(FlagIndicator.STATE_EMPTY,FlagIndicator.STATE_DEFAULT);
}
public function guiShowFlagCarried(param1:CommonFlag) : void {
this.guiModel.setIndicatorState(param1.carrier.teamType,FlagIndicator.STATE_BLINK);
this.guiModel.setIndicatorState(this.oppositeTeam(param1.carrier.teamType),FlagIndicator.STATE_DEFAULT);
}
public function guiShowFlagAtBase(param1:CommonFlag) : void {
this.guiModel.setBothIndicatorsState(FlagIndicator.STATE_DEFAULT,FlagIndicator.STATE_DEFAULT);
}
public function notifyFlagTaken(param1:CommonFlag, param2:Tank) : void {
var local3:String = this.messages.getBattleLogMessage(RugbyMessages.TAKE);
this.guiModel.showUserBattleLogMessage(param2.getUser().id,UserAction.RGB_PLAYER_PICK_BALL);
var local4:Tank = ICommonFlagModeModel(object.adapt(ICommonFlagModeModel)).getLocalTank();
var local5:Boolean = Boolean(local4) && local4.teamType == param2.teamType;
var local6:SoundResource = local5 ? getInitParam().sounds.ballTakePositiveSound : getInitParam().sounds.ballTakeNegativeSound;
battleService.soundManager.playSound(local6.sound);
}
public function notifyFlagReturned(param1:CommonFlag, param2:IGameObject) : void {
}
public function notifyFlagDropped(param1:CommonFlag) : void {
this.guiModel.setBothIndicatorsState(FlagIndicator.STATE_DEFAULT,FlagIndicator.STATE_DEFAULT);
if(param1.carrier != null) {
this.guiModel.showUserBattleLogMessage(param1.carrierId,UserAction.RGB_PLAYER_LOOSE_BALL);
this.ballDroppedCommon(param1);
}
}
public function notifyFlagThrown(param1:CommonFlag) : void {
this.guiModel.setBothIndicatorsState(FlagIndicator.STATE_DEFAULT,FlagIndicator.STATE_DEFAULT);
if(param1.carrier != null) {
this.guiModel.showUserBattleLogMessage(param1.carrierId,UserAction.RGB_PLAYER_THREW_BALL);
this.ballDroppedCommon(param1);
}
}
private function ballDroppedCommon(param1:CommonFlag) : void {
var local2:Tank = ICommonFlagModeModel(object.adapt(ICommonFlagModeModel)).getLocalTank();
var local3:Boolean = Boolean(local2) && local2.teamType != param1.carrier.teamType;
var local4:SoundResource = local3 ? getInitParam().sounds.ballDropPositiveSound : getInitParam().sounds.ballDropNegativeSound;
battleService.soundManager.playSound(local4.sound);
}
public function notifyFlagDelivered(param1:CommonFlag, param2:Tank) : void {
this.guiModel.showUserBattleLogMessage(param2.getUser().id,UserAction.RGB_PLAYER_DELIVER_BALL);
var local3:FlagMessage = this.messages.getMessage(RugbyMessages.GOAL,param2.teamType);
this.guiModel.showBattleMessage(local3.color,local3.text);
this.guiModel.setIndicatorState(param2.teamType,FlagIndicator.STATE_FLASHING);
this.guiModel.setIndicatorState(this.oppositeTeam(param2.teamType),FlagIndicator.STATE_DEFAULT);
var local4:Tank = ICommonFlagModeModel(object.adapt(ICommonFlagModeModel)).getLocalTank();
var local5:Boolean = Boolean(local4) && local4.teamType == param2.teamType;
var local6:SoundResource = local5 ? getInitParam().sounds.goalPositiveSound : getInitParam().sounds.goalNegativeSound;
battleService.soundManager.playSound(local6.sound);
this.nextNotificationTime = getTimer() + 1500;
battleService.getBattleRunner().addLogicUnit(this);
}
public function runLogic(param1:int, param2:int) : void {
if(param1 >= this.nextNotificationTime) {
this.notifyReadyToFaceOff();
battleService.getBattleRunner().removeLogicUnit(this);
}
}
public function getBattleType() : BattleType {
return BattleType.RUGBY;
}
public function notifyFlagFacedOff(param1:CommonFlag) : void {
var local2:FlagMessage = this.messages.getFacedOffMessage();
this.guiModel.showBattleMessage(local2.color,local2.text);
this.guiModel.setBothIndicatorsState(FlagIndicator.STATE_DEFAULT,FlagIndicator.STATE_DEFAULT);
battleService.soundManager.playSound(getInitParam().sounds.ballFaceOffSound.sound);
}
public function notifyReadyToFaceOff() : void {
this.guiModel.setBothIndicatorsState(FlagIndicator.STATE_DEFAULT,FlagIndicator.STATE_DEFAULT);
var local1:FlagMessage = this.messages.getReadyToFaceOffMessage();
this.guiModel.showBattleMessage(local1.color,local1.text);
}
private function onBattleFinish(param1:Object) : void {
if(this.ball.isFlying()) {
this.ball.stopFalling();
this.ball.returnToBase();
}
}
private function onBattleRestart(param1:Object) : void {
FlagNotification(object.adapt(FlagNotification)).notifyReadyToFaceOff();
}
private function oppositeTeam(param1:BattleTeam) : BattleTeam {
if(param1 == BattleTeam.BLUE) {
return BattleTeam.RED;
}
if(param1 == BattleTeam.RED) {
return BattleTeam.BLUE;
}
return BattleTeam.NONE;
}
}
}
|
package alternativa.tanks.service.payment {
import projects.tanks.client.panel.model.payment.CrystalsPaymentCC;
import projects.tanks.client.panel.model.payment.panel.PaymentButtonCC;
import projects.tanks.client.panel.model.payment.types.PaymentRequestUrl;
public interface IPaymentService {
function getAccountId() : String;
function getManualDescription() : String;
function getCrystalCost() : Number;
function getLessMinimumCrystalsMessage() : String;
function getLessMinimumMoneyMessage() : String;
function getGreaterMaximumCrystalsMessage() : String;
function getGreaterMaximumMoneyMessage() : String;
function getCrystals() : int;
function setCrystals(param1:int) : void;
function initManualDescription(param1:String) : void;
function init(param1:CrystalsPaymentCC) : void;
function setShouldChooseLocation(param1:Boolean) : void;
function isEnabled() : Boolean;
function initPaymentMode(param1:PaymentButtonCC) : void;
function isEnabledFullPayment() : Boolean;
function isPaymentInLinkMode() : Boolean;
function getPaymentUrl() : PaymentRequestUrl;
function shouldChooseLocation() : Boolean;
}
}
|
package alternativa.tanks.models.weapon.ricochet
{
public class RicochetData
{
public var shotRadius:Number;
public var shotSpeed:Number;
public var energyCapacity:int;
public var energyPerShot:int;
public var energyRechargeSpeed:Number;
public var shotDistance:Number;
public function RicochetData(shotRadius:Number, shotSpeed:Number, energyCapacity:int, energyPerShot:int, energyRechargeSpeed:int, shotDistance:Number)
{
super();
this.shotRadius = shotRadius;
this.shotSpeed = shotSpeed;
this.energyCapacity = energyCapacity;
this.energyPerShot = energyPerShot;
this.energyRechargeSpeed = energyRechargeSpeed;
this.shotDistance = shotDistance;
}
}
}
|
package alternativa.tanks.view.mainview.grouplist.header {
import controls.base.LabelBase;
import controls.statassets.StatLineHeader;
import flash.display.Sprite;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
public class GroupHeaderItem extends Sprite {
private var bg:StatLineHeader = new StatLineHeader();
private var label:LabelBase = new LabelBase();
private var partOfHeader:int;
public function GroupHeaderItem(param1:String, param2:int) {
super();
this.partOfHeader = param2;
this.bg.width = width;
this.bg.height = 18;
addChild(this.bg);
addChild(this.label);
this.label.color = 860685;
this.label.x = 2;
this.label.y = 0;
this.label.mouseEnabled = false;
this.label.autoSize = TextFieldAutoSize.NONE;
this.label.align = TextFormatAlign.LEFT;
this.label.height = 18;
this.label.text = param1;
}
override public function set width(param1:Number) : void {
super.width = width;
this.bg.width = param1;
this.label.width = width - 4;
}
public function getPartOfHeader() : int {
return this.partOfHeader;
}
}
}
|
package projects.tanks.client.battlefield.models.user.reloader {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class TankReloaderModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:TankReloaderModelServer;
private var client:ITankReloaderModelBase = ITankReloaderModelBase(this);
private var modelId:Long = Long.getLong(1286074115,-176946994);
private var _dieId:Long = Long.getLong(343596326,-230405373);
private var _die_respawnDelayCodec:ICodec;
private var _onDeathScheduledId:Long = Long.getLong(208555485,-6667003);
private var _onDeathScheduled_suicideDelayMSCodec:ICodec;
private var _onReloadId:Long = Long.getLong(154981282,1951339013);
public function TankReloaderModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new TankReloaderModelServer(IModel(this));
this._die_respawnDelayCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
this._onDeathScheduled_suicideDelayMSCodec = this._protocol.getCodec(new TypeCodecInfo(int,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._dieId:
this.client.die(int(this._die_respawnDelayCodec.decode(param2)));
break;
case this._onDeathScheduledId:
this.client.onDeathScheduled(int(this._onDeathScheduled_suicideDelayMSCodec.decode(param2)));
break;
case this._onReloadId:
this.client.onReload();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.controller.commands {
import alternativa.tanks.service.IEntranceServerFacade;
import alternativa.tanks.view.events.SendChangeUidAndPasswordEvent;
import org.robotlegs.mvcs.Command;
public class SendChangeUidAndPasswordCommand extends Command {
[Inject]
public var event:SendChangeUidAndPasswordEvent;
[Inject]
public var serverFacade:IEntranceServerFacade;
public function SendChangeUidAndPasswordCommand() {
super();
}
override public function execute() : void {
this.serverFacade.changeUidAndPassword(this.event.uid,this.event.password);
}
}
}
|
package alternativa.tanks.model.gift.opened
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GiftOpenedView_Mote extends BitmapAsset
{
public function GiftOpenedView_Mote()
{
super();
}
}
}
|
package alternativa.tanks.model.payment.shop.lootboxandpaint {
import alternativa.tanks.gui.shop.shopitems.item.base.ShopButton;
import alternativa.tanks.model.payment.shop.ShopItemView;
import projects.tanks.client.panel.model.shop.lootboxandpaintkit.ILootboxAndPaintModelBase;
import projects.tanks.client.panel.model.shop.lootboxandpaintkit.LootboxAndPaintModelBase;
[ModelInfo]
public class LootboxAndPaintModel extends LootboxAndPaintModelBase implements ILootboxAndPaintModelBase, ShopItemView {
public function LootboxAndPaintModel() {
super();
}
public function getButtonView() : ShopButton {
return new LootboxAndPaintButton(object,getInitParam());
}
}
}
|
package alternativa.types {
import alternativa.ILauncherListener;
import alternativa.osgi.service.launcherparams.ILauncherParams;
public class DummyListener implements ILauncherListener {
private var logOutput:LogOutput;
public function DummyListener(param1:LogOutput) {
super();
this.logOutput = param1;
}
public function onConfigLoadingStart() : void {
this.log("Config loading start");
}
public function onConfigLoadingComplete() : void {
this.log("Config loading complete");
}
public function onConfigLoadingProgress(param1:uint, param2:uint) : void {
}
public function onLibrariesLoadingStart() : void {
this.log("Libraries loading start");
}
public function onLibrariesLoadingComplete(param1:ILauncherParams, param2:Function) : void {
this.log("Libraries loading complete");
param2();
}
public function onLibraryLoadingError(param1:String) : void {
this.log("Library loading error: " + param1);
}
public function onLibrariesLoadingProgress(param1:uint, param2:uint) : void {
}
public function onServerUnavailable() : void {
this.log("Server is unavailable");
}
public function onServerOverloaded() : void {
this.log("Server is overloaded");
}
public function onConfigLoadingError(param1:String) : void {
this.log("Configuration loading error: " + param1);
}
public function onLibrariesInitialized() : void {
this.log("Libraries have been initialized");
}
private function log(param1:String) : void {
if(this.logOutput != null) {
this.logOutput.addLine(param1);
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.kitoffer.log {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.panel.model.kitoffer.log.KitOfferAction;
public class CodecKitOfferAction implements ICodec {
public function CodecKitOfferAction() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:KitOfferAction = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = KitOfferAction.BUY_BUTTON_CLICK;
break;
case 1:
local2 = KitOfferAction.PICTURE_CLICK;
break;
case 2:
local2 = KitOfferAction.EXIT_BUTTON_CLICK;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package alternativa.tanks.models.clan {
import alternativa.types.Long;
[ModelInterface]
public interface IClanModel {
function leaveClan() : void;
function addClanMember(param1:Long) : void;
function excludeClanMember(param1:Long) : void;
function rejectRequest(param1:Long) : void;
function acceptRequest(param1:Long) : void;
function rejectAllRequests() : void;
function inviteByUid(param1:String) : void;
function revokeRequest(param1:Long) : void;
}
}
|
package alternativa.tanks.models.weapon.shaft {
public interface ShaftAimingStateListener {
function onAimingStart() : void;
function onAimingStop() : void;
function onAimedShot() : void;
}
}
|
package alternativa.tanks.models.weapon.shaft.states {
import alternativa.tanks.models.weapon.shaft.ShaftEventType;
public class Transition {
public var eventType:ShaftEventType;
public var state:IShaftState;
public var newState:IShaftState;
public var handler:ITransitionHandler;
public function Transition(param1:ShaftEventType, param2:IShaftState, param3:IShaftState, param4:ITransitionHandler) {
super();
this.eventType = param1;
this.state = param2;
this.newState = param3;
this.handler = param4;
}
}
}
|
package projects.tanks.client.entrance.model.entrance.logging {
public interface IRegistrationUXLoggerModelBase {
}
}
|
package projects.tanks.client.battlefield.models.drone {
public class DroneIndicatorCC {
private var _batteryAmount:int;
private var _canOverheal:Boolean;
private var _droneReady:Boolean;
private var _timeToReloadMs:int;
public function DroneIndicatorCC(param1:int = 0, param2:Boolean = false, param3:Boolean = false, param4:int = 0) {
super();
this._batteryAmount = param1;
this._canOverheal = param2;
this._droneReady = param3;
this._timeToReloadMs = param4;
}
public function get batteryAmount() : int {
return this._batteryAmount;
}
public function set batteryAmount(param1:int) : void {
this._batteryAmount = param1;
}
public function get canOverheal() : Boolean {
return this._canOverheal;
}
public function set canOverheal(param1:Boolean) : void {
this._canOverheal = param1;
}
public function get droneReady() : Boolean {
return this._droneReady;
}
public function set droneReady(param1:Boolean) : void {
this._droneReady = param1;
}
public function get timeToReloadMs() : int {
return this._timeToReloadMs;
}
public function set timeToReloadMs(param1:int) : void {
this._timeToReloadMs = param1;
}
public function toString() : String {
var local1:String = "DroneIndicatorCC [";
local1 += "batteryAmount = " + this.batteryAmount + " ";
local1 += "canOverheal = " + this.canOverheal + " ";
local1 += "droneReady = " + this.droneReady + " ";
local1 += "timeToReloadMs = " + this.timeToReloadMs + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.animations {
public class AnimationTrack {
private var times:Vector.<Number>;
private var values:Vector.<Number>;
private var numFrames:int;
private var minTime:Number;
private var maxTime:Number;
public function AnimationTrack(param1:Vector.<Number>, param2:Vector.<Number>) {
super();
this.times = param1;
this.values = param2;
this.numFrames = param1.length;
this.minTime = param1[0];
this.maxTime = param1[this.numFrames - 1];
}
public function getFrameTime(param1:int) : Number {
return this.times[param1];
}
public function getNumFrames() : int {
return this.numFrames;
}
public function getMinTime() : Number {
return this.minTime;
}
public function getMaxTime() : Number {
return this.maxTime;
}
public function getFrameValue(param1:int) : Number {
return this.values[param1];
}
}
}
|
package projects.tanks.client.users.model.friends {
public class FriendsCC {
private var _acceptedLimit:int;
private var _incomingLimit:int;
private var _local:Boolean;
public function FriendsCC(param1:int = 0, param2:int = 0, param3:Boolean = false) {
super();
this._acceptedLimit = param1;
this._incomingLimit = param2;
this._local = param3;
}
public function get acceptedLimit() : int {
return this._acceptedLimit;
}
public function set acceptedLimit(param1:int) : void {
this._acceptedLimit = param1;
}
public function get incomingLimit() : int {
return this._incomingLimit;
}
public function set incomingLimit(param1:int) : void {
this._incomingLimit = param1;
}
public function get local() : Boolean {
return this._local;
}
public function set local(param1:Boolean) : void {
this._local = param1;
}
public function toString() : String {
var local1:String = "FriendsCC [";
local1 += "acceptedLimit = " + this.acceptedLimit + " ";
local1 += "incomingLimit = " + this.incomingLimit + " ";
local1 += "local = " + this.local + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.dialogs.gui {
public class DialogEvent {
public static const CLOSE:String = "DialogEvent:CLOSE";
public function DialogEvent() {
super();
}
}
}
|
package alternativa.tanks.models.battlefield.effects.graffiti
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class TexturesManager_graffiti_firegraff extends BitmapAsset
{
public function TexturesManager_graffiti_firegraff()
{
super();
}
}
}
|
package alternativa.tanks.models.tank.device {
import alternativa.types.Long;
[ModelInterface]
public interface TankDevice {
function getDevice() : Long;
}
}
|
package alternativa.tanks.model.quest.challenge.gui {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.quest.challenge.gui.TierRenderer_notPickedBgClass.png")]
public class TierRenderer_notPickedBgClass extends BitmapAsset {
public function TierRenderer_notPickedBgClass() {
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank13.png")]
public class PremiumRankBitmaps_bitmapBigRank13 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank13() {
super();
}
}
}
|
package alternativa.tanks.view.mainview.grouplist.item {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.service.matchmaking.MatchmakingGroupInviteService;
import alternativa.tanks.view.mainview.grouplist.header.GroupHeader;
import controls.base.LabelBase;
import controls.dropdownlist.DeleteEvent;
import controls.dropdownlist.DeleteIndicator;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormatAlign;
import forms.ColorConstants;
import forms.userlabel.UserLabel;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.matchmakinggroup.MatchmakingGroupService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoService;
public class GroupUserItem extends Sprite {
[Inject]
public static var userInfoService:IUserInfoService;
[Inject]
public static var matchmakingGroupService:MatchmakingGroupService;
[Inject]
public static var inviteService:MatchmakingGroupInviteService;
[Inject]
public static var localeService:ILocaleService;
private var itemWidth:Number = 0;
private var userLabel:UserLabel;
private var weaponLabel:LabelBase;
private var armorLabel:LabelBase;
private var deleteIndicator:DeleteIndicator;
private var deleteCanBeVisible:Boolean;
public function GroupUserItem(param1:Object) {
super();
if(Boolean(param1.isInviteSlot)) {
this.createInviteSlot();
return;
}
this.userLabel = new UserLabel(param1.id);
this.userLabel.inviteBattleEnable = false;
this.userLabel.showClanProfile = false;
this.userLabel.x = -4;
this.userLabel.y = 1;
addChild(this.userLabel);
this.weaponLabel = this.createItemLabel(param1.weaponName);
this.armorLabel = this.createItemLabel(param1.armorName);
addChild(this.weaponLabel);
addChild(this.armorLabel);
this.deleteCanBeVisible = Boolean(matchmakingGroupService.isGroupInviteEnabled()) && param1.id != userInfoService.getCurrentUserId();
if(this.deleteCanBeVisible) {
this.deleteIndicator = new DeleteIndicator(param1);
this.deleteIndicator.visible = false;
this.deleteIndicator.y = 1;
addEventListener(DeleteEvent.REMOVED,this.onClickDelete);
addChild(this.deleteIndicator);
}
}
private function createInviteSlot() : void {
var local1:LabelBase = this.createItemLabel(localeService.getText(TanksLocale.TEXT_GROUP_INVITE_BUTTON));
local1.buttonMode = true;
local1.y += 1;
local1.addEventListener(MouseEvent.CLICK,this.onInviteClick,false,0,true);
addChild(local1);
}
private function onInviteClick(param1:MouseEvent) : void {
inviteService.openInviteWindow();
}
private function onClickDelete(param1:DeleteEvent) : void {
removeEventListener(DeleteEvent.REMOVED,this.onClickDelete);
removeChild(this.deleteIndicator);
}
private function createItemLabel(param1:String) : LabelBase {
var local2:LabelBase = new LabelBase();
local2.color = ColorConstants.GREEN_LABEL;
local2.autoSize = TextFieldAutoSize.LEFT;
local2.align = TextFormatAlign.LEFT;
local2.text = param1;
local2.y = 1;
return local2;
}
override public function set width(param1:Number) : void {
this.itemWidth = param1;
this.resize();
}
override public function get width() : Number {
return this.itemWidth;
}
public function showDeleteIndicator() : void {
if(this.deleteCanBeVisible) {
this.deleteIndicator.visible = true;
}
}
public function hideDeleteIndicator() : void {
if(this.deleteCanBeVisible) {
this.deleteIndicator.visible = false;
}
}
private function resize() : void {
var local1:int = 4;
if(this.weaponLabel != null) {
this.weaponLabel.x = GroupHeader.HEADER_INFOS[1].x - local1;
this.armorLabel.x = GroupHeader.HEADER_INFOS[2].x - local1;
}
if(this.deleteCanBeVisible) {
this.deleteIndicator.x = this.itemWidth - this.deleteIndicator.width - 7;
}
this.redraw();
}
private function redraw() : void {
graphics.clear();
graphics.beginFill(0,0);
graphics.drawRect(0,0,this.itemWidth,20);
graphics.endFill();
}
}
}
|
package alternativa.tanks.view.battleinfo.renderer {
import controls.cellrenderer.ButtonState;
public class BattleInfoBlueUserListRenderer extends BattleInfoUserListRenderer {
private var style:ButtonState = new CellBlue();
public function BattleInfoBlueUserListRenderer() {
super();
}
override public function getCurrentStyle() : ButtonState {
return this.style;
}
}
}
|
package alternativa.tanks.models.panel.create {
import flash.events.IEventDispatcher;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
public interface ClanCreateService extends IEventDispatcher {
function createClan(param1:String, param2:String, param3:String, param4:ClanFlag) : void;
function validateName(param1:String) : void;
function validateTag(param1:String) : void;
function incorrectName() : void;
function incorrectTag() : void;
function correctName() : void;
function correctTag() : void;
function notUniqueName() : void;
function notUniqueTag() : void;
function get flags() : Vector.<ClanFlag>;
function set flags(param1:Vector.<ClanFlag>) : void;
function get defaultFlag() : ClanFlag;
function otherError() : void;
function alreadyInClan() : void;
}
}
|
package alternativa.tanks.models.weapon.healing {
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
public class HealingGunStream extends Mesh {
private var width:Number;
private var deviation:Number;
private var phase:Number;
private var rnd:Number;
private var count:int = 20;
private var verts:Vector.<Vertex>;
private var vertsLen:int = 0;
private var segment:Number;
private var offset:Number = 0;
private var wave1Offset:Number = 0;
private var wave2Offset:Number = 0;
private var direction:int;
public function HealingGunStream(param1:Number, param2:Number, param3:Number) {
var local7:Vertex = null;
var local8:Vertex = null;
this.rnd = Math.random();
this.verts = new Vector.<Vertex>();
super();
var local4:Vertex = addVertex(-1,0,0);
var local5:Vertex = addVertex(1,0,0);
this.verts[this.vertsLen] = local4;
++this.vertsLen;
this.verts[this.vertsLen] = local5;
++this.vertsLen;
var local6:int = 0;
while(local6 < this.count) {
local7 = addVertex(-1,-local6 - 1,0);
local8 = addVertex(1,-local6 - 1,0);
this.verts[this.vertsLen] = local7;
++this.vertsLen;
this.verts[this.vertsLen] = local8;
++this.vertsLen;
addQuadFace(local4,local7,local8,local5);
local4 = local7;
local5 = local8;
local6++;
}
calculateFacesNormals();
sorting = Sorting.DYNAMIC_BSP;
this.width = param1;
this.deviation = param2;
this.phase = param3;
this.shadowMapAlphaThreshold = 2;
this.depthMapAlphaThreshold = 2;
this.useShadowMap = false;
this.useLight = false;
this.direction = 1;
}
public function init() : void {
var local3:Vertex = null;
var local4:Vertex = null;
var local5:Number = NaN;
var local1:Number = this.width * 0.5;
var local2:int = 0;
while(local2 < this.vertsLen) {
local3 = this.verts[local2];
local2++;
local4 = this.verts[local2];
local5 = Math.cos((-local3.y / this.count * 2 - 1) * Math.PI / 2) * this.deviation;
local3.x = -local1 + local5;
local3.u = 0;
local4.x = local1 + local5;
local4.u = 1;
local2++;
}
this.offset = 0;
}
public function setMaterial(param1:TextureMaterial, param2:int) : void {
this.direction = param2;
setMaterialToAllFaces(param1);
if(param1 != null && param1.texture != null) {
this.segment = this.width * param1.texture.height / param1.texture.width;
} else {
this.segment = this.width;
}
this.offset = 0;
this.wave1Offset = 0;
this.wave2Offset = 0;
}
public function update(param1:int, param2:Number = 512) : void {
var local14:Vertex = null;
var local15:Vertex = null;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local3:Number = 600;
var local4:Number = 350;
var local5:Number = 0.13;
var local6:Number = 450;
var local7:Number = 400;
this.wave1Offset += local6 * param1 / 1000;
this.wave2Offset += local7 * param1 / 1000;
var local8:Number = 1.1 * this.direction;
this.offset += local8 * param1 / 1000;
var local9:Number = param2 / this.count;
var local10:Number = param2 / 2;
var local11:Number = 150;
var local12:Number = 1;
var local13:int = 0;
while(local13 < this.vertsLen) {
local14 = this.verts[local13];
local13++;
local15 = this.verts[local13];
local14.y = param2 - (local13 >> 1) * local9;
local15.y = local14.y;
local16 = local10 - local14.y;
local14.v = local16 / this.segment + this.offset + this.rnd;
local15.v = local14.v;
if(local14.y < local10) {
local12 = local14.y / local11;
} else {
local12 = (param2 - local14.y) / local11;
}
if(local12 > 1) {
local12 = 1;
}
local17 = Math.sin((Math.PI * 2 + this.phase) * (local16 + this.wave1Offset) / local3);
local18 = Math.sin((Math.PI * 2 + this.phase) * (local16 + this.wave2Offset) / local4);
local14.u = (local17 + local18) * 0.5 * local5 * local12;
local15.u = 1 + local14.u;
local13++;
}
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.user.spawn {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.user.spawn.TankSpawnerCC;
public class VectorCodecTankSpawnerCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecTankSpawnerCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(TankSpawnerCC,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.<TankSpawnerCC> = new Vector.<TankSpawnerCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = TankSpawnerCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:TankSpawnerCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<TankSpawnerCC> = Vector.<TankSpawnerCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.model.payment.shop.itemcategory {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ShopItemCategoryEvents implements ShopItemCategory {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ShopItemCategoryEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getCategory() : IGameObject {
var result:IGameObject = null;
var i:int = 0;
var m:ShopItemCategory = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ShopItemCategory(this.impl[i]);
result = m.getCategory();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package com.lorentz.SVG.data.filters
{
import com.lorentz.SVG.utils.ICloneable;
import flash.filters.BitmapFilter;
public class SVGFilterCollection implements ICloneable
{
public var svgFilters:Vector.<ISVGFilter> = new Vector.<ISVGFilter>();
public function getFlashFilters():Array {
var flashFilters:Array = [];
for each(var svgFilter:ISVGFilter in svgFilters){
var flashFilter:BitmapFilter = svgFilter.getFlashFilter();
if(flashFilter)
flashFilters.push(flashFilter);
}
return flashFilters;
}
public function clone():Object
{
var c:SVGFilterCollection = new SVGFilterCollection();
for(var i:int = 0; i < svgFilters.length; i++){
c.svgFilters.push(svgFilters[i].clone());
}
return c;
}
}
}
|
package alternativa.tanks.controller.commands.socialnetwork {
import alternativa.tanks.controller.events.socialnetwork.ExternalLoginEvent;
import alternativa.tanks.service.AccountService;
import alternativa.tanks.service.IEntranceServerFacade;
import org.robotlegs.mvcs.Command;
public class ExternalLoginCommand extends Command {
[Inject]
public var entranceGateway:IEntranceServerFacade;
[Inject]
public var loginEvent:ExternalLoginEvent;
[Inject]
public var accountService:AccountService;
public function ExternalLoginCommand() {
super();
}
override public function execute() : void {
this.accountService.storedUserName = this.loginEvent.callsign;
this.entranceGateway.loginExternal(this.loginEvent.callsign,this.loginEvent.password);
}
}
}
|
package alternativa.tanks.gui.payment.forms.mobile {
import alternativa.osgi.service.display.IDisplay;
import assets.icons.InputCheckIcon;
import controls.base.LabelBase;
import controls.base.TankInputBase;
import flash.events.Event;
public class PhoneNumberInput extends TankInputBase {
[Inject]
public static var displayService:IDisplay;
private var phoneLength:int = 10;
private var countryCode:String = "7";
private var countryCodeLabel:LabelBase = new LabelBase();
private var wait:InputCheckIcon = new InputCheckIcon();
public function PhoneNumberInput(param1:Boolean = false) {
super();
restrict = "0-9";
maxChars = 15;
width = param1 ? 150 : 115;
textField.width = 90;
textField.text = "";
this.countryCodeLabel.width = 30;
this.countryCodeLabel.text = "+7";
addChild(this.countryCodeLabel);
this.countryCodeLabel.x = 3;
this.countryCodeLabel.y = textField.y;
textField.x = this.countryCodeLabel.x + this.countryCodeLabel.textWidth + 3;
validValue = true;
textField.addEventListener(Event.CHANGE,this.onTextChange);
}
private function onTextChange(param1:Event = null) : void {
var local2:Boolean = textField.text.length == this.phoneLength;
if(local2) {
this.waiting();
displayService.stage.focus = null;
textField.mouseEnabled = false;
} else {
this.hideWait();
}
dispatchEvent(new PhoneNumberEvent(PhoneNumberEvent.CHANGED,this.getPhoneNumber(),local2));
}
public function isPhoneNonEmpty() : Boolean {
return textField.text.length > 0;
}
public function setCountryCode(param1:int, param2:int) : void {
this.phoneLength = param2;
maxChars = param2;
this.countryCode = param1.toString();
this.countryCodeLabel.text = "+" + this.countryCode;
textField.x = this.countryCodeLabel.x + this.countryCodeLabel.textWidth + 3;
this.onTextChange();
}
public function getPhoneNumber() : String {
return this.countryCode + textField.text;
}
public function onValidNumber() : void {
this.showWait(2);
textField.mouseEnabled = true;
}
public function onInvalidNumber() : void {
this.showWait(3);
textField.mouseEnabled = true;
displayService.stage.focus = textField;
}
public function waiting() : void {
this.showWait(1);
}
private function showWait(param1:int) : void {
if(this.wait.parent == null) {
addChild(this.wait);
}
this.wait.gotoAndStop(param1);
this.wait.x = width - this.wait.width - 15;
this.wait.y = height - this.wait.height >> 1;
}
private function hideWait() : void {
if(this.wait.parent != null) {
removeChild(this.wait);
}
}
public function reset() : void {
textField.text = "";
this.hideWait();
textField.mouseEnabled = true;
displayService.stage.focus = textField;
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.asyncurl {
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 AsyncUrlModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _getUrlId:Long = Long.getLong(1083850912,1603838584);
private var _getUrl_shopItemCodec:ICodec;
private var model:IModel;
public function AsyncUrlModelServer(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._getUrl_shopItemCodec = this.protocol.getCodec(new TypeCodecInfo(IGameObject,false));
}
public function getUrl(param1:IGameObject) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._getUrl_shopItemCodec.encode(this.protocolBuffer,param1);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local2:SpaceCommand = new SpaceCommand(Model.object.id,this._getUrlId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package _codec.projects.tanks.client.clans.clan.permissions {
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.clans.clan.permissions.ClanPermissionsCC;
public class VectorCodecClanPermissionsCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecClanPermissionsCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ClanPermissionsCC,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.<ClanPermissionsCC> = new Vector.<ClanPermissionsCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ClanPermissionsCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ClanPermissionsCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ClanPermissionsCC> = Vector.<ClanPermissionsCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank28.png")]
public class PremiumRankBitmaps_bitmapSmallRank28 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank28() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.rocketlauncher {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class RocketLauncherModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:RocketLauncherModelServer;
private var client:IRocketLauncherModelBase = IRocketLauncherModelBase(this);
private var modelId:Long = Long.getLong(941970784,-960815088);
public function RocketLauncherModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new RocketLauncherModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(RocketLauncherCC,false)));
}
protected function getInitParam() : RocketLauncherCC {
return RocketLauncherCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.osgi.service.log
{
public interface ILogService
{
function log(param1:int, param2:String, param3:String = null) : void;
}
}
|
package alternativa.tanks.calculators {
public interface IExchangeCalculator {
function calculateWithoutPackets(param1:int) : Number;
function calculateCrystalsWithoutPackets(param1:Number) : int;
function calculate(param1:int) : Number;
function calculateUsingPaymentPackages(param1:int) : Number;
function calculateInverse(param1:Number) : int;
function calculateBonus(param1:Number) : int;
function calculatePremiumDuration(param1:Number) : int;
}
}
|
package alternativa.engine3d.lights
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Light3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import flash.display.Sprite;
use namespace alternativa3d;
public class TubeLight extends Light3D
{
public var length:Number;
public var attenuationBegin:Number;
public var attenuationEnd:Number;
public var falloff:Number;
public function TubeLight(param1:uint, param2:Number, param3:Number, param4:Number, param5:Number)
{
super();
this.color = param1;
this.length = param2;
this.attenuationBegin = param3;
this.attenuationEnd = param4;
this.falloff = param5;
calculateBounds();
}
public function lookAt(param1:Number, param2:Number, param3:Number) : void
{
var _loc5_:Number = NaN;
var _loc4_:Number = NaN;
_loc4_ = param1 - this.x;
_loc5_ = param2 - this.y;
var _loc6_:Number = param3 - this.z;
rotationX = Math.atan2(_loc6_,Math.sqrt(_loc4_ * _loc4_ + _loc5_ * _loc5_)) - Math.PI / 2;
rotationY = 0;
rotationZ = -Math.atan2(_loc4_,_loc5_);
}
override public function clone() : Object3D
{
var _loc1_:TubeLight = new TubeLight(color,this.length,this.attenuationBegin,this.attenuationEnd,this.falloff);
_loc1_.clonePropertiesFrom(this);
return _loc1_;
}
override alternativa3d function drawDebug(param1:Camera3D) : void
{
var _loc3_:Sprite = null;
var _loc4_:Number = NaN;
var _loc5_:Number = NaN;
var _loc6_:Number = NaN;
var _loc7_:int = 0;
var _loc8_:Number = NaN;
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:Number = NaN;
var _loc13_:Number = NaN;
var _loc14_:Number = NaN;
var _loc15_:Number = NaN;
var _loc16_:Number = NaN;
var _loc17_:Number = NaN;
var _loc18_:Number = NaN;
var _loc19_:Number = NaN;
var _loc20_:Number = NaN;
var _loc21_:Number = NaN;
var _loc22_:Number = NaN;
var _loc23_:Number = NaN;
var _loc24_:Number = NaN;
var _loc25_:Number = NaN;
var _loc26_:Number = NaN;
var _loc27_:Number = NaN;
var _loc28_:Number = NaN;
var _loc29_:Number = NaN;
var _loc30_:Number = NaN;
var _loc31_:Number = NaN;
var _loc32_:Number = NaN;
var _loc33_:Number = NaN;
var _loc34_:Number = NaN;
var _loc35_:Number = NaN;
var _loc36_:Number = NaN;
var _loc37_:Number = NaN;
var _loc38_:Number = NaN;
var _loc39_:Number = NaN;
var _loc40_:Number = NaN;
var _loc41_:Number = NaN;
var _loc42_:Number = NaN;
var _loc43_:Number = NaN;
var _loc44_:Number = NaN;
var _loc45_:Number = NaN;
var _loc46_:Number = NaN;
var _loc47_:Number = NaN;
var _loc48_:Number = NaN;
var _loc49_:Number = NaN;
var _loc50_:Number = NaN;
var _loc51_:Number = NaN;
var _loc52_:Number = NaN;
var _loc53_:Number = NaN;
var _loc54_:Number = NaN;
var _loc55_:Number = NaN;
var _loc2_:int = param1.checkInDebug(this);
if(_loc2_ > 0)
{
_loc3_ = param1.view.canvas;
if(_loc2_ & Debug.LIGHTS && ml > param1.nearClipping)
{
_loc4_ = (color >> 16 & 255) * intensity;
_loc5_ = (color >> 8 & 255) * intensity;
_loc6_ = (color & 255) * intensity;
_loc7_ = ((_loc4_ > 255 ? 255 : _loc4_) << 16) + ((_loc5_ > 255 ? 255 : _loc5_) << 8) + (_loc6_ > 255 ? 255 : _loc6_);
_loc8_ = md + ma * this.attenuationBegin;
_loc9_ = mh + me * this.attenuationBegin;
_loc10_ = ml + mi * this.attenuationBegin;
_loc11_ = md + (ma * this.attenuationBegin + mb * this.attenuationBegin) * 0.9;
_loc12_ = mh + (me * this.attenuationBegin + mf * this.attenuationBegin) * 0.9;
_loc13_ = ml + (mi * this.attenuationBegin + mj * this.attenuationBegin) * 0.9;
_loc14_ = md + mb * this.attenuationBegin;
_loc15_ = mh + mf * this.attenuationBegin;
_loc16_ = ml + mj * this.attenuationBegin;
_loc17_ = md - (ma * this.attenuationBegin - mb * this.attenuationBegin) * 0.9;
_loc18_ = mh - (me * this.attenuationBegin - mf * this.attenuationBegin) * 0.9;
_loc19_ = ml - (mi * this.attenuationBegin - mj * this.attenuationBegin) * 0.9;
_loc20_ = md - ma * this.attenuationBegin;
_loc21_ = mh - me * this.attenuationBegin;
_loc22_ = ml - mi * this.attenuationBegin;
_loc23_ = md - (ma * this.attenuationBegin + mb * this.attenuationBegin) * 0.9;
_loc24_ = mh - (me * this.attenuationBegin + mf * this.attenuationBegin) * 0.9;
_loc25_ = ml - (mi * this.attenuationBegin + mj * this.attenuationBegin) * 0.9;
_loc26_ = md - mb * this.attenuationBegin;
_loc27_ = mh - mf * this.attenuationBegin;
_loc28_ = ml - mj * this.attenuationBegin;
_loc29_ = md + (ma * this.attenuationBegin - mb * this.attenuationBegin) * 0.9;
_loc30_ = mh + (me * this.attenuationBegin - mf * this.attenuationBegin) * 0.9;
_loc31_ = ml + (mi * this.attenuationBegin - mj * this.attenuationBegin) * 0.9;
_loc32_ = md + mc * this.length + ma * this.attenuationBegin;
_loc33_ = mh + mg * this.length + me * this.attenuationBegin;
_loc34_ = ml + mk * this.length + mi * this.attenuationBegin;
_loc35_ = md + mc * this.length + (ma * this.attenuationBegin + mb * this.attenuationBegin) * 0.9;
_loc36_ = mh + mg * this.length + (me * this.attenuationBegin + mf * this.attenuationBegin) * 0.9;
_loc37_ = ml + mk * this.length + (mi * this.attenuationBegin + mj * this.attenuationBegin) * 0.9;
_loc38_ = md + mc * this.length + mb * this.attenuationBegin;
_loc39_ = mh + mg * this.length + mf * this.attenuationBegin;
_loc40_ = ml + mk * this.length + mj * this.attenuationBegin;
_loc41_ = md + mc * this.length - (ma * this.attenuationBegin - mb * this.attenuationBegin) * 0.9;
_loc42_ = mh + mg * this.length - (me * this.attenuationBegin - mf * this.attenuationBegin) * 0.9;
_loc43_ = ml + mk * this.length - (mi * this.attenuationBegin - mj * this.attenuationBegin) * 0.9;
_loc44_ = md + mc * this.length - ma * this.attenuationBegin;
_loc45_ = mh + mg * this.length - me * this.attenuationBegin;
_loc46_ = ml + mk * this.length - mi * this.attenuationBegin;
_loc47_ = md + mc * this.length - (ma * this.attenuationBegin + mb * this.attenuationBegin) * 0.9;
_loc48_ = mh + mg * this.length - (me * this.attenuationBegin + mf * this.attenuationBegin) * 0.9;
_loc49_ = ml + mk * this.length - (mi * this.attenuationBegin + mj * this.attenuationBegin) * 0.9;
_loc50_ = md + mc * this.length - mb * this.attenuationBegin;
_loc51_ = mh + mg * this.length - mf * this.attenuationBegin;
_loc52_ = ml + mk * this.length - mj * this.attenuationBegin;
_loc53_ = md + mc * this.length + (ma * this.attenuationBegin - mb * this.attenuationBegin) * 0.9;
_loc54_ = mh + mg * this.length + (me * this.attenuationBegin - mf * this.attenuationBegin) * 0.9;
_loc55_ = ml + mk * this.length + (mi * this.attenuationBegin - mj * this.attenuationBegin) * 0.9;
if(_loc10_ > param1.nearClipping && _loc13_ > param1.nearClipping && _loc16_ > param1.nearClipping && _loc19_ > param1.nearClipping && _loc22_ > param1.nearClipping && _loc25_ > param1.nearClipping && _loc28_ > param1.nearClipping && _loc31_ > param1.nearClipping && _loc34_ > param1.nearClipping && _loc37_ > param1.nearClipping && _loc40_ > param1.nearClipping && _loc43_ > param1.nearClipping && _loc46_ > param1.nearClipping && _loc49_ > param1.nearClipping && _loc52_ > param1.nearClipping && _loc55_ > param1.nearClipping)
{
_loc3_.graphics.lineStyle(1,_loc7_);
_loc3_.graphics.moveTo(_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_);
_loc3_.graphics.curveTo(_loc11_ * param1.viewSizeX / _loc13_,_loc12_ * param1.viewSizeY / _loc13_,_loc14_ * param1.viewSizeX / _loc16_,_loc15_ * param1.viewSizeY / _loc16_);
_loc3_.graphics.curveTo(_loc17_ * param1.viewSizeX / _loc19_,_loc18_ * param1.viewSizeY / _loc19_,_loc20_ * param1.viewSizeX / _loc22_,_loc21_ * param1.viewSizeY / _loc22_);
_loc3_.graphics.curveTo(_loc23_ * param1.viewSizeX / _loc25_,_loc24_ * param1.viewSizeY / _loc25_,_loc26_ * param1.viewSizeX / _loc28_,_loc27_ * param1.viewSizeY / _loc28_);
_loc3_.graphics.curveTo(_loc29_ * param1.viewSizeX / _loc31_,_loc30_ * param1.viewSizeY / _loc31_,_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_);
_loc3_.graphics.moveTo(_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_);
_loc3_.graphics.curveTo(_loc35_ * param1.viewSizeX / _loc37_,_loc36_ * param1.viewSizeY / _loc37_,_loc38_ * param1.viewSizeX / _loc40_,_loc39_ * param1.viewSizeY / _loc40_);
_loc3_.graphics.curveTo(_loc41_ * param1.viewSizeX / _loc43_,_loc42_ * param1.viewSizeY / _loc43_,_loc44_ * param1.viewSizeX / _loc46_,_loc45_ * param1.viewSizeY / _loc46_);
_loc3_.graphics.curveTo(_loc47_ * param1.viewSizeX / _loc49_,_loc48_ * param1.viewSizeY / _loc49_,_loc50_ * param1.viewSizeX / _loc52_,_loc51_ * param1.viewSizeY / _loc52_);
_loc3_.graphics.curveTo(_loc53_ * param1.viewSizeX / _loc55_,_loc54_ * param1.viewSizeY / _loc55_,_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_);
_loc3_.graphics.moveTo(_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_);
_loc3_.graphics.lineTo(_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_);
_loc3_.graphics.moveTo(_loc14_ * param1.viewSizeX / _loc16_,_loc15_ * param1.viewSizeY / _loc16_);
_loc3_.graphics.lineTo(_loc38_ * param1.viewSizeX / _loc40_,_loc39_ * param1.viewSizeY / _loc40_);
_loc3_.graphics.moveTo(_loc20_ * param1.viewSizeX / _loc22_,_loc21_ * param1.viewSizeY / _loc22_);
_loc3_.graphics.lineTo(_loc44_ * param1.viewSizeX / _loc46_,_loc45_ * param1.viewSizeY / _loc46_);
_loc3_.graphics.moveTo(_loc26_ * param1.viewSizeX / _loc28_,_loc27_ * param1.viewSizeY / _loc28_);
_loc3_.graphics.lineTo(_loc50_ * param1.viewSizeX / _loc52_,_loc51_ * param1.viewSizeY / _loc52_);
}
_loc8_ = md - mc * this.falloff + ma * this.attenuationEnd;
_loc9_ = mh - mg * this.falloff + me * this.attenuationEnd;
_loc10_ = ml - mk * this.falloff + mi * this.attenuationEnd;
_loc11_ = md - mc * this.falloff + (ma * this.attenuationEnd + mb * this.attenuationEnd) * 0.9;
_loc12_ = mh - mg * this.falloff + (me * this.attenuationEnd + mf * this.attenuationEnd) * 0.9;
_loc13_ = ml - mk * this.falloff + (mi * this.attenuationEnd + mj * this.attenuationEnd) * 0.9;
_loc14_ = md - mc * this.falloff + mb * this.attenuationEnd;
_loc15_ = mh - mg * this.falloff + mf * this.attenuationEnd;
_loc16_ = ml - mk * this.falloff + mj * this.attenuationEnd;
_loc17_ = md - mc * this.falloff - (ma * this.attenuationEnd - mb * this.attenuationEnd) * 0.9;
_loc18_ = mh - mg * this.falloff - (me * this.attenuationEnd - mf * this.attenuationEnd) * 0.9;
_loc19_ = ml - mk * this.falloff - (mi * this.attenuationEnd - mj * this.attenuationEnd) * 0.9;
_loc20_ = md - mc * this.falloff - ma * this.attenuationEnd;
_loc21_ = mh - mg * this.falloff - me * this.attenuationEnd;
_loc22_ = ml - mk * this.falloff - mi * this.attenuationEnd;
_loc23_ = md - mc * this.falloff - (ma * this.attenuationEnd + mb * this.attenuationEnd) * 0.9;
_loc24_ = mh - mg * this.falloff - (me * this.attenuationEnd + mf * this.attenuationEnd) * 0.9;
_loc25_ = ml - mk * this.falloff - (mi * this.attenuationEnd + mj * this.attenuationEnd) * 0.9;
_loc26_ = md - mc * this.falloff - mb * this.attenuationEnd;
_loc27_ = mh - mg * this.falloff - mf * this.attenuationEnd;
_loc28_ = ml - mk * this.falloff - mj * this.attenuationEnd;
_loc29_ = md - mc * this.falloff + (ma * this.attenuationEnd - mb * this.attenuationEnd) * 0.9;
_loc30_ = mh - mg * this.falloff + (me * this.attenuationEnd - mf * this.attenuationEnd) * 0.9;
_loc31_ = ml - mk * this.falloff + (mi * this.attenuationEnd - mj * this.attenuationEnd) * 0.9;
_loc32_ = md + mc * (this.length + this.falloff) + ma * this.attenuationEnd;
_loc33_ = mh + mg * (this.length + this.falloff) + me * this.attenuationEnd;
_loc34_ = ml + mk * (this.length + this.falloff) + mi * this.attenuationEnd;
_loc35_ = md + mc * (this.length + this.falloff) + (ma * this.attenuationEnd + mb * this.attenuationEnd) * 0.9;
_loc36_ = mh + mg * (this.length + this.falloff) + (me * this.attenuationEnd + mf * this.attenuationEnd) * 0.9;
_loc37_ = ml + mk * (this.length + this.falloff) + (mi * this.attenuationEnd + mj * this.attenuationEnd) * 0.9;
_loc38_ = md + mc * (this.length + this.falloff) + mb * this.attenuationEnd;
_loc39_ = mh + mg * (this.length + this.falloff) + mf * this.attenuationEnd;
_loc40_ = ml + mk * (this.length + this.falloff) + mj * this.attenuationEnd;
_loc41_ = md + mc * (this.length + this.falloff) - (ma * this.attenuationEnd - mb * this.attenuationEnd) * 0.9;
_loc42_ = mh + mg * (this.length + this.falloff) - (me * this.attenuationEnd - mf * this.attenuationEnd) * 0.9;
_loc43_ = ml + mk * (this.length + this.falloff) - (mi * this.attenuationEnd - mj * this.attenuationEnd) * 0.9;
_loc44_ = md + mc * (this.length + this.falloff) - ma * this.attenuationEnd;
_loc45_ = mh + mg * (this.length + this.falloff) - me * this.attenuationEnd;
_loc46_ = ml + mk * (this.length + this.falloff) - mi * this.attenuationEnd;
_loc47_ = md + mc * (this.length + this.falloff) - (ma * this.attenuationEnd + mb * this.attenuationEnd) * 0.9;
_loc48_ = mh + mg * (this.length + this.falloff) - (me * this.attenuationEnd + mf * this.attenuationEnd) * 0.9;
_loc49_ = ml + mk * (this.length + this.falloff) - (mi * this.attenuationEnd + mj * this.attenuationEnd) * 0.9;
_loc50_ = md + mc * (this.length + this.falloff) - mb * this.attenuationEnd;
_loc51_ = mh + mg * (this.length + this.falloff) - mf * this.attenuationEnd;
_loc52_ = ml + mk * (this.length + this.falloff) - mj * this.attenuationEnd;
_loc53_ = md + mc * (this.length + this.falloff) + (ma * this.attenuationEnd - mb * this.attenuationEnd) * 0.9;
_loc54_ = mh + mg * (this.length + this.falloff) + (me * this.attenuationEnd - mf * this.attenuationEnd) * 0.9;
_loc55_ = ml + mk * (this.length + this.falloff) + (mi * this.attenuationEnd - mj * this.attenuationEnd) * 0.9;
if(_loc10_ > param1.nearClipping && _loc13_ > param1.nearClipping && _loc16_ > param1.nearClipping && _loc19_ > param1.nearClipping && _loc22_ > param1.nearClipping && _loc25_ > param1.nearClipping && _loc28_ > param1.nearClipping && _loc31_ > param1.nearClipping && _loc34_ > param1.nearClipping && _loc37_ > param1.nearClipping && _loc40_ > param1.nearClipping && _loc43_ > param1.nearClipping && _loc46_ > param1.nearClipping && _loc49_ > param1.nearClipping && _loc52_ > param1.nearClipping && _loc55_ > param1.nearClipping)
{
_loc3_.graphics.lineStyle(1,_loc7_);
_loc3_.graphics.moveTo(_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_);
_loc3_.graphics.curveTo(_loc11_ * param1.viewSizeX / _loc13_,_loc12_ * param1.viewSizeY / _loc13_,_loc14_ * param1.viewSizeX / _loc16_,_loc15_ * param1.viewSizeY / _loc16_);
_loc3_.graphics.curveTo(_loc17_ * param1.viewSizeX / _loc19_,_loc18_ * param1.viewSizeY / _loc19_,_loc20_ * param1.viewSizeX / _loc22_,_loc21_ * param1.viewSizeY / _loc22_);
_loc3_.graphics.curveTo(_loc23_ * param1.viewSizeX / _loc25_,_loc24_ * param1.viewSizeY / _loc25_,_loc26_ * param1.viewSizeX / _loc28_,_loc27_ * param1.viewSizeY / _loc28_);
_loc3_.graphics.curveTo(_loc29_ * param1.viewSizeX / _loc31_,_loc30_ * param1.viewSizeY / _loc31_,_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_);
_loc3_.graphics.moveTo(_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_);
_loc3_.graphics.curveTo(_loc35_ * param1.viewSizeX / _loc37_,_loc36_ * param1.viewSizeY / _loc37_,_loc38_ * param1.viewSizeX / _loc40_,_loc39_ * param1.viewSizeY / _loc40_);
_loc3_.graphics.curveTo(_loc41_ * param1.viewSizeX / _loc43_,_loc42_ * param1.viewSizeY / _loc43_,_loc44_ * param1.viewSizeX / _loc46_,_loc45_ * param1.viewSizeY / _loc46_);
_loc3_.graphics.curveTo(_loc47_ * param1.viewSizeX / _loc49_,_loc48_ * param1.viewSizeY / _loc49_,_loc50_ * param1.viewSizeX / _loc52_,_loc51_ * param1.viewSizeY / _loc52_);
_loc3_.graphics.curveTo(_loc53_ * param1.viewSizeX / _loc55_,_loc54_ * param1.viewSizeY / _loc55_,_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_);
_loc3_.graphics.moveTo(_loc8_ * param1.viewSizeX / _loc10_,_loc9_ * param1.viewSizeY / _loc10_);
_loc3_.graphics.lineTo(_loc32_ * param1.viewSizeX / _loc34_,_loc33_ * param1.viewSizeY / _loc34_);
_loc3_.graphics.moveTo(_loc14_ * param1.viewSizeX / _loc16_,_loc15_ * param1.viewSizeY / _loc16_);
_loc3_.graphics.lineTo(_loc38_ * param1.viewSizeX / _loc40_,_loc39_ * param1.viewSizeY / _loc40_);
_loc3_.graphics.moveTo(_loc20_ * param1.viewSizeX / _loc22_,_loc21_ * param1.viewSizeY / _loc22_);
_loc3_.graphics.lineTo(_loc44_ * param1.viewSizeX / _loc46_,_loc45_ * param1.viewSizeY / _loc46_);
_loc3_.graphics.moveTo(_loc26_ * param1.viewSizeX / _loc28_,_loc27_ * param1.viewSizeY / _loc28_);
_loc3_.graphics.lineTo(_loc50_ * param1.viewSizeX / _loc52_,_loc51_ * param1.viewSizeY / _loc52_);
}
}
if(_loc2_ & Debug.BOUNDS)
{
Debug.drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ,10092288);
}
}
}
override alternativa3d function updateBounds(param1:Object3D, param2:Object3D = null) : void
{
var _loc3_:Vertex = null;
if(param2 != null)
{
_loc3_ = boundVertexList;
_loc3_.x = -this.attenuationEnd;
_loc3_.y = -this.attenuationEnd;
_loc3_.z = -this.falloff;
_loc3_ = _loc3_.next;
_loc3_.x = this.attenuationEnd;
_loc3_.y = -this.attenuationEnd;
_loc3_.z = -this.falloff;
_loc3_ = _loc3_.next;
_loc3_.x = -this.attenuationEnd;
_loc3_.y = this.attenuationEnd;
_loc3_.z = -this.falloff;
_loc3_ = _loc3_.next;
_loc3_.x = this.attenuationEnd;
_loc3_.y = this.attenuationEnd;
_loc3_.z = -this.falloff;
_loc3_ = _loc3_.next;
_loc3_.x = -this.attenuationEnd;
_loc3_.y = -this.attenuationEnd;
_loc3_.z = this.length + this.falloff;
_loc3_ = _loc3_.next;
_loc3_.x = this.attenuationEnd;
_loc3_.y = -this.attenuationEnd;
_loc3_.z = this.length + this.falloff;
_loc3_ = _loc3_.next;
_loc3_.x = -this.attenuationEnd;
_loc3_.y = this.attenuationEnd;
_loc3_.z = this.length + this.falloff;
_loc3_ = _loc3_.next;
_loc3_.x = this.attenuationEnd;
_loc3_.y = this.attenuationEnd;
_loc3_.z = this.length + this.falloff;
_loc3_ = boundVertexList;
while(_loc3_ != null)
{
_loc3_.cameraX = param2.ma * _loc3_.x + param2.mb * _loc3_.y + param2.mc * _loc3_.z + param2.md;
_loc3_.cameraY = param2.me * _loc3_.x + param2.mf * _loc3_.y + param2.mg * _loc3_.z + param2.mh;
_loc3_.cameraZ = param2.mi * _loc3_.x + param2.mj * _loc3_.y + param2.mk * _loc3_.z + param2.ml;
if(_loc3_.cameraX < param1.boundMinX)
{
param1.boundMinX = _loc3_.cameraX;
}
if(_loc3_.cameraX > param1.boundMaxX)
{
param1.boundMaxX = _loc3_.cameraX;
}
if(_loc3_.cameraY < param1.boundMinY)
{
param1.boundMinY = _loc3_.cameraY;
}
if(_loc3_.cameraY > param1.boundMaxY)
{
param1.boundMaxY = _loc3_.cameraY;
}
if(_loc3_.cameraZ < param1.boundMinZ)
{
param1.boundMinZ = _loc3_.cameraZ;
}
if(_loc3_.cameraZ > param1.boundMaxZ)
{
param1.boundMaxZ = _loc3_.cameraZ;
}
_loc3_ = _loc3_.next;
}
}
else
{
if(-this.attenuationEnd < param1.boundMinX)
{
param1.boundMinX = -this.attenuationEnd;
}
if(this.attenuationEnd > param1.boundMaxX)
{
param1.boundMaxX = this.attenuationEnd;
}
if(-this.attenuationEnd < param1.boundMinY)
{
param1.boundMinY = -this.attenuationEnd;
}
if(this.attenuationEnd > param1.boundMaxY)
{
param1.boundMaxY = this.attenuationEnd;
}
if(-this.falloff < param1.boundMinZ)
{
param1.boundMinZ = -this.falloff;
}
if(this.length + this.falloff > param1.boundMaxZ)
{
param1.boundMaxZ = this.length + this.falloff;
}
}
}
}
}
|
package alternativa.engine3d.core
{
import alternativa.gfx.agal.FragmentShader;
import alternativa.gfx.agal.SamplerDim;
import alternativa.gfx.agal.SamplerFilter;
import alternativa.gfx.agal.SamplerMipMap;
import alternativa.gfx.agal.SamplerRepeat;
public class DepthRendererSSAOFragmentShader extends FragmentShader
{
public function DepthRendererSSAOFragmentShader(param1:int)
{
super();
tex(ft0,v0,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
mul(ft0.zw,ft0,fc[6]);
cos(ft1,ft0);
sin(ft2,ft0);
mul(ft1.x,ft1.w,ft1.z);
mul(ft1.y,ft2.w,ft1.z);
neg(ft1.z,ft2);
dp3(ft2.z,ft0,fc[0]);
mul(ft2.xy,v2,ft2.z);
tex(ft3,v1,fs1.dim(SamplerDim.D2).repeat(SamplerRepeat.WRAP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
mul(ft3.z,ft3,fc[1]);
mul(ft3,ft3.z,ft3);
var _loc2_:int = 0;
while(_loc2_ < param1)
{
if(_loc2_ > 0)
{
if(_loc2_ % 2 > 0)
{
dp3(ft6,ft3,fc[4]);
dp3(ft6.y,ft3,fc[5]);
}
else
{
dp3(ft3.x,ft6,fc[4]);
dp3(ft3.y,ft6,fc[5]);
}
}
if(_loc2_ % 2 > 0)
{
div(ft4,ft6,fc[3]);
}
else
{
div(ft4,ft3,fc[3]);
}
div(ft4,ft4,ft2.z);
div(ft4,ft4,fc[1]);
add(ft4,v0,ft4);
min(ft5,ft4,fc[6]);
tex(ft5,ft5,fs0.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
dp3(ft5.z,ft5,fc[0]);
mul(ft5.xy,ft4,fc[1]);
sub(ft5.xy,ft5,fc[2]);
mul(ft5.xy,ft5,ft5.z);
sub(ft5,ft5,ft2);
mul(ft5,ft5,fc[3]);
dp3(ft5.w,ft5,ft5);
sqt(ft5.w,ft5);
div(ft5.xyz,ft5,ft5.w);
mul(ft5.w,ft5,fc[3]);
sub(ft5.w,fc[1],ft5);
max(ft5.w,ft5,fc[4]);
dp3(ft5.z,ft5,ft1);
sub(ft5.z,ft5,fc[2]);
max(ft5.z,ft5,fc[0]);
mul(ft5.w,ft5,ft5.z);
if(_loc2_ == 0)
{
mov(ft0.w,ft5);
}
else
{
add(ft0.w,ft0,ft5);
}
_loc2_++;
}
mul(ft0.w,ft0,fc[2]);
mov(oc,ft0);
}
}
}
|
package alternativa.tanks.gui.friends {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.FriendsWindowStateBigButton_clanClass.png")]
public class FriendsWindowStateBigButton_clanClass extends BitmapAsset {
public function FriendsWindowStateBigButton_clanClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.errors {
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 ErrorsDescriptionModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ErrorsDescriptionModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.models.weapons.targeting {
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapons.targeting.direction.sector.SectorDirectionCalculator;
import alternativa.tanks.models.weapons.targeting.priority.TargetingPriorityCalculator;
import alternativa.tanks.models.weapons.targeting.priority.targeting.ShaftTargetPriorityCalculator;
import alternativa.tanks.models.weapons.targeting.processor.SingleTargetDirectionProcessor;
import platform.client.fp10.core.type.IGameObject;
public class ShaftTargetingSystem extends TargetingSystem {
public function ShaftTargetingSystem(param1:IGameObject, param2:WeaponObject, param3:Number) {
var local4:TargetingPriorityCalculator = new TargetingPriorityCalculator(new ShaftTargetPriorityCalculator(param2));
super(new SectorDirectionCalculator(param1,param2,param3,local4),new SingleTargetDirectionProcessor(param1,param3),local4);
}
}
}
|
package alternativa.tanks.models.weapon.shaft.sfx
{
import alternativa.tanks.sfx.MobileSound3DEffect;
import flash.media.SoundChannel;
public class ShaftSFXUserData
{
public var manualModeEffect:MobileSound3DEffect;
public var turretSoundChannel:SoundChannel;
public function ShaftSFXUserData()
{
super();
}
}
}
|
package _codec.projects.tanks.client.panel.model.payment.modes.sms {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.payment.modes.sms.SMSPayModeCC;
public class VectorCodecSMSPayModeCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecSMSPayModeCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(SMSPayModeCC,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.<SMSPayModeCC> = new Vector.<SMSPayModeCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = SMSPayModeCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:SMSPayModeCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<SMSPayModeCC> = Vector.<SMSPayModeCC>(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 {
import flash.display.Sprite;
import flash.system.Security;
public class _94a1da8e22a2c6b985d5245debdf86fd15df9f417d92201a6b36b2cb9f179ba6_flash_display_Sprite extends Sprite {
public function _94a1da8e22a2c6b985d5245debdf86fd15df9f417d92201a6b36b2cb9f179ba6_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.statistics {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventListener;
import alternativa.tanks.battle.events.ControlMiniHelpCloseEvent;
import alternativa.tanks.models.battle.gui.gui.help.ControlsMiniHelp;
import alternativa.tanks.services.battlegui.BattleGUIService;
import flash.events.Event;
import flash.net.SharedObject;
import platform.client.fp10.core.type.AutoClosable;
import projects.tanks.clients.fp10.libraries.tanksservices.service.storage.IStorageService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
public class ControlsMiniHelpSupport implements AutoClosable, BattleEventListener {
[Inject]
public static var storageService:IStorageService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var userPropertiesService:IUserPropertiesService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var battleGuiService:BattleGUIService;
private static const SHARED_OBJECT_KEY:String = "disableControlsMiniHelp";
private var controlsMiniHelp:ControlsMiniHelp;
public function ControlsMiniHelpSupport() {
super();
var local1:SharedObject = storageService.getStorage();
if(!local1.data[SHARED_OBJECT_KEY]) {
if(userPropertiesService.rank == 1) {
local1.data[SHARED_OBJECT_KEY] = 1;
this.setupMiniHelp();
}
}
}
private function setupMiniHelp() : void {
this.controlsMiniHelp = new ControlsMiniHelp();
battleGuiService.getGuiContainer().addChild(this.controlsMiniHelp);
this.setPosition();
battleEventDispatcher.addBattleEventListener(ControlMiniHelpCloseEvent,this);
display.stage.addEventListener(Event.RESIZE,this.onResize);
}
private function onResize(param1:Event) : void {
this.setPosition();
}
private function setPosition() : void {
this.controlsMiniHelp.x = display.stage.stageWidth - this.controlsMiniHelp.width >> 1;
this.controlsMiniHelp.y = display.stage.stageHeight - this.controlsMiniHelp.height * 2;
}
public function handleBattleEvent(param1:Object) : void {
if(param1 is ControlMiniHelpCloseEvent) {
this.close();
}
}
[Obfuscation(rename="false")]
public function close() : void {
if(this.controlsMiniHelp != null) {
display.stage.removeEventListener(Event.RESIZE,this.onResize);
battleEventDispatcher.removeBattleEventListener(ControlMiniHelpCloseEvent,this);
this.controlsMiniHelp.parent.removeChild(this.controlsMiniHelp);
this.controlsMiniHelp = null;
}
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.