code
stringlengths 57
237k
|
|---|
package alternativa.tanks.loader.dishonestprogressbar {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.loader.dishonestprogressbar.DishonestProgressBar_blickClass.png")]
public class DishonestProgressBar_blickClass extends BitmapAsset {
public function DishonestProgressBar_blickClass() {
super();
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.angles.verticals {
public class VerticalAnglesCC {
private var _angleDown:Number;
private var _angleUp:Number;
public function VerticalAnglesCC(param1:Number = 0, param2:Number = 0) {
super();
this._angleDown = param1;
this._angleUp = param2;
}
public function get angleDown() : Number {
return this._angleDown;
}
public function set angleDown(param1:Number) : void {
this._angleDown = param1;
}
public function get angleUp() : Number {
return this._angleUp;
}
public function set angleUp(param1:Number) : void {
this._angleUp = param1;
}
public function toString() : String {
var local1:String = "VerticalAnglesCC [";
local1 += "angleDown = " + this.angleDown + " ";
local1 += "angleUp = " + this.angleUp + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.gui.payment.controls {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.payment.controls.ProceedButton_ButtonLeft.png")]
public class ProceedButton_ButtonLeft extends BitmapAsset {
public function ProceedButton_ButtonLeft() {
super();
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.clanmanagement.ClanStateButton_ButtonDownRight.png")]
public class ClanStateButton_ButtonDownRight extends BitmapAsset {
public function ClanStateButton_ButtonDownRight() {
super();
}
}
}
|
package forms.friends
{
public interface FriendsWindowButtonType
{
function getType() : FriendsWindowState;
}
}
|
package projects.tanks.client.battleselect.model.battle.dm {
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 BattleDMInfoModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BattleDMInfoModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.panel.model.donationalert {
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 DonationAlertModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _confirmId:Long = Long.getLong(938311383,322743647);
private var _confirm_timeCodec:ICodec;
private var _confirmWithEmailId:Long = Long.getLong(1212563039,-983677993);
private var _confirmWithEmail_timeCodec:ICodec;
private var _confirmWithEmail_emailCodec:ICodec;
private var _validateEmailId:Long = Long.getLong(1600620010,1076269957);
private var _validateEmail_emailCodec:ICodec;
private var model:IModel;
public function DonationAlertModelServer(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._confirm_timeCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._confirmWithEmail_timeCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
this._confirmWithEmail_emailCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._validateEmail_emailCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
}
public function confirm(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._confirm_timeCodec.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._confirmId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function confirmWithEmail(param1:Long, param2:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._confirmWithEmail_timeCodec.encode(this.protocolBuffer,param1);
this._confirmWithEmail_emailCodec.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._confirmWithEmailId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function validateEmail(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._validateEmail_emailCodec.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._validateEmailId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.gui.payment.forms.mobile {
import flash.events.Event;
public class PhoneNumberEvent extends Event {
public static const CHANGED:String = "PhoneNumberEvent:Changed";
private var phoneNumber:String;
private var correctLength:Boolean;
public function PhoneNumberEvent(param1:String, param2:String, param3:Boolean) {
super(param1);
this.phoneNumber = param2;
this.correctLength = param3;
}
public function getPhoneNumber() : String {
return this.phoneNumber;
}
public function isCorrectLength() : Boolean {
return this.correctLength;
}
}
}
|
package alternativa.tanks.camera {
public class DummyCameraController implements CameraController {
public static const INSTANCE:DummyCameraController = new DummyCameraController();
public function DummyCameraController() {
super();
}
public function update(param1:GameCamera, param2:int, param3:int) : void {
}
public function deactivate() : void {
}
public function activate(param1:GameCamera) : void {
}
}
}
|
package projects.tanks.client.panel.model.userscounter.panel {
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 UsersCounterPanelModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _hasNotUniqueUserIdId:Long = Long.getLong(171321216,342438057);
private var _receiveUniqueUserIdId:Long = Long.getLong(1973874434,750187617);
private var _receiveUniqueUserId_idCodec:ICodec;
private var model:IModel;
public function UsersCounterPanelModelServer(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._receiveUniqueUserId_idCodec = this.protocol.getCodec(new TypeCodecInfo(Long,false));
}
public function hasNotUniqueUserId() : 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._hasNotUniqueUserIdId,this.protocolBuffer);
var local2:IGameObject = Model.object;
var local3:ISpace = local2.space;
local3.commandSender.sendCommand(local1);
this.protocolBuffer.optionalMap.clear();
}
public function receiveUniqueUserId(param1:Long) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._receiveUniqueUserId_idCodec.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._receiveUniqueUserIdId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.gui.socialnetwork.ok {
import alternativa.tanks.gui.socialnetwork.AbstractSNGroupEnteringWindow;
import flash.display.Bitmap;
import flash.display.BitmapData;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class OkGroupReminderWindow extends AbstractSNGroupEnteringWindow {
public static var OK_GROUP_RUL:String = "https://ok.ru/group/53061641699507";
private static var OkGroupEnteringReminderBitmapDataClass:Class = OkGroupReminderWindow_OkGroupEnteringReminderBitmapDataClass;
private static var okGroupEnteringReminderBitmapData:BitmapData = Bitmap(new OkGroupEnteringReminderBitmapDataClass()).bitmapData;
public function OkGroupReminderWindow() {
super(okGroupEnteringReminderBitmapData,OK_GROUP_RUL,localeService.getText(TanksLocale.TEXT_OK_ENTER_GROUP_REMINDER));
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.helper {
public final class HelperAlign {
public static const NONE:int = 0;
public static const TOP_LEFT:int = 9;
public static const TOP_CENTER:int = 17;
public static const TOP_RIGHT:int = 33;
public static const MIDDLE_LEFT:int = 10;
public static const MIDDLE_CENTER:int = 18;
public static const MIDDLE_RIGHT:int = 34;
public static const BOTTOM_LEFT:int = 12;
public static const BOTTOM_CENTER:int = 20;
public static const BOTTOM_RIGHT:int = 36;
public static const TOP_MASK:int = 1;
public static const MIDDLE_MASK:int = 2;
public static const BOTTOM_MASK:int = 4;
public static const LEFT_MASK:int = 8;
public static const CENTER_MASK:int = 16;
public static const RIGHT_MASK:int = 32;
public function HelperAlign() {
super();
}
public static function stringOf(param1:int) : String {
var local2:String = null;
switch(param1) {
case 0:
local2 = "NONE";
break;
case 9:
local2 = "TOP_LEFT";
break;
case 17:
local2 = "TOP_CENTER";
break;
case 33:
local2 = "TOP_RIGHT";
break;
case 10:
local2 = "MIDDLE_LEFT";
break;
case 18:
local2 = "MIDDLE_CENTER";
break;
case 34:
local2 = "MIDDLE_RIGHT";
break;
case 12:
local2 = "BOTTOM_LEFT";
break;
case 20:
local2 = "BOTTOM_CENTER";
break;
case 36:
local2 = "BOTTOM_RIGHT";
}
return local2;
}
}
}
|
package alternativa.tanks.view.battlelist.modefilter {
import flash.display.Bitmap;
import flash.display.BitmapData;
import projects.tanks.client.battleservice.BattleMode;
public class BattleModeIcons {
private static const dmIconClass:Class = BattleModeIcons_dmIconClass;
private static const dmIconBitmapData:BitmapData = Bitmap(new dmIconClass()).bitmapData;
private static const tdmIconClass:Class = BattleModeIcons_tdmIconClass;
private static const tdmIconBitmapData:BitmapData = Bitmap(new tdmIconClass()).bitmapData;
private static const ctfIconClass:Class = BattleModeIcons_ctfIconClass;
private static const ctfIconBitmapData:BitmapData = Bitmap(new ctfIconClass()).bitmapData;
private static const cpIconClass:Class = BattleModeIcons_cpIconClass;
private static const cpIconBitmapData:BitmapData = Bitmap(new cpIconClass()).bitmapData;
private static const asIconClass:Class = BattleModeIcons_asIconClass;
private static const asIconBitmapData:BitmapData = Bitmap(new asIconClass()).bitmapData;
private static const rugbyIconClass:Class = BattleModeIcons_rugbyIconClass;
private static const rugbyIconBitmapData:BitmapData = Bitmap(new rugbyIconClass()).bitmapData;
private static const jgrIconClass:Class = BattleModeIcons_jgrIconClass;
private static const jgrIconBitmapData:BitmapData = Bitmap(new jgrIconClass()).bitmapData;
public function BattleModeIcons() {
super();
}
public static function getIcon(param1:BattleMode) : BitmapData {
switch(param1) {
case BattleMode.DM:
return dmIconBitmapData;
case BattleMode.TDM:
return tdmIconBitmapData;
case BattleMode.CTF:
return ctfIconBitmapData;
case BattleMode.CP:
return cpIconBitmapData;
case BattleMode.AS:
return asIconBitmapData;
case BattleMode.RUGBY:
return rugbyIconBitmapData;
case BattleMode.JGR:
return jgrIconBitmapData;
default:
return null;
}
}
}
}
|
package alternativa.startup {
public class ConnectionParameters {
public var serverAddress:String;
public var serverPorts:Vector.<int>;
public var resourcesRootURL:String;
public var secure:Boolean;
public function ConnectionParameters(param1:String, param2:Vector.<int>, param3:String, param4:Boolean) {
super();
this.serverAddress = param1;
this.serverPorts = param2;
this.resourcesRootURL = param3;
this.secure = param4;
}
}
}
|
package forms.friends.list.renderer
{
import alternativa.init.Main;
import fl.controls.listClasses.CellRenderer;
import fl.controls.listClasses.ListData;
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import forms.ColorConstants;
import forms.friends.FriendActionIndicator;
import forms.friends.list.renderer.background.RendererBackGroundOutgoingList;
import forms.userlabel.UserLabel;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
public class FriendsOutgoingListRenderer extends CellRenderer
{
private var _labelsContainer:DisplayObject;
private var _userLabel:UserLabel;
private var _cancelRequestIndicator:FriendActionIndicator;
public function FriendsOutgoingListRenderer()
{
super();
}
override public function set data(value:Object) : void
{
_data = value;
mouseEnabled = false;
mouseChildren = true;
useHandCursor = false;
buttonMode = false;
var _loc2_:RendererBackGroundOutgoingList = new RendererBackGroundOutgoingList(false);
var _loc3_:RendererBackGroundOutgoingList = new RendererBackGroundOutgoingList(true);
setStyle("upSkin",_loc2_);
setStyle("downSkin",_loc2_);
setStyle("overSkin",_loc2_);
setStyle("selectedUpSkin",_loc3_);
setStyle("selectedOverSkin",_loc3_);
setStyle("selectedDownSkin",_loc3_);
this._labelsContainer = this.createLabels(_data);
if(this._cancelRequestIndicator == null)
{
this._cancelRequestIndicator = new FriendActionIndicator(FriendActionIndicator.NO);
addChild(this._cancelRequestIndicator);
}
this._cancelRequestIndicator.visible = false;
this.addEventListener(Event.RESIZE,this.onResize,false,0,true);
this.addEventListener(MouseEvent.ROLL_OVER,this.onRollOver,false,0,true);
this.addEventListener(MouseEvent.ROLL_OUT,this.onRollOut,false,0,true);
this.resize();
this._cancelRequestIndicator.addEventListener(MouseEvent.CLICK,this.onClickCancelRequest,false,0,true);
}
private function onResize(event:Event) : void
{
this.resize();
}
private function resize() : void
{
this._cancelRequestIndicator.x = _width - this._cancelRequestIndicator.width - 6;
}
private function createLabels(data:Object) : Sprite
{
var _loc2_:Sprite = new Sprite();
if(data.id != null)
{
this._userLabel = new UserLabel(data.id);
this._userLabel.setUidColor(ColorConstants.GREEN_LABEL);
this._userLabel.x = -3;
this._userLabel.y = -1;
this._userLabel.setRank(data.rank);
this._userLabel.setUid(data.uid,data.uid);
_loc2_.addChild(this._userLabel);
}
return _loc2_;
}
private function onRollOver(event:MouseEvent) : void
{
this._cancelRequestIndicator.visible = true;
super.selected = true;
}
private function onRollOut(event:MouseEvent) : void
{
this._cancelRequestIndicator.visible = false;
super.selected = false;
}
private function onClickCancelRequest(event:MouseEvent) : void
{
Network(Main.osgi.getService(INetworker)).send("lobby;cancel_request;" + this._userLabel.uid);
}
override public function set selected(a:Boolean) : void
{
}
override public function set listData(value:ListData) : void
{
_listData = value;
label = _listData.label;
if(this._labelsContainer != null)
{
setStyle("icon",this._labelsContainer);
}
}
override protected function drawBackground() : void
{
var _loc1_:String = !!enabled ? mouseState : "disabled";
if(selected)
{
_loc1_ = "selected" + _loc1_.substr(0,1).toUpperCase() + _loc1_.substr(1);
}
_loc1_ += "Skin";
var _loc2_:DisplayObject = background;
background = getDisplayObjectInstance(getStyleValue(_loc1_));
addChildAt(background,0);
if(_loc2_ != null && _loc2_ != background)
{
removeChild(_loc2_);
}
}
}
}
|
package alternativa.tanks.model.challenge.greenpanel.green
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GreenPack_left_botom_corner extends BitmapAsset
{
public function GreenPack_left_botom_corner()
{
super();
}
}
}
|
package platform.client.core.general.socialnetwork.models.socialnetworkparameters {
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 SocialNetworkParametersModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function SocialNetworkParametersModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.view.icons {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.view.icons.BattleParamsCheckButtonIcons_bonusesClass.png")]
public class BattleParamsCheckButtonIcons_bonusesClass extends BitmapAsset {
public function BattleParamsCheckButtonIcons_bonusesClass() {
super();
}
}
}
|
package alternativa.tanks.loader {
import alternativa.init.TanksServicesActivator;
import alternativa.osgi.OSGi;
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.loader.dishonestprogressbar.DishonestProgressBar;
import alternativa.tanks.utils.TransparentJPG;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObjectContainer;
import flash.display.Shape;
import flash.display.Sprite;
import flash.display.Stage;
import flash.events.Event;
import flash.events.TimerEvent;
import flash.utils.Timer;
public class ModalLoader extends Sprite implements IModalLoaderService {
private static const WindowRGB:Class = ModalLoader_WindowRGB;
private static const WindowRGBChina:Class = ModalLoader_WindowRGBChina;
private static const WindowAlpha:Class = ModalLoader_WindowAlpha;
private static const DELAY:int = 9000;
private var _stage:Stage;
private var layer:DisplayObjectContainer;
private var windowBmp:Bitmap;
private var _timer:Timer;
private var dishonestProgressBar:DishonestProgressBar;
private var shape:Shape;
public function ModalLoader() {
super();
var local1:IDisplay = IDisplay(TanksServicesActivator.osgi.getService(IDisplay));
this.layer = local1.loaderLayer;
this._stage = local1.stage;
this.addTransparentBackground();
var local2:BitmapData = getLoaderBackgroundBitmap(TanksServicesActivator.osgi.getService(ILocaleService) as ILocaleService);
this.windowBmp = TransparentJPG.createImageFromRGBAndAlpha(local2,new WindowAlpha().bitmapData);
addChild(this.windowBmp);
this.dishonestProgressBar = new DishonestProgressBar(this.progressBarFinished);
addChild(this.dishonestProgressBar);
this.dishonestProgressBar.x = 10;
this.dishonestProgressBar.y = 239;
this._timer = new Timer(DELAY,1);
this._timer.addEventListener(TimerEvent.TIMER_COMPLETE,this.onNextTipTimerComplete);
}
private static function getLoaderBackgroundBitmap(param1:ILocaleService) : BitmapData {
if(param1.language == "cn") {
return new WindowRGBChina().bitmapData;
}
return new WindowRGB().bitmapData;
}
private function addTransparentBackground() : void {
this.shape = new Shape();
this.shape.graphics.beginFill(0,0);
this.shape.graphics.drawRect(0,0,1,1);
this.shape.graphics.endFill();
addChild(this.shape);
}
private function progressBarFinished() : void {
if(this.layer.contains(this)) {
this.layer.removeChild(this);
}
}
private function onNextTipTimerComplete(param1:TimerEvent = null) : void {
var local2:ILoaderTipsService = OSGi.getInstance().getService(ILoaderTipsService) as ILoaderTipsService;
if(local2 != null) {
local2.getTip();
}
this._timer.stop();
this._timer.reset();
this._timer.start();
}
public function show() : void {
if(!this.layer.contains(this)) {
this.dishonestProgressBar.start();
this.layer.addChild(this);
this._stage.addEventListener(Event.RESIZE,this.align);
this.align();
this._timer.start();
this.onNextTipTimerComplete();
}
}
private function align(param1:Event = null) : void {
this.x = this._stage.stageWidth - this.windowBmp.width >>> 1;
this.y = this._stage.stageHeight - this.windowBmp.height >>> 1;
this.shape.width = this._stage.stageWidth;
this.shape.height = this._stage.stageHeight;
this.shape.x = -x;
this.shape.y = -y;
}
public function hide() : void {
if(this.layer.contains(this)) {
this._timer.stop();
this.dishonestProgressBar.forciblyFinish();
this._stage.removeEventListener(Event.RESIZE,this.align);
}
}
public function hideForcibly() : void {
if(this.layer.contains(this)) {
this._timer.stop();
this.dishonestProgressBar.forciblyStop();
this._stage.removeEventListener(Event.RESIZE,this.align);
this.layer.removeChild(this);
}
}
public function isVisible() : Boolean {
return this.layer.contains(this);
}
}
}
|
package alternativa.tanks.view {
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.tanks.controller.events.CaptchaAnswerIsIncorrectEvent;
import alternativa.tanks.controller.events.EntranceErrorEvent;
import alternativa.tanks.controller.events.showform.ShowBlockValidationAlertEvent;
import alternativa.tanks.controller.events.showform.ShowChangeEmailAndPasswordFormEvent;
import alternativa.tanks.controller.events.showform.ShowConfirmEmailAlertEvent;
import alternativa.tanks.controller.events.showform.ShowExternalEntranceFormEvent;
import alternativa.tanks.controller.events.showform.ShowFormEvent;
import alternativa.tanks.controller.events.showform.ShowLoginFormEvent;
import alternativa.tanks.controller.events.showform.ShowPartnersFormEvent;
import alternativa.tanks.controller.events.showform.ShowRegistrationFormEvent;
import alternativa.tanks.view.forms.primivites.Alert;
import alternativa.tanks.view.layers.EntranceView;
import alternativa.tanks.ymservice.YandexMetricaService;
import org.robotlegs.core.IInjector;
import org.robotlegs.mvcs.Mediator;
public class EntranceViewMediator extends Mediator {
[Inject]
public static var clientLog:IClientLog;
[Inject]
public static var ymService:YandexMetricaService;
private static const REGISTRATION_LOAD_FINISH:String = "RegistrationLoad:finish";
[Inject]
public var layer:EntranceView;
[Inject]
public var injector:IInjector;
public function EntranceViewMediator() {
super();
}
override public function onRegister() : void {
this.injector.injectInto(this.layer);
addContextListener(ShowRegistrationFormEvent.SHOW,this.onShowRegistrationForm,ShowRegistrationFormEvent);
addContextListener(ShowChangeEmailAndPasswordFormEvent.SHOW,this.onShowChangeEmailAndPassword,ShowChangeEmailAndPasswordFormEvent);
addContextListener(ShowLoginFormEvent.SHOW,this.onShowLoginForm,ShowLoginFormEvent);
addContextListener(ShowConfirmEmailAlertEvent.SHOW,this.onShowConfirmEmailStatusAlert,ShowConfirmEmailAlertEvent);
addContextListener(CaptchaAnswerIsIncorrectEvent.EVENT_TYPE,this.onCaptchaFailed);
addContextListener(ShowFormEvent.SHOW_RESTORE_PASSWORD_FORM,this.onShowRestorePasswordForm,ShowFormEvent);
addContextListener(ShowFormEvent.SHOW_INVITE_FORM,this.onShowInviteForm,ShowFormEvent);
addContextListener(ShowFormEvent.SHOW_STAND_ALONE_CAPTCHA,this.onShowStandAloneCaptcha,ShowFormEvent);
addContextListener(ShowFormEvent.SHOW_RECOVERY_HASH_IS_WRONG_ALERT,this.onShowRecoveryHashIsWrongAlert,ShowFormEvent);
addContextListener(ShowPartnersFormEvent.REGISTRATION_FORM,this.onShowPartnersRegistration,ShowPartnersFormEvent);
addContextListener(ShowPartnersFormEvent.LOGIN_FORM,this.onShowPartnersLogin,ShowPartnersFormEvent);
addContextListener(ShowBlockValidationAlertEvent.YOU_WERE_KICKED,this.onShowKickAlert,ShowBlockValidationAlertEvent);
addContextListener(ShowBlockValidationAlertEvent.YOU_WERE_BLOCKED,this.onShowBlockAlert,ShowBlockValidationAlertEvent);
addContextListener(ShowExternalEntranceFormEvent.REGISTRATION_FORM,this.onShowExternalRegistrationForm,ShowExternalEntranceFormEvent);
addContextListener(ShowExternalEntranceFormEvent.LOGIN_FORM,this.onShowExternalLoginForm,ShowExternalEntranceFormEvent);
addContextListener(ShowFormEvent.SHOW_CHANGE_UID_AND_PASSWORD_FORM,this.onShowChangeUidAndPasswordForm,ShowFormEvent);
addContextListener(ShowFormEvent.SHOW_CHANGE_UID_FORM,this.onShowChangeUidForm,ShowFormEvent);
addContextListener(EntranceErrorEvent.SERVER_FROZEN,this.onServerFrozen);
addContextListener(EntranceErrorEvent.SERVER_HALT,this.onServerHalt);
}
private function onServerFrozen(param1:EntranceErrorEvent) : void {
this.layer.showAlertServerIsFrozen();
}
private function onServerHalt(param1:EntranceErrorEvent) : void {
this.layer.showAlertServerIsHalt();
}
private function onShowBlockAlert(param1:ShowBlockValidationAlertEvent) : void {
this.layer.showBlockAlert(param1.reason);
}
private function onShowKickAlert(param1:ShowBlockValidationAlertEvent) : void {
this.layer.showKickAlert(param1.reason,param1.minutes,param1.hours,param1.days);
}
private function onCaptchaFailed(param1:CaptchaAnswerIsIncorrectEvent) : void {
this.layer.showErrorWindow(Alert.CAPTCHA_INCORRECT);
}
private function onShowChangeEmailAndPassword(param1:ShowChangeEmailAndPasswordFormEvent) : void {
this.layer.showChangeEmailAndPassword(param1.email);
}
private function onShowRegistrationForm(param1:ShowRegistrationFormEvent) : void {
ymService.reachGoalIfPlayerWasInTutorial(REGISTRATION_LOAD_FINISH);
this.layer.showRegistrationForm(param1.backgroundImage,param1.captchaEnabled,param1.antiAddictionEnabled,param1.skipRegistrationEnabled,param1.goToLoginPageEnabled,param1.registrationThroughEmail);
}
private function onShowLoginForm(param1:ShowLoginFormEvent) : void {
this.layer.showLoginForm(param1.uid,param1.registrationEnabled,param1.loginCaptchaEnabled,param1.password);
}
private function onShowConfirmEmailStatusAlert(param1:ShowConfirmEmailAlertEvent) : void {
this.layer.showConfirmEmailStatusAlert(param1.status);
}
private function onShowStandAloneCaptcha(param1:ShowFormEvent) : void {
this.layer.showStandAloneCaptcha();
}
private function onShowInviteForm(param1:ShowFormEvent) : void {
this.layer.showInviteForm();
}
private function onShowPartnersRegistration(param1:ShowPartnersFormEvent) : void {
ymService.reachGoalIfPlayerWasInTutorial(REGISTRATION_LOAD_FINISH);
this.layer.showPartnersRegistrationForm(param1.backgroundImage,param1.allowExternalLogin);
}
private function onShowPartnersLogin(param1:ShowPartnersFormEvent) : void {
this.layer.showPartnerLoginForm(param1.backgroundImage,param1.loginCaptchaEnabled);
}
private function onShowRestorePasswordForm(param1:ShowFormEvent) : void {
this.layer.showRestorePasswordForm();
}
private function onShowRecoveryHashIsWrongAlert(param1:ShowFormEvent) : void {
this.layer.showRecoveryHashIsWrongAlert();
}
private function onShowExternalRegistrationForm(param1:ShowExternalEntranceFormEvent) : void {
ymService.reachGoalIfPlayerWasInTutorial(REGISTRATION_LOAD_FINISH);
this.layer.showExternalRegistrationForm(param1.socialNetworkId);
}
private function onShowExternalLoginForm(param1:ShowExternalEntranceFormEvent) : void {
this.layer.showExternalLoginForm(param1.socialNetworkId,param1.presetCallsign,param1.loginCaptchaEnabled);
}
private function onShowChangeUidAndPasswordForm(param1:ShowFormEvent) : void {
this.layer.showChangeUidAndPasswordForm();
}
private function onShowChangeUidForm(param1:ShowFormEvent) : void {
this.layer.showChangeUidForm();
}
}
}
|
package controls
{
import assets.window.bitmaps.WindowBGTile;
import assets.window.bitmaps.WindowBottom;
import assets.window.bitmaps.WindowLeft;
import assets.window.bitmaps.WindowRight;
import assets.window.bitmaps.WindowTop;
import assets.window.elemets.WindowBottomLeftCorner;
import assets.window.elemets.WindowBottomRightCorner;
import assets.window.elemets.WindowTopLeftCorner;
import assets.window.elemets.WindowTopRightCorner;
import flash.display.Shape;
import flash.display.Sprite;
public class TankWindow extends Sprite
{
private var _width:int;
private var _height:int;
private var tl:WindowTopLeftCorner;
private var tr:WindowTopRightCorner;
private var bl:WindowBottomLeftCorner;
private var br:WindowBottomRightCorner;
private var bgBMP:WindowBGTile;
private var topBMP:WindowTop;
private var bottomBMP:WindowBottom;
private var leftBMP:WindowLeft;
private var rightBMP:WindowRight;
private var bg:Shape;
private var top:Shape;
private var bottom:Shape;
private var left:Shape;
private var right:Shape;
private var mcHeader:TankWindowHeader;
public var headerLang:String = "en";
private var _header:int = 0;
public function TankWindow(param1:int = -1, param2:int = -1)
{
this.tl = new WindowTopLeftCorner();
this.tr = new WindowTopRightCorner();
this.bl = new WindowBottomLeftCorner();
this.br = new WindowBottomRightCorner();
this.bgBMP = new WindowBGTile(0,0);
this.topBMP = new WindowTop(0,0);
this.bottomBMP = new WindowBottom(0,0);
this.leftBMP = new WindowLeft(0,0);
this.rightBMP = new WindowRight(0,0);
this.bg = new Shape();
this.top = new Shape();
this.bottom = new Shape();
this.left = new Shape();
this.right = new Shape();
super();
this._width = param1;
this._height = param2;
this.ConfigUI();
this.draw();
}
override public function set width(param1:Number) : void
{
this._width = int(param1);
this.draw();
}
override public function get width() : Number
{
return this._width;
}
override public function set height(param1:Number) : void
{
this._height = int(param1);
this.draw();
}
override public function get height() : Number
{
return this._height;
}
private function ConfigUI() : void
{
this._width = this._width == -1 ? int(scaleX * 100) : int(this._width);
this._height = this._height == -1 ? int(scaleY * 100) : int(this._height);
scaleX = 1;
scaleY = 1;
//removeChildAt(0);
addChild(this.bg);
addChild(this.top);
addChild(this.bottom);
addChild(this.left);
addChild(this.right);
addChild(this.tl);
addChild(this.tr);
addChild(this.bl);
addChild(this.br);
}
public function set header(param1:int) : void
{
this._header = param1;
this.mcHeader = new TankWindowHeader(param1,this.headerLang);
addChild(this.mcHeader);
if(param1 > 22)
{
this.mcHeader.x = -13;
}
else
{
this.mcHeader.y = -13;
}
this.draw();
}
private function draw() : void
{
this.bg.graphics.clear();
this.bg.graphics.beginBitmapFill(this.bgBMP);
this.bg.graphics.drawRect(7,7,this._width - 14,this._height - 14);
this.bg.graphics.endFill();
this.top.graphics.clear();
this.top.graphics.beginBitmapFill(this.topBMP);
this.top.graphics.drawRect(0,0,this._width - 22,11);
this.top.graphics.endFill();
this.top.x = 11;
this.bottom.graphics.clear();
this.bottom.graphics.beginBitmapFill(this.bottomBMP);
this.bottom.graphics.drawRect(0,0,this._width - 22,11);
this.bottom.graphics.endFill();
this.bottom.x = 11;
this.bottom.y = this._height - 11;
this.left.graphics.clear();
this.left.graphics.beginBitmapFill(this.leftBMP);
this.left.graphics.drawRect(0,0,11,this._height - 22);
this.left.graphics.endFill();
this.left.x = 0;
this.left.y = 11;
this.right.graphics.clear();
this.right.graphics.beginBitmapFill(this.rightBMP);
this.right.graphics.drawRect(0,0,11,this._height - 22);
this.right.graphics.endFill();
this.right.x = this._width - 11;
this.right.y = 11;
this.tl.x = 0;
this.tl.y = 0;
this.tr.x = this._width - this.tr.width;
this.tr.y = 0;
this.bl.x = 0;
this.bl.y = this._height - this.bl.height;
this.br.x = this._width - this.br.width;
this.br.y = this._height - this.br.height;
if(this.mcHeader != null)
{
if(this._header > 22)
{
this.mcHeader.y = int(this._height / 2);
}
else
{
this.mcHeader.x = int(this._width / 2);
}
}
}
}
}
|
package alternativa.tanks.model.news
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class NewsIcons_update extends BitmapAsset
{
public function NewsIcons_update()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.thunder
{
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.model.IModel;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.physics.collision.ICollisionDetector;
import alternativa.physics.collision.types.RayIntersection;
import alternativa.register.ObjectRegister;
import alternativa.service.IModelService;
import alternativa.tanks.models.battlefield.BattlefieldData;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.sfx.shoot.thunder.IThunderSFXModel;
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.WeaponConst;
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.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.sfx.EffectsPair;
import alternativa.tanks.vehicles.tanks.Tank;
import com.alternativaplatform.projects.tanks.client.commons.types.Vector3d;
import com.alternativaplatform.projects.tanks.client.models.tank.TankSpawnState;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.thunder.IThunderModelBase;
import com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.thunder.ThunderModelBase;
import com.reygazu.anticheat.variables.SecureInt;
import scpacker.networking.INetworker;
import scpacker.networking.Network;
import scpacker.tanks.WeaponsManager;
public class ThunderModel extends ThunderModelBase implements IThunderModelBase, IWeaponController, IObjectLoadListener
{
private static const DECAL_RADIUS:Number = 250;
private static const DECAL:Class = ThunderModel_DECAL;
private static var decalMaterial:TextureMaterial;
private var weaponUtils:WeaponUtils;
private var modelService:IModelService;
private var battlefieldModel:IBattleField;
private var tankInterface:TankModel;
private var commonModel:IWeaponCommonModel;
private var weakeningModel:IWeaponWeakeningModel;
private var sfxModel:IThunderSFXModel;
private var localTankData:TankData;
private var localShotData:ShotData;
private var localThunderData:ThunderData;
private var localWeaponCommonData:WeaponCommonData;
private var _triggerPressed:Boolean;
private var nextReadyTime:SecureInt;
private var targetSystem:CommonTargetSystem;
private var hitInfo:HitInfo;
private var _hitPos:Vector3;
private var _hitPosLocal:Vector3;
private var _hitPosGlobal:Vector3;
private var _gunDirGlobal:Vector3;
private var _muzzlePosGlobal:Vector3;
private var _barrelOrigin:Vector3;
private var _xAxis:Vector3;
private var _vector:Vector3;
private var _rayOrigin:Vector3;
private var _rayInteresction:RayIntersection;
private var _hitPos3d:Vector3d;
private var _targetPos3d:Vector3d;
private var _splashTargetIds:Array;
private var _splashTargetIncarnations:Array;
private var _splashTargetDistances:Array;
private var _splashTargetPositions:Array;
private var testPointsAux:Vector.<Vector3>;
private var testPoints:Vector.<Vector3>;
private var targetEvaluator:CommonTargetEvaluator;
private var maxTargetingDistance:Number = 100000;
public function ThunderModel()
{
this.weaponUtils = WeaponUtils.getInstance();
this.nextReadyTime = new SecureInt("nextReadyTime.value thunder");
this.hitInfo = new HitInfo();
this._hitPos = new Vector3();
this._hitPosLocal = new Vector3();
this._hitPosGlobal = new Vector3();
this._gunDirGlobal = new Vector3();
this._muzzlePosGlobal = new Vector3();
this._barrelOrigin = new Vector3();
this._xAxis = new Vector3();
this._vector = new Vector3();
this._rayOrigin = new Vector3();
this._rayInteresction = new RayIntersection();
this._hitPos3d = new Vector3d(0,0,0);
this._targetPos3d = new Vector3d(0,0,0);
this._splashTargetIds = [];
this._splashTargetIncarnations = [];
this._splashTargetDistances = [];
this._splashTargetPositions = [];
this.testPointsAux = Vector.<Vector3>([new Vector3(),new Vector3(),new Vector3()]);
this.testPoints = Vector.<Vector3>([new Vector3(),new Vector3(),new Vector3()]);
super();
_interfaces.push(IModel,IWeaponController,IObjectLoadListener);
if(decalMaterial == null)
{
decalMaterial = new TextureMaterial(new DECAL().bitmapData);
}
}
public function initObject(clientObject:ClientObject, impactForce:Number, maxSplashDamageRadius:Number, minSplashDamagePercent:Number, minSplashDamageRadius:Number) : void
{
var data:ThunderData = new ThunderData(maxSplashDamageRadius,minSplashDamageRadius,minSplashDamagePercent,impactForce * WeaponConst.BASE_IMPACT_FORCE);
clientObject.putParams(ThunderModel,data);
WeaponsManager.getThunderSFX(WeaponsManager.getObjectFor(clientObject.id));
this.objectLoaded(clientObject);
}
public function fire(clientObject:ClientObject, shooterId:String, hitPoint:Vector3d, mainTargetId:String, weakeningCoeff:Number, splashTargetIds:Array, splashWeakeningCoeffs:Array) : void
{
var shooterData:TankData = null;
var mainTargetData:TankData = null;
var len:int = 0;
var i:int = 0;
var targetData:TankData = null;
var splashWeakeningCoeff:Number = NaN;
var objectRegister:ObjectRegister = clientObject.register;
shooterData = this.getTankData(shooterId,objectRegister);
if(shooterData == null || shooterData.tank == null || shooterData.tank.skin == null)
{
return;
}
if(this.tankInterface.localUserData != null)
{
if(shooterData.userName == this.tankInterface.localUserData.userName)
{
return;
}
}
var commonData:WeaponCommonData = this.commonModel.getCommonData(shooterData.turret);
this.weaponUtils.calculateGunParamsAux(shooterData.tank.skin.turretMesh,commonData.muzzles[0],this._muzzlePosGlobal,this._gunDirGlobal);
this.createShotEffects(shooterData,commonData.muzzles[0]);
this._vector.vCopy(this._gunDirGlobal).vScale(-commonData.kickback);
shooterData.tank.addWorldForce(this._muzzlePosGlobal,this._vector);
if(hitPoint == null)
{
return;
}
this._hitPos.x = hitPoint.x;
this._hitPos.y = hitPoint.y;
this._hitPos.z = hitPoint.z;
var thunderData:ThunderData = this.getData(shooterData.turret);
if(mainTargetId != null)
{
mainTargetData = this.getTankData(mainTargetId,objectRegister);
if(mainTargetData == null || mainTargetData.tank == null)
{
return;
}
mainTargetData.tank.baseMatrix.transformVector(this._hitPos,this._vector);
this._hitPos.vSum(this._vector,mainTargetData.tank.state.pos);
this.applyMainImpactForce(mainTargetData.tank,this._hitPos,this._gunDirGlobal,commonData.impactForce,thunderData.impactForce,weakeningCoeff);
this.battlefieldModel.tankHit(mainTargetData,this._gunDirGlobal,commonData.impactCoeff * weakeningCoeff);
}
else
{
this.battlefieldModel.addDecal(this._hitPos,this._barrelOrigin,DECAL_RADIUS,decalMaterial);
}
this.createExplosionEffects(shooterData,this._hitPos);
var impactCoeff:Number = thunderData.impactForce / WeaponConst.BASE_IMPACT_FORCE;
if(splashTargetIds != null)
{
len = splashTargetIds.length;
for(i = 0; i < len; i++)
{
targetData = this.getTankData(splashTargetIds[i],objectRegister);
if(!(targetData == null || targetData.tank == null))
{
this._vector.vDiff(targetData.tank.state.pos,this._hitPos).vNormalize();
splashWeakeningCoeff = 1;
this.battlefieldModel.tankHit(targetData,this._vector,splashWeakeningCoeff * impactCoeff);
this._vector.vScale(thunderData.impactForce * splashWeakeningCoeff);
targetData.tank.addForce(this._vector);
}
}
}
}
public function stopEffects(ownerTankData:TankData) : void
{
}
public function reset() : void
{
this._triggerPressed = false;
this.nextReadyTime.value = 0;
}
public function setLocalUser(localUserData:TankData) : void
{
this.localTankData = localUserData;
this.localShotData = WeaponsManager.shotDatas[localUserData.turret.id];
this.localThunderData = ThunderData(localUserData.turret.getParams(ThunderModel));
this.localWeaponCommonData = this.commonModel.getCommonData(localUserData.turret);
this.targetEvaluator = CommonTargetEvaluator.create(this.localTankData,this.localShotData,this.battlefieldModel,this.weakeningModel,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 activateWeapon(time:int) : void
{
this._triggerPressed = true;
}
public function deactivateWeapon(time:int, sendServerCommand:Boolean) : void
{
this._triggerPressed = false;
}
public function update(time:int, deltaTime:int) : Number
{
var distance:Number = NaN;
var directImpactCoeff:Number = NaN;
var hitX:Number = NaN;
var hitY:Number = NaN;
var hitZ:Number = NaN;
var mainTarget:TankData = null;
var numSplashTargets:int = 0;
var splashRadiusSqr:Number = NaN;
var key:* = undefined;
var hitPos3d:Vector3d = null;
var mainTargetId:String = null;
var mainTargetIncarnation:int = 0;
var mainTargetPosition:Vector3d = null;
var splashTargetIds:Array = null;
var splashTargetIncarnations:Array = null;
var splashTargetDistances:Array = null;
var splashTargetPositions:Array = null;
var td:* = null;
var tank:Tank = null;
var targetPos:Vector3 = null;
var dx:Number = NaN;
var dy:Number = NaN;
var dz:Number = NaN;
var d:Number = NaN;
var targetPos3d:Vector3d = null;
var v:Vector3 = null;
if(!this._triggerPressed || time < this.nextReadyTime.value)
{
if(time < this.nextReadyTime.value)
{
return 1 + (time - this.nextReadyTime.value) / this.localShotData.reloadMsec.value;
}
return 1;
}
this.nextReadyTime.value = time + this.localShotData.reloadMsec.value;
this.weaponUtils.calculateGunParams(this.localTankData.tank.skin.turretMesh,this.localWeaponCommonData.muzzles[0],this._muzzlePosGlobal,this._barrelOrigin,this._xAxis,this._gunDirGlobal);
this._vector.vCopy(this._gunDirGlobal).vScale(-this.localWeaponCommonData.kickback);
this.localTankData.tank.addWorldForce(this._muzzlePosGlobal,this._vector);
this.createShotEffects(this.localTankData,this.localWeaponCommonData.muzzles[0]);
var bfData:BattlefieldData = this.battlefieldModel.getBattlefieldData();
var collisionDetector:ICollisionDetector = bfData.collisionDetector;
if(this.targetSystem.getTarget(this._barrelOrigin,this._gunDirGlobal,this._xAxis,this.localTankData.tank,this.hitInfo))
{
distance = this.hitInfo.distance * 0.01;
directImpactCoeff = this.weakeningModel.getImpactCoeff(this.localTankData.turret,distance);
hitX = this.hitInfo.position.x;
hitY = this.hitInfo.position.y;
hitZ = this.hitInfo.position.z;
splashRadiusSqr = 10000 * this.localThunderData.minSplashDamageRadius * this.localThunderData.minSplashDamageRadius;
for(td in bfData.activeTanks)
{
tank = td.tank;
if(td.spawnState != TankSpawnState.NEWCOME)
{
if(tank == this.hitInfo.body)
{
mainTarget = td;
}
else
{
targetPos = tank.state.pos;
dx = targetPos.x - hitX;
dy = targetPos.y - hitY;
dz = targetPos.z - hitZ;
d = dx * dx + dy * dy + dz * dz;
if(d <= splashRadiusSqr)
{
if(this.testForSplashHit(tank,this.hitInfo,collisionDetector))
{
d = Math.sqrt(d) * 0.01;
this._splashTargetIds[numSplashTargets] = td.user.id;
this._splashTargetIncarnations[numSplashTargets] = td.incarnation;
this._splashTargetDistances[numSplashTargets] = d;
targetPos3d = this._splashTargetPositions[numSplashTargets];
if(targetPos3d == null)
{
targetPos3d = new Vector3d(0,0,0);
this._splashTargetPositions[numSplashTargets] = targetPos3d;
}
targetPos3d.x = targetPos.x;
targetPos3d.y = targetPos.y;
targetPos3d.z = targetPos.z;
numSplashTargets++;
this._vector.vNormalize();
this._vector.vScale(this.localThunderData.impactForce * directImpactCoeff * this.getSplashImpactCoeff(d));
tank.addForce(this._vector);
}
}
}
}
}
hitPos3d = this._hitPos3d;
if(mainTarget != null)
{
mainTargetId = mainTarget.user.id;
mainTargetIncarnation = mainTarget.incarnation;
mainTargetPosition = this._targetPos3d;
v = mainTarget.tank.state.pos;
mainTargetPosition.x = v.x;
mainTargetPosition.y = v.y;
mainTargetPosition.z = v.z;
this.applyMainImpactForce(mainTarget.tank,this.hitInfo.position,this._gunDirGlobal,this.localWeaponCommonData.impactForce,this.localThunderData.impactForce,directImpactCoeff);
this._hitPosGlobal.vDiff(this.hitInfo.position,v);
mainTarget.tank.baseMatrix.transformVectorInverse(this._hitPosGlobal,this._hitPosLocal);
hitPos3d.x = this._hitPosLocal.x;
hitPos3d.y = this._hitPosLocal.y;
hitPos3d.z = this._hitPosLocal.z;
}
else
{
hitPos3d.x = hitX;
hitPos3d.y = hitY;
hitPos3d.z = hitZ;
}
if(numSplashTargets > 0)
{
splashTargetIds = this._splashTargetIds;
splashTargetIds.length = numSplashTargets;
splashTargetIncarnations = this._splashTargetIncarnations;
splashTargetIncarnations.length = numSplashTargets;
splashTargetDistances = this._splashTargetDistances;
splashTargetDistances.length = numSplashTargets;
splashTargetPositions = this._splashTargetPositions;
splashTargetPositions.length = numSplashTargets;
}
this.fireCommand(this.localTankData.turret,hitPos3d,mainTargetId,mainTargetIncarnation,mainTargetPosition,distance,splashTargetIds,splashTargetIncarnations,splashTargetDistances,splashTargetPositions);
this.createExplosionEffects(this.localTankData,this.hitInfo.position);
if(mainTarget == null)
{
this.battlefieldModel.addDecal(this.hitInfo.position,this._barrelOrigin,DECAL_RADIUS,decalMaterial);
}
}
else
{
this.fireCommand(this.localTankData.turret,null,null,0,null,0,null,null,null,null);
}
return 0;
}
private function fireCommand(turr:ClientObject, hitPos:Vector3d, mainTargetId:String, mainTargetIncarnation:int, mainTargetPosition:Vector3d, distance:int, splashTargetIds:Array, splashTargetIncarnations:Array, splashTargetDistances:Array, splashTargetPositions:Array) : void
{
var js:Object = new Object();
js.hitPos = hitPos;
js.mainTargetId = mainTargetId;
js.mainTargetPosition = mainTargetPosition;
js.distance = distance;
js.splashTargetIds = splashTargetIds;
js.splashTargetDistances = splashTargetDistances;
js.reloadTime = this.localShotData.reloadMsec.value;
Network(Main.osgi.getService(INetworker)).send("battle;fire;" + JSON.stringify(js));
}
public function objectLoaded(object:ClientObject) : void
{
if(this.commonModel == null)
{
this.modelService = IModelService(Main.osgi.getService(IModelService));
this.battlefieldModel = IBattleField(this.modelService.getModelsByInterface(IBattleField)[0]);
this.tankInterface = Main.osgi.getService(ITank) as TankModel;
this.commonModel = IWeaponCommonModel(this.modelService.getModelsByInterface(IWeaponCommonModel)[0]);
this.weakeningModel = IWeaponWeakeningModel(this.modelService.getModelsByInterface(IWeaponWeakeningModel)[0]);
this.sfxModel = WeaponsManager.getThunderSFX(WeaponsManager.getObjectFor(object.id));
}
this.nextReadyTime.value = 0;
}
public function objectUnloaded(object:ClientObject) : void
{
}
private function getSplashImpactCoeff(distance:Number) : Number
{
if(distance < this.localThunderData.maxSplashDamageRadius)
{
return 1;
}
return 0.01 * (this.localThunderData.minSplashDamagePercent + (this.localThunderData.minSplashDamageRadius - distance) * (100 - this.localThunderData.minSplashDamagePercent) / (this.localThunderData.minSplashDamageRadius - this.localThunderData.maxSplashDamageRadius));
}
private function getTankData(objectId:String, objectRegister:ObjectRegister) : TankData
{
var object:ClientObject = BattleController.activeTanks[objectId];
if(object == null)
{
return null;
}
return this.tankInterface.getTankData(object);
}
private function createShotEffects(tankData:TankData, muzzlePosLocal:Vector3) : void
{
var effects:EffectsPair = this.sfxModel.createShotEffects(WeaponsManager.getObjectFor(tankData.turret.id),muzzlePosLocal,tankData.tank.skin.turretMesh);
this.battlefieldModel.addGraphicEffect(effects.graphicEffect);
this.battlefieldModel.addSound3DEffect(effects.soundEffect);
}
private function createExplosionEffects(tankData:TankData, position:Vector3) : void
{
var effects:EffectsPair = this.sfxModel.createExplosionEffects(tankData.turret,position);
this.battlefieldModel.addGraphicEffect(effects.graphicEffect);
this.battlefieldModel.addSound3DEffect(effects.soundEffect);
}
private function testForSplashHit(tank:Tank, hitInfo:HitInfo, collisionDetector:ICollisionDetector) : Boolean
{
var v:Vector3 = null;
var offset:Number = 0.75 * tank.mainCollisionBox.hs.y;
Vector3(this.testPointsAux[0]).y = -offset;
Vector3(this.testPointsAux[2]).y = offset;
this._rayOrigin.vCopy(hitInfo.position).vAdd(hitInfo.normal);
var pos:Vector3 = tank.state.pos;
for(var i:int = 0; i < 3; i++)
{
v = this.testPoints[i];
tank.baseMatrix.transformVector(this.testPointsAux[i],v);
v.vAdd(pos);
this._vector.vDiff(v,hitInfo.position);
if(!collisionDetector.intersectRayWithStatic(this._rayOrigin,this._vector,CollisionGroup.STATIC,1,null,this._rayInteresction))
{
return true;
}
}
return false;
}
private function getData(clientObject:ClientObject) : ThunderData
{
return ThunderData(clientObject.getParams(ThunderModel));
}
private function applyMainImpactForce(target:Tank, globalPos:Vector3, gunDir:Vector3, commonImpact:Number, thunderImpact:Number, weakeningCoeff:Number) : void
{
this._vector.vCopy(gunDir).vScale(commonImpact * weakeningCoeff);
target.addWorldForce(globalPos,this._vector);
this._vector.vDiff(target.state.pos,globalPos).vNormalize().vScale(thunderImpact * weakeningCoeff);
target.addForce(this._vector);
}
}
}
|
package alternativa.tanks.models.tank.resistance {
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.LocalWeaponController;
import alternativa.tanks.models.tank.bosstate.IBossState;
import alternativa.tanks.services.tankregistry.TankUsersRegistry;
import flash.utils.Dictionary;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.user.bossstate.BossRelationRole;
import projects.tanks.client.battlefield.models.user.resistance.ITankResistancesModelBase;
import projects.tanks.client.battlefield.models.user.resistance.TankResistance;
import projects.tanks.client.battlefield.models.user.resistance.TankResistancesModelBase;
import projects.tanks.client.garage.models.item.properties.ItemProperty;
[ModelInfo]
public class TankResistancesModel extends TankResistancesModelBase implements ITankResistancesModelBase, TankResistances, ObjectLoadPostListener {
[Inject]
public static var usersRegistry:TankUsersRegistry;
public function TankResistancesModel() {
super();
}
[Obfuscation(rename="false")]
public function objectLoadedPost() : void {
var local1:IGameObject = null;
if(Boolean(usersRegistry.existLocalUser()) && usersRegistry.getLocalUser() == object) {
for each(local1 in usersRegistry.getUsers()) {
if(local1 != object) {
this.setResistance(local1,true);
}
}
} else {
this.setResistance(object,true);
}
}
public function getResistance(param1:Boolean) : int {
if(!usersRegistry.existLocalUser() || usersRegistry.getLocalUser() == object) {
return 0;
}
var local2:IGameObject = usersRegistry.getLocalUser();
if(this.isBoss(local2)) {
return 0;
}
var local3:ITankModel = ITankModel(local2.adapt(ITankModel));
var local4:Dictionary = Dictionary(getData(Dictionary));
if(local4 == null || param1) {
local4 = this.createResistanceDictionary();
putData(Dictionary,local4);
}
if(ItemProperty.ALL_RESISTANCE in local4) {
return local4[ItemProperty.ALL_RESISTANCE];
}
var local5:LocalWeaponController = LocalWeaponController(local3.getWeaponController());
var local6:ItemProperty = local5.getResistanceProperty();
if(local6 in local4) {
return local4[local6];
}
return 0;
}
private function isBoss(param1:IGameObject) : Boolean {
return IBossState(param1.adapt(IBossState)).role() == BossRelationRole.BOSS;
}
public function getResistances() : Vector.<TankResistance> {
return getInitParam().resistances;
}
private function createResistanceDictionary() : Dictionary {
var local2:TankResistance = null;
var local1:Dictionary = new Dictionary();
for each(local2 in getInitParam().resistances) {
local1[local2.resistanceProperty] = local2.resistanceInPercent;
}
return local1;
}
private function setResistance(param1:IGameObject, param2:Boolean) : void {
var local3:int = int(TankResistances(param1.adapt(TankResistances)).getResistance(param2));
ITankModel(param1.adapt(ITankModel)).getTitle().setResistance(local3);
}
public function updateOthersResistances() : void {
var local1:IGameObject = null;
for each(local1 in usersRegistry.getUsers()) {
if(local1 != object) {
this.setResistance(local1,true);
}
}
}
}
}
|
package alternativa.tanks.model.quest.common.gui.greenpanel {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.model.quest.common.gui.greenpanel.GreenPanelBitmaps_LEFT_TOP_CORNER_BITMAP.png")]
public class GreenPanelBitmaps_LEFT_TOP_CORNER_BITMAP extends BitmapAsset {
public function GreenPanelBitmaps_LEFT_TOP_CORNER_BITMAP() {
super();
}
}
}
|
package controls.scroller.blue {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.scroller.blue.ScrollSkinBlue_track.png")]
public class ScrollSkinBlue_track extends BitmapAsset {
public function ScrollSkinBlue_track() {
super();
}
}
}
|
package alternativa.tanks.engine3d
{
import alternativa.engine3d.alternativa3d;
import flash.display.BitmapData;
import flash.events.TimerEvent;
import flash.utils.Dictionary;
import flash.utils.Timer;
public class MaterialSequenceRegistry implements IMaterialSequenceRegistry
{
private var _useMipMapping:Boolean;
private var sequenceByImage:Dictionary;
private var scheduledSequences:Vector.<MaterialSequence>;
private var numScheduledSequences:int;
private var timer:Timer;
public function MaterialSequenceRegistry(timerInterval:int)
{
this.sequenceByImage = new Dictionary();
this.scheduledSequences = new Vector.<MaterialSequence>();
super();
this.timer = new Timer(timerInterval);
}
public function set timerInterval(value:int) : void
{
this.timer.delay = value;
}
public function get useMipMapping() : Boolean
{
return this._useMipMapping;
}
public function set useMipMapping(value:Boolean) : void
{
this._useMipMapping = value;
}
public function getSequence(materialType:MaterialType, sourceImage:BitmapData, frameWidth:int, mipMapResolution:Number, disposeSourceImage:Boolean = false, createMirroredFrames:Boolean = false) : MaterialSequence
{
var sequence:MaterialSequence = this.sequenceByImage[sourceImage];
if(sequence == null)
{
sequence = new MaterialSequence(this,sourceImage,frameWidth,createMirroredFrames,disposeSourceImage,this._useMipMapping,mipMapResolution);
this.sequenceByImage[sourceImage] = sequence;
this.scheduleSequence(sequence);
}
++sequence.referenceCount;
return sequence;
}
public function getSquareSequence(materialType:MaterialType, sourceImage:BitmapData, mipMapResolution:Number, disposeSourceImage:Boolean = false, createMirroredFrames:Boolean = false) : MaterialSequence
{
return this.getSequence(materialType,sourceImage,sourceImage.height,mipMapResolution,disposeSourceImage,createMirroredFrames);
}
public function clear() : void
{
var sequence:MaterialSequence = null;
for each(sequence in this.sequenceByImage)
{
this.disposeSequence(sequence);
}
}
public function getDump() : String
{
var numSequences:int = 0;
var totalBitmapSize:int = 0;
var numMaps:int = 0;
var key:* = undefined;
var numSequenceMaps:int = 0;
var sequence:MaterialSequence = null;
var materialIndex:int = 0;
var material:TanksTextureMaterial = null;
var mapIndex:int = 0;
var bmp:BitmapData = null;
var w:int = 0;
var h:int = 0;
var s:String = "=== MaterialSequenceRegistry ===\n";
for(key in this.sequenceByImage)
{
numSequences++;
numSequenceMaps = 0;
sequence = this.sequenceByImage[key];
for(materialIndex = 0; materialIndex < sequence.materials.length; materialIndex++)
{
material = TanksTextureMaterial(sequence.materials[materialIndex]);
if(material.alternativa3d::mipMap != null)
{
for(mapIndex = 0; mapIndex < material.alternativa3d::numMaps; mapIndex++)
{
bmp = material.alternativa3d::mipMap[mapIndex];
totalBitmapSize += bmp.height * bmp.width * 4;
}
numSequenceMaps += material.alternativa3d::numMaps;
}
else
{
w = material.texture.width;
h = material.texture.height;
totalBitmapSize += w * h * 4;
}
}
numMaps += numSequenceMaps;
s += "Sequence " + numSequences + ": numMaps: " + numSequenceMaps + "\n";
}
return s + ("Total mipmaps: " + numMaps + "\n" + "Total bitmap size: " + totalBitmapSize + "\n" + "Scheduled sequences: " + this.numScheduledSequences + "\n");
}
public function disposeSequence(sequence:MaterialSequence) : void
{
delete this.sequenceByImage[sequence.sourceImage];
var index:int = this.scheduledSequences.indexOf(sequence);
if(index > -1)
{
this.removeScheduledSequence(index);
}
sequence.dispose();
}
private function scheduleSequence(sequence:MaterialSequence) : void
{
var _loc2_:* = this.numScheduledSequences++;
this.scheduledSequences[_loc2_] = sequence;
if(this.numScheduledSequences == 1)
{
this.timer.addEventListener(TimerEvent.TIMER,this.onTimer);
this.timer.start();
}
}
private function removeScheduledSequence(index:int) : void
{
this.scheduledSequences[index] = this.scheduledSequences[--this.numScheduledSequences];
this.scheduledSequences[this.numScheduledSequences] = null;
if(this.numScheduledSequences == 0)
{
this.timer.stop();
this.timer.removeEventListener(TimerEvent.TIMER,this.onTimer);
}
}
private function onTimer(e:TimerEvent) : void
{
var sequence:MaterialSequence = null;
for(var i:int = 0; i < this.numScheduledSequences; i++)
{
sequence = this.scheduledSequences[i];
if(sequence.tick())
{
this.removeScheduledSequence(i);
i--;
}
}
}
}
}
|
package _codec.platform.client.core.general.socialnetwork.types {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.MapCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import flash.utils.Dictionary;
import platform.client.core.general.socialnetwork.types.LoginParameters;
public class CodecLoginParameters implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_parameters:ICodec;
public function CodecLoginParameters() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_parameters = param1.getCodec(new MapCodecInfo(new TypeCodecInfo(String,false),new TypeCodecInfo(String,false),false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:LoginParameters = new LoginParameters();
local2.parameters = this.codec_parameters.decode(param1) as Dictionary;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:LoginParameters = LoginParameters(param2);
this.codec_parameters.encode(param1,local3.parameters);
}
}
}
|
package alternativa.tanks.servermodels.socialnetwork {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IExternalEntranceModelEvents implements IExternalEntranceModel {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function IExternalEntranceModelEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function startExternalRegisterUser(param1:String, param2:Boolean, param3:String) : void {
var i:int = 0;
var m:IExternalEntranceModel = null;
var socialNetworkId:String = param1;
var rememberMe:Boolean = param2;
var domain:String = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IExternalEntranceModel(this.impl[i]);
m.startExternalRegisterUser(socialNetworkId,rememberMe,domain);
i++;
}
}
finally {
Model.popObject();
}
}
public function startExternalLoginUser(param1:String, param2:Boolean, param3:String) : void {
var i:int = 0;
var m:IExternalEntranceModel = null;
var socialNetworkId:String = param1;
var rememberMe:Boolean = param2;
var domain:String = param3;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IExternalEntranceModel(this.impl[i]);
m.startExternalLoginUser(socialNetworkId,rememberMe,domain);
i++;
}
}
finally {
Model.popObject();
}
}
public function finishExternalRegisterUser(param1:String, param2:String) : void {
var i:int = 0;
var m:IExternalEntranceModel = null;
var uid:String = param1;
var referralHash:String = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IExternalEntranceModel(this.impl[i]);
m.finishExternalRegisterUser(uid,referralHash);
i++;
}
}
finally {
Model.popObject();
}
}
public function login(param1:String, param2:String) : void {
var i:int = 0;
var m:IExternalEntranceModel = null;
var uid:String = param1;
var password:String = param2;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = IExternalEntranceModel(this.impl[i]);
m.login(uid,password);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.tankparts.weapon.thunder
{
import scpacker.Base;
public class ThunderModelBase extends Base
{
public function ThunderModelBase()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.shaft {
public class ShaftAimingType {
public static const DIRECTIONAL:ShaftAimingType = new ShaftAimingType();
public static const MOUSE:ShaftAimingType = new ShaftAimingType();
public function ShaftAimingType() {
super();
}
}
}
|
package scpacker.resource
{
import flash.media.Sound;
public class SoundResource
{
public var sound:Sound;
public var nameID:String;
public function SoundResource(sound:Sound, id:String)
{
super();
this.nameID = id;
this.sound = sound;
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.candidates.ClanIncomingListRenderer;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.candidates.HeaderClanCandidateList;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.list.ClanMembersDataProvider;
import alternativa.tanks.gui.notinclan.dialogs.ClanDialog;
import alternativa.tanks.models.clan.incoming.IClanIncomingModel;
import alternativa.tanks.models.service.ClanNotificationsManager;
import alternativa.tanks.service.clan.ClanMembersListEvent;
import alternativa.types.Long;
import controls.base.DefaultButtonBase;
import controls.windowinner.WindowInner;
import fl.controls.List;
import flash.events.MouseEvent;
import flash.utils.Dictionary;
import forms.Styles;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanFunctionsService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoLabelUpdater;
import projects.tanks.clients.fp10.libraries.tanksservices.service.user.IUserInfoService;
import utils.ScrollStyleUtils;
public class ClanIncomingRequestsDialog extends ClanDialog {
[Inject]
public static var clanFunctionsService:ClanFunctionsService;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var userInfoService:IUserInfoService;
public static const WIDTH:Number = 550;
public static const HEIGHT:Number = 450;
private var viewed:Dictionary;
private var inner:WindowInner;
private var list:List;
private var dataProvider:ClanMembersDataProvider;
private var _header:HeaderClanCandidateList;
private var rejectAllButton:DefaultButtonBase;
private var incomingModel:IClanIncomingModel;
public function ClanIncomingRequestsDialog(param1:IGameObject) {
super();
this.viewed = new Dictionary();
this.incomingModel = IClanIncomingModel(param1.adapt(IClanIncomingModel));
this.incomingModel.setClanIncomingWindow(this);
this.inner = new WindowInner(WIDTH,HEIGHT,WindowInner.GREEN);
window.addChild(this.inner);
this._header = new HeaderClanCandidateList();
this.inner.addChild(this._header);
this.dataProvider = new ClanMembersDataProvider();
this.dataProvider.getItemAtHandler = this.markAsViewed;
this.list = new List();
this.list.rowHeight = 20;
this.list.setStyle(Styles.CELL_RENDERER,ClanIncomingListRenderer);
this.list.focusEnabled = true;
this.list.selectable = false;
this.list.dataProvider = this.dataProvider;
ScrollStyleUtils.setGreenStyle(this.list);
this.inner.addChild(this.list);
ScrollStyleUtils.setGreenStyle(this.list);
this.fillData();
this.rejectAllButton = new DefaultButtonBase();
this.rejectAllButton.label = localeService.getText(TanksLocale.TEXT_FRIENDS_DECLINE_ALL_BUTTON);
window.addChild(this.rejectAllButton);
this.list.addEventListener(ClanMembersListEvent.REJECT_USER,this.onRejectUser);
this.list.addEventListener(ClanMembersListEvent.ACCEPTED_USER,this.onAcceptedUser);
this.rejectAllButton.addEventListener(MouseEvent.CLICK,this.onRejectAll);
this.resize();
}
private function markAsViewed(param1:Object) : void {
if(!this.isViewed(param1)) {
this.setAsViewed(param1);
}
}
public function removeAllViewed() : void {
var local1:Object = null;
for(local1 in this.viewed) {
ClanNotificationsManager.removeIncomingNotification(local1.id);
}
}
protected function isViewed(param1:Object) : Boolean {
return param1 in this.viewed;
}
protected function setAsViewed(param1:Object) : void {
this.viewed[param1] = true;
}
private function onRejectAll(param1:MouseEvent) : void {
clanFunctionsService.rejectAllRequests();
}
private function onAcceptedUser(param1:ClanMembersListEvent) : void {
clanFunctionsService.acceptRequest(param1.userId);
}
private function onRejectUser(param1:ClanMembersListEvent) : void {
clanFunctionsService.rejectRequest(param1.userId);
}
public function resize() : void {
this.inner.x = MARGIN;
this.inner.y = MARGIN;
this.inner.width = WIDTH - 2 * MARGIN;
this.inner.height = closeButton.y - MARGIN - SMALL_MARGIN;
this._header.x = 3;
this._header.y = 3;
this._header.width = this.inner.width - 6;
this.list.x = 3;
this.list.y = 23;
this.list.height = this.inner.height - 24;
var local1:Boolean = this.list.maxVerticalScrollPosition > 0;
this.list.width = local1 ? this.inner.width + 2 : this.inner.width - 6;
if(this.rejectAllButton != null) {
this.rejectAllButton.x = MARGIN;
this.rejectAllButton.y = this.height - MARGIN - this.rejectAllButton.height;
}
}
public function fillData() : void {
var local1:Long = null;
var local2:IUserInfoLabelUpdater = null;
var local3:Object = null;
this.dataProvider.removeAll();
for each(local1 in this.incomingModel.getUsers()) {
local2 = userInfoService.getOrCreateUpdater(local1);
local3 = {};
local3.id = local1;
local3.isNew = ClanNotificationsManager.userInIncomingNotifications(local1);
local3.uid = local2.uid;
this.dataProvider.addItem(local3);
}
this.sort();
this.resize();
}
private function sort() : void {
this.dataProvider.sortOn(["isNew","uid"],[Array.NUMERIC | Array.DESCENDING,Array.CASEINSENSITIVE]);
}
public function addUser(param1:Long) : void {
this.dataProvider.addItem({"id":param1});
this.sort();
this.resize();
}
public function removeUser(param1:Long) : void {
var local2:int = this.dataProvider.getItemIndexById(param1);
if(local2 >= 0) {
this.dataProvider.removeItemAt(local2);
}
this.sort();
this.resize();
}
override protected function onCloseClick(param1:MouseEvent) : void {
this.removeAllViewed();
super.onCloseClick(param1);
}
override public function updateActions() : void {
if(!clanUserInfoService.hasAction(ClanAction.ADDING_TO_CLAN)) {
destroy();
}
}
override public function get height() : Number {
return HEIGHT;
}
override public function get width() : Number {
return WIDTH;
}
override protected function getImageHeaderId() : String {
return TanksLocale.TEXT_HEADER_CLAN_MANAGMENT;
}
}
}
|
package projects.tanks.client.panel.model.presents {
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 PresentsSettingsModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _setReceivePresentsId:Long = Long.getLong(1855531100,1174233969);
private var _setReceivePresents_enabledCodec:ICodec;
private var model:IModel;
public function PresentsSettingsModelServer(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._setReceivePresents_enabledCodec = this.protocol.getCodec(new TypeCodecInfo(Boolean,false));
}
public function setReceivePresents(param1:Boolean) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._setReceivePresents_enabledCodec.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._setReceivePresentsId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package alternativa.tanks.models.weapons.targeting.processor {
import alternativa.math.Vector3;
import alternativa.physics.collision.types.RayHit;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.weapon.AllGlobalGunParams;
import alternativa.tanks.models.weapon.railgun.MultibodyCollisionFilter;
import alternativa.tanks.physics.TanksCollisionDetector;
import platform.client.fp10.core.type.IGameObject;
public class DirectionProcessorForPenetratingWeapons extends CommonDirectionProcessor implements TargetingDirectionProcessor {
[Inject]
public static var battleService:BattleService;
private var self:IGameObject;
private var maxDistance:Number;
private var collisionDetector:TanksCollisionDetector;
private var multibodyFilter:MultibodyCollisionFilter = new MultibodyCollisionFilter();
private var rayHitResult:RayHit = new RayHit();
private var hits:Vector.<RayHit> = new Vector.<RayHit>();
public function DirectionProcessorForPenetratingWeapons(param1:IGameObject, param2:Number) {
super(param2,this.multibodyFilter);
this.self = param1;
this.maxDistance = param2;
this.collisionDetector = battleService.getBattleRunner().getCollisionDetector();
}
override public function process(param1:AllGlobalGunParams, param2:Vector3) : Vector.<RayHit> {
this.multibodyFilter.addBody(this.getTank(this.self).getBody());
this.hits.length = 0;
while(raycast(getOrigin(param1,param2),param2,this.rayHitResult)) {
this.hits.push(this.rayHitResult.clone());
if(this.rayHitResult.staticHit) {
break;
}
this.multibodyFilter.addBody(this.rayHitResult.shape.body);
}
this.multibodyFilter.clear();
return this.hits;
}
private function getTank(param1:IGameObject) : Tank {
var local2:ITankModel = ITankModel(param1.adapt(ITankModel));
return local2.getTank();
}
}
}
|
package controls.slider
{
import controls.Slider;
import flash.events.Event;
import flash.events.MouseEvent;
public class SelectRank extends Slider
{
private var _minRang:int = 0;
private var _maxRang:int = 0;
private var _currentRang:int = 1;
public var _maxRangRange:int = 27;
private var sthumb:SelectRankThumb;
protected var _thumbTick:Number;
public function SelectRank()
{
this.sthumb = new SelectRankThumb();
super();
removeChild(track);
track = new SliderTrack(false);
addChild(track);
removeChild(thumb);
addChild(this.sthumb);
_thumb_width = 36;
}
override protected function UnConfigUI(e:Event) : void
{
stage.removeEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
stage.removeEventListener(MouseEvent.MOUSE_MOVE,this.dragThumb);
}
override protected function ConfigUI(e:Event) : void
{
this.sthumb.leftDrag.addEventListener(MouseEvent.MOUSE_DOWN,onMouseDown);
this.sthumb.rightDrag.addEventListener(MouseEvent.MOUSE_DOWN,onMouseDown);
this.sthumb.centerDrag.addEventListener(MouseEvent.MOUSE_DOWN,onMouseDown);
stage.addEventListener(MouseEvent.MOUSE_UP,this.onMouseUp);
}
protected function checkMinRang() : void
{
if(this._minRang < _minValue)
{
this._minRang = _minValue;
}
else if(this._minRang < this._currentRang - this._maxRangRange)
{
this._minRang = this._currentRang - this._maxRangRange;
this._maxRang = this._currentRang;
}
else if(this._minRang < this._maxRang - this._maxRangRange)
{
this._maxRang = this._minRang + this._maxRangRange;
}
else if(this._minRang > this._currentRang)
{
this._minRang = this._currentRang;
}
}
protected function checkMaxRang() : void
{
if(this._maxRang > _maxValue)
{
this._maxRang = _maxValue;
}
else if(this._maxRang > this._currentRang + this._maxRangRange)
{
this._maxRang = this._currentRang + this._maxRangRange;
this._minRang = this._currentRang;
}
else if(this._maxRang > this._minRang + this._maxRangRange)
{
this._minRang = this._maxRang - this._maxRangRange;
}
else if(this._maxRang < this._currentRang)
{
this._maxRang = this._currentRang;
}
}
public function get minRang() : int
{
return this._minRang;
}
public function set minRang(minRang:int) : void
{
this._minRang = minRang;
}
public function get maxRang() : int
{
return this._maxRang;
}
public function set maxRang(maxRang:int) : void
{
this._maxRang = maxRang;
}
public function get currentRang() : int
{
return this._currentRang;
}
public function set currentRang(currentRang:int) : void
{
this._currentRang = currentRang;
value = this._minRang = this._maxRang = this._currentRang;
}
override public function set width(w:Number) : void
{
super.width = w;
var rz:int = _maxValue - _minValue;
this._thumbTick = (_width + 2 - _thumb_width) / rz;
this.drawThumb();
}
override protected function onMouseUp(e:MouseEvent) : void
{
if(e != null)
{
stage.removeEventListener(MouseEvent.MOUSE_MOVE,this.dragThumb);
}
}
override protected function dragThumb(e:MouseEvent) : void
{
var leftFlag:Boolean = trgt.mouseX < curThumbX;
var rightFlag:Boolean = trgt.mouseX > curThumbX;
var maxMinRangFlag:Boolean = this._minRang < this._currentRang;
var minMaxRangFlag:Boolean = this._maxRang > this._currentRang;
var rz:int = 0;
if(trgt == this.sthumb.leftDrag && (leftFlag || maxMinRangFlag))
{
this._minRang += int((this.sthumb.leftDrag.mouseX - curThumbX) / this._thumbTick);
this.checkMinRang();
this.checkMaxRang();
}
else if(trgt == this.sthumb.rightDrag && (rightFlag || minMaxRangFlag))
{
this._maxRang += int((this.sthumb.rightDrag.mouseX - curThumbX) / this._thumbTick);
this.checkMinRang();
this.checkMaxRang();
}
else if(trgt == this.sthumb.centerDrag && ((leftFlag || maxMinRangFlag) && (rightFlag || minMaxRangFlag)))
{
this._minRang += int((this.sthumb.centerDrag.mouseX - curThumbX) / this._thumbTick);
this._maxRang += int((this.sthumb.centerDrag.mouseX - curThumbX) / this._thumbTick);
if(this._minRang < _minValue)
{
rz = this._maxRang - this._minRang;
this._minRang = _minValue;
this._maxRang = _minValue + rz;
}
if(this._maxRang > _maxValue)
{
rz = this._maxRang - this._minRang;
this._maxRang = _maxValue;
this._minRang = this._maxRang - rz;
}
rz = this._maxRang - this._minRang;
if(this._minRang > this._currentRang)
{
this._minRang = this._currentRang;
this._maxRang = this._minRang + rz;
}
if(this._maxRang < this._currentRang)
{
this._maxRang = this._currentRang;
this._minRang = this._maxRang - rz;
}
}
this.drawThumb();
}
private function drawThumb() : void
{
var rz:int = this._maxRang - this._minRang;
this.sthumb.width = _thumb_width + this._thumbTick * rz;
this.sthumb.x = int(this._thumbTick * (this._minRang - _minValue));
this.sthumb.minRang = this._minRang;
this.sthumb.maxRang = this._maxRang;
}
}
}
|
package alternativa.engine3d.core
{
import flash.geom.Point;
import flash.geom.Vector3D;
public class RayIntersectionData
{
public var object:Object3D;
public var face:Face;
public var point:Vector3D;
public var uv:Point;
public var time:Number;
public function RayIntersectionData()
{
super();
}
public function toString() : String
{
return "[RayIntersectionData " + this.object + ", " + this.face + ", " + this.point + ", " + this.uv + ", " + this.time + "]";
}
}
}
|
package projects.tanks.client.battlefield.models.battle.pointbased {
import projects.tanks.client.battlefield.types.Vector3d;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class ClientTeamPoint {
private var _flagBasePosition:Vector3d;
private var _id:int;
private var _teamType:BattleTeam;
public function ClientTeamPoint(param1:Vector3d = null, param2:int = 0, param3:BattleTeam = null) {
super();
this._flagBasePosition = param1;
this._id = param2;
this._teamType = param3;
}
public function get flagBasePosition() : Vector3d {
return this._flagBasePosition;
}
public function set flagBasePosition(param1:Vector3d) : void {
this._flagBasePosition = param1;
}
public function get id() : int {
return this._id;
}
public function set id(param1:int) : void {
this._id = param1;
}
public function get teamType() : BattleTeam {
return this._teamType;
}
public function set teamType(param1:BattleTeam) : void {
this._teamType = param1;
}
public function toString() : String {
var local1:String = "ClientTeamPoint [";
local1 += "flagBasePosition = " + this.flagBasePosition + " ";
local1 += "id = " + this.id + " ";
local1 += "teamType = " + this.teamType + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.panel.model.shop.featuring {
public interface IShopItemFeaturingModelBase {
}
}
|
package alternativa.tanks.sfx {
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.objects.Mesh;
public class SimplePlane extends Mesh {
protected var a:Vertex;
protected var b:Vertex;
protected var c:Vertex;
protected var d:Vertex;
private var originX:Number;
private var originY:Number;
public function SimplePlane(param1:Number, param2:Number, param3:Number, param4:Number) {
super();
this.originX = param3;
this.originY = param4;
boundMinX = -param3 * param1;
boundMaxX = boundMinX + param1;
boundMinY = -param4 * param2;
boundMaxY = boundMinY + param2;
boundMinZ = 0;
boundMaxZ = 0;
var local5:Vector.<Number> = Vector.<Number>([boundMinX,boundMinY,0,boundMaxX,boundMinY,0,boundMaxX,boundMaxY,0,boundMinX,boundMaxY,0]);
var local6:Vector.<Number> = Vector.<Number>([0,1,1,1,1,0,0,0]);
var local7:Vector.<int> = Vector.<int>([4,0,1,2,3]);
addVerticesAndFaces(local5,local6,local7,true);
calculateFacesNormals();
this.writeVertices();
}
private function writeVertices() : void {
var local1:Vector.<Vertex> = this.vertices;
this.a = local1[0];
this.b = local1[1];
this.c = local1[2];
this.d = local1[3];
}
public function setUVs(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number) : void {
this.a.u = param1;
this.a.v = param2;
this.b.u = param3;
this.b.v = param4;
this.c.u = param5;
this.c.v = param6;
this.d.u = param7;
this.d.v = param8;
}
public function set width(param1:Number) : void {
boundMinX = this.a.x = this.d.x = -this.originX * param1;
boundMaxX = this.b.x = this.c.x = boundMinX + param1;
}
public function get length() : Number {
return boundMaxY - boundMinY;
}
public function set length(param1:Number) : void {
boundMinY = this.a.y = this.b.y = -this.originY * param1;
boundMaxY = this.d.y = this.c.y = boundMinY + param1;
}
public function resize(param1:Number, param2:Number) : void {
this.width = param1;
this.length = param2;
}
}
}
|
package alternativa.tanks.models.battlefield.effects.graffiti
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class TexturesManager_graffiti_glhf extends BitmapAsset
{
public function TexturesManager_graffiti_glhf()
{
super();
}
}
}
|
package alternativa.tanks.gui.clanmanagement.clanmemberlist.members {
import alternativa.tanks.gui.clanmanagement.clanmemberlist.list.ClanUserListRenderer;
import flash.events.MouseEvent;
public class ClanMembersListRenderer extends ClanUserListRenderer {
public function ClanMembersListRenderer() {
super();
}
override public function set data(param1:Object) : void {
item = new ClanMemberItem(param1);
super.data = param1;
}
override protected function onRollOut(param1:MouseEvent) : void {
item.deleteIndicator.visible = false;
var local2:ClanMemberItem = ClanMemberItem(item);
if(!local2) {
super.onRollOut(param1);
return;
}
local2.newIndicator.updateNotifications();
super.onRollOut(param1);
}
override protected function onRollOver(param1:MouseEvent) : void {
var local2:ClanMemberItem = ClanMemberItem(item);
if(!local2) {
super.onRollOver(param1);
return;
}
local2.newIndicator.visible = false;
super.onRollOver(param1);
}
}
}
|
package alternativa.tanks.models.weapon.smoky {
import alternativa.math.Vector3;
import alternativa.physics.Body;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleUtils;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.StateCorrectionEvent;
import alternativa.tanks.battle.events.TankAddedToBattleEvent;
import alternativa.tanks.battle.events.TankRemovedFromBattleEvent;
import alternativa.tanks.battle.events.TankUnloadedEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.Weapon;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.ultimate.hunter.stun.UltimateStunListener;
import alternativa.tanks.models.weapon.IWeaponModel;
import alternativa.tanks.models.weapon.WeaponForces;
import alternativa.tanks.models.weapon.WeaponObject;
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import alternativa.tanks.models.weapon.common.WeaponBuffListener;
import alternativa.tanks.models.weapon.common.WeaponCommonData;
import alternativa.tanks.models.weapon.shared.SimpleWeaponController;
import alternativa.tanks.models.weapon.shared.shot.WeaponReloadTimeChangedListener;
import alternativa.tanks.models.weapon.smoky.sfx.ISmokySFXModel;
import alternativa.tanks.models.weapon.weakening.DistanceWeakening;
import alternativa.tanks.models.weapon.weakening.IWeaponWeakeningModel;
import alternativa.tanks.models.weapons.targeting.CommonTargetingSystem;
import alternativa.tanks.models.weapons.targeting.TargetingSystem;
import flash.utils.Dictionary;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.tankparts.weapon.smoky.ISmokyModelBase;
import projects.tanks.client.battlefield.models.tankparts.weapon.smoky.SmokyModelBase;
import projects.tanks.client.battlefield.types.Vector3d;
[ModelInfo]
public class SmokyModel extends SmokyModelBase implements ISmokyModelBase, IWeaponModel, SmokyCallback, WeaponBuffListener, WeaponReloadTimeChangedListener, UltimateStunListener {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
private static const MAX_TARGETING_DISTANCE:Number = 1000000;
private var battleEventSupport:BattleEventSupport;
private var weapons:Dictionary = new Dictionary();
private var tanksInBattle:Dictionary = new Dictionary();
private var localWeapon:SmokyWeapon;
public function SmokyModel() {
super();
this.battleEventSupport = new BattleEventSupport(battleEventDispatcher);
this.battleEventSupport.addEventHandler(TankAddedToBattleEvent,this.onTankAddedToBattle);
this.battleEventSupport.addEventHandler(TankRemovedFromBattleEvent,this.onTankRemovedFromBattle);
this.battleEventSupport.addEventHandler(TankUnloadedEvent,this.onTankUnloaded);
this.battleEventSupport.activateHandlers();
}
private static function getWeaponCommonData() : WeaponCommonData {
var local1:IWeaponCommonModel = IWeaponCommonModel(object.adapt(IWeaponCommonModel));
return local1.getCommonData();
}
private static function getWeakening() : DistanceWeakening {
var local1:IWeaponWeakeningModel = IWeaponWeakeningModel(object.adapt(IWeaponWeakeningModel));
return local1.getDistanceWeakening();
}
private static function getEffects() : ISmokyEffects {
var local1:ISmokySFXModel = ISmokySFXModel(object.adapt(ISmokySFXModel));
return local1.getEffects();
}
[Obfuscation(rename="false")]
public function shoot(param1:IGameObject) : void {
var local2:RemoteSmokyWeapon = this.weapons[param1];
if(local2 != null) {
local2.simulateShot();
}
}
[Obfuscation(rename="false")]
public function shootStatic(param1:IGameObject, param2:Vector3d) : void {
var local3:RemoteSmokyWeapon = this.weapons[param1];
if(local3 != null) {
local3.simulateStaticShot(BattleUtils.getVector3(param2));
}
}
[Obfuscation(rename="false")]
public function shootTarget(param1:IGameObject, param2:IGameObject, param3:Vector3d, param4:Number, param5:Boolean) : void {
var local7:Tank = null;
var local8:Vector3 = null;
var local6:RemoteSmokyWeapon = this.weapons[param1];
if(local6 != null) {
local7 = this.tanksInBattle[param2];
if(local7 != null) {
local8 = BattleUtils.getVector3(param3);
BattleUtils.localToGlobal(local7.getBody(),local8);
local6.simulateTargetShot(local7,local8,param4,param5);
}
}
}
[Obfuscation(rename="false")]
public function localCriticalHit(param1:IGameObject) : void {
var local2:Tank = this.tanksInBattle[param1];
this.localWeapon.createCriticalHitEffect(local2.getBody().state.position);
}
public function createLocalWeapon(param1:IGameObject) : Weapon {
var local2:WeaponObject = new WeaponObject(object);
var local3:TargetingSystem = new CommonTargetingSystem(param1,local2,MAX_TARGETING_DISTANCE);
var local4:WeaponCommonData = getWeaponCommonData();
var local5:WeaponForces = new WeaponForces(local4.getImpactForce(),local4.getRecoilForce());
this.localWeapon = new SmokyWeapon(local2,local5,local3,getWeakening(),getEffects(),SmokyCallback(object.adapt(SmokyCallback)),new SimpleWeaponController());
this.weapons[param1] = this.localWeapon;
return this.localWeapon;
}
public function createRemoteWeapon(param1:IGameObject) : Weapon {
var local2:WeaponCommonData = getWeaponCommonData();
var local3:WeaponForces = new WeaponForces(local2.getImpactForce(),local2.getRecoilForce());
var local4:Weapon = new RemoteSmokyWeapon(local3,getEffects());
this.weapons[param1] = local4;
return local4;
}
public function onShot(param1:int) : void {
server.fireCommand(param1);
}
public function onShotStatic(param1:int, param2:Vector3) : void {
server.fireStaticCommand(param1,BattleUtils.getVector3d(param2));
}
public function onShotTarget(param1:int, param2:Vector3, param3:Body) : void {
var local4:Tank = param3.tank;
var local5:Vector3 = param2.clone();
BattleUtils.globalToLocal(param3,local5);
this.battleEventSupport.dispatchEvent(StateCorrectionEvent.MANDATORY_UPDATE);
server.fireTargetCommand(param1,local4.getUser(),local4.incarnation,BattleUtils.getVector3d(param3.state.position),BattleUtils.getVector3d(local5),BattleUtils.getVector3d(param2));
}
private function onTankAddedToBattle(param1:TankAddedToBattleEvent) : void {
this.tanksInBattle[param1.tank.getUser()] = param1.tank;
}
private function onTankRemovedFromBattle(param1:TankRemovedFromBattleEvent) : void {
delete this.tanksInBattle[param1.tank.getUser()];
}
private function onTankUnloaded(param1:TankUnloadedEvent) : void {
var local2:Weapon = this.weapons[param1.tank.getUser()];
if(local2 == this.localWeapon) {
this.localWeapon = null;
}
delete this.weapons[param1.tank.getUser()];
}
public function weaponReloadTimeChanged(param1:int, param2:int) : void {
var local3:Tank = null;
if(this.isLocalWeapon()) {
local3 = IWeaponCommonModel(object.adapt(IWeaponCommonModel)).getTank();
Weapon(this.weapons[local3.user]).weaponReloadTimeChanged(param1,param2);
}
}
public function weaponBuffStateChanged(param1:IGameObject, param2:Boolean, param3:Number) : void {
var local4:Weapon = this.weapons[param1];
if(local4 != null) {
local4.updateRecoilForce(param3);
if(local4 == this.localWeapon && !param2) {
this.localWeapon.fullyRecharge();
}
}
}
private function isLocalWeapon() : Boolean {
var local1:Tank = IWeaponCommonModel(object.adapt(IWeaponCommonModel)).getTank();
return ITankModel(local1.user.adapt(ITankModel)).isLocal();
}
public function onStun(param1:Tank, param2:Boolean) : void {
if(param2) {
this.localWeapon.stun();
}
}
public function onCalm(param1:Tank, param2:Boolean, param3:int) : void {
if(param2) {
this.localWeapon.calm(param3);
}
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices {
import flash.display.Sprite;
import flash.events.IEventDispatcher;
public interface IAlertService extends IEventDispatcher {
function showAlert(param1:String, param2:Vector.<String>) : void;
function showAlertWithCustomButtons(param1:String, param2:Vector.<String>, param3:Vector.<Sprite>) : void;
function showOkAlert(param1:String) : void;
function showAlertById(param1:int) : void;
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapBigRank31.png")]
public class PremiumRankBitmaps_bitmapBigRank31 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapBigRank31() {
super();
}
}
}
|
package projects.tanks.client.battleselect.model.battle.entrance {
public interface IBattleEntranceModelBase {
function enterToBattleFailed() : void;
function equipmentNotMatchConstraints() : void;
function fightFailedServerIsHalting() : void;
}
}
|
package alternativa.tanks.gui.friends {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.FriendActionIndicator_noIconClass.png")]
public class FriendActionIndicator_noIconClass extends BitmapAsset {
public function FriendActionIndicator_noIconClass() {
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.renameshopitem {
public interface IRenameShopItemModelBase {
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ItemInfoPanel_bitmapFireRateShaft extends BitmapAsset
{
public function ItemInfoPanel_bitmapFireRateShaft()
{
super();
}
}
}
|
package alternativa.model.timeperiod {
[ModelInterface]
public interface TimePeriod {
function isEnabled() : Boolean;
function isTimeless() : Boolean;
function getModelLoadingTimeInMillis() : int;
function getTimeLeftInSeconds() : int;
function getTimeToStartInSeconds() : int;
}
}
|
package projects.tanks.client.panel.model.shop.androidspecialoffer.offers {
public interface IAndroidSpecialOfferModelBase {
}
}
|
package alternativa.tanks.models.battle.facilities {
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.TankRemovedFromBattleEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.tank.LocalTankInfoService;
import alternativa.tanks.models.tank.event.TankEntityCreationListener;
import flash.utils.Dictionary;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.battle.battlefield.facilities.BattleFacilitiesModelBase;
import projects.tanks.client.battlefield.models.battle.battlefield.facilities.IBattleFacilitiesModelBase;
import projects.tanks.client.battlefield.models.user.tank.TankLogicState;
[ModelInfo]
public class BattleFacilitiesModel extends BattleFacilitiesModelBase implements IBattleFacilitiesModelBase, BattleFacilities, ObjectLoadPostListener, BattleFacilitiesChecker, TankEntityCreationListener, ObjectUnloadListener {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var localTankInfoService:LocalTankInfoService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
private var battleEventSupport:BattleEventSupport;
private var diff:Vector3 = new Vector3();
private var virtualPrevPos:Vector3 = new Vector3();
private var localTankZone:CheckZone = null;
private var tankMoves:Dictionary = new Dictionary();
public function BattleFacilitiesModel() {
super();
this.battleEventSupport = new BattleEventSupport(battleEventDispatcher);
this.battleEventSupport.addEventHandler(TankRemovedFromBattleEvent,this.onTankRemovedFromBattle);
this.battleEventSupport.activateHandlers();
}
public function register(param1:IGameObject) : void {
Dictionary(getData(Dictionary))[param1] = param1;
}
public function unregister(param1:IGameObject) : void {
delete Dictionary(getData(Dictionary))[param1];
}
public function addCheckZone(param1:IGameObject, param2:Vector3, param3:Number, param4:Boolean) : void {
CheckZones(getData(CheckZones)).add(param1,param2,param3,param4);
}
public function addDynamicCheckZone(param1:IGameObject, param2:Tank, param3:Number, param4:Boolean) : void {
var local5:CheckZones = CheckZones(getData(CheckZones));
var local6:CheckZone = local5.addDynamic(param1,param2,param3,param4);
if(Boolean(localTankInfoService.isLocalTankLoaded()) && localTankInfoService.getLocalTank() == param2) {
this.localTankZone = local6;
this.tankMoves = new Dictionary();
}
}
public function removeCheckZone(param1:IGameObject) : void {
if(!localTankInfoService.isLocalTankLoaded()) {
this.localTankZone = null;
this.tankMoves = new Dictionary();
}
var local2:CheckZone = CheckZones(getData(CheckZones)).remove(param1);
if(local2 != null && Boolean(localTankInfoService.isLocalTankLoaded()) && local2.tank == localTankInfoService.getLocalTank()) {
this.localTankZone = null;
this.tankMoves = new Dictionary();
}
}
public function objectLoadedPost() : void {
putData(CheckZones,new CheckZones(battleService.getBattleRunner().getCollisionDetector()));
putData(Dictionary,new Dictionary());
}
public function checkFacilityZonesDemandsStateCorrection(param1:Vector3, param2:Vector3) : Boolean {
var local4:Vector3 = null;
var local3:Boolean = CheckZones(getData(CheckZones)).checkZoneChanged(param1,param2);
if(!local3 && this.localTankZone != null) {
for each(local4 in this.tankMoves) {
this.diff.copy(param2).subtract(param1);
this.virtualPrevPos.copy(local4).add(this.diff);
if(CheckZones.checkZoneBordersCrossed(this.localTankZone,this.virtualPrevPos,local4)) {
return true;
}
}
}
return local3;
}
public function onMoveCommand(param1:Tank, param2:Vector3, param3:Vector3) : void {
if(this.localTankZone != null && param1 != localTankInfoService.getLocalTank()) {
this.tankMoves[param1] = param3.clone();
}
}
public function onTankEntityCreated(param1:Tank, param2:Boolean, param3:TankLogicState) : void {
var local4:IGameObject = null;
for each(local4 in Dictionary(getData(Dictionary))) {
TankEntityCreationListener(local4.event(TankEntityCreationListener)).onTankEntityCreated(param1,param2,param3);
}
}
private function onTankRemovedFromBattle(param1:TankRemovedFromBattleEvent) : void {
delete this.tankMoves[param1.tank];
}
public function objectUnloaded() : void {
var local1:IGameObject = null;
for each(local1 in Dictionary(getData(Dictionary))) {
BattleUnloadListener(local1.event(BattleUnloadListener)).battleUnload();
}
}
}
}
|
package alternativa.tanks.battle.events {
public class SuicideEvent {
public function SuicideEvent() {
super();
}
}
}
|
package alternativa.tanks.sfx
{
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.models.battlefield.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class PlaneMuzzleFlashEffect extends PooledObject implements IGraphicEffect
{
private static const gunDirection:Vector3 = new Vector3();
private static const globalMuzzlePosition:Vector3 = new Vector3();
private static const turretMatrix:Matrix4 = new Matrix4();
private var plane:SimplePlane;
private var timetoLive:int;
private var turret:Object3D;
private var localMuzzlePosition:Vector3;
private var container:Scene3DContainer;
public function PlaneMuzzleFlashEffect(param1:ObjectPool)
{
this.localMuzzlePosition = new Vector3();
super(param1);
this.plane = new SimplePlane(1,1,0.5,0);
this.plane.setUVs(0,0,0,1,1,1,1,0);
this.plane.shadowMapAlphaThreshold = 2;
this.plane.depthMapAlphaThreshold = 2;
this.plane.useShadowMap = false;
this.plane.useLight = false;
}
public function init(param1:Vector3, param2:Object3D, param3:TextureMaterial, param4:int, param5:Number, param6:Number) : void
{
this.localMuzzlePosition.copyFrom(param1);
this.turret = param2;
this.timetoLive = param4;
this.plane.setMaterialToAllFaces(param3);
this.plane.width = param5;
this.plane.length = param6;
}
public function play(param1:int, param2:GameCamera) : Boolean
{
if(this.timetoLive < 0)
{
return false;
}
this.timetoLive -= param1;
turretMatrix.setMatrix(this.turret.x,this.turret.y,this.turret.z,this.turret.rotationX,this.turret.rotationY,this.turret.rotationZ);
turretMatrix.transformVector(this.localMuzzlePosition,globalMuzzlePosition);
turretMatrix.getAxis(1,gunDirection);
SFXUtils.alignObjectPlaneToView(this.plane,globalMuzzlePosition,gunDirection,param2.pos);
return true;
}
public function destroy() : void
{
this.container.removeChild(this.plane);
this.plane = null;
this.container = null;
this.turret = null;
}
public function kill() : void
{
this.timetoLive = -1;
}
public function addToContainer(param1:Scene3DContainer) : void
{
this.container = param1;
param1.addChild(this.plane);
}
public function get owner() : ClientObject
{
return null;
}
}
}
|
package controls.rangicons {
import flash.display.MovieClip;
public class RangIcon extends MovieClip {
private static const rangs:Array = ["Recruit","Private","Gefreiter","Corporal","Master Corporal","Sergeant","Staff Sergeant","Master Sergeant","First Sergeant","Sergeant-Major","Warrant Officer 1","Warrant Officer 2","Warrant Officer 3","Warrant Officer 4","Warrant Officer 5","Third Lieutenant","Second Lieutenant","First Lieutenant","Captain","Major","Lieutenant Colonel","Colonel","Brigadier","Major General","Lieutenant General","General","Marshal"];
private var _rang:int = 1;
public function RangIcon(param1:int = 1) {
super();
this.rang = param1;
}
public static function rangName(param1:int) : String {
return rangs[param1 - 1];
}
public function set rang(param1:int) : void {
this._rang = param1;
gotoAndStop(this._rang);
}
public function get rang() : int {
return this._rang;
}
}
}
|
package alternativa.engine3d.materials {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Canvas;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Light3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.lights.AmbientLight;
import alternativa.engine3d.lights.DirectionalLight;
import alternativa.engine3d.lights.OmniLight;
import alternativa.engine3d.lights.SpotLight;
import flash.display.BitmapData;
import flash.geom.ColorTransform;
import flash.utils.Dictionary;
use namespace alternativa3d;
public class AverageLightMaterial extends TextureMaterial {
alternativa3d static var colorTransform:ColorTransform = new ColorTransform();
alternativa3d var weights:Dictionary = new Dictionary();
public var cameraDependence:Number = 1;
public var defaultLightWeight:Number = 1;
public function AverageLightMaterial(param1:BitmapData = null, param2:Boolean = false, param3:Boolean = true, param4:int = 0, param5:Number = 1) {
super(param1,param2,param3,param4,param5);
}
public function setLightWeight(param1:Light3D, param2:Number) : void {
this.alternativa3d::weights[param1] = param2;
}
public function getLightWeight(param1:Light3D) : Number {
var local2:Number = Number(this.alternativa3d::weights[param1]);
return local2 == local2 ? local2 : this.defaultLightWeight;
}
public function setLightWeightToDefault(param1:Light3D) : void {
delete this.alternativa3d::weights[param1];
}
public function setAllLightWeightsToDefault() : void {
var local1:* = undefined;
for(local1 in this.alternativa3d::weights) {
delete this.alternativa3d::weights[local1];
}
}
override public function clone() : Material {
var local1:AverageLightMaterial = new AverageLightMaterial(alternativa3d::_texture,repeat,smooth,alternativa3d::_mipMapping,resolution);
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Material) : void {
super.clonePropertiesFrom(param1);
var local2:AverageLightMaterial = param1 as AverageLightMaterial;
this.defaultLightWeight = local2.defaultLightWeight;
}
override alternativa3d function draw(param1:Camera3D, param2:Canvas, param3:Face, param4:Number) : void {
this.alternativa3d::calculateLight(param1,param2.alternativa3d::object);
if(param2.alternativa3d::modifiedColorTransform) {
super.alternativa3d::draw(param1,param2.alternativa3d::getChildCanvas(true,false,param2.alternativa3d::object,1,"normal",alternativa3d::colorTransform),param3,param4);
} else {
super.alternativa3d::draw(param1,param2,param3,param4);
param2.transform.colorTransform = alternativa3d::colorTransform;
param2.alternativa3d::modifiedColorTransform = true;
}
}
override alternativa3d function drawViewAligned(param1:Camera3D, param2:Canvas, param3:Face, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Number) : void {
this.alternativa3d::calculateLight(param1,param2.alternativa3d::object);
if(param2.alternativa3d::modifiedColorTransform) {
super.alternativa3d::drawViewAligned(param1,param2.alternativa3d::getChildCanvas(true,false,param2.alternativa3d::object,1,"normal",alternativa3d::colorTransform),param3,param4,param5,param6,param7,param8,param9,param10);
} else {
super.alternativa3d::drawViewAligned(param1,param2,param3,param4,param5,param6,param7,param8,param9,param10);
param2.transform.colorTransform = alternativa3d::colorTransform;
param2.alternativa3d::modifiedColorTransform = true;
}
}
alternativa3d function calculateLight(param1:Camera3D, param2:Object3D) : void {
var local8:Light3D = null;
var local9:Number = NaN;
var local10:Number = NaN;
var local11:Number = NaN;
var local12:Number = NaN;
var local13:Number = NaN;
var local14:Number = NaN;
var local15:Number = NaN;
var local16:Number = NaN;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local20:Number = NaN;
var local21:Number = NaN;
var local22:Number = NaN;
var local23:Number = NaN;
var local24:Number = NaN;
var local25:DirectionalLight = null;
var local26:OmniLight = null;
var local27:SpotLight = null;
var local28:Number = NaN;
var local29:Number = NaN;
var local30:Number = NaN;
var local31:Number = NaN;
var local32:Number = NaN;
var local33:Number = NaN;
var local34:Number = NaN;
var local3:Number = 0;
var local4:Number = 0;
var local5:Number = 0;
var local6:Number = this.cameraDependence * 0.5;
var local7:int = 0;
while(local7 < param1.alternativa3d::lightsLength) {
local8 = param1.alternativa3d::lights[local7];
local9 = Number(this.alternativa3d::weights[local8]);
if(local9 != local9) {
local9 = this.defaultLightWeight;
}
if(local9 > 0) {
local8.alternativa3d::calculateObjectMatrix(param2);
if(local8.alternativa3d::checkBoundsIntersection(param2)) {
local22 = (local8.color >> 16 & 0xFF) * local8.intensity * local9;
local23 = (local8.color >> 8 & 0xFF) * local8.intensity * local9;
local24 = (local8.color & 0xFF) * local8.intensity * local9;
if(local8 is AmbientLight) {
local3 += local22;
local4 += local23;
local5 += local24;
} else if(local8 is DirectionalLight) {
local25 = local8 as DirectionalLight;
local10 = param2.alternativa3d::imd;
local11 = param2.alternativa3d::imh;
local12 = param2.alternativa3d::iml;
local13 = Math.sqrt(local10 * local10 + local11 * local11 + local12 * local12);
local10 /= local13;
local11 /= local13;
local12 /= local13;
local14 = Number(local25.alternativa3d::omc);
local15 = Number(local25.alternativa3d::omg);
local16 = Number(local25.alternativa3d::omk);
local17 = Math.sqrt(local14 * local14 + local15 * local15 + local16 * local16);
local14 /= local17;
local15 /= local17;
local16 /= local17;
local18 = (-local10 * local14 - local11 * local15 - local12 * local16 - 1) * local6 + 1;
local3 += local22 * local18;
local4 += local23 * local18;
local5 += local24 * local18;
} else if(local8 is OmniLight) {
local26 = local8 as OmniLight;
local19 = Math.sqrt(local26.alternativa3d::oma * local26.alternativa3d::oma + local26.alternativa3d::ome * local26.alternativa3d::ome + local26.alternativa3d::omi * local26.alternativa3d::omi);
local19 += Math.sqrt(local26.alternativa3d::omb * local26.alternativa3d::omb + local26.alternativa3d::omf * local26.alternativa3d::omf + local26.alternativa3d::omj * local26.alternativa3d::omj);
local19 += Math.sqrt(local26.alternativa3d::omc * local26.alternativa3d::omc + local26.alternativa3d::omg * local26.alternativa3d::omg + local26.alternativa3d::omk * local26.alternativa3d::omk);
local19 /= 3;
local20 = local26.attenuationBegin * local19;
local21 = local26.attenuationEnd * local19;
local14 = -local26.alternativa3d::omd;
local15 = -local26.alternativa3d::omh;
local16 = -local26.alternativa3d::oml;
local17 = local14 * local14 + local15 * local15 + local16 * local16;
if(local17 < local21 * local21) {
local10 = param2.alternativa3d::imd;
local11 = param2.alternativa3d::imh;
local12 = param2.alternativa3d::iml;
local13 = Math.sqrt(local10 * local10 + local11 * local11 + local12 * local12);
local10 /= local13;
local11 /= local13;
local12 /= local13;
local17 = Math.sqrt(local17);
local14 /= local17;
local15 /= local17;
local16 /= local17;
local18 = (-local10 * local14 - local11 * local15 - local12 * local16 - 1) * local6 + 1;
if(local17 > local20) {
local18 *= 1 - (local17 - local20) / (local21 - local20);
}
local3 += local22 * local18;
local4 += local23 * local18;
local5 += local24 * local18;
}
} else if(local8 is SpotLight) {
local27 = local8 as SpotLight;
local19 = Math.sqrt(local27.alternativa3d::oma * local27.alternativa3d::oma + local27.alternativa3d::ome * local27.alternativa3d::ome + local27.alternativa3d::omi * local27.alternativa3d::omi);
local19 += Math.sqrt(local27.alternativa3d::omb * local27.alternativa3d::omb + local27.alternativa3d::omf * local27.alternativa3d::omf + local27.alternativa3d::omj * local27.alternativa3d::omj);
local19 += Math.sqrt(local27.alternativa3d::omc * local27.alternativa3d::omc + local27.alternativa3d::omg * local27.alternativa3d::omg + local27.alternativa3d::omk * local27.alternativa3d::omk);
local19 /= 3;
local20 = local27.attenuationBegin * local19;
local21 = local27.attenuationEnd * local19;
local14 = -local27.alternativa3d::omd;
local15 = -local27.alternativa3d::omh;
local16 = -local27.alternativa3d::oml;
local17 = local14 * local14 + local15 * local15 + local16 * local16;
if(local17 < local21 * local21) {
local17 = Math.sqrt(local17);
local14 /= local17;
local15 /= local17;
local16 /= local17;
local28 = Number(local27.alternativa3d::omc);
local29 = Number(local27.alternativa3d::omg);
local30 = Number(local27.alternativa3d::omk);
local31 = Math.sqrt(local28 * local28 + local29 * local29 + local30 * local30);
local28 /= local31;
local29 /= local31;
local30 /= local31;
local32 = Math.cos(local27.hotspot * 0.5);
local33 = Math.cos(local27.falloff * 0.5);
local34 = local28 * local14 + local29 * local15 + local30 * local16;
if(local34 > local33) {
local10 = param2.alternativa3d::imd;
local11 = param2.alternativa3d::imh;
local12 = param2.alternativa3d::iml;
local13 = Math.sqrt(local10 * local10 + local11 * local11 + local12 * local12);
local10 /= local13;
local11 /= local13;
local12 /= local13;
local18 = (-local10 * local14 - local11 * local15 - local12 * local16 - 1) * local6 + 1;
if(local17 > local20) {
local18 *= 1 - (local17 - local20) / (local21 - local20);
}
if(local34 < local32) {
local18 *= (local34 - local33) / (local32 - local33);
}
local3 += local22 * local18;
local4 += local23 * local18;
local5 += local24 * local18;
}
}
}
}
}
local7++;
}
alternativa3d::colorTransform.redMultiplier = local3 / 127.5;
alternativa3d::colorTransform.greenMultiplier = local4 / 127.5;
alternativa3d::colorTransform.blueMultiplier = local5 / 127.5;
}
}
}
|
package projects.tanks.client.panel.model.quest.weekly {
import alternativa.types.Long;
public interface IWeeklyQuestShowingModelBase {
function openWeeklyQuest(param1:Vector.<WeeklyQuestInfo>) : void;
function prizeGiven(param1:Long) : void;
}
}
|
package alternativa.tanks.services.battleinput {
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.service.settings.keybinding.GameActionEnum;
import alternativa.tanks.service.settings.keybinding.KeysBindingService;
import alternativa.tanks.utils.BitMask;
import flash.display.Stage;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.FullScreenEvent;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.utils.Dictionary;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenService;
public class BattleInputServiceImpl extends EventDispatcher implements BattleInputService {
[Inject]
public static var fullScreenService:FullscreenService;
[Inject]
public static var settingsService:ISettingsService;
private var stage:Stage;
private var keysBindingService:KeysBindingService;
private const inputLocks:BitMask = new BitMask();
private const mouseLockLocks:BitMask = new BitMask();
private const pressedKeys:Dictionary = new Dictionary();
private var activeActions:Dictionary = new Dictionary();
private const actionListeners:Vector.<GameActionListener> = new Vector.<GameActionListener>();
private const mouseLockListeners:Vector.<MouseLockListener> = new Vector.<MouseLockListener>();
private const mouseMoveListeners:Vector.<MouseMovementListener> = new Vector.<MouseMovementListener>();
private const mouseWheelListeners:Vector.<MouseWheelListener> = new Vector.<MouseWheelListener>();
private var isFullScreen:Boolean = false;
private const leftMouseAction:MouseButtonAction = new MouseButtonAction(GameActionEnum.SHOT);
private const rightMouseAction:MouseButtonAction = new MouseButtonAction(GameActionEnum.LOOK_AROUND);
private var mouseJustLocked:Boolean = false;
private var isMouseLockAllowed:Boolean = true;
public function BattleInputServiceImpl(param1:Stage, param2:KeysBindingService) {
super();
this.stage = param1;
this.keysBindingService = param2;
this.lock(BattleInputLockType.INACTIVE_BATTLE);
param1.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDown);
param1.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
param1.addEventListener(Event.DEACTIVATE,this.onPlayerDeactivate);
param1.addEventListener(MouseEvent.MOUSE_DOWN,this.onLeftMouseDown);
param1.addEventListener(MouseEvent.MOUSE_UP,this.onLeftMouseUp);
param1.addEventListener(MouseEvent.RIGHT_MOUSE_DOWN,this.onRightMouseDown);
param1.addEventListener(MouseEvent.RIGHT_MOUSE_UP,this.onRightMouseUp);
param1.addEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMove);
param1.addEventListener(MouseEvent.MOUSE_WHEEL,this.onMouseWheel);
param1.addEventListener(Event.MOUSE_LEAVE,this.onMouseLeave);
param1.addEventListener(FullScreenEvent.FULL_SCREEN,this.onFullScreen);
param1.addEventListener(FullScreenEvent.FULL_SCREEN_INTERACTIVE_ACCEPTED,this.onFullScreen);
}
public function forbidMouseLock() : void {
this.isMouseLockAllowed = false;
}
public function allowMouseLock() : void {
this.isMouseLockAllowed = true;
}
private function onKeyDown(param1:KeyboardEvent) : void {
var local3:GameActionEnum = null;
var local2:Boolean = this.pressedKeys[param1.keyCode] != true;
if(local2) {
this.pressedKeys[param1.keyCode] = true;
if(this.isNotLocked()) {
local3 = this.keysBindingService.getBindingAction(param1.keyCode);
if(local3 != null) {
this.handleActionActivation(local3);
}
}
}
}
private function handleActionActivation(param1:GameActionEnum) : void {
var local2:int = int(this.activeActions[param1]) + 1;
this.activeActions[param1] = local2;
if(local2 == 1) {
this.dispatchActionEvent(param1,true);
}
}
private function onKeyUp(param1:KeyboardEvent) : void {
var local3:GameActionEnum = null;
var local2:Boolean = this.pressedKeys[param1.keyCode] == true;
if(local2) {
delete this.pressedKeys[param1.keyCode];
if(this.isNotLocked()) {
local3 = this.keysBindingService.getBindingAction(param1.keyCode);
if(local3 != null) {
this.handleActionDeactivation(local3);
}
}
}
}
private function handleActionDeactivation(param1:GameActionEnum) : void {
var local2:int = int(this.activeActions[param1]);
if(local2 > 0) {
if(local2 == 1) {
delete this.activeActions[param1];
this.dispatchActionEvent(param1,false);
} else {
this.activeActions[param1] = local2 - 1;
}
}
}
private function onPlayerDeactivate(param1:Event) : void {
var local2:* = undefined;
var local3:Dictionary = null;
var local4:* = undefined;
this.leftMouseAction.isActive = false;
this.rightMouseAction.isActive = false;
for(local2 in this.pressedKeys) {
delete this.pressedKeys[local2];
}
local3 = this.activeActions;
this.activeActions = new Dictionary();
if(this.isNotLocked()) {
for(local4 in local3) {
this.dispatchActionEvent(GameActionEnum(local4),false);
}
}
}
private function onLeftMouseDown(param1:MouseEvent) : void {
if(this.isLocked()) {
return;
}
if(this.isFullScreen) {
if(this.stage.mouseLock) {
this.activateMouseAction(this.leftMouseAction);
} else if(param1.target == this.stage && this.canLockMouse()) {
this.setMouseLock(true);
}
} else if(param1.target == this.stage && this.canLockMouse()) {
fullScreenService.switchFullscreen();
}
}
private function onLeftMouseUp(param1:MouseEvent) : void {
this.deactivateMouseAction(this.leftMouseAction);
}
private function onRightMouseDown(param1:MouseEvent) : void {
if(this.stage.mouseLock) {
this.activateMouseAction(this.rightMouseAction);
}
}
private function onRightMouseUp(param1:MouseEvent) : void {
this.deactivateMouseAction(this.rightMouseAction);
}
private function onMouseMove(param1:MouseEvent) : void {
var local2:int = 0;
if(this.stage.mouseLock) {
if(this.mouseJustLocked) {
this.mouseJustLocked = false;
} else {
local2 = 0;
while(local2 < this.mouseMoveListeners.length) {
this.mouseMoveListeners[local2].onMouseRelativeMovement(param1.movementX,param1.movementY);
local2++;
}
}
}
}
private function onMouseWheel(param1:MouseEvent) : void {
var local2:int = 0;
if(this.stage.mouseLock) {
local2 = 0;
while(local2 < this.mouseWheelListeners.length) {
this.mouseWheelListeners[local2].onMouseWheel(param1.delta);
local2++;
}
}
}
private function onMouseLeave(param1:Event) : void {
}
private function onFullScreen(param1:FullScreenEvent) : void {
this.isFullScreen = param1.fullScreen;
if(this.isLocked()) {
return;
}
if(this.isFullScreen) {
if(this.canLockMouse()) {
this.setMouseLock(true);
}
} else {
this.deactivateMouseAction(this.leftMouseAction);
this.deactivateMouseAction(this.rightMouseAction);
this.setMouseLock(false);
}
}
private function dispatchActionEvent(param1:GameActionEnum, param2:Boolean) : void {
var local3:int = 0;
while(local3 < this.actionListeners.length) {
this.actionListeners[local3].onGameAction(param1,param2);
local3++;
}
}
public function lock(param1:BattleInputLockType) : void {
var local4:* = undefined;
var local2:Boolean = this.isChatLocked();
var local3:Boolean = this.isInputLocked();
this.inputLocks.setBits(param1.getMask());
if(!local2 && this.isChatLocked()) {
dispatchEvent(new BattleInputLockEvent(BattleInputLockEvent.CHAT_LOCKED));
}
if(!local3 && this.isInputLocked()) {
if(this.stage.mouseLock) {
this.setMouseLock(false);
}
for(local4 in this.activeActions) {
this.dispatchActionEvent(GameActionEnum(local4),false);
}
this.activeActions = new Dictionary();
dispatchEvent(new BattleInputLockEvent(BattleInputLockEvent.INPUT_LOCKED));
}
}
public function unlock(param1:BattleInputLockType) : void {
var local4:* = undefined;
var local5:GameActionEnum = null;
var local2:Boolean = this.isChatLocked();
var local3:Boolean = this.isLocked();
this.inputLocks.clearBits(param1.getMask());
if(local2 && !this.isChatLocked()) {
dispatchEvent(new BattleInputLockEvent(BattleInputLockEvent.CHAT_UNLOCKED));
}
if(local3 && this.isNotLocked()) {
for(local4 in this.pressedKeys) {
local5 = this.keysBindingService.getBindingAction(local4);
if(local5 != null) {
this.handleActionActivation(local5);
}
}
if(this.isFullScreen && !this.stage.mouseLock && this.canLockMouse()) {
this.setMouseLock(true);
}
dispatchEvent(new BattleInputLockEvent(BattleInputLockEvent.INPUT_UNLOCKED));
}
}
public function lockMouseLocking(param1:MouseLockLockType) : void {
var local2:Boolean = this.mouseLockLocks.isEmpty();
this.mouseLockLocks.setBits(param1.bit);
if(local2 && this.mouseLockLocks.isNotEmpty()) {
if(this.stage.mouseLock) {
this.setMouseLock(false);
}
}
}
public function unlockMouseLocking(param1:MouseLockLockType) : void {
var local2:Boolean = this.mouseLockLocks.isNotEmpty();
this.mouseLockLocks.clearBits(param1.bit);
if(local2 && this.canLockMouse()) {
if(this.isNotLocked() && this.isFullScreen && !this.stage.mouseLock) {
this.setMouseLock(true);
}
}
}
public function isInputLocked() : Boolean {
return this.isLocked();
}
private function isChatLocked() : Boolean {
return this.inputLocks.hasAnyBit(BattleInputLockType.MODAL_DIALOG.getMask());
}
public function addGameActionListener(param1:GameActionListener) : void {
var local2:* = undefined;
if(this.actionListeners.indexOf(param1) < 0) {
this.actionListeners.push(param1);
if(this.inputLocks.isEmpty()) {
for(local2 in this.activeActions) {
param1.onGameAction(GameActionEnum(local2),true);
}
}
}
}
public function removeGameActionListener(param1:GameActionListener) : void {
var local2:int = int(this.actionListeners.indexOf(param1));
if(local2 >= 0) {
this.actionListeners.splice(local2,1);
}
}
public function addMouseLockListener(param1:MouseLockListener) : void {
var local2:int = int(this.mouseLockListeners.indexOf(param1));
if(local2 < 0) {
this.mouseLockListeners.push(param1);
if(this.stage.mouseLock) {
param1.onMouseLock(true);
}
}
}
public function removeMouseLockListener(param1:MouseLockListener) : void {
var local2:int = int(this.mouseLockListeners.indexOf(param1));
if(local2 >= 0) {
this.mouseLockListeners.splice(local2,1);
}
}
public function addMouseMoveListener(param1:MouseMovementListener) : void {
var local2:int = int(this.mouseMoveListeners.indexOf(param1));
if(local2 < 0) {
this.mouseMoveListeners.push(param1);
}
}
public function removeMouseMoveListener(param1:MouseMovementListener) : void {
var local2:int = int(this.mouseMoveListeners.indexOf(param1));
if(local2 >= 0) {
this.mouseMoveListeners.splice(local2,1);
}
}
public function addMouseWheelListener(param1:MouseWheelListener) : void {
var local2:int = int(this.mouseWheelListeners.indexOf(param1));
if(local2 < 0) {
this.mouseWheelListeners.push(param1);
}
}
public function removeMouseWheelListener(param1:MouseWheelListener) : void {
var local2:int = int(this.mouseWheelListeners.indexOf(param1));
if(local2 >= 0) {
this.mouseWheelListeners.splice(local2,1);
}
}
private function activateMouseAction(param1:MouseButtonAction) : void {
if(!param1.isActive) {
param1.isActive = true;
this.handleActionActivation(param1.gameAction);
}
}
private function deactivateMouseAction(param1:MouseButtonAction) : void {
if(param1.isActive) {
param1.isActive = false;
this.handleActionDeactivation(param1.gameAction);
}
}
private function setMouseLock(param1:Boolean) : void {
if(param1) {
this.mouseJustLocked = true;
}
if(this.isFullScreen) {
this.stage.mouseLock = param1;
}
var local2:int = 0;
while(local2 < this.mouseLockListeners.length) {
this.mouseLockListeners[local2].onMouseLock(param1);
local2++;
}
}
private function isLocked() : Boolean {
return this.inputLocks.isNotEmpty();
}
private function isNotLocked() : Boolean {
return this.inputLocks.isEmpty();
}
private function canLockMouse() : Boolean {
return this.isMouseLockAllowed && this.mouseLockLocks.isEmpty() && Boolean(settingsService.mouseControl) && Boolean(fullScreenService.isMouseLockEnabled());
}
public function releaseMouse() : void {
if(this.stage.mouseLock) {
this.setMouseLock(false);
}
}
}
}
|
package alternativa.tanks.model.quest.common.gui.window {
import base.DiscreteSprite;
public class QuestsTabView extends DiscreteSprite {
public function QuestsTabView() {
super();
}
public function show() : void {
}
public function hide() : void {
}
public function close() : void {
}
}
}
|
package alternativa.tanks.gui
{
import controls.Label;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import flash.text.TextFormatAlign;
public class ItemPropertyIcon extends Sprite
{
public var bmp:Bitmap;
private var label:Label;
private var _module:String;
private const space:int = 2;
private var _text:String;
public function ItemPropertyIcon(icon:BitmapData, module:String)
{
super();
this._module = module;
this.bmp = new Bitmap(icon);
addChild(this.bmp);
this.label = new Label();
this.label.size = 10;
addChild(this.label);
this.label.text = this._module;
this.label.color = 59156;
this.label.align = TextFormatAlign.CENTER;
this.label.sharpness = -100;
this.label.thickness = 100;
this.posLabel();
this.label.y = this.bmp.height + this.space;
}
public function set labelText(text:String) : void
{
if(text != null && text != "null")
{
this._text = text;
}
else
{
this._text = "—";
}
this.label.text = this._module + "\n" + this._text;
this.posLabel();
}
private function posLabel() : void
{
if(this.bmp.width > this.label.textWidth)
{
this.label.x = Math.round((this.bmp.width - this.label.textWidth) * 0.5) - 3;
}
else if(this.label.textWidth > this.bmp.width)
{
this.label.x = -Math.round((this.label.textWidth - this.bmp.width) * 0.5) - 3;
}
else
{
this.label.x = -3;
}
}
public function get labelCoord() : int
{
return this.label.x;
}
}
}
|
package alternativa.tanks.models.battlefield.common
{
import alternativa.tanks.models.battlefield.event.ChatOutputLineEvent;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.filters.GlowFilter;
import flash.utils.Timer;
import flash.utils.setTimeout;
public class MessageLine extends Sprite
{
private static const LIFE_TIME:int = 30000;
protected var _live:Boolean = true;
private var glowFilter:GlowFilter;
private var fltrs:Array;
private var killTimer:Timer;
private var stop:Boolean = false;
private var runOut:Boolean = false;
public function MessageLine()
{
this.glowFilter = new GlowFilter(0,0.8,4,4,3);
this.fltrs = [this.glowFilter];
super();
addEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
filters = this.fltrs;
addEventListener(MouseEvent.MOUSE_OVER,this.onMouseOver);
addEventListener(MouseEvent.MOUSE_OUT,this.onMouseOut);
}
public function killStop() : void
{
alpha = 1;
removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
this.stop = true;
}
public function killStart() : void
{
this.stop = false;
if(this.runOut)
{
this.killSelf();
}
}
public function get live() : Boolean
{
return this._live;
}
private function onAddedToStage(e:Event) : void
{
setTimeout(this.timeRunOut,LIFE_TIME);
}
private function timeRunOut() : void
{
this.runOut = true;
if(!this.stop)
{
this.killSelf();
}
}
private function killSelf() : void
{
this.killTimer = new Timer(50,20);
this.killTimer.addEventListener(TimerEvent.TIMER,this.onKillTimer);
this.killTimer.addEventListener(TimerEvent.TIMER_COMPLETE,this.onKillComplete);
this.killTimer.start();
}
private function onKillTimer(e:TimerEvent) : void
{
if(!this.stop)
{
alpha -= 0.05;
}
else
{
this.killTimer.stop();
alpha = 1;
}
}
private function onKillComplete(e:TimerEvent) : void
{
this._live = false;
dispatchEvent(new ChatOutputLineEvent(ChatOutputLineEvent.KILL_ME,this));
removeEventListener(Event.ADDED_TO_STAGE,this.onAddedToStage);
}
private function onMouseOut(event:MouseEvent) : void
{
this.glowFilter.strength = 3;
filters = this.fltrs;
}
private function onMouseOver(event:MouseEvent) : void
{
this.glowFilter.strength = 5;
filters = this.fltrs;
}
}
}
|
package alternativa.engine3d.core
{
import alternativa.gfx.agal.VertexShader;
public class DepthRendererDepthVertexShader extends VertexShader
{
public function DepthRendererDepthVertexShader(param1:Boolean, param2:Boolean)
{
super();
mov(vt0,vc[0]);
dp4(vt0.x,va0,vc[0]);
dp4(vt0.y,va0,vc[1]);
dp4(vt0.z,va0,vc[2]);
mul(vt0.xy,vt0,vc[4]);
mul(vt1,vc[5],vt0.z);
sub(vt0.xy,vt0,vt1);
mul(v0,vt0,vc[4]);
if(param1)
{
dp3(vt1,va1,vc[0]);
dp3(vt1.y,va1,vc[1]);
mul(v0.xy,vt1,vc[6]);
dp3(v0.w,va1,vc[2]);
}
mov(op.xw,vt0.xz);
neg(op.y,vt0);
mul(vt0.z,vt0,vc[3]);
add(op.z,vt0,vc[3].w);
if(param2)
{
mul(v1,va2,vc[7]);
}
}
}
}
|
package projects.tanks.clients.fp10.TanksLauncherErrorScreen {
import flash.display.Sprite;
import flash.events.TextEvent;
import mx.utils.StringUtil;
import projects.tanks.clients.tankslauncershared.service.Locale;
public class TanksErrorMessage extends Sprite implements ITanksErrorMessage {
private static const ERROR_UNAVAILABLE_TEST:Vector.<String> = new <String>["В данный момент на сервере ведутся технические работы,<br/>поэтому он недоступен.<br/>" + "Приносим извинения за временные неудобства.<br/>" + "Попробуйте вернуться позднее или выберите другой тестовый сервер: <font color=\'#59ff32\'><u><a href=\"event:http://test.tankionline.com\">test.tankionline.com</a></u></font>","Server is unavailable as it is under maintenance. " + "We apologize for any inconvenience caused.<br/>" + "Please try again later or use another test server: <font color=\'#59ff32\'><u><a href=\"event:http://test.tankionline.com\">test.tankionline.com</a></u></font>","Wegen Wartungsarbeiten ist der Server im Moment nicht erreichbar.<br/>" + "Wir entschuldigen uns für diese vorläufigen Unannehmlichkeiten.<br/>" + "Wiederholen Sie bitte den Versuch zum späteren Zeitpunkt oder gehen Sie in einen anderen Testserver: <font color=\'#59ff32\'><u><a href=\"event:http://test.tankionline.com\">test.tankionline.com</a></u></font>","目前该服务器正在进行技术维护，所以您暂时无法进入。<br/>" + "很抱歉给您造成不便。<br/>" + "请稍后尝试登陆或者进入其他测试服务器：<font color=\'#59ff32\'><u><a href=\"event:http://test.3dtank.com\">test.3dtank.com</a></u></font>","O servidor está indisponível temporariamente<br/> devido à manutenção agendada.<br/>" + "Pedimos desculpas pela inconveniência.<br/>" + "Tente mais tarde ou escolha <font color=\'#59ff32\'><u><a href=\"event:http://test.tankionline.com\">test.tankionline.com</a></u></font>","Serwer jest tymczasowo niedostępny<br/> w związku z zaplanowanymi pracami konserwacyjnymi.<br/>" + "Przepraszamy za ewentualne niedogodności.<br/>" + "Spróbuj ponownie później lub wybierz inny serwer testowy: <font color=\'#59ff32\'><u><a href=\"event:http://test.tankionline.com\">test.tankionline.com</a></u></font>"];
private static const ERROR_MAX_COUNT_TEST:Vector.<String> = new <String>["Сейчас на сервере находится предельно возможное количество игроков, поэтому он недоступен для новых подключений.<br/>" + "Попробуйте вернуться позднее или выберите другой тестовый сервер: <font color=\'#59ff32\'><u><a href=\"event:http://test.tankionline.com\">test.tankionline.com</a></u></font>","Server has reached its maximum capacity. " + "Please try again later or use another test server: <font color=\'#59ff32\'><u><a href=\"event:http://test.tankionline.com\">test.tankionline.com</a></u></font>","Der Server ist im Moment wegen der hohen Spieleranzahl überlastet und ist für die neuen Anschlüsse nicht zugänglich.<br/>" + "Wiederholen Sie bitte den Versuch zum späteren Zeitpunkt oder gehen Sie in einen anderen Testserver: <font color=\'#59ff32\'><u><a href=\"event:http://test.tankionline.com\">test.tankionline.com</a></u></font>","目前该服务器已经人满，无法承载更多的玩家进入。<br/>" + "请稍后尝试登陆或者选择其他测试服务器登陆：<font color=\'#59ff32\'><u><a href=\"event:http://test.3dtank.com\">test.3dtank.com</a></u></font>","Este servidor alcançou o limite de jogadores. Não há conexões novas disponíveis.<br/>" + "Tente mais tarde ou escolha outro servidor de teste: <font color=\'#59ff32\'><u><a href=\"event:http://test.tankionline.com\">test.tankionline.com</a></u></font>","Na tym serwerze jest już maksymalna liczba graczy. Brak nowych połączeń.<br/>" + "Spróbuj ponownie później lub wybierz inny serwer testowy: <font color=\'#59ff32\'><u><a href=\"event:http://test.tankionline.com\">test.tankionline.com</a></u></font>"];
private static const ERROR_UNAVAILABLE:Vector.<String> = new <String>["В данный момент на сервере ведутся технические работы,<br/>поэтому он недоступен.<br/>" + "Приносим извинения за временные неудобства.<br/>" + "Попробуйте вернуться позднее или выберите <font color=\'#59ff32\'><u><a href=\"event:{0}\">другой игровой сервер</a></u></font>","Server is unavailable as it is under maintenance. " + "We apologize for any inconvenience caused.<br/>" + "Please try again later or use <font color=\'#59ff32\'><u><a href=\"event:{0}\">another game server</a></u></font>","Wegen Wartungsarbeiten ist der Server im Moment nicht erreichbar.<br/>" + "Wir entschuldigen uns für diese vorläufigen Unannehmlichkeiten.<br/>" + "Wiederholen Sie bitte den Versuch zum späteren Zeitpunkt oder wählen Sie einen <font color=\'#59ff32\'><u><a href=\"event:{0}\">anderen Spielserver aus</a></u></font>","目前该服务器正在进行技术维护，所以您暂时无法进入。<br/>" + "很抱歉给您造成不便。请稍后尝试登陆或者选择登陆 <font color=\'#59ff32\'><u><a href=\"event:{0}\">其他服务器</a></u></font>","O servidor está indisponível temporariamente<br/> devido à manutenção agendada.<br/>" + "Pedimos desculpas pela inconveniência.<br/>" + "Tente mais tarde ou escolha <font color=\'#59ff32\'><u><a href=\"event:{0}\">outro servidor</a></u></font>","Serwer jest tymczasowo niedostępny<br/> w związku z zaplanowanymi pracami konserwacyjnymi.<br/>" + "Przepraszamy za ewentualne niedogodności.<br/>" + "Spróbuj ponownie później lub wybierz <font color=\'#59ff32\'><u><a href=\"event:{0}\">inny serwer gry</a></u></font>"];
private static const ERROR_MAX_COUNT:Vector.<String> = new <String>["Сейчас на сервере находится предельно возможное количество игроков, поэтому он недоступен для новых подключений.<br/>" + "Попробуйте вернуться позднее или выберите <font color=\'#59ff32\'><u><a href=\"event:{0}\">другой игровой сервер</a></u></font>","Server has reached its maximum capacity. " + "Please try again later or use <font color=\'#59ff32\'><u><a href=\"event:{0}\">another game server</a></u></font>","Der Server ist im Moment wegen der hohen Spieleanzahl überlastet und ist für die neuen Anschlüsse nicht zugänglich.<br/>" + "Wiederholen Sie bitte den Versuch zum späteren Zeitpunkt oder wählen Sie einen <font color=\'#59ff32\'><u><a href=\"event:{0}\">anderen Spielserver aus</a></u></font>","目前该服务器已经人满，无法承载更多的玩家进入。<br/>" + "请稍后尝试登陆或者选择 <font color=\'#59ff32\'><u><a href=\"event:{0}\">其他服务器</a></u></font> 登陆","Este servidor alcançou o limite de jogadores. Não há conexões novas disponíveis.<br/>" + "Tente mais tarde ou escolha <font color=\'#59ff32\'><u><a href=\"event:{0}\">outro servidor</a></u></font>","Na tym serwerze jest już maksymalna liczba graczy. Brak nowych połączeń.<br/>" + "Spróbuj ponownie później lub wybierz <font color=\'#59ff32\'><u><a href=\"event:{0}\">inny serwer gry</a></u></font>"];
private static const errorMessages:Vector.<Vector.<String>> = new <Vector.<String>>[ERROR_UNAVAILABLE_TEST,ERROR_MAX_COUNT_TEST,ERROR_UNAVAILABLE,ERROR_MAX_COUNT];
private const OVERLOADED_ERROR:String = "overloaded";
private const NOTAVAILABLE_ERROR:String = "notavailable";
private var tew:TankErrorWindow;
private var tb:TankBackground;
public function TanksErrorMessage() {
super();
mouseEnabled = false;
tabEnabled = false;
new TankFont();
this.tb = new TankBackground();
addChild(this.tb);
this.tew = new TankErrorWindow();
this.tew.addEventListener(TextEvent.LINK,this.onLinkClicked);
addChild(this.tew);
}
private function onLinkClicked(event:TextEvent) : void {
dispatchEvent(new TextEvent("LINK_CLICKED",true,false,event.text));
}
public function init(errorCode:String, isTestServer:Boolean, anotherGameServerUrl:String, locale:String) : void {
this.tew.init(this.getErrorMessage(errorCode,isTestServer,anotherGameServerUrl,locale),locale);
}
public function redraw(stageWidth:int, stageHeight:int) : void {
this.tew.x = stageWidth - this.tew.width >> 1;
this.tew.y = stageHeight - this.tew.height >> 1;
this.tb.redraw(stageWidth,stageHeight);
}
private function getErrorMessage(errorCode:String, isTestServer:Boolean, anotherGameServerUrl:String, locale:String) : String {
var local5:int = errorCode == this.OVERLOADED_ERROR ? 1 : 0;
local5 += isTestServer ? 0 : 2;
var local6:String = errorMessages[local5][Locale.LOCALES.indexOf(locale)];
if(!isTestServer) {
local6 = StringUtil.substitute(local6,anotherGameServerUrl);
}
return local6;
}
}
}
|
package projects.tanks.client.garage.models.item.view {
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 ItemViewCategoryModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ItemViewCategoryModelServer;
private var client:IItemViewCategoryModelBase = IItemViewCategoryModelBase(this);
private var modelId:Long = Long.getLong(1424296501,-807048170);
public function ItemViewCategoryModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ItemViewCategoryModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ItemViewCategoryCC,false)));
}
protected function getInitParam() : ItemViewCategoryCC {
return ItemViewCategoryCC(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.tanks.gui.panel {
public class StarsIcon {
public static const icon_class:Class = StarsIcon_icon_class;
public function StarsIcon() {
super();
}
}
}
|
package controls.base {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.base.TankBaseButton_ButtonOver.png")]
public class TankBaseButton_ButtonOver extends BitmapAsset {
public function TankBaseButton_ButtonOver() {
super();
}
}
}
|
package alternativa.tanks.models.battlefield.gui
{
import alternativa.tanks.models.dom.hud.panel.KeyPointsHUDPanel;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
public interface IBattlefieldGUI
{
function logUserAction(param1:String, param2:String, param3:String = null) : void;
function logAction(param1:String, param2:String = null) : void;
function ctfShowFlagAtBase(param1:BattleTeamType) : void;
function ctfShowFlagCarried(param1:BattleTeamType) : void;
function ctfShowFlagDropped(param1:BattleTeamType) : void;
function updateHealthIndicator(param1:Number) : void;
function updateWeaponIndicator(param1:Number) : void;
function showPauseIndicator(param1:Boolean) : void;
function setPauseTimeout(param1:int) : void;
function updatePointsHUD() : void;
function createPointsHUD(param1:KeyPointsHUDPanel) : void;
}
}
|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ItemInfoPanel_bitmapHeatingTime extends BitmapAsset
{
public function ItemInfoPanel_bitmapHeatingTime()
{
super();
}
}
}
|
package alternativa.gfx.agal {
import flash.utils.ByteArray;
public class Register {
protected var parent:Register;
protected var swizzle:int = 228;
protected var destMask:int = 15;
protected var index:int;
protected var emitCode:int;
protected var relOffset:int;
protected var relType:int;
protected var relSel:uint;
public function Register() {
super();
}
public static function get(param1:int = 228, param2:int = 15, param3:Register = null) : Register {
var local4:Register = new Register();
local4.parent = param3;
if(param3 != null) {
local4.index = param3.index;
local4.emitCode = param3.emitCode;
}
local4.swizzle = param1;
local4.destMask = param2;
return local4;
}
protected static function getSwizzle(param1:int = 0, param2:int = 1, param3:int = 2, param4:int = 3) : int {
return param1 | param2 << 2 | param3 << 4 | param4 << 6;
}
protected static function getDestMask(param1:Boolean, param2:Boolean, param3:Boolean, param4:Boolean) : int {
var local5:int = 0;
if(param1) {
local5 |= 1;
}
if(param2) {
local5 |= 2;
}
if(param3) {
local5 |= 4;
}
if(param4) {
local5 |= 8;
}
return local5;
}
public function writeDest(param1:ByteArray) : void {
param1.writeShort(this.parent != null ? this.parent.index : this.index);
param1.writeByte(this.destMask);
param1.writeByte(this.parent != null ? this.parent.emitCode : this.emitCode);
}
public function writeSource(param1:ByteArray) : void {
param1.writeShort(this.parent != null ? this.parent.index : this.index);
param1.writeByte(this.parent != null ? this.parent.relOffset : this.relOffset);
param1.writeByte(this.swizzle);
param1.writeByte(this.parent != null ? this.parent.emitCode : this.emitCode);
param1.writeByte(this.parent != null ? this.parent.relType : this.relType);
param1.writeShort(this.parent != null ? int(this.parent.relSel) : int(this.relSel));
}
protected function relate(param1:Register, param2:uint) : void {
this.relType = param1.emitCode;
this.index = param1.index;
if((param1.destMask & param1.destMask - 1) != 0) {
throw new Error("Register must has simple swizzle: .x, .y, .z, .w");
}
this.relSel = Math.log(param1.destMask) / Math.LN2;
this.relSel |= 1 << 15;
this.relOffset = param2;
}
}
}
|
package alternativa.tanks.controller.commands.goto_ {
import alternativa.tanks.controller.events.showform.ShowFormEvent;
import org.robotlegs.mvcs.Command;
public class GoToRestorePasswordCommand extends Command {
public function GoToRestorePasswordCommand() {
super();
}
override public function execute() : void {
dispatch(new ShowFormEvent(ShowFormEvent.SHOW_RESTORE_PASSWORD_FORM));
}
}
}
|
package _codec.projects.tanks.client.panel.model.shop.clientlayoutkit.entity {
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.shop.clientlayoutkit.entity.BundleImage;
public class CodecBundleImage implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_height:ICodec;
private var codec_image:ICodec;
private var codec_positionPercentX:ICodec;
private var codec_positionPercentY:ICodec;
public function CodecBundleImage() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_height = param1.getCodec(new TypeCodecInfo(int,true));
this.codec_image = param1.getCodec(new TypeCodecInfo(ImageResource,false));
this.codec_positionPercentX = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_positionPercentY = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BundleImage = new BundleImage();
local2.height = this.codec_height.decode(param1) as int;
local2.image = this.codec_image.decode(param1) as ImageResource;
local2.positionPercentX = this.codec_positionPercentX.decode(param1) as int;
local2.positionPercentY = this.codec_positionPercentY.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BundleImage = BundleImage(param2);
this.codec_height.encode(param1,local3.height);
this.codec_image.encode(param1,local3.image);
this.codec_positionPercentX.encode(param1,local3.positionPercentX);
this.codec_positionPercentY.encode(param1,local3.positionPercentY);
}
}
}
|
package alternativa.tanks.gui.shop.payment {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.shop.components.itemcategoriesview.ItemCategoriesView;
import alternativa.tanks.gui.shop.components.itemscategory.ItemsCategoryView;
import alternativa.tanks.gui.shop.components.paymentview.PaymentView;
import alternativa.tanks.gui.shop.paymentform.item.PaymentFormItemBase;
import alternativa.tanks.gui.shop.shopitems.item.base.ShopButton;
import alternativa.tanks.gui.shop.shopitems.item.base.ShopButtonClickDisable;
import alternativa.tanks.gui.shop.shopitems.item.base.ShopButtonDiscount;
import alternativa.tanks.model.payment.modes.PayMode;
import alternativa.tanks.model.payment.shop.ShopItemView;
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class PaymentFormView extends PaymentView {
[Inject]
public static var localeService:ILocaleService;
private static const CATEGORY_ID:Long = Long.ZERO;
private var view:ItemCategoriesView;
private var selectedItem:IGameObject;
private var chosenPayMode:IGameObject;
private var _width:int;
private var _height:int;
public function PaymentFormView(param1:IGameObject, param2:IGameObject) {
super();
this.selectedItem = param1;
this.chosenPayMode = param2;
this.view = new ItemCategoriesView();
addChild(this.view);
this.addSelectedItemView();
if(param2 != null) {
this.addPaymentCategory();
}
}
private function addSelectedItemView() : void {
var local1:ItemsCategoryView = new ItemsCategoryView(localeService.getText(TanksLocale.TEXT_SHOP_WINDOW_YOUR_CHOICE),"",this.selectedItem.id);
var local2:ShopButton = ShopItemView(this.selectedItem.adapt(ShopItemView)).getButtonView();
ShopButtonClickDisable(local2).disableClick();
if(this.chosenPayMode != null) {
ShopButtonDiscount(local2).applyPayModeDiscountAndUpdatePriceLabel(this.chosenPayMode);
}
local1.addItem(local2);
this.view.addCategory(local1);
}
private function addPaymentCategory() : void {
var local1:PayMode = PayMode(this.chosenPayMode.adapt(PayMode));
var local2:ItemsCategoryView = new ItemsCategoryView(local1.getName(),local1.getDescription(),CATEGORY_ID);
this.view.addCategory(local2);
}
public function addPaymentForm(param1:PaymentFormItemBase) : void {
this.view.addItem(CATEGORY_ID,param1);
}
override public function render(param1:int, param2:int) : void {
this._width = param1;
this._height = param2;
this.view.render(param1,param2);
}
override public function get width() : Number {
return this._width;
}
override public function get height() : Number {
return this._height;
}
override public function destroy() : void {
super.destroy();
this.view.destroy();
this.selectedItem = null;
this.chosenPayMode = null;
this.view = null;
}
}
}
|
package controls.scroller.gray {
public class ScrollSkinGray {
public static const thumbTop:Class = ScrollSkinGray_thumbTop;
public static const thumbMiddle:Class = ScrollSkinGray_thumbMiddle;
public static const track:Class = ScrollSkinGray_track;
public static const trackTop:Class = ScrollSkinGray_trackTop;
public static const trackBottom:Class = ScrollSkinGray_trackBottom;
public function ScrollSkinGray() {
super();
}
}
}
|
package _codec.projects.tanks.client.garage.skins {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.skins.MountedSkinCC;
public class VectorCodecMountedSkinCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecMountedSkinCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(MountedSkinCC,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.<MountedSkinCC> = new Vector.<MountedSkinCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = MountedSkinCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:MountedSkinCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<MountedSkinCC> = Vector.<MountedSkinCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.client.entrance.model.entrance.telegram {
public class TelegramEntranceModelCC {
private var _botName:String;
public function TelegramEntranceModelCC(param1:String = null) {
super();
this._botName = param1;
}
public function get botName() : String {
return this._botName;
}
public function set botName(param1:String) : void {
this._botName = param1;
}
public function toString() : String {
var local1:String = "TelegramEntranceModelCC [";
local1 += "botName = " + this.botName + " ";
return local1 + "]";
}
}
}
|
package forms.buttons
{
import flash.display.Bitmap;
public class MainPanelSpinsButton extends MainPanelWideButton
{
private static const iconN:Class = MainPanelSpinsButton_iconN;
[Embed(source="1018.png")]
private static const overBtn:Class;
[Embed(source="1202.png")]
private static const normalBtn:Class;
public function MainPanelSpinsButton()
{
super(new Bitmap(new iconN().bitmapData),3,3,new Bitmap(new overBtn().bitmapData),new Bitmap(new normalBtn().bitmapData));
}
}
}
|
package alternativa.tanks.gui.payment.forms.commons {
import alternativa.tanks.gui.payment.forms.TemplateDescription;
import alternativa.tanks.gui.shop.windows.ShopWindow;
import alternativa.tanks.model.payment.category.PayFullDescription;
import alternativa.tanks.model.payment.modes.PayMode;
import alternativa.tanks.model.payment.modes.description.PayModeBottomDescription;
import base.DiscreteSprite;
import controls.TankWindowInner;
import controls.base.LabelBase;
import fl.containers.ScrollPane;
import fl.controls.ScrollPolicy;
import flash.display.Sprite;
import platform.client.fp10.core.type.IGameObject;
import utils.ScrollStyleUtils;
public class DescriptionBlock extends DiscreteSprite {
private var payMode:IGameObject;
private var headerLabel:LabelBase;
private var descriptionControl:TemplateDescription;
private var scrollPane:ScrollPane;
private var innerWindowDescription:TankWindowInner;
private var innerWindowHeight:int;
public function DescriptionBlock(param1:IGameObject, param2:int) {
super();
this.payMode = param1;
this.innerWindowHeight = param2;
this.addHeader();
this.addDescriptionBlock();
}
public function updateHeight(param1:int) : void {
this.innerWindowHeight = param1;
this.innerWindowDescription.height = this.innerWindowHeight;
this.scrollPane.setSize(this.innerWindowDescription.width,this.innerWindowHeight - 2 * ShopWindow.WINDOW_PADDING);
}
public function getInnerWindowHeight() : int {
return this.innerWindowHeight;
}
private function addHeader() : void {
this.headerLabel = new LabelBase();
this.headerLabel.wordWrap = true;
this.headerLabel.text = PayMode(this.payMode.adapt(PayMode)).getName();
this.headerLabel.size = 18;
this.headerLabel.width = 200;
addChild(this.headerLabel);
}
private function addDescriptionBlock() : void {
this.innerWindowDescription = new TankWindowInner(0,0,TankWindowInner.GREEN);
this.innerWindowDescription.showBlink = true;
this.innerWindowDescription.y = this.headerLabel.y + this.headerLabel.height;
this.innerWindowDescription.width = ShopWindow.WINDOW_WIDTH - ShopWindow.WINDOW_PADDING * 2;
this.innerWindowDescription.height = this.innerWindowHeight;
addChild(this.innerWindowDescription);
var local1:Sprite = new Sprite();
this.scrollPane = new ScrollPane();
ScrollStyleUtils.setGreenStyle(this.scrollPane);
this.scrollPane.horizontalScrollPolicy = ScrollPolicy.OFF;
this.scrollPane.verticalScrollPolicy = ScrollPolicy.AUTO;
this.scrollPane.source = local1;
this.scrollPane.update();
this.scrollPane.focusEnabled = false;
this.scrollPane.y = this.innerWindowDescription.y + ShopWindow.WINDOW_PADDING;
addChild(this.scrollPane);
this.descriptionControl = new TemplateDescription();
this.descriptionControl.x = ShopWindow.WINDOW_PADDING;
this.descriptionControl.width = this.innerWindowDescription.width - 2 * ShopWindow.WINDOW_PADDING;
local1.addChild(this.descriptionControl);
this.scrollPane.setSize(this.innerWindowDescription.width,this.innerWindowHeight - 2 * ShopWindow.WINDOW_PADDING);
this.updateDescription();
}
public function updateDescription() : void {
var local1:PayModeBottomDescription = null;
this.descriptionControl.description.htmlText = PayFullDescription(this.payMode.adapt(PayFullDescription)).getFullDescription();
if(this.payMode.hasModel(PayModeBottomDescription)) {
local1 = PayModeBottomDescription(this.payMode.adapt(PayModeBottomDescription));
if(local1.enabled()) {
this.descriptionControl.setBottomDescription(local1.getDescription(),local1.getImages());
} else {
this.descriptionControl.hideBottomDescription();
}
} else {
this.descriptionControl.hideBottomDescription();
}
this.scrollPane.update();
}
public function getHeight() : Number {
return this.innerWindowHeight + this.headerLabel.height + ShopWindow.WINDOW_PADDING;
}
}
}
|
package projects.tanks.client.garage.models.item.grouped {
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 GroupedItemModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:GroupedItemModelServer;
private var client:IGroupedItemModelBase = IGroupedItemModelBase(this);
private var modelId:Long = Long.getLong(434340673,532838092);
public function GroupedItemModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new GroupedItemModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(GroupedCC,false)));
}
protected function getInitParam() : GroupedCC {
return GroupedCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.engine3d.core
{
import alternativa.engine3d.alternativa3d;
use namespace alternativa3d;
public class Vertex
{
alternativa3d static var collector:Vertex;
public var x:Number = 0;
public var y:Number = 0;
public var z:Number = 0;
public var u:Number = 0;
public var v:Number = 0;
public var normalX:Number;
public var normalY:Number;
public var normalZ:Number;
alternativa3d var cameraX:Number;
alternativa3d var cameraY:Number;
alternativa3d var cameraZ:Number;
alternativa3d var offset:Number = 1;
alternativa3d var transformId:int = 0;
alternativa3d var drawId:int = 0;
alternativa3d var index:int;
alternativa3d var next:Vertex;
alternativa3d var value:Vertex;
public var id:Object;
public function Vertex()
{
super();
}
alternativa3d static function createList(param1:int) : Vertex
{
var _loc3_:Vertex = null;
var _loc2_:Vertex = collector;
if(_loc2_ != null)
{
_loc3_ = _loc2_;
while(param1 > 1)
{
_loc3_.transformId = 0;
_loc3_.drawId = 0;
if(_loc3_.next == null)
{
while(param1 > 1)
{
_loc3_.next = new Vertex();
_loc3_ = _loc3_.next;
param1--;
}
break;
}
_loc3_ = _loc3_.next;
param1--;
}
collector = _loc3_.next;
_loc3_.transformId = 0;
_loc3_.drawId = 0;
_loc3_.next = null;
}
else
{
_loc2_ = new Vertex();
_loc3_ = _loc2_;
while(param1 > 1)
{
_loc3_.next = new Vertex();
_loc3_ = _loc3_.next;
param1--;
}
}
return _loc2_;
}
alternativa3d function create() : Vertex
{
var _loc1_:Vertex = null;
if(collector != null)
{
_loc1_ = collector;
collector = _loc1_.next;
_loc1_.next = null;
_loc1_.transformId = 0;
_loc1_.drawId = 0;
return _loc1_;
}
return new Vertex();
}
public function toString() : String
{
return "[Vertex " + this.id + " " + this.x.toFixed(2) + ", " + this.y.toFixed(2) + ", " + this.z.toFixed(2) + ", " + this.u.toFixed(3) + ", " + this.v.toFixed(3) + "]";
}
public function destroy() : *
{
delete this;
}
}
}
|
package alternativa.tanks.service.battle {
import alternativa.tanks.model.item.BattleFriendsListener;
import alternativa.types.Long;
import projects.tanks.clients.fp10.libraries.tanksservices.model.friends.FriendState;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.FriendStateChangeEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendInfoService;
public class BattleFriendNotifier {
[Inject]
public static var friendsInfoService:IFriendInfoService;
[Inject]
public static var battleUserInfoService:IBattleUserInfoService;
public function BattleFriendNotifier() {
super();
friendsInfoService.addEventListener(FriendStateChangeEvent.CHANGE,this.onChangeFriendState);
}
public function destroy() : void {
friendsInfoService.removeEventListener(FriendStateChangeEvent.CHANGE,this.onChangeFriendState);
}
private function onChangeFriendState(param1:FriendStateChangeEvent) : void {
var local5:BattleFriendsListener = null;
var local2:Long = param1.userId;
var local3:FriendState = param1.state;
var local4:FriendState = param1.prevState;
if(battleUserInfoService.userInBattle(local2)) {
local5 = BattleFriendsListener(battleUserInfoService.getBattle(local2).adapt(BattleFriendsListener));
if(local3 == FriendState.ACCEPTED) {
local5.onAddFriend(local2);
}
if(local3 == FriendState.UNKNOWN && local4 == FriendState.ACCEPTED) {
local5.onDeleteFriend(local2);
}
}
}
}
}
|
package projects.tanks.client.panel.model.shop.emailrequired {
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 EmailRequiredModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function EmailRequiredModelServer(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());
}
}
}
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 16