code
stringlengths 57
237k
|
|---|
package alternativa.tanks.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ItemInfoPanel_bitmapHealRate extends BitmapAsset
{
public function ItemInfoPanel_bitmapHealRate()
{
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.DefaultRanksBitmaps_bitmapBigRank29.png")]
public class DefaultRanksBitmaps_bitmapBigRank29 extends BitmapAsset {
public function DefaultRanksBitmaps_bitmapBigRank29() {
super();
}
}
}
|
package alternativa.tanks.view.battlecreate.slider {
import flash.events.Event;
public class SelectRankSliderEvent extends Event {
public static const RANK_LIMIT_CHANGED:String = "SelectRankSliderEvent_LimitChanged";
public function SelectRankSliderEvent() {
super(RANK_LIMIT_CHANGED);
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.angles.verticals {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class VerticalAutoAimingModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:VerticalAutoAimingModelServer;
private var client:IVerticalAutoAimingModelBase = IVerticalAutoAimingModelBase(this);
private var modelId:Long = Long.getLong(504614809,-1413592676);
public function VerticalAutoAimingModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new VerticalAutoAimingModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.servermodels.serverhalt {
import alternativa.tanks.service.IEntranceClientFacade;
import platform.client.fp10.core.model.IObjectLoadListener;
import projects.tanks.client.entrance.model.entrance.clienthalt.IServerHaltEntranceModelBase;
import projects.tanks.client.entrance.model.entrance.clienthalt.ServerHaltEntranceModelBase;
[ModelInfo]
public class ServerHaltEntranceModel extends ServerHaltEntranceModelBase implements IServerHaltEntranceModelBase, IObjectLoadListener {
[Inject]
public static var facade:IEntranceClientFacade;
public function ServerHaltEntranceModel() {
super();
}
public function serverHalt() : void {
facade.serverHalt();
}
public function objectLoaded() : void {
if(getInitParam().serverHalt) {
facade.serverHalt();
}
}
public function objectLoadedPost() : void {
}
public function objectUnloaded() : void {
}
public function objectUnloadedPost() : void {
}
}
}
|
package alternativa.tanks.service {
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.models.captcha.CaptchaLocation;
public interface IEntranceServerFacade {
function checkCallsign(param1:String) : void;
function checkEmail(param1:String) : void;
function checkInviteCode(param1:String) : void;
function sendEmailRestoreMessage(param1:String) : void;
function login(param1:String, param2:String, param3:Boolean) : void;
function loginExternal(param1:String, param2:String) : void;
function fightWithoutRegistration() : void;
function checkEmailChangeHash(param1:String) : void;
function changePasswordAndEmail(param1:String, param2:String) : void;
function loginByHash(param1:String) : void;
function loginBySingleUseHash(param1:String) : void;
function confirmEmail(param1:String, param2:String) : void;
function checkChangeUidHash(param1:String, param2:String) : void;
function changeUidAndPassword(param1:String, param2:String) : void;
function changeUid(param1:String) : void;
function set entranceObject(param1:IGameObject) : void;
function registerUserThroughPassword(param1:String, param2:String, param3:String, param4:Boolean, param5:String, param6:String, param7:String) : void;
function registerThroughEmail(param1:String, param2:String, param3:String, param4:String, param5:String, param6:String) : void;
function getNewCaptcha(param1:CaptchaLocation) : void;
function checkCaptcha(param1:String, param2:CaptchaLocation) : void;
function startExternalRegisterUser(param1:String, param2:Boolean, param3:String) : void;
function startExternalLoginUser(param1:String, param2:Boolean, param3:String) : void;
function finishExternalRegisterUser(param1:String, param2:String) : void;
function loadPartnerObject(param1:String) : void;
function finishPartnerRegistration(param1:String, param2:String) : void;
function bindAccountToPartner(param1:String, param2:String) : void;
function googleLogin(param1:String) : void;
}
}
|
package projects.tanks.client.users.model.switchbattleinvite {
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 NotificationEnabledModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _enableId:Long = Long.getLong(2095583187,-547646417);
private var _enable_receiveCodec:ICodec;
private var model:IModel;
public function NotificationEnabledModelServer(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._enable_receiveCodec = this.protocol.getCodec(new TypeCodecInfo(Boolean,false));
}
public function enable(param1:Boolean) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._enable_receiveCodec.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._enableId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package _codec.projects.tanks.client.panel.model.coin {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.coin.CoinInfoCC;
public class VectorCodecCoinInfoCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecCoinInfoCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(CoinInfoCC,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<CoinInfoCC> = new Vector.<CoinInfoCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = CoinInfoCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:CoinInfoCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<CoinInfoCC> = Vector.<CoinInfoCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package controls.base {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/controls.base.TankBaseButton_ButtonDown.png")]
public class TankBaseButton_ButtonDown extends BitmapAsset {
public function TankBaseButton_ButtonDown() {
super();
}
}
}
|
package controls.statassets
{
import flash.display.Bitmap;
import flash.display.Sprite;
public class ReferalStatLineBackgroundSelected extends Sprite
{
public static var bg:Bitmap = new Bitmap();
public function ReferalStatLineBackgroundSelected()
{
super();
addChild(new Bitmap(bg.bitmapData));
}
}
}
|
package controls.base
{
import controls.DefaultButton;
public class DefaultButtonBase extends DefaultButton
{
public function DefaultButtonBase()
{
super();
_label.sharpness = 40;
_label.thickness = 70;
}
}
}
|
package com.lorentz.SVG.display {
import com.lorentz.SVG.display.base.SVGShape;
import com.lorentz.SVG.drawing.IDrawer;
import com.lorentz.SVG.utils.SVGUtil;
import com.lorentz.SVG.display.base.SVGElement;
public class SVGRect extends SVGShape {
private var _xUnits:Number;
private var _yUnits:Number;
private var _widthUnits:Number;
private var _heightUnits:Number;
private var _rxUnits:Number;
private var _ryUnits:Number;
public function SVGRect(){
super("rect");
}
private var _svgX:String;
public function get svgX():String {
return _svgX;
}
public function set svgX(value:String):void {
if(_svgX != value){
_svgX = value;
invalidateRender();
}
}
private var _svgY:String;
public function get svgY():String {
return _svgY;
}
public function set svgY(value:String):void {
if(_svgY != value){
_svgY = value;
invalidateRender();
}
}
private var _svgWidth:String;
public function get svgWidth():String {
return _svgWidth;
}
public function set svgWidth(value:String):void {
if(_svgWidth != value){
_svgWidth = value;
invalidateRender();
}
}
private var _svgHeight:String;
public function get svgHeight():String {
return _svgHeight;
}
public function set svgHeight(value:String):void {
if(_svgHeight != value){
_svgHeight = value;
invalidateRender();
}
}
private var _svgRx:String;
public function get svgRx():String {
return _svgRx;
}
public function set svgRx(value:String):void {
if(_svgRx != value){
_svgRx = value;
invalidateRender();
}
}
private var _svgRy:String;
public function get svgRy():String {
return _svgRy;
}
public function set svgRy(value:String):void {
if(_svgRy != value){
_svgRy = value;
invalidateRender();
}
}
override protected function beforeDraw():void {
super.beforeDraw();
_xUnits = getViewPortUserUnit(svgX, SVGUtil.WIDTH);
_yUnits = getViewPortUserUnit(svgY, SVGUtil.HEIGHT);
_widthUnits = getViewPortUserUnit(svgWidth, SVGUtil.WIDTH);
_heightUnits = getViewPortUserUnit(svgHeight, SVGUtil.HEIGHT);
_rxUnits = 0;
_ryUnits = 0;
if(svgRx){
_rxUnits = getViewPortUserUnit(svgRx, SVGUtil.WIDTH);
if(!svgRy)
_ryUnits = _rxUnits;
}
if(svgRy){
_ryUnits = getViewPortUserUnit(svgRy, SVGUtil.HEIGHT);
if(!svgRx)
_rxUnits = _ryUnits;
}
}
override protected function drawToDrawer(drawer:IDrawer):void {
if(_rxUnits == 0 && _ryUnits == 0){
drawer.moveTo(_xUnits, _yUnits);
drawer.lineTo(_xUnits + _widthUnits, _yUnits);
drawer.lineTo(_xUnits + _widthUnits, _yUnits + _heightUnits);
drawer.lineTo(_xUnits, _yUnits + _heightUnits);
drawer.lineTo(_xUnits, _yUnits);
} else {
drawer.moveTo(_xUnits + _rxUnits, _yUnits);
drawer.lineTo(_xUnits + _widthUnits - _rxUnits, _yUnits);
drawer.arcTo(_ryUnits, _rxUnits, 90, false, true, _xUnits + _widthUnits, _yUnits + _ryUnits);
drawer.lineTo(_xUnits + _widthUnits, _yUnits + _heightUnits - _ryUnits);
drawer.arcTo(_ryUnits, _rxUnits, 90, false, true, _xUnits + _widthUnits - _rxUnits, _yUnits + _heightUnits);
drawer.lineTo(_xUnits + _rxUnits, _yUnits + _heightUnits);
drawer.arcTo(_ryUnits, _rxUnits, 90, false, true, _xUnits, _yUnits + _heightUnits - _ryUnits);
drawer.lineTo(_xUnits, _yUnits + _ryUnits);
drawer.arcTo(_ryUnits, _rxUnits, 90, false, true, _xUnits + _rxUnits, _yUnits);
}
}
override public function clone():Object {
var c:SVGRect = super.clone() as SVGRect;
c.svgX = svgX;
c.svgY = svgY;
c.svgWidth = svgWidth;
c.svgHeight = svgHeight;
c.svgRx = svgRx;
c.svgRy = svgRy;
return c;
}
}
}
|
package alternativa.tanks.model.garage.temperature {
public class TemperatureConfigImpl implements TemperatureConfig {
private var _temperatureAutoDecrement:Number;
public function TemperatureConfigImpl() {
super();
}
public function get temperatureAutoDecrement() : Number {
return this._temperatureAutoDecrement;
}
public function set temperatureAutoDecrement(param1:Number) : void {
this._temperatureAutoDecrement = param1;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_assaultammunitionIconClass.png")]
public class DeviceIcons_assaultammunitionIconClass extends BitmapAsset {
public function DeviceIcons_assaultammunitionIconClass() {
super();
}
}
}
|
package alternativa.tanks.model.clanchat {
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.osgi.service.display.IDisplay;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.clanchat.SendChatMessageEvent;
import alternativa.tanks.gui.communication.tabs.clanchat.ClanChatTab;
import alternativa.tanks.gui.communication.tabs.clanchat.ClanChatViewEvent;
import alternativa.tanks.gui.communication.tabs.clanchat.IClanChatView;
import alternativa.tanks.tracker.ITrackerService;
import alternativa.tanks.utils.LinksInterceptor;
import alternativa.types.Long;
import flash.events.TextEvent;
import flash.net.URLRequest;
import flash.net.navigateToURL;
import flash.utils.Dictionary;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.chat.models.clanchat.clanchat.ClanChatModelBase;
import projects.tanks.client.chat.models.clanchat.clanchat.IClanChatModelBase;
import projects.tanks.client.chat.types.BattleChatLink;
import projects.tanks.client.chat.types.ChatMessage;
import projects.tanks.client.chat.types.MessageType;
import projects.tanks.client.tanksservices.types.battle.BattleInfoData;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.activator.IBattleLinkActivatorService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.BattleInfoUtils;
[ModelInfo]
public class ClanChatModel extends ClanChatModelBase implements IClanChatModelBase, ObjectLoadPostListener, ObjectUnloadListener {
[Inject]
public static var clanChatView:IClanChatView;
[Inject]
public static var trackerService:ITrackerService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var userPropertyService:IUserPropertiesService;
[Inject]
public static var battleLinkActivatorService:IBattleLinkActivatorService;
[Inject]
public static var clientLog:IClientLog;
private static const LOG_CHANNEL_NAME:String = "chat";
private const HTML_PATTERN:RegExp = /(<)(.*?)(>)/gi;
private const BATTLE_ID_REG_EXP:RegExp = /^([0-9a-f]{16})$/gi;
private var htmlFlag:Boolean = false;
private var sharpLinks:Array;
private var battleId2Data:Dictionary;
private var clanChat:ClanChatTab;
public function ClanChatModel() {
super();
}
public function objectLoadedPost() : void {
this.battleId2Data = new Dictionary();
this.clanChat = new ClanChatTab();
this.clanChat.selfUid = getInitParam().selfName;
this.clanChat.addEventListener(SendChatMessageEvent.SEND_CHAT_MESSAGE,getFunctionWrapper(this.onSendChatMessage));
this.clanChat.addEventListener(TextEvent.LINK,getFunctionWrapper(this.onTextLink));
if(getInitParam().inClan) {
clanChatView.setClanChat(this.clanChat);
} else {
clanChatView.addEventListener(ClanChatViewEvent.UPDATE_CLAN_CHAT_VIEW,this.onClanChatViewNeedsUpdating);
}
trackerService.trackEvent(LOG_CHANNEL_NAME,"ChatStart","");
this.prepareSharpLink();
}
private function onClanChatViewNeedsUpdating(param1:ClanChatViewEvent) : void {
clanChatView.setClanChat(this.clanChat);
}
public function objectUnloaded() : void {
clanChatView.removeEventListener(ClanChatViewEvent.UPDATE_CLAN_CHAT_VIEW,this.onClanChatViewNeedsUpdating);
this.battleId2Data = null;
this.clanChat.removeEventListener(SendChatMessageEvent.SEND_CHAT_MESSAGE,getFunctionWrapper(this.onSendChatMessage));
this.clanChat.removeEventListener(TextEvent.LINK,getFunctionWrapper(this.onTextLink));
this.clanChat.hide();
}
private function onSendChatMessage(param1:SendChatMessageEvent) : void {
server.sendMessage(param1.recipientUid,param1.message);
}
public function showMessagesHistory(param1:Vector.<ChatMessage>) : void {
var local2:ChatMessage = null;
for each(local2 in param1) {
this.showMessage(local2);
}
}
public function receiveMessage(param1:ChatMessage) : void {
this.showMessage(param1);
this.clanChat.sendNotificationNewMessageAdded();
}
private function showMessage(param1:ChatMessage) : void {
var local4:BattleChatLink = null;
var local5:LinksInterceptor = null;
var local6:BattleInfoData = null;
var local2:String = param1.text;
clientLog.log(LOG_CHANNEL_NAME,"showMessages : %1",local2);
this.htmlFlag = false;
var local3:int = int(local2.search(this.HTML_PATTERN));
if(local3 > -1) {
if(param1.messageType == MessageType.USER) {
local2 = local2.replace(this.HTML_PATTERN,"<$2>");
}
this.htmlFlag = true;
}
local2 += " ";
if(param1.messageType == MessageType.USER) {
local5 = new LinksInterceptor(new Vector.<String>());
local2 = local5.checkLinks(local2);
this.htmlFlag = local5.htmlFlag;
}
for each(local4 in param1.battleLinks) {
local6 = new BattleInfoData();
local6.battleId = Long.fromHexString(local4.battleIdHex);
this.battleId2Data[local4.battleIdHex] = local6;
local2 = local2.replace("#battle|" + local4.battleIdHex,"<u><a href=\'event:" + local4.battleIdHex + "\'>" + BattleInfoUtils.buildBattleName(local4.battleName,local4.battleMode) + "</a></u>");
this.htmlFlag = true;
}
local2 = this.replaceSharpLinks(local2);
this.clanChat.addMessage(param1,local2,this.htmlFlag);
}
private function onTextLink(param1:TextEvent) : void {
var local3:String = null;
var local2:String = param1.text;
if(local2.search(this.BATTLE_ID_REG_EXP) > -1) {
local3 = local2.substr(local2.length - 16);
if(this.battleId2Data[local3] != null) {
battleLinkActivatorService.activateBattle(this.battleId2Data[local3]);
}
} else {
this.proceedExternalLink(local2);
}
}
private function proceedExternalLink(param1:String) : void {
navigateToURL(new URLRequest(param1),"_blank");
}
private function prepareSharpLink() : void {
this.sharpLinks = [localeService.getText(TanksLocale.TEXT_CHAT_SHARP_HELP).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_RULES).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_PLANS).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_RANKS).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_CLANS).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_FORUM).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_UPDATES).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_THEFT).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_FEEDBACK).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_NICK).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_NEWS).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_COMMANDS).split("|"),localeService.getText(TanksLocale.TEXT_CHAT_SHARP_WIKI).split("|")];
var local1:int = 0;
while(local1 < this.sharpLinks.length) {
this.sharpLinks[local1][0] = new RegExp("#" + this.sharpLinks[local1][0],"gi");
local1++;
}
}
private function replaceSharpLinks(param1:String) : String {
var local5:RegExp = null;
var local2:int = 0;
var local3:String = param1;
var local4:int = 0;
while(local4 < this.sharpLinks.length) {
local5 = this.sharpLinks[local4][0];
local2 = int(local3.search(local5));
if(local2 > -1) {
local3 = local3.replace(local5,"<u><a href=\'" + this.sharpLinks[local4][2] + "\' target=\'_blank\'>" + this.sharpLinks[local4][1] + "</a></u>");
this.htmlFlag = true;
}
local4++;
}
return local3;
}
}
}
|
package scpacker.gui
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class GTanksI_coldload4 extends BitmapAsset
{
public function GTanksI_coldload4()
{
super();
}
}
}
|
package forms.ranks {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/forms.ranks.PremiumRankBitmaps_bitmapSmallRank22.png")]
public class PremiumRankBitmaps_bitmapSmallRank22 extends BitmapAsset {
public function PremiumRankBitmaps_bitmapSmallRank22() {
super();
}
}
}
|
package alternativa.tanks.models.bonus.bonuslight {
import alternativa.tanks.models.teamlight.TeamLightColor;
public class BonusLight {
private var lightColor:TeamLightColor;
private var attenuationBegin:Number;
private var attenuationEnd:Number;
public function BonusLight(param1:TeamLightColor, param2:Number, param3:Number) {
super();
this.lightColor = param1;
this.attenuationBegin = param2;
this.attenuationEnd = param3;
}
public function getLightColor() : TeamLightColor {
return this.lightColor;
}
public function getAttenuationBegin() : Number {
return this.attenuationBegin;
}
public function getAttenuationEnd() : Number {
return this.attenuationEnd;
}
}
}
|
package alternativa.tanks.servermodels.loginwithoutregistration {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class ILoginWithoutRegistrationEvents implements ILoginWithoutRegistration {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function ILoginWithoutRegistrationEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function passToFirstBattle() : void {
var i:int = 0;
var m:ILoginWithoutRegistration = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = ILoginWithoutRegistration(this.impl[i]);
m.passToFirstBattle();
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package forms.friends.list.renderer.background
{
import controls.cellrenderer.ButtonState;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Graphics;
public class UserOfflineCellSelected extends ButtonState
{
[Embed(source="932.png")]
private static var leftIconClass:Class;
private static var leftIconBitmapData:BitmapData = Bitmap(new leftIconClass()).bitmapData;
[Embed(source="825.png")]
private static var centerIconClass:Class;
private static var centerIconBitmapData:BitmapData = Bitmap(new centerIconClass()).bitmapData;
[Embed(source="995.png")]
private static var rightIconClass:Class;
private static var rightIconBitmapData:BitmapData = Bitmap(new rightIconClass()).bitmapData;
public function UserOfflineCellSelected()
{
super();
bmpLeft = leftIconBitmapData;
bmpCenter = centerIconBitmapData;
bmpRight = rightIconBitmapData;
}
override public function draw() : void
{
var _loc1_:Graphics = null;
_loc1_ = l.graphics;
_loc1_.clear();
_loc1_.beginBitmapFill(bmpLeft);
_loc1_.drawRect(0,0,5,20);
_loc1_.endFill();
l.x = 0;
l.y = 1;
_loc1_ = c.graphics;
_loc1_.clear();
_loc1_.beginBitmapFill(bmpCenter);
_loc1_.drawRect(0,0,_width - 10,20);
_loc1_.endFill();
c.x = 5;
c.y = 1;
_loc1_ = r.graphics;
_loc1_.clear();
_loc1_.beginBitmapFill(bmpRight);
_loc1_.drawRect(0,0,5,20);
_loc1_.endFill();
r.x = _width - 5;
r.y = 1;
}
}
}
|
package alternativa.tanks.models.battle.gui.chat.cmdhandlers {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.models.battle.gui.chat.BattleChatOutput;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.blockuser.IBlockUserService;
public class UnblockCommandHandler implements IChatCommandHandler {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var blockUserService:IBlockUserService;
private var output:BattleChatOutput;
public function UnblockCommandHandler(param1:BattleChatOutput) {
super();
this.output = param1;
}
public function handleCommand(param1:Array) : Boolean {
if(param1.length == 0) {
return false;
}
var local2:String = param1[0];
blockUserService.unblockUser(local2);
this.output.addSystemMessage(localeService.getText(TanksLocale.TEXT_CHAT_PANEL_COMMAND_UNBLOCK,local2));
return true;
}
}
}
|
package _codec.projects.tanks.client.panel.model.garage.availableupgrades {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.garage.availableupgrades.AvailableUpgradesCC;
public class VectorCodecAvailableUpgradesCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecAvailableUpgradesCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(AvailableUpgradesCC,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<AvailableUpgradesCC> = new Vector.<AvailableUpgradesCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = AvailableUpgradesCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:AvailableUpgradesCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<AvailableUpgradesCC> = Vector.<AvailableUpgradesCC>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.servermodels.timezoneoffset {
import projects.tanks.client.entrance.model.entrance.timezone.ITimeZoneOffsetModelBase;
import projects.tanks.client.entrance.model.entrance.timezone.TimeZoneOffsetModelBase;
[ModelInfo]
public class TimeZoneOffsetModel extends TimeZoneOffsetModelBase implements ITimeZoneOffsetModelBase {
public function TimeZoneOffsetModel() {
super();
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_vampireIconClass.png")]
public class DeviceIcons_vampireIconClass extends BitmapAsset {
public function DeviceIcons_vampireIconClass() {
super();
}
}
}
|
package alternativa.tanks.gui.category {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.category.ItemCategoryButton_weaponIconClass.png")]
public class ItemCategoryButton_weaponIconClass extends BitmapAsset {
public function ItemCategoryButton_weaponIconClass() {
super();
}
}
}
|
package alternativa.tanks.models.clan.membersdata {
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.clans.clan.clanmembersdata.ClanMembersDataModelBase;
import projects.tanks.client.clans.clan.clanmembersdata.IClanMembersDataModelBase;
import projects.tanks.client.clans.clan.clanmembersdata.UserData;
[ModelInfo]
public class ClanMembersDataModel extends ClanMembersDataModelBase implements IClanMembersDataModelBase, ObjectLoadListener {
[Inject]
public static var clanMembersService:ClanMembersDataService;
public function ClanMembersDataModel() {
super();
}
public function objectLoaded() : void {
var local1:UserData = null;
for each(local1 in getInitParam().users) {
clanMembersService.setData(local1);
}
}
public function sendData(param1:UserData) : void {
clanMembersService.setData(param1);
}
}
}
|
package alternativa.protocol.info {
public class EnumCodecInfo extends TypeCodecInfo {
public function EnumCodecInfo(param1:Class, param2:Boolean) {
super(param1,param2);
}
override public function toString() : String {
return "[EnumCodec " + super.toString() + " type=" + type.toString();
}
}
}
|
package alternativa.tanks.model.garage.upgrade {
import flash.utils.clearTimeout;
import flash.utils.getTimer;
import flash.utils.setTimeout;
import platform.client.fp10.core.type.IGameObject;
public class DelayUpgrades {
private const MAX_DELAY_MS:int = 20000;
private const DELAY_MS:int = 2000;
private var numLevels:int;
private var updradeStarted:Boolean;
private var startUpgradePrice:int;
private var upgradeTime:int;
private var totalPrice:int;
private var time:int;
private var flush:FlushUpgrades;
private var timeoutId:int;
private var item:IGameObject;
public function DelayUpgrades(param1:FlushUpgrades) {
super();
this.flush = param1;
this.clear();
}
private function clear() : void {
this.item = null;
this.numLevels = 0;
this.updradeStarted = false;
this.totalPrice = 0;
this.timeoutId = -1;
}
public function startUpgrade(param1:IGameObject, param2:int, param3:int) : void {
if(!this.isDelayedItem(param1) || this.updradeStarted) {
if(this.isDelayed()) {
this.flushToServer();
}
this.item = param1;
this.time = getTimer();
}
this.startUpgradePrice = param2;
this.updradeStarted = true;
this.upgradeTime = param3;
this.delay();
}
public function speedUp(param1:int) : void {
this.totalPrice += param1 + this.startUpgradePrice;
++this.numLevels;
this.updradeStarted = false;
this.delay();
}
private function delay() : void {
var local1:int = getTimer();
if(this.timeoutId != -1) {
clearTimeout(this.timeoutId);
this.timeoutId = -1;
}
if(local1 - this.time + this.DELAY_MS > this.MAX_DELAY_MS) {
this.flushToServer();
} else {
this.timeoutId = setTimeout(this.flushToServer,this.DELAY_MS);
}
}
public function flushToServer() : void {
if(this.timeoutId != -1) {
clearTimeout(this.timeoutId);
this.timeoutId = -1;
}
this.flush.flushToServer(this,this.item);
this.clear();
}
public function isDelayed() : Boolean {
return this.item != null;
}
public function isDelayedItem(param1:IGameObject) : Boolean {
return this.item == param1;
}
public function getNumLevels() : int {
return this.numLevels;
}
public function getPrice() : int {
return this.totalPrice;
}
public function isUpgradeStarted() : Boolean {
return this.updradeStarted;
}
public function getStartUpgradePrice() : int {
return this.startUpgradePrice;
}
public function getUpgradeTime() : int {
return this.upgradeTime;
}
}
}
|
package alternativa.tanks.model.tutorialhints {
import projects.tanks.client.panel.model.tutorialhints.ITutorialHintsModelBase;
import projects.tanks.client.panel.model.tutorialhints.TutorialHintsData;
import projects.tanks.client.panel.model.tutorialhints.TutorialHintsModelBase;
[ModelInfo]
public class TutorialHintsModel extends TutorialHintsModelBase implements ITutorialHintsModelBase {
public function TutorialHintsModel() {
super();
}
public function update(param1:TutorialHintsData) : void {
}
}
}
|
package alternativa.tanks.model.referals
{
public interface IReferalsListener
{
function updateReferalsData(param1:Array) : void;
}
}
|
package alternativa.tanks.models.tank {
import alternativa.tanks.battle.objects.tank.Tank;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class TankPartResetEvents implements TankPartReset {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function TankPartResetEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function resetTankPart(param1:Tank) : void {
var i:int = 0;
var m:TankPartReset = null;
var tank:Tank = param1;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = TankPartReset(this.impl[i]);
m.resetTankPart(tank);
i++;
}
}
finally {
Model.popObject();
}
}
}
}
|
package projects.tanks.clients.tankslauncershared.service {
public class Locale {
public static const RU:String = "RU";
public static const EN:String = "EN";
public static const DE:String = "DE";
public static const CN:String = "CN";
public static const PT_BR:String = "PT_BR";
public static const PL:String = "PL";
public static const LOCALES:Array = [Locale.RU,Locale.EN,Locale.DE,Locale.CN,Locale.PT_BR,Locale.PL];
public function Locale() {
super();
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.partners.odnoklassniki {
import projects.tanks.client.partners.impl.odnoklassniki.OdnoklassnikiUrlParams;
public class ParamHelper {
public function ParamHelper() {
super();
}
public static function name(param1:OdnoklassnikiUrlParams) : String {
return param1.name.toLocaleLowerCase();
}
}
}
|
package alternativa.tanks.gui.friends.button.friends {
import alternativa.osgi.service.display.IDisplay;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendInfoService;
public class RequestCountIndicator extends Sprite {
[Inject]
public static var friendInfoService:IFriendInfoService;
[Inject]
public static var display:IDisplay;
private static var leftIconClass:Class = RequestCountIndicator_leftIconClass;
private static var leftIconBitmapData:BitmapData = Bitmap(new leftIconClass()).bitmapData;
private static var centerIconClass:Class = RequestCountIndicator_centerIconClass;
private static var centerIconBitmapData:BitmapData = Bitmap(new centerIconClass()).bitmapData;
private static var rightIconClass:Class = RequestCountIndicator_rightIconClass;
private static var rightIconBitmapData:BitmapData = Bitmap(new rightIconClass()).bitmapData;
private var _leftIcon:Bitmap;
private var _centerIcon:Bitmap;
private var _rightIcon:Bitmap;
private var indicatorLabel:LabelBase;
private var _currentCount:int = 0;
private var _newCount:int = 0;
public function RequestCountIndicator() {
super();
this.init();
}
private function init() : void {
this._leftIcon = new Bitmap(leftIconBitmapData);
addChild(this._leftIcon);
this._centerIcon = new Bitmap(centerIconBitmapData);
addChild(this._centerIcon);
this._rightIcon = new Bitmap(rightIconBitmapData);
addChild(this._rightIcon);
this.indicatorLabel = new LabelBase();
addChild(this.indicatorLabel);
this.setRequestCount(this._currentCount,this._newCount);
this.resize();
}
public function setRequestCount(param1:int, param2:int) : void {
this._currentCount = param1;
this._newCount = param2;
this.visible = param2 != 0;
this.indicatorLabel.text = String(param2);
this.resize();
}
private function resize() : void {
this._rightIcon.x = -5;
this.indicatorLabel.x = -int(this.indicatorLabel.width) - 1;
this._centerIcon.width = this.getCenterIconWidth();
this._centerIcon.x = this._rightIcon.x - this._centerIcon.width;
this._leftIcon.x = this._centerIcon.x - this._leftIcon.width;
}
private function getCenterIconWidth() : int {
var local1:int = 0;
var local2:int = this.indicatorLabel.text.length;
if(local2 == 1) {
local1 = 1;
} else if(local2 > 1) {
local1 = (local2 - 1) * 6;
}
return local1;
}
public function set currentCount(param1:int) : void {
this.setRequestCount(param1,this._newCount);
}
public function set newCount(param1:int) : void {
this.setRequestCount(this._currentCount,param1);
}
}
}
|
package forms.friends
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class FriendsWindowStateBigButton_ButtonRight extends BitmapAsset
{
public function FriendsWindowStateBigButton_ButtonRight()
{
super();
}
}
}
|
package alternativa.tanks.sfx {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.sfx.LevelUpEffectFactory_SparkTexture.jpg")]
public class LevelUpEffectFactory_SparkTexture extends BitmapAsset {
public function LevelUpEffectFactory_SparkTexture() {
super();
}
}
}
|
package alternativa.tanks.models.sfx.shoot.railgun
{
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.Material;
import alternativa.engine3d.objects.AnimSprite;
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.sfx.IGraphicEffect;
import alternativa.tanks.utils.objectpool.ObjectPool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.geom.ColorTransform;
use namespace alternativa3d;
public class ChargeEffect extends PooledObject implements IGraphicEffect
{
private static var globalPosition:Vector3 = new Vector3();
private static var matrix:Matrix4 = new Matrix4();
protected var sprite:AnimSprite;
private var _owner:ClientObject;
private var framesPerMillisecond:Number;
private var currFrame:Number;
private var materials:Vector.<Material>;
private var numFrames:int;
private var localMuzzlePosition:Vector3;
private var turret:Object3D;
public function ChargeEffect(objectPool:ObjectPool)
{
this.localMuzzlePosition = new Vector3();
super(objectPool);
}
public function init(owner:ClientObject, width:Number, height:Number, materials:Vector.<Material>, localMuzzlePosition:Vector3, turret:Object3D, rotation:Number, fps:Number, colorTransform:ColorTransform) : void
{
this._owner = owner;
this.initSprite(width,height,rotation,colorTransform);
this.materials = materials;
this.framesPerMillisecond = 0.001 * fps;
this.localMuzzlePosition.vCopy(localMuzzlePosition);
this.localMuzzlePosition.y += 10;
this.turret = turret;
this.numFrames = materials.length;
this.currFrame = 1;
this.sprite.materials = materials;
this.sprite.material = materials[1];
this.sprite.frame = 1;
this.sprite.softAttenuation = 140;
this.sprite.loop = true;
}
public function addToContainer(container:Scene3DContainer) : void
{
container.addChild(this.sprite);
}
public function get owner() : ClientObject
{
return this._owner;
}
public function play(timeDelta:int, camera:GameCamera) : Boolean
{
if(this.currFrame + 1 >= this.numFrames)
{
return false;
}
matrix.setMatrix(this.turret.x,this.turret.y,this.turret.z,this.turret.rotationX,this.turret.rotationY,this.turret.rotationZ);
matrix.transformVector(this.localMuzzlePosition,globalPosition);
this.sprite.x = globalPosition.x;
this.sprite.y = globalPosition.y;
this.sprite.z = globalPosition.z;
this.sprite.frame = int(this.currFrame);
this.currFrame += this.framesPerMillisecond * timeDelta;
return true;
}
public function destroy() : void
{
this.sprite.removeFromParent();
this.sprite.material = null;
this.sprite.destroy();
this.materials = null;
storeInPool();
}
public function kill() : void
{
this.currFrame = this.numFrames + 1;
}
override protected function getClass() : Class
{
return ChargeEffect;
}
private function initSprite(width:Number, height:Number, rotation:Number, colorTransform:ColorTransform) : void
{
if(this.sprite == null)
{
this.sprite = new AnimSprite(width,height);
}
else
{
this.sprite.width = width;
this.sprite.height = height;
}
this.sprite.rotation = rotation;
this.sprite.colorTransform = colorTransform;
}
}
}
|
package forms.friends.list.renderer.background
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class UserOfflineCellSelected_centerIconClass extends BitmapAsset
{
public function UserOfflineCellSelected_centerIconClass()
{
super();
}
}
}
|
package projects.tanks.client.panel.model.shop.premiumpackage {
public class PremiumPackageCC {
private var _durationInDays:int;
public function PremiumPackageCC(param1:int = 0) {
super();
this._durationInDays = param1;
}
public function get durationInDays() : int {
return this._durationInDays;
}
public function set durationInDays(param1:int) : void {
this._durationInDays = param1;
}
public function toString() : String {
var local1:String = "PremiumPackageCC [";
local1 += "durationInDays = " + this.durationInDays + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.battleservice.model.statistics.team {
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 StatisticsTeamModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function StatisticsTeamModelServer(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.console
{
import flash.display.Graphics;
import flash.display.Sprite;
import flash.display.Stage;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.TextEvent;
import flash.text.TextField;
import flash.text.TextFieldType;
import flash.text.TextFormat;
import flash.ui.Keyboard;
import flash.utils.setTimeout;
public class Console implements IConsole
{
private static const DEFAULT_BG_COLOR:uint = 0;
private static const DEFAULT_FONT_COLOR:uint = 65280;
private static const DEFAULT_TEXT_FORMAT:TextFormat = new TextFormat("Courier New",12,DEFAULT_FONT_COLOR);
private static const tokenizer:RegExp = /(?:[^"\s]+)|(?:"[^"]*")/g;
private var stage:Stage;
private var container:Sprite;
private var output:TextField;
private var input:TextField;
private var toggleKeys:Vector.<ToggleKey>;
private var commandHandlers:Object;
private var variables:Object;
private var _height:Number;
private var _width:Number;
private var visible:Boolean;
private var preventInput:Boolean;
private var _alpha:Number;
private var _bgColor:uint = 0;
private var commandHistory:Array;
private var commandHistoryIndex:int = 0;
private var debugMode:Boolean;
public function Console(stage:Stage, debugMode:Boolean, width:int = 500, height:int = 400, alpha:Number = 0.9)
{
this.toggleKeys = new Vector.<ToggleKey>();
this.commandHandlers = {};
this.variables = {};
this.commandHistory = [];
super();
if(stage == null)
{
throw new ArgumentError("Parameter stage cannot be null");
}
this.stage = stage;
this.debugMode = debugMode;
this.container = new Sprite();
this.container.mouseEnabled = false;
this.container.tabEnabled = false;
this.container.tabChildren = false;
this.initInput();
this.initOutput();
this.initDefaultCommands();
this.setWidth(width);
this.setHeight(height);
this.setAlpha(alpha);
this.printGreeting();
stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
stage.addEventListener(Event.RESIZE,this.resize);
}
public function addVariable(variable:ConsoleVar) : void
{
this.variables[variable.getName()] = variable;
}
public function removeVariable(variableName:String) : void
{
delete this.variables[variableName];
}
public function addToggleKey(keyCode:uint, altKey:Boolean = false, ctrlKey:Boolean = false, shiftKey:Boolean = false) : void
{
this.toggleKeys.push(new ToggleKey(keyCode,altKey,ctrlKey,shiftKey));
}
public function dispose() : void
{
this.hide();
this.stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
this.stage.removeEventListener(Event.RESIZE,this.resize);
this.stage = null;
}
public function getAlpha() : Number
{
return this.container.alpha;
}
public function setAlpha(value:Number) : void
{
this._alpha = value;
this.resize();
}
public function getWidth() : int
{
return this._width;
}
public function setWidth(value:int) : void
{
this._width = value;
this.resize();
}
public function getHeight() : int
{
return this._height;
}
public function setHeight(value:int) : void
{
this._height = value;
this.resize();
}
public function show() : void
{
if(this.stage == null)
{
return;
}
this.visible = true;
this.stage.addChild(this.container);
this.stage.focus = this.input;
this.preventInput = false;
this.resize();
}
public function hide() : void
{
if(this.stage == null)
{
return;
}
if(this.visible)
{
this.stage.removeChild(this.container);
this.stage.focus = this.stage;
this.visible = false;
}
}
public function hideDelayed(delay:uint) : void
{
setTimeout(this.hide,delay);
}
public function addLine(text:String) : void
{
this.output.appendText(text + "\n");
this.output.scrollV = this.output.maxScrollV;
}
public function clear() : void
{
this.output.text = "";
}
public function addCommandHandler(command:String, handler:Function) : void
{
this.commandHandlers[command] = handler;
}
public function removeCommandHandler(command:String) : void
{
delete this.commandHandlers[command];
}
public function getCommandList() : Array
{
var key:* = null;
var list:Array = [];
for(key in this.commandHandlers)
{
list.push(key);
}
list.sort();
return list;
}
public function isDebugMode() : Boolean
{
return this.debugMode;
}
public function getText() : String
{
return this.output.text;
}
public function setFontSize(size:int) : void
{
var textFormat:TextFormat = this.output.defaultTextFormat;
textFormat.size = size;
var text:String = this.output.text;
this.output.text = "";
this.output.defaultTextFormat = textFormat;
this.output.text = text;
this.input.defaultTextFormat = textFormat;
}
private function resize(e:Event = null) : void
{
if(!this.visible || this.stage == null)
{
return;
}
this.output.width = this.stage.stageWidth - 1;
this.input.width = this.stage.stageWidth - 1;
var h:int = this._height > this.stage.stageHeight ? int(int(this.stage.stageHeight)) : int(int(this._height));
this.output.height = h - this.input.height;
this.input.y = this.output.height;
var gfx:Graphics = this.container.graphics;
gfx.clear();
gfx.beginFill(this._bgColor,this._alpha);
gfx.drawRect(0,0,this.container.width,this.container.height);
gfx.endFill();
}
private function initInput() : void
{
this.input = new TextField();
this.input.defaultTextFormat = DEFAULT_TEXT_FORMAT;
this.input.height = 20;
this.input.type = TextFieldType.INPUT;
this.input.border = true;
this.input.borderColor = DEFAULT_FONT_COLOR;
this.input.addEventListener(KeyboardEvent.KEY_DOWN,this.onInputKeyDown);
this.input.addEventListener(KeyboardEvent.KEY_UP,this.onInputKeyUp);
this.input.addEventListener(TextEvent.TEXT_INPUT,this.onTextInput);
this.container.addChild(this.input);
}
private function initOutput() : void
{
this.output = new TextField();
this.output.defaultTextFormat = DEFAULT_TEXT_FORMAT;
this.output.type = TextFieldType.DYNAMIC;
this.output.border = true;
this.output.borderColor = DEFAULT_FONT_COLOR;
this.output.multiline = true;
this.output.wordWrap = true;
this.container.addChild(this.output);
}
private function onInputKeyDown(e:KeyboardEvent) : void
{
if(this.isToggleKey(e))
{
this.preventInput = true;
}
switch(e.keyCode)
{
case Keyboard.ENTER:
this.processInput();
break;
case Keyboard.ESCAPE:
if(this.input.text != "")
{
this.clearInput();
}
else
{
this.hideDelayed(50);
}
break;
case Keyboard.TAB:
this.contextExpand();
break;
case Keyboard.UP:
this.historyUp();
break;
case Keyboard.DOWN:
this.historyDown();
break;
case Keyboard.PAGE_UP:
this.output.scrollV -= 10;
break;
case Keyboard.PAGE_DOWN:
this.output.scrollV += 10;
}
e.stopPropagation();
}
private function onInputKeyUp(e:KeyboardEvent) : void
{
if(!this.isToggleKey(e))
{
e.stopPropagation();
}
}
private function onTextInput(e:TextEvent) : void
{
if(this.preventInput)
{
e.preventDefault();
this.preventInput = false;
}
}
private function processInput() : void
{
var handler:Function = null;
var text:String = this.input.text;
var len:int = this.commandHistory.length;
if(len == 0 || this.commandHistory[len - 1] != text)
{
this.commandHistory.push(text);
}
this.commandHistoryIndex = this.commandHistory.length;
this.clearInput();
this.addLine("> " + text);
if(text.match(/^\s*$/))
{
return;
}
var tokens:Array = text.match(tokenizer);
var commandName:String = tokens.shift();
var variable:ConsoleVar = this.variables[commandName];
if(variable != null)
{
variable.processConsoleInput(this,tokens);
}
else
{
handler = this.commandHandlers[commandName];
if(handler != null)
{
handler.call(null,this,tokens);
}
}
}
private function clearInput() : void
{
this.input.text = "";
}
private function contextExpand() : void
{
}
private function historyUp() : void
{
if(this.commandHistoryIndex == 0)
{
return;
}
--this.commandHistoryIndex;
this.input.text = this.commandHistory[this.commandHistoryIndex];
}
private function historyDown() : void
{
if(this.commandHistoryIndex > this.commandHistory.length - 2)
{
return;
}
++this.commandHistoryIndex;
this.input.text = this.commandHistory[this.commandHistoryIndex];
}
private function onKeyUp(e:KeyboardEvent) : void
{
if(this.isToggleKey(e))
{
if(this.visible)
{
this.hide();
}
else
{
this.show();
}
}
}
private function isToggleKey(e:KeyboardEvent) : Boolean
{
return e.keyCode == 75 && e.ctrlKey && e.shiftKey;
}
private function printGreeting() : void
{
this.addLine("Alternativa console");
this.addLine("Type cmdlist to get list of commands");
}
private function initDefaultCommands() : void
{
var consoleCommands:ConsoleCommands = new ConsoleCommands();
this.addCommandHandler("clear",consoleCommands.clearOutput);
this.addCommandHandler("close",consoleCommands.close);
this.addCommandHandler("copy",consoleCommands.copyOutput);
this.addCommandHandler("fontsize",consoleCommands.fontSize);
this.addCommandHandler("cmdlist",consoleCommands.cmdList);
this.addCommandHandler("console",consoleCommands.consoleCommand);
this.addCommandHandler("dump",consoleCommands.dump);
this.addCommandHandler("varlist",this.printVars);
this.addCommandHandler("varlistv",this.printVarsValues);
}
private function printVars(console:IConsole, args:Array) : void
{
this.printVariables(args[0],false);
}
private function printVarsValues(console:IConsole, args:Array) : void
{
this.printVariables(args[0],true);
}
private function printVariables(start:String, showValues:Boolean) : void
{
var name:* = null;
var variable:ConsoleVar = null;
var s:String = null;
var vars:Array = [];
for(name in this.variables)
{
if(start == null || start == "" || name.indexOf(start) == 0)
{
variable = this.variables[name];
vars.push(!!showValues ? name + " = " + variable.toString() : name);
}
}
if(vars.length > 0)
{
vars.sort();
for each(s in vars)
{
this.addLine(s);
}
}
}
}
}
import flash.events.KeyboardEvent;
class ToggleKey
{
public var keyCode:uint;
public var altKey:Boolean;
public var ctrlKey:Boolean;
public var shiftKey:Boolean;
function ToggleKey(keyCode:uint, altKey:Boolean, ctrlKey:Boolean, shiftKey:Boolean)
{
super();
this.keyCode = keyCode;
this.altKey = altKey;
this.ctrlKey = ctrlKey;
this.shiftKey = shiftKey;
}
public function match(e:KeyboardEvent) : Boolean
{
return e.keyCode == this.keyCode && e.altKey == this.altKey && e.ctrlKey == this.ctrlKey && e.shiftKey == this.shiftKey;
}
}
import alternativa.console.IConsole;
import alternativa.init.Main;
import alternativa.osgi.service.dump.IDumpService;
import alternativa.osgi.service.dump.dumper.IDumper;
import flash.system.System;
class ConsoleCommands
{
private var consoleCommandHandlers:Object;
function ConsoleCommands()
{
this.consoleCommandHandlers = {};
super();
this.consoleCommandHandlers["alpha"] = this.setAlpha;
this.consoleCommandHandlers["height"] = this.setHeight;
}
public function clearOutput(console:IConsole, args:Array) : void
{
console.clear();
}
public function close(console:IConsole, args:Array) : void
{
console.hideDelayed(100);
}
public function copyOutput(console:IConsole, args:Array) : void
{
System.setClipboard(console.getText());
}
public function dump(console:IConsole, args:Array) : Boolean
{
var dumperName:String = null;
var dumpers:Vector.<IDumper> = null;
var names:Array = null;
var i:int = 0;
var dumper:IDumper = null;
var dump:String = null;
var dumpService:IDumpService = IDumpService(Main.osgi.getService(IDumpService));
if(args.length == 0)
{
dumpers = dumpService.dumpersList;
names = [];
for(i = 0; i < dumpers.length; i++)
{
names[i] = IDumper(dumpers[i]).dumperName;
}
names.sort();
console.addLine("List of registered dumpers:");
for each(dumperName in names)
{
console.addLine(" " + dumperName);
}
}
else
{
dumperName = args.shift();
dumper = dumpService.dumpers[dumperName];
if(dumper == null)
{
console.addLine("Uknown dumper name");
}
else
{
dump = dumper.dump(Vector.<String>(args));
console.addLine(dump);
}
}
return true;
}
public function cmdList(console:IConsole, args:Array) : void
{
var command:String = null;
for each(command in console.getCommandList())
{
console.addLine(command);
}
}
public function consoleCommand(console:IConsole, args:Array) : void
{
if(args.length == 0)
{
return;
}
var param:String = args.shift();
var handler:Function = this.consoleCommandHandlers[param];
if(handler != null)
{
handler.call(null,console,args);
}
}
public function fontSize(console:IConsole, args:Array) : void
{
var size:int = 0;
if(args.length > 0)
{
size = int(args[0]);
if(size > 0)
{
console.setFontSize(size);
}
}
}
private function setAlpha(console:IConsole, args:Array) : void
{
var alpha:Number = NaN;
if(args.length == 0)
{
console.addLine("alpha = " + console.getAlpha().toString());
}
else
{
alpha = Number(args[0]);
if(isNaN(alpha) || alpha < 0)
{
console.addLine("Wrong alpha value");
}
else
{
console.setAlpha(alpha);
}
}
}
private function setHeight(console:IConsole, args:Array) : void
{
var h:int = 0;
if(args.length == 0)
{
console.addLine("height = " + console.getHeight());
}
else
{
h = int(args[0]);
if(h <= 0)
{
console.addLine("Height must be positive integer");
}
else
{
console.setHeight(h);
}
}
}
}
|
package alternativa.engine3d.animation.keys {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.animation.AnimationState;
use namespace alternativa3d;
public class Track {
public var object:String;
alternativa3d var _length:Number = 0;
public function Track() {
super();
}
public function get length() : Number {
return this.alternativa3d::_length;
}
alternativa3d function get keyFramesList() : Keyframe {
return null;
}
alternativa3d function set keyFramesList(param1:Keyframe) : void {
}
alternativa3d function addKeyToList(param1:Keyframe) : void {
var local3:Keyframe = null;
var local2:Number = param1.alternativa3d::_time;
if(this.alternativa3d::keyFramesList == null) {
this.alternativa3d::keyFramesList = param1;
this.alternativa3d::_length = local2 <= 0 ? 0 : local2;
return;
}
if(this.alternativa3d::keyFramesList.alternativa3d::_time > local2) {
param1.alternativa3d::nextKeyFrame = this.alternativa3d::keyFramesList;
this.alternativa3d::keyFramesList = param1;
return;
}
local3 = this.alternativa3d::keyFramesList;
while(local3.alternativa3d::nextKeyFrame != null && local3.alternativa3d::nextKeyFrame.alternativa3d::_time <= local2) {
local3 = local3.alternativa3d::nextKeyFrame;
}
if(local3.alternativa3d::nextKeyFrame == null) {
local3.alternativa3d::nextKeyFrame = param1;
this.alternativa3d::_length = local2 <= 0 ? 0 : local2;
} else {
param1.alternativa3d::nextKeyFrame = local3.alternativa3d::nextKeyFrame;
local3.alternativa3d::nextKeyFrame = param1;
}
}
public function removeKey(param1:Keyframe) : Keyframe {
var local2:Keyframe = null;
if(this.alternativa3d::keyFramesList != null) {
if(this.alternativa3d::keyFramesList == param1) {
this.alternativa3d::keyFramesList = this.alternativa3d::keyFramesList.alternativa3d::nextKeyFrame;
if(this.alternativa3d::keyFramesList == null) {
this.alternativa3d::_length = 0;
}
return param1;
}
local2 = this.alternativa3d::keyFramesList;
while(local2.alternativa3d::nextKeyFrame != null && local2.alternativa3d::nextKeyFrame != param1) {
local2 = local2.alternativa3d::nextKeyFrame;
}
if(local2.alternativa3d::nextKeyFrame == param1) {
if(param1.alternativa3d::nextKeyFrame == null) {
this.alternativa3d::_length = local2.alternativa3d::_time <= 0 ? 0 : local2.alternativa3d::_time;
}
local2.alternativa3d::nextKeyFrame = param1.alternativa3d::nextKeyFrame;
return param1;
}
}
throw new Error("Key not found");
}
public function get keys() : Vector.<Keyframe> {
var local1:Vector.<Keyframe> = new Vector.<Keyframe>();
var local2:int = 0;
var local3:Keyframe = this.alternativa3d::keyFramesList;
while(local3 != null) {
local1[local2] = local3;
local2++;
local3 = local3.alternativa3d::nextKeyFrame;
}
return local1;
}
alternativa3d function blend(param1:Number, param2:Number, param3:AnimationState) : void {
}
public function slice(param1:Number, param2:Number = 1.7976931348623157e+308) : Track {
return null;
}
alternativa3d function createKeyFrame() : Keyframe {
return null;
}
alternativa3d function interpolateKeyFrame(param1:Keyframe, param2:Keyframe, param3:Keyframe, param4:Number) : void {
}
alternativa3d function sliceImplementation(param1:Track, param2:Number, param3:Number) : void {
var local5:Keyframe = null;
var local8:Keyframe = null;
var local4:Number = param2 > 0 ? param2 : 0;
var local6:Keyframe = this.alternativa3d::keyFramesList;
var local7:Keyframe = this.alternativa3d::createKeyFrame();
while(local6 != null && local6.alternativa3d::_time <= param2) {
local5 = local6;
local6 = local6.alternativa3d::nextKeyFrame;
}
if(local5 != null) {
if(local6 != null) {
this.alternativa3d::interpolateKeyFrame(local7,local5,local6,(param2 - local5.alternativa3d::_time) / (local6.alternativa3d::_time - local5.alternativa3d::_time));
local7.alternativa3d::_time = param2 - local4;
} else {
this.alternativa3d::interpolateKeyFrame(local7,local7,local5,1);
}
} else {
if(local6 == null) {
return;
}
this.alternativa3d::interpolateKeyFrame(local7,local7,local6,1);
local7.alternativa3d::_time = local6.alternativa3d::_time - local4;
local5 = local6;
local6 = local6.alternativa3d::nextKeyFrame;
}
param1.alternativa3d::keyFramesList = local7;
if(local6 == null || param3 <= param2) {
param1.alternativa3d::_length = local7.alternativa3d::_time <= 0 ? 0 : local7.alternativa3d::_time;
return;
}
while(local6 != null && local6.alternativa3d::_time <= param3) {
local8 = this.alternativa3d::createKeyFrame();
this.alternativa3d::interpolateKeyFrame(local8,local8,local6,1);
local8.alternativa3d::_time = local6.alternativa3d::_time - local4;
local7.alternativa3d::nextKeyFrame = local8;
local7 = local8;
local5 = local6;
local6 = local6.alternativa3d::nextKeyFrame;
}
if(local6 != null) {
local8 = this.alternativa3d::createKeyFrame();
this.alternativa3d::interpolateKeyFrame(local8,local5,local6,(param3 - local5.alternativa3d::_time) / (local6.alternativa3d::_time - local5.alternativa3d::_time));
local8.alternativa3d::_time = param3 - local4;
local7.alternativa3d::nextKeyFrame = local8;
}
if(local8 != null) {
param1.alternativa3d::_length = local8.alternativa3d::_time <= 0 ? 0 : local8.alternativa3d::_time;
}
}
}
}
|
package alternativa.tanks.models.weapon.plasma
{
import alternativa.math.Vector3;
import alternativa.physics.Body;
public interface IPlasmaShotListener
{
function plasmaShotDissolved(param1:PlasmaShot) : void;
function plasmaShotHit(param1:PlasmaShot, param2:Vector3, param3:Vector3, param4:Body) : void;
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.fund {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.field.fund.FundAndLimits_asIconClass.png")]
public class FundAndLimits_asIconClass extends BitmapAsset {
public function FundAndLimits_asIconClass() {
super();
}
}
}
|
package alternativa.tanks.gui.notinclan.clanslist {
public class ClanListType {
public static const OUTGOING:String = "OUTGOING";
public static const INCOMING:String = "INCOMING";
public function ClanListType() {
super();
}
}
}
|
package alternativa.tanks.gui.buttons {
import flash.events.Event;
public class TimerButtonEvent extends Event {
public static const TIME_ON_COMPLETE_TIMER_BUTTON:String = "TimerButtonEventTimeOnCompleteTimerButton";
public function TimerButtonEvent(param1:String, param2:Boolean = false, param3:Boolean = false) {
super(param1,param2,param3);
}
}
}
|
package alternativa.tanks.models.weapon.artillery.rotation {
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.battle.objects.tank.controllers.BarrelElevator;
import alternativa.tanks.camera.FollowCameraController;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.service.settings.keybinding.GameActionEnum;
import alternativa.tanks.services.battleinput.BattleInputService;
import alternativa.tanks.services.battleinput.GameActionListener;
import alternativa.tanks.services.battleinput.MouseLockListener;
import alternativa.tanks.services.battleinput.MouseMovementListener;
import alternativa.tanks.utils.MathUtils;
import projects.tanks.clients.fp10.libraries.tanksservices.service.fullscreen.FullscreenService;
public class BarrelElevationController implements GameActionListener, MouseLockListener, MouseMovementListener {
[Inject]
public static var settingsService:ISettingsService;
[Inject]
public static var battleInputService:BattleInputService;
[Inject]
public static var fullScreenService:FullscreenService;
private static const MOUSE_SENS_MUL:Number = 0.0001;
private var tank:Tank;
private var barrelElevator:BarrelElevator;
private var isEnabled:Boolean = false;
private var up:Boolean;
private var down:Boolean;
private var mouseLookDirection:Number = 0;
public function BarrelElevationController(param1:Tank, param2:BarrelElevator) {
super();
this.tank = param1;
this.barrelElevator = param2;
}
public function enable() : void {
if(!this.isEnabled) {
this.isEnabled = true;
battleInputService.addMouseLockListener(this);
battleInputService.addMouseMoveListener(this);
battleInputService.addGameActionListener(this);
}
}
public function disable() : void {
if(this.isEnabled) {
this.isEnabled = false;
this.up = false;
this.down = false;
this.barrelElevator.setUserControl(BarrelElevator.STOP);
battleInputService.removeMouseLockListener(this);
battleInputService.removeMouseMoveListener(this);
battleInputService.removeGameActionListener(this);
}
}
public function onMouseLock(param1:Boolean) : void {
if(param1) {
if(FollowCameraController.getFollowCameraMode() != FollowCameraController.CAMERA_FOLLOWS_MOUSE) {
this.mouseLookDirection = this.tank.getInterpolatedTurretWorldDirection();
FollowCameraController.setFollowCameraMode(FollowCameraController.CAMERA_FOLLOWS_MOUSE);
FollowCameraController.setFollowCameraDirection(this.mouseLookDirection);
}
} else if(!fullScreenService.isFullScreenNow()) {
FollowCameraController.setFollowCameraMode(FollowCameraController.CAMERA_FOLLOWS_TURRET);
}
}
public function onMouseRelativeMovement(param1:Number, param2:Number) : void {
this.mouseLookDirection = MathUtils.clampAngle(this.mouseLookDirection - param1 * settingsService.mouseSensitivity * MOUSE_SENS_MUL);
FollowCameraController.setFollowCameraDirection(this.mouseLookDirection);
}
public function onGameAction(param1:GameActionEnum, param2:Boolean) : void {
switch(param1) {
case GameActionEnum.ROTATE_TURRET_LEFT:
this.rotateDown(param2);
break;
case GameActionEnum.ROTATE_TURRET_RIGHT:
this.rotateUp(param2);
break;
case GameActionEnum.CENTER_TURRET:
this.center(param2);
break;
case GameActionEnum.LOOK_AROUND:
if(param2) {
battleInputService.releaseMouse();
FollowCameraController.setFollowCameraMode(FollowCameraController.CAMERA_FOLLOWS_TURRET);
}
}
}
private function rotateUp(param1:Boolean) : void {
this.up = param1;
this.setDirectionalRotation();
}
private function rotateDown(param1:Boolean) : void {
this.down = param1;
this.setDirectionalRotation();
}
private function setDirectionalRotation() : void {
if(this.up == this.down) {
this.barrelElevator.setUserControl(BarrelElevator.STOP);
} else if(this.up) {
this.barrelElevator.setUserControl(BarrelElevator.UP);
} else if(this.down) {
this.barrelElevator.setUserControl(BarrelElevator.DOWN);
}
}
private function center(param1:Boolean) : void {
if(param1 && !(this.up || this.down)) {
this.barrelElevator.setUserControl(BarrelElevator.CENTER);
}
}
public function onAddToBattle() : void {
if(FollowCameraController.getFollowCameraMode() == FollowCameraController.CAMERA_FOLLOWS_MOUSE) {
this.mouseLookDirection = this.tank.getInterpolatedTurretWorldDirection();
FollowCameraController.setFollowCameraDirection(this.mouseLookDirection);
}
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.inventory.HudInventoryIcon_goldWhiteIconClass.png")]
public class HudInventoryIcon_goldWhiteIconClass extends BitmapAsset {
public function HudInventoryIcon_goldWhiteIconClass() {
super();
}
}
}
|
package alternativa.tanks.model.item.droppablegold {
import alternativa.tanks.gui.item.actionpanel.SingleActionWithCheckBoxPanel;
import alternativa.tanks.model.garage.passtoshop.PassToShopService;
import alternativa.tanks.model.item.info.ItemActionPanel;
import alternativa.tanks.service.item.ItemService;
import flash.display.DisplayObjectContainer;
import flash.events.IEventDispatcher;
import platform.client.fp10.core.model.ObjectLoadListener;
import projects.tanks.client.commons.types.ShopCategoryEnum;
import projects.tanks.client.garage.models.item.droppablegold.DroppableGoldItemModelBase;
import projects.tanks.client.garage.models.item.droppablegold.IDroppableGoldItemModelBase;
import projects.tanks.clients.flash.commons.services.payment.PaymentDisplayService;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties.IUserPropertiesService;
[ModelInfo]
public class DroppableGoldItemModel extends DroppableGoldItemModelBase implements IDroppableGoldItemModelBase, ItemActionPanel, ObjectLoadListener {
[Inject]
public static var paymentDisplayService:PaymentDisplayService;
[Inject]
public static var itemService:ItemService;
[Inject]
public static var userProperties:IUserPropertiesService;
[Inject]
public static var passToShop:PassToShopService;
public function DroppableGoldItemModel() {
super();
}
public function objectLoaded() : void {
var local1:SingleActionWithCheckBoxPanel = new SingleActionWithCheckBoxPanel(TanksLocale.TEXT_GARAGE_INFO_PANEL_BUTTON_BUY_TEXT,!!passToShop.isPassToShopEnabled() ? this.openPayment : null);
local1.initCheckBox(TanksLocale.TEXT_GOLD_CHECKBOX,getInitParam().showDroppableGoldAuthor,getFunctionWrapper(this.setShowGoldAuthor));
putData(SingleActionWithCheckBoxPanel,local1);
}
private function setShowGoldAuthor() : void {
server.setShowGoldAuthor(this.getActionPanel().isChecked());
}
public function updateActionElements(param1:DisplayObjectContainer, param2:IEventDispatcher) : void {
var local3:SingleActionWithCheckBoxPanel = this.getActionPanel();
local3.updateActionElements(param1);
local3.enabled = userProperties.rank >= itemService.getMinRankIndex(object);
}
public function handleDoubleClickOnItemPreview() : void {
if(Boolean(passToShop.isPassToShopEnabled()) && this.getActionPanel().enabled) {
this.openPayment();
}
}
private function openPayment() : void {
if(passToShop.isPassToShopEnabled()) {
paymentDisplayService.openPaymentAt(ShopCategoryEnum.GOLD_BOXES);
}
}
private function getActionPanel() : SingleActionWithCheckBoxPanel {
return SingleActionWithCheckBoxPanel(getData(SingleActionWithCheckBoxPanel));
}
}
}
|
package scpacker.networking.aes
{
public interface IAESModel
{
}
}
|
package projects.tanks.client.panel.model.shop.promo {
import projects.tanks.client.panel.model.donationalert.types.GoodInfoData;
public interface IShopPromoCodeModelBase {
function codeActivated(param1:Vector.<GoodInfoData>) : void;
function codeActivationBlocked() : void;
function codeIsInvalid() : void;
}
}
|
package alternativa.engine3d.objects {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Debug;
import alternativa.engine3d.core.Face;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.VG;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.core.Wrapper;
import alternativa.gfx.core.IndexBufferResource;
import alternativa.gfx.core.VertexBufferResource;
use namespace alternativa3d;
public class Decal extends Mesh {
public var attenuation:Number = 1000000;
public function Decal() {
super();
shadowMapAlphaThreshold = 100;
}
public function createGeometry(param1:Mesh, param2:Boolean = false) : void {
if(!param2) {
param1 = param1.clone() as Mesh;
}
alternativa3d::faceList = param1.alternativa3d::faceList;
alternativa3d::vertexList = param1.alternativa3d::vertexList;
param1.alternativa3d::faceList = null;
param1.alternativa3d::vertexList = null;
var local3:Vertex = alternativa3d::vertexList;
while(local3 != null) {
local3.alternativa3d::transformId = 0;
local3.id = null;
local3 = local3.alternativa3d::next;
}
var local4:Face = alternativa3d::faceList;
while(local4 != null) {
local4.id = null;
local4 = local4.alternativa3d::next;
}
calculateBounds();
}
override public function clone() : Object3D {
var local1:Decal = new Decal();
local1.clonePropertiesFrom(this);
return local1;
}
override protected function clonePropertiesFrom(param1:Object3D) : void {
super.clonePropertiesFrom(param1);
var local2:Decal = param1 as Decal;
this.attenuation = local2.attenuation;
}
override alternativa3d function draw(param1:Camera3D) : void {
var local3:Face = null;
var local4:Vertex = null;
if(alternativa3d::faceList == null) {
return;
}
if(clipping == 0) {
if(Boolean(alternativa3d::culling & 1)) {
return;
}
alternativa3d::culling = 0;
}
this.alternativa3d::prepareResources();
alternativa3d::useDepth = true;
if(alternativa3d::faceList.material != null) {
param1.alternativa3d::addDecal(this);
alternativa3d::transformConst[0] = alternativa3d::ma;
alternativa3d::transformConst[1] = alternativa3d::mb;
alternativa3d::transformConst[2] = alternativa3d::mc;
alternativa3d::transformConst[3] = alternativa3d::md;
alternativa3d::transformConst[4] = alternativa3d::me;
alternativa3d::transformConst[5] = alternativa3d::mf;
alternativa3d::transformConst[6] = alternativa3d::mg;
alternativa3d::transformConst[7] = alternativa3d::mh;
alternativa3d::transformConst[8] = alternativa3d::mi;
alternativa3d::transformConst[9] = alternativa3d::mj;
alternativa3d::transformConst[10] = alternativa3d::mk;
alternativa3d::transformConst[11] = alternativa3d::ml;
}
var local2:int = param1.debug ? int(param1.alternativa3d::checkInDebug(this)) : 0;
if(Boolean(local2 & Debug.BOUNDS)) {
Debug.alternativa3d::drawBounds(param1,this,boundMinX,boundMinY,boundMinZ,boundMaxX,boundMaxY,boundMaxZ);
}
if(Boolean(local2 & Debug.EDGES)) {
if(alternativa3d::transformId > 500000000) {
alternativa3d::transformId = 0;
local4 = alternativa3d::vertexList;
while(local4 != null) {
local4.alternativa3d::transformId = 0;
local4 = local4.alternativa3d::next;
}
}
++alternativa3d::transformId;
alternativa3d::calculateInverseMatrix();
local3 = alternativa3d::prepareFaces(param1,alternativa3d::faceList);
if(local3 == null) {
return;
}
Debug.alternativa3d::drawEdges(param1,local3,16777215);
}
}
override alternativa3d function getVG(param1:Camera3D) : VG {
this.alternativa3d::draw(param1);
return null;
}
override alternativa3d function prepareResources() : void {
var local1:Vector.<Number> = null;
var local2:int = 0;
var local3:int = 0;
var local4:Vertex = null;
var local5:Vector.<uint> = null;
var local6:int = 0;
var local7:Face = null;
var local8:Wrapper = null;
var local9:uint = 0;
var local10:uint = 0;
var local11:uint = 0;
if(alternativa3d::vertexBuffer == null) {
local1 = new Vector.<Number>();
local2 = 0;
local3 = 0;
local4 = alternativa3d::vertexList;
while(local4 != null) {
local1[local2] = local4.x;
local2++;
local1[local2] = local4.y;
local2++;
local1[local2] = local4.z;
local2++;
local1[local2] = local4.u;
local2++;
local1[local2] = local4.v;
local2++;
local1[local2] = local4.normalX;
local2++;
local1[local2] = local4.normalY;
local2++;
local1[local2] = local4.normalZ;
local2++;
local4.alternativa3d::index = local3;
local3++;
local4 = local4.alternativa3d::next;
}
alternativa3d::vertexBuffer = new VertexBufferResource(local1,8);
local5 = new Vector.<uint>();
local6 = 0;
alternativa3d::numTriangles = 0;
local7 = alternativa3d::faceList;
while(local7 != null) {
local8 = local7.alternativa3d::wrapper;
local9 = uint(local8.alternativa3d::vertex.alternativa3d::index);
local8 = local8.alternativa3d::next;
local10 = uint(local8.alternativa3d::vertex.alternativa3d::index);
local8 = local8.alternativa3d::next;
while(local8 != null) {
local11 = uint(local8.alternativa3d::vertex.alternativa3d::index);
local5[local6] = local9;
local6++;
local5[local6] = local10;
local6++;
local5[local6] = local11;
local6++;
local10 = local11;
++alternativa3d::numTriangles;
local8 = local8.alternativa3d::next;
}
local7 = local7.alternativa3d::next;
}
alternativa3d::indexBuffer = new IndexBufferResource(local5);
}
}
}
}
|
package _codec.projects.tanks.client.entrance.model.entrance.logging {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.EnumCodecInfo;
import projects.tanks.client.entrance.model.entrance.logging.RegistrationUXScreen;
public class VectorCodecRegistrationUXScreenLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRegistrationUXScreenLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(RegistrationUXScreen,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<RegistrationUXScreen> = new Vector.<RegistrationUXScreen>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = RegistrationUXScreen(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:RegistrationUXScreen = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<RegistrationUXScreen> = Vector.<RegistrationUXScreen>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.display.usertitle {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.display.usertitle.EffectIndicator_iconNitroCls.png")]
public class EffectIndicator_iconNitroCls extends BitmapAsset {
public function EffectIndicator_iconNitroCls() {
super();
}
}
}
|
package projects.tanks.client.panel.model.rankupbonus.alert {
public interface IRankUpBonusAlertPanelModelBase {
function showAlert(param1:RankUpBonusAlertItem) : void;
}
}
|
package alternativa.physics.collision.types {
import alternativa.math.Vector3;
public class Ray {
public var origin:Vector3 = new Vector3();
public var dir:Vector3 = new Vector3();
public function Ray() {
super();
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.machinegun.sfx {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.tankparts.weapons.machinegun.sfx.MachineGunSFXCC;
public class VectorCodecMachineGunSFXCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecMachineGunSFXCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(MachineGunSFXCC,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.<MachineGunSFXCC> = new Vector.<MachineGunSFXCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = MachineGunSFXCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:MachineGunSFXCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<MachineGunSFXCC> = Vector.<MachineGunSFXCC>(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.battlefield.models.tankparts.weapon.healing {
import projects.tanks.client.battlefield.models.tankparts.weapons.common.discrete.TargetHit;
public interface IIsisModelBase {
function addEnergy(param1:int) : void;
function reconfigureWeapon(param1:Number, param2:Number, param3:Number, param4:Number) : void;
function resetTarget() : void;
function setTarget(param1:IsisState, param2:TargetHit) : void;
function stopWeapon() : void;
}
}
|
package alternativa.tanks.models.dom.sfx
{
import alternativa.console.ConsoleVarFloat;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.engine3d.debug.TextureMaterialRegistry;
import flash.display.BitmapData;
import projects.tanks.client.battleservice.model.team.BattleTeamType;
public class AllBeamProperties
{
private static const conBeamWidth:ConsoleVarFloat = new ConsoleVarFloat("beam_width",100,0,1000);
private static const conUnitLength:ConsoleVarFloat = new ConsoleVarFloat("beam_ulength",500,0,10000);
private static const conAnimationSpeed:ConsoleVarFloat = new ConsoleVarFloat("beam_anim_speed",-0.6,-1000,1000);
private static const conURange:ConsoleVarFloat = new ConsoleVarFloat("beam_urange",0.6,0.1,1);
private static const conAlpha:ConsoleVarFloat = new ConsoleVarFloat("beam_alpha",1,0,1);
[Embed(source="885.png")]
private static const blueRay:Class;
[Embed(source="1176.png")]
private static const blueRayTip:Class;
[Embed(source="1019.png")]
private static const redRay:Class;
[Embed(source="1138.png")]
private static const redRayTip:Class;
private var blueBeamProperties:BeamProperties;
private var redBeamProperties:BeamProperties;
public function AllBeamProperties(param1:TextureMaterialRegistry)
{
super();
this.blueBeamProperties = createBeamProperties(param1,new blueRay().bitmapData,new blueRayTip().bitmapData,50,100,1,1,1);
this.redBeamProperties = createBeamProperties(param1,new redRay().bitmapData,new redRayTip().bitmapData,50,100,1,1,1);
}
private static function createBeamProperties(param1:TextureMaterialRegistry, param2:BitmapData, param3:BitmapData, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number) : BeamProperties
{
var _loc9_:TextureMaterial = new TextureMaterial(param2);
_loc9_.repeat = true;
var _loc10_:TextureMaterial = new TextureMaterial(param3);
return new BeamProperties(_loc9_,_loc10_,param4,param5,param6,param7,param8);
}
private static function createProperties(param1:BeamProperties) : BeamProperties
{
return new BeamProperties(param1.beamMaterial,param1.beamTipMaterial,conBeamWidth.value,conUnitLength.value,conAnimationSpeed.value,conURange.value,conAlpha.value);
}
private function getBlueBeamProperties() : BeamProperties
{
return createProperties(this.blueBeamProperties);
}
private function getRedBeamProperties() : BeamProperties
{
return createProperties(this.redBeamProperties);
}
public function getBeamProperties(param1:BattleTeamType) : BeamProperties
{
return param1 == BattleTeamType.BLUE ? this.getBlueBeamProperties() : this.getRedBeamProperties();
}
}
}
|
package controls.cellrenderer
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class CellNormal_normalLeft extends BitmapAsset
{
public function CellNormal_normalLeft()
{
super();
}
}
}
|
package alternativa.tanks.models.battle.battlefield {
import alternativa.tanks.models.sfx.lighting.LightingSfx;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class BattleSfxEvents implements BattleSfx {
private var object:IGameObject;
private var impl:Vector.<Object>;
public function BattleSfxEvents(param1:IGameObject, param2:Vector.<Object>) {
super();
this.object = param1;
this.impl = param2;
}
public function getLightingSfx() : LightingSfx {
var result:LightingSfx = null;
var i:int = 0;
var m:BattleSfx = null;
try {
Model.object = this.object;
i = 0;
while(i < this.impl.length) {
m = BattleSfx(this.impl[i]);
result = m.getLightingSfx();
i++;
}
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package alternativa.tanks.models.sfx.shoot.hwthunder
{
import alternativa.engine3d.core.Object3D;
import alternativa.math.Vector3;
import alternativa.object.ClientObject;
import alternativa.tanks.sfx.EffectsPair;
public interface IHWThunderSFXModel
{
function createShotEffects(param1:ClientObject, param2:Vector3, param3:Object3D) : EffectsPair;
function createExplosionEffects(param1:ClientObject, param2:Vector3) : EffectsPair;
}
}
|
package alternativa.tanks.controller.commands.goto_ {
import alternativa.tanks.controller.events.showform.ShowExternalEntranceFormEvent;
import alternativa.tanks.controller.events.socialnetwork.NavigationExternalEvent;
import alternativa.tanks.tracker.ITrackerService;
import org.robotlegs.mvcs.Command;
public class GoToExternalRegistrationCommand extends Command {
[Inject]
public var trackerService:ITrackerService;
[Inject]
public var event:NavigationExternalEvent;
public function GoToExternalRegistrationCommand() {
super();
}
override public function execute() : void {
dispatch(new ShowExternalEntranceFormEvent(ShowExternalEntranceFormEvent.REGISTRATION_FORM,this.event.socialNetworkId,null,false));
this.trackerService.trackEvent("entrance","showRegistrationForm","");
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.sfx.shoot.twins {
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 TwinsShootSFXModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function TwinsShootSFXModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.droppablegold {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.droppablegold.DroppableGoldItemCC;
public class CodecDroppableGoldItemCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_showDroppableGoldAuthor:ICodec;
public function CodecDroppableGoldItemCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_showDroppableGoldAuthor = param1.getCodec(new TypeCodecInfo(Boolean,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:DroppableGoldItemCC = new DroppableGoldItemCC();
local2.showDroppableGoldAuthor = this.codec_showDroppableGoldAuthor.decode(param1) as Boolean;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:DroppableGoldItemCC = DroppableGoldItemCC(param2);
this.codec_showDroppableGoldAuthor.encode(param1,local3.showDroppableGoldAuthor);
}
}
}
|
package scpacker.tanks
{
import alternativa.init.Main;
import alternativa.object.ClientObject;
import alternativa.register.ClientClass;
import alternativa.tanks.models.sfx.flame.FlamethrowerSFXModel;
import alternativa.tanks.models.sfx.healing.HealingGunSFXModel;
import alternativa.tanks.models.sfx.shoot.ICommonShootSFX;
import alternativa.tanks.models.sfx.shoot.gun.SmokySFXModel;
import alternativa.tanks.models.sfx.shoot.hwthunder.HWThunderSFXModel;
import alternativa.tanks.models.sfx.shoot.plasma.PlasmaSFXModel;
import alternativa.tanks.models.sfx.shoot.pumpkingun.PumpkingunSFXModel;
import alternativa.tanks.models.sfx.shoot.railgun.RailgunSFXModel;
import alternativa.tanks.models.sfx.shoot.ricochet.RicochetSFXModel;
import alternativa.tanks.models.sfx.shoot.snowman.SnowmanSFXModel;
import alternativa.tanks.models.sfx.shoot.thunder.ThunderSFXModel;
import alternativa.tanks.models.weapon.IWeapon;
import alternativa.tanks.models.weapon.common.IWeaponCommonModel;
import alternativa.tanks.models.weapon.common.WeaponCommonModel;
import alternativa.tanks.models.weapon.freeze.FreezeSFXModel;
import alternativa.tanks.models.weapon.shaft.sfx.ShaftSFXModel;
import com.alternativaplatform.projects.tanks.client.warfare.models.sfx.healing.IHealingSFXModelBase;
import flash.utils.Dictionary;
public class WeaponsManager
{
public static var shotDatas:Dictionary = new Dictionary();
public static var specialEntity:Dictionary = new Dictionary();
private static var railgunSFXModels:Dictionary = new Dictionary();
private static var smokySFXModels:Dictionary = new Dictionary();
private static var flamethrowerSFXModels:Dictionary = new Dictionary();
private static var twinsSFXModels:Dictionary = new Dictionary();
private static var isidaSFXModel:HealingGunSFXModel;
private static var thunderSFXModels:ThunderSFXModel;
private static var hwthunderSFXModels:HWThunderSFXModel;
private static var frezeeSFXModels:FreezeSFXModel;
private static var ricochetSFXModels:RicochetSFXModel;
private static var pumpkingunSFXModels:PumpkingunSFXModel;
private static var shaftSFXModel:Dictionary = new Dictionary();
private static var turretObjects:Dictionary = new Dictionary();
private static var snowmanSFXModels:Dictionary = new Dictionary();
private static var terminatorSFXModels:Dictionary = new Dictionary();
public function WeaponsManager()
{
super();
}
public static function getWeapon(owner:ClientObject, clientObject:ClientObject, impactForce:Number, kickback:Number, turretRotationAcceleration:Number, turretRotationSpeed:Number) : IWeapon
{
var model:WeaponCommonModel = Main.osgi.getService(IWeaponCommonModel) as WeaponCommonModel;
if(model == null)
{
model = new WeaponCommonModel();
Main.osgi.registerService(IWeaponCommonModel,model);
}
model.initObject(clientObject,impactForce,kickback,turretRotationAcceleration,turretRotationSpeed);
model.objectLoaded(clientObject);
return model;
}
public static function getRailgunSFX(clientObject:ClientObject) : RailgunSFXModel
{
var returned:RailgunSFXModel = null;
if(railgunSFXModels == null)
{
railgunSFXModels = new Dictionary();
}
if(railgunSFXModels[clientObject.id] == null)
{
railgunSFXModels[clientObject.id] = new RailgunSFXModel();
railgunSFXModels[clientObject.id].initObject(clientObject,clientObject.id + "_" + "chargingPart1",clientObject.id + "_" + "chargingPart2",clientObject.id + "_" + "chargingPart3",clientObject.id + "_" + "shot","");
}
returned = railgunSFXModels[clientObject.id];
if(returned == null)
{
throw new Error("пизда бачок " + clientObject.id);
}
return returned;
}
public static function getTerminatorSFX(clientObject:ClientObject) : RailgunSFXModel
{
var returned:RailgunSFXModel = null;
if(terminatorSFXModels == null)
{
terminatorSFXModels = new Dictionary();
}
if(terminatorSFXModels[clientObject.id] == null)
{
terminatorSFXModels[clientObject.id] = new RailgunSFXModel();
terminatorSFXModels[clientObject.id].initObject(clientObject,clientObject.id + "_" + "chargingPart1",clientObject.id + "_" + "chargingPart2",clientObject.id + "_" + "chargingPart3",clientObject.id + "_" + "shot","");
}
returned = terminatorSFXModels[clientObject.id];
if(returned == null)
{
throw new Error("пизда бачок " + clientObject.id);
}
return returned;
}
public static function getSmokySFX(clientObject:ClientObject) : SmokySFXModel
{
var returnObject:SmokySFXModel = null;
if(smokySFXModels == null)
{
smokySFXModels = new Dictionary();
}
if(smokySFXModels[clientObject.id] == null)
{
smokySFXModels[clientObject.id] = new SmokySFXModel();
smokySFXModels[clientObject.id].initObject(clientObject,clientObject.id + "_explosion",clientObject.id + "_explosion_sound",clientObject.id + "_shot",clientObject.id + "_shot_sound");
}
return smokySFXModels[clientObject.id];
}
public static function getFlamethrowerSFX(clientObject:ClientObject) : FlamethrowerSFXModel
{
if(flamethrowerSFXModels == null)
{
flamethrowerSFXModels = new Dictionary();
}
if(flamethrowerSFXModels[clientObject.id] == null)
{
flamethrowerSFXModels[clientObject.id] = new FlamethrowerSFXModel();
flamethrowerSFXModels[clientObject.id].initObject(clientObject,clientObject.id + "_fire","flamethrower_sound");
flamethrowerSFXModels[clientObject.id].objectLoaded(clientObject);
}
return flamethrowerSFXModels[clientObject.id];
}
public static function getTwinsSFX(clientObject:ClientObject) : PlasmaSFXModel
{
if(twinsSFXModels == null)
{
twinsSFXModels = new Dictionary();
}
if(twinsSFXModels[clientObject.id] == null)
{
twinsSFXModels[clientObject.id] = new PlasmaSFXModel();
twinsSFXModels[clientObject.id].initObject(clientObject,"twins_explosionSound",clientObject.id + "_explosionTexture",clientObject.id + "_plasmaTexture","twins_shotSound",clientObject.id + "_shotTexture");
}
return twinsSFXModels[clientObject.id];
}
public static function getIsidaSFX(clientObject:ClientObject) : HealingGunSFXModel
{
if(isidaSFXModel == null)
{
isidaSFXModel = new HealingGunSFXModel();
Main.osgi.registerService(IHealingSFXModelBase,isidaSFXModel);
}
isidaSFXModel.initObject(clientObject,clientObject.id + "_damagingRayId","damagingSoundId",clientObject.id + "_damagingTargetBallId",clientObject.id + "_damagingWeaponBallId",clientObject.id + "_healingRayId","healingSoundId",clientObject.id + "_healingTargetBallId",clientObject.id + "_healingWeaponBallId","idleSoundId",clientObject.id + "_idleWeaponBallId");
return isidaSFXModel;
}
public static function getThunderSFX(clientObject:ClientObject) : ThunderSFXModel
{
if(thunderSFXModels == null)
{
thunderSFXModels = new ThunderSFXModel();
}
thunderSFXModels.initObject(clientObject,clientObject.id + "_explosionResourceId","thunder_explosionSoundResourceId",clientObject.id + "_shotResourceId","thunder_shotSoundResourceId");
return thunderSFXModels;
}
public static function getHWThunderSFX(clientObject:ClientObject) : HWThunderSFXModel
{
if(hwthunderSFXModels == null)
{
hwthunderSFXModels = new HWThunderSFXModel();
}
hwthunderSFXModels.initObject(clientObject,clientObject.id + "_explosionResourceId","hwthunder_explosionSoundResourceId",clientObject.id + "_shotResourceId","hwthunder_shotSoundResourceId");
return hwthunderSFXModels;
}
public static function getFrezeeSFXModel(clientObject:ClientObject) : FreezeSFXModel
{
if(frezeeSFXModels == null)
{
frezeeSFXModels = new FreezeSFXModel();
}
frezeeSFXModels.initObject(clientObject,17,clientObject.id + "_particleTextureResourceId",clientObject.id + "_planeTextureResourceId","frezee_sound");
return frezeeSFXModels;
}
public static function getRicochetSFXModel(clientObject:ClientObject) : RicochetSFXModel
{
if(ricochetSFXModels == null)
{
ricochetSFXModels = new RicochetSFXModel();
}
ricochetSFXModels.initObject(clientObject,clientObject.id + "_bumpFlashTextureId","ricochet_explosionSoundId",clientObject.id + "_explosionTextureId","ricochetSoundId",clientObject.id + "_shotFlashTextureId","ricochet_shotSoundId",clientObject.id + "_shotTextureId",clientObject.id + "_tailTrailTextureId");
return ricochetSFXModels;
}
public static function getPumpkingunSFXModel(clientObject:ClientObject) : PumpkingunSFXModel
{
if(pumpkingunSFXModels == null)
{
pumpkingunSFXModels = new PumpkingunSFXModel();
}
pumpkingunSFXModels.initObject(clientObject,clientObject.id + "_bumpFlashTextureId","pumpkingun_explosionSoundId",clientObject.id + "_explosionTextureId","pumpkingunSoundId",clientObject.id + "_shotFlashTextureId","pumpkingun_shotSoundId",clientObject.id + "_shotTextureId",clientObject.id + "_tailTrailTextureId");
return pumpkingunSFXModels;
}
public static function getShaftSFX(clientObject:ClientObject) : ShaftSFXModel
{
var returnObject:ShaftSFXModel = null;
if(shaftSFXModel == null)
{
shaftSFXModel = new Dictionary();
}
if(shaftSFXModel[clientObject.id] == null)
{
shaftSFXModel[clientObject.id] = new ShaftSFXModel();
shaftSFXModel[clientObject.id].initObject(clientObject,"shaft_zoomModeSound","shaft_targetingSound",clientObject.id + "_explosionTexture",clientObject.id + "_trail",clientObject.id + "_shot");
}
return shaftSFXModel[clientObject.id];
}
public static function getObjectFor(id:String) : ClientObject
{
if(turretObjects[id] == null)
{
turretObjects[id] = initObject(id);
}
return turretObjects[id];
}
public static function getSnowmanSFX(clientObject:ClientObject) : SnowmanSFXModel
{
if(snowmanSFXModels == null)
{
snowmanSFXModels = new Dictionary();
}
if(snowmanSFXModels[clientObject.id] == null)
{
snowmanSFXModels[clientObject.id] = new SnowmanSFXModel();
snowmanSFXModels[clientObject.id].initObject(clientObject,"snowman_shotExplosion",clientObject.id + "_fire",clientObject.id + "_snow","snowman_shotSound",clientObject.id + "_snow");
}
return snowmanSFXModels[clientObject.id];
}
public static function getCommonShotSFX(turret:ClientObject) : ICommonShootSFX
{
var returnObject:ICommonShootSFX = null;
var id:String = turret.id.split("_")[0];
switch(id)
{
case "smoky":
returnObject = getSmokySFX(turret);
break;
case "smokyxt":
returnObject = getSmokySFX(turret);
break;
case "twins":
returnObject = getTwinsSFX(turret);
break;
case "twinsxt":
returnObject = getTwinsSFX(turret);
break;
case "shaft":
break;
case "snowman":
returnObject = getSnowmanSFX(turret);
}
return returnObject;
}
private static function initObject(id:String) : ClientObject
{
return new ClientObject(id,new ClientClass(id,null,id,null),id,null);
}
public static function destroy() : void
{
isidaSFXModel = null;
twinsSFXModels = null;
flamethrowerSFXModels = null;
smokySFXModels = null;
railgunSFXModels = null;
thunderSFXModels = null;
ricochetSFXModels = null;
frezeeSFXModels = null;
shaftSFXModel = null;
snowmanSFXModels = null;
}
}
}
|
package alternativa.tanks.models.weapon.gauss.sfx {
import alternativa.engine3d.objects.Mesh;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.engine3d.EffectsMaterialRegistry;
import alternativa.tanks.models.sfx.lighting.LightingSfx;
import alternativa.tanks.utils.GraphicsUtils;
import flash.media.Sound;
import platform.client.fp10.core.model.ObjectLoadPostListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.battlefield.models.tankparts.weapon.gauss.sfx.GaussSFXCC;
import projects.tanks.client.battlefield.models.tankparts.weapon.gauss.sfx.GaussSFXModelBase;
import projects.tanks.client.battlefield.models.tankparts.weapon.gauss.sfx.IGaussSFXModelBase;
[ModelInfo]
public class GaussSFXModel extends GaussSFXModelBase implements IGaussSFXModelBase, ObjectLoadPostListener, ObjectUnloadListener, IGaussSFXModel {
[Inject]
public static var battleService:BattleService;
[Inject]
public static var materialRegistry:EffectsMaterialRegistry;
public function GaussSFXModel() {
super();
}
private static function releaseMaterials(param1:GaussSFXData) : void {
materialRegistry.releaseMaterial(param1.electroTextureMaterial);
materialRegistry.releaseMaterial(param1.explosionElectroTextureAnimation.material);
materialRegistry.releaseMaterial(param1.explosionTextureAnimation.material);
materialRegistry.releaseMaterial(param1.fireTextureMaterial);
materialRegistry.releaseMaterial(param1.flameTextureMaterial);
materialRegistry.releaseMaterial(param1.lightningTextureMaterial);
materialRegistry.releaseMaterial(param1.tracerTextureMaterial);
materialRegistry.releaseMaterial(param1.trailTextureMaterial);
materialRegistry.releaseMaterial(param1.smokeTextureMaterial);
materialRegistry.releaseMaterial(param1.primaryHitMarkerMaterial);
}
public function objectLoadedPost() : void {
var local1:GaussSFXCC = getInitParam();
var local2:GaussSFXData = new GaussSFXData();
local2.electroTextureMaterial = materialRegistry.getMaterial(local1.electroTexture.data);
local2.explosionElectroTextureAnimation = GraphicsUtils.getTextureAnimationFromResource(materialRegistry,local1.explosionElectroTexture);
local2.explosionTextureAnimation = GraphicsUtils.getTextureAnimationFromResource(materialRegistry,local1.explosionTexture);
local2.fireTextureMaterial = materialRegistry.getMaterial(local1.fireTexture.data);
local2.flameTextureMaterial = materialRegistry.getMaterial(local1.flameTexture.data);
local2.lightningTextureMaterial = materialRegistry.getMaterial(local1.lightningTexture.data);
local2.lightningTextureMaterial.repeat = true;
local2.tracerTextureMaterial = materialRegistry.getMaterial(local1.tracerTexture.data);
local2.trailTextureMaterial = materialRegistry.getMaterial(local1.trailTexture.data);
local2.smokeTextureMaterial = materialRegistry.getMaterial(local1.smokeTexture.data);
local2.primaryHitMarkerMaterial = materialRegistry.getMaterial(local1.hitMarkerTexture.data);
local2.shellMesh = this.createShell(local1);
var local3:LightingSfx = new LightingSfx(getInitParam().lightingSFXEntity);
local2.primaryShotLightAnimation = local3.createAnimation("shot");
local2.primaryExplosionLightAnimation = local3.createAnimation("hit");
local2.primaryShellLightAnimation = local3.createAnimation("shell");
local2.secondaryShotLightAnimation = local3.createAnimation("powershot");
local2.secondaryExplosionLightAnimation = local3.createAnimation("powerhit");
local2.secondaryLightningLightAnimation = local3.createAnimation("lightning");
local2.primaryHitSound = local1.primaryHitSound.sound;
local2.primaryShotSound = local1.primaryShotSound.sound;
local2.secondaryHitSound = local1.secondaryHitSound.sound;
local2.secondaryShotSound = local1.secondaryShotSound.sound;
local2.antennaUpSound = local1.antennaUpSound.sound;
local2.antennaDownSound = local1.antennaDownSound.sound;
local2.startAimingSound = local1.startAimingSound.sound;
local2.targetLockSound = local1.targetLockSound.sound;
local2.targetLostSound = local1.targetLostSound.sound;
local2.shellFlightSound = local1.primaryShellFlightSound.sound;
local2.powerShotFarSounds = Vector.<Sound>([local1.powerShotFarSound1.sound,local1.powerShotFarSound2.sound,local1.powerShotFarSound3.sound]);
putData(GaussSFXData,local2);
}
public function objectUnloaded() : void {
releaseMaterials(this.getSFXData());
}
private function createShell(param1:GaussSFXCC) : Mesh {
var local2:Mesh = Mesh(param1.shell.objects[0].clone());
local2.setMaterialToAllFaces(materialRegistry.getMaterial(param1.shellTexture.data));
return local2;
}
public function getSFXData() : GaussSFXData {
return GaussSFXData(getData(GaussSFXData));
}
}
}
|
package alternativa.tanks.service.battle {
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
public interface IBattleUserInfoService {
function getBattle(param1:Long) : IGameObject;
function connect(param1:Long, param2:IGameObject) : void;
function disconnect(param1:Long) : void;
function userInBattle(param1:Long) : Boolean;
function deleteBattleItem(param1:IGameObject) : void;
}
}
|
package projects.tanks.clients.fp10.Prelauncher.steam {
import flash.display.Shape;
import flash.events.Event;
public class SteamRenderer extends Shape {
public function SteamRenderer() {
super();
graphics.beginFill(0,0);
graphics.drawRect(0,0,1,1);
graphics.endFill();
addEventListener(Event.ADDED,this.onAdded);
}
private function onAdded(event:Event) : void {
removeEventListener(Event.ADDED,this.onAdded);
addEventListener(Event.ENTER_FRAME,this.onEnterFrame);
}
private function onEnterFrame(event:Event) : void {
rotation += 1;
}
}
}
|
package alternativa.tanks.models.weapons.shell {
import alternativa.math.Vector3;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.weapons.shell.states.ShellStates;
public class DummyShellWeaponCommunication implements ShellWeaponCommunication {
public static const INSTANCE:ShellWeaponCommunication = new DummyShellWeaponCommunication();
public function DummyShellWeaponCommunication() {
super();
}
public function tryToShoot(param1:int, param2:int, param3:int, param4:Vector3) : void {
}
public function tryToShootWithTarget(param1:int, param2:int, param3:int, param4:Vector3, param5:Tank, param6:Vector3) : void {
}
public function tryToDummyShoot(param1:int, param2:int) : void {
}
public function tryToHit(param1:int, param2:ShellStates, param3:Tank = null) : void {
}
}
}
|
package com.alternativaplatform.projects.tanks.client.models.tank.explosion
{
public interface ITankExplosionModelBase
{
}
}
|
package alternativa.service
{
import flash.display.Stage;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.system.System;
import flash.text.TextField;
import flash.text.TextFormat;
public class ErrorLog
{
private var stage:Stage;
private var btnShowLog:ErrorLogButton;
private var btnCloseLog:ErrorLogButton;
private var btnCopyLog:ErrorLogButton;
private var log:TextField;
private var logStrings:Array;
public function ErrorLog(stage:Stage)
{
this.btnShowLog = new ErrorLogButton("[Click to view log messages]",16776960,16711680);
this.btnCloseLog = new ErrorLogButton("[Close]",65280,0);
this.btnCopyLog = new ErrorLogButton("[Copy to clipboard]",65280,0);
this.logStrings = [];
super();
this.stage = stage;
this.btnShowLog.addEventListener(MouseEvent.CLICK,this.onBtnShowLogClick);
this.btnCloseLog.addEventListener(MouseEvent.CLICK,this.onBtnCloseClick);
this.btnCopyLog.addEventListener(MouseEvent.CLICK,this.onBtnCopyClick);
this.btnCopyLog.x = this.btnCloseLog.width;
this.createLog();
}
public function addLogMessage(logLevel:String, message:String) : void
{
var s:String = "[" + logLevel + "]: " + message;
if(this.log.parent == null)
{
this.logStrings.push(s);
this.stage.addChild(this.btnShowLog);
}
else
{
this.addStringToLog(s);
}
}
private function createLog() : void
{
this.log = new TextField();
this.log.defaultTextFormat = new TextFormat("Tahoma",12,0);
this.log.background = true;
this.log.backgroundColor = 14540253;
this.log.selectable = true;
this.log.multiline = true;
this.log.wordWrap = true;
this.log.mouseWheelEnabled = true;
this.log.y = this.btnCloseLog.height;
}
private function onBtnShowLogClick(e:Event) : void
{
this.stage.removeChild(this.btnShowLog);
var len:int = this.logStrings.length;
for(var i:int = 0; i < len; i++)
{
this.log.appendText(this.logStrings[i] + "\n");
}
this.logStrings.length = 0;
this.stage.addChild(this.log);
this.stage.addChild(this.btnCloseLog);
this.stage.addChild(this.btnCopyLog);
this.onStageResize(null);
this.stage.addEventListener(Event.RESIZE,this.onStageResize);
}
private function addStringToLog(s:String) : void
{
this.log.appendText(s + "\n");
this.log.scrollV = this.log.maxScrollV;
}
private function onStageResize(e:Event) : void
{
this.log.width = this.stage.stageWidth;
this.log.height = this.stage.stageHeight - this.btnCloseLog.height;
}
private function onBtnCloseClick(e:Event) : void
{
this.stage.removeChild(this.log);
this.stage.removeChild(this.btnCloseLog);
this.stage.removeChild(this.btnCopyLog);
this.log.text = "";
this.stage.focus = this.stage;
}
private function onBtnCopyClick(e:Event) : void
{
System.setClipboard(this.log.text);
}
}
}
import flash.display.Sprite;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
class ErrorLogButton extends Sprite
{
private var label:TextField;
function ErrorLogButton(caption:String, fontColor:uint, bgColor:uint)
{
super();
mouseChildren = false;
buttonMode = true;
this.label = new TextField();
this.label.defaultTextFormat = new TextFormat("Tahoma",12,fontColor);
this.label.autoSize = TextFieldAutoSize.LEFT;
this.label.text = caption;
this.label.background = true;
this.label.backgroundColor = bgColor;
addChild(this.label);
}
}
|
package alternativa.tanks.models.weapon.shotgun {
import alternativa.math.Vector3;
import projects.tanks.client.battlefield.models.tankparts.weapons.shotgun.aiming.ShotGunAimingCC;
public class PelletDirectionCalculator {
private static const horizontalVector:Vector3 = new Vector3();
private static const verticalVector:Vector3 = new Vector3();
private var directions:Vector.<Vector3>;
private var result:Vector.<Vector3>;
private var params:ShotGunAimingCC;
private var MAX_X:Number;
private var MAX_Y:Number;
public function PelletDirectionCalculator(param1:ShotGunAimingCC) {
super();
this.MAX_X = Math.tan(param1.coneHorizontalAngle * 0.5);
this.MAX_Y = Math.tan(param1.coneVerticalAngle * 0.5);
this.params = param1;
this.directions = new Vector.<Vector3>(param1.pelletCount,true);
this.result = new Vector.<Vector3>(param1.pelletCount,true);
var local2:int = 0;
while(local2 < this.directions.length) {
this.directions[local2] = new Vector3();
this.result[local2] = new Vector3();
local2++;
}
}
public function next() : void {
var local1:int = 0;
while(local1 < this.directions.length) {
this.nextPelletDirection(this.directions[local1]);
local1++;
}
}
private function nextPelletDirection(param1:Vector3) : void {
var local2:Number = Math.random();
var local3:Number = Math.random() * Math.PI * 2;
param1.x = Math.cos(local3) * local2 * this.MAX_X;
param1.y = Math.sin(local3) * local2 * this.MAX_Y;
}
public function getDirectionsFor(param1:Vector3, param2:Vector3) : Vector.<Vector3> {
var local4:Vector3 = null;
this.calculateOrtho(param1,param2);
var local3:int = 0;
while(local3 < this.directions.length) {
local4 = this.directions[local3];
this.calculateDirection(local4.x,local4.y,param2,this.result[local3]);
local3++;
}
return this.result;
}
private function calculateDirection(param1:Number, param2:Number, param3:Vector3, param4:Vector3) : void {
param4.reset();
param4.addScaled(param1,horizontalVector);
param4.addScaled(param2,verticalVector);
param4.add(param3);
param4.normalize();
}
private function calculateOrtho(param1:Vector3, param2:Vector3) : void {
horizontalVector.copy(param1);
verticalVector.cross2(horizontalVector,param2).normalize();
}
}
}
|
package projects.tanks.client.garage.models.item.relativeproperties {
public class RelativePropertiesCC {
private var _properties:Vector.<RelativeProperty>;
public function RelativePropertiesCC(param1:Vector.<RelativeProperty> = null) {
super();
this._properties = param1;
}
public function get properties() : Vector.<RelativeProperty> {
return this._properties;
}
public function set properties(param1:Vector.<RelativeProperty>) : void {
this._properties = param1;
}
public function toString() : String {
var local1:String = "RelativePropertiesCC [";
local1 += "properties = " + this.properties + " ";
return local1 + "]";
}
}
}
|
package projects.tanks.client.panel.model.garage {
import alternativa.types.Long;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.commons.types.ItemCategoryEnum;
import projects.tanks.client.commons.types.ItemViewCategoryEnum;
public class GarageItemInfo {
private var _category:ItemCategoryEnum;
private var _garageItemId:Long;
private var _item:IGameObject;
private var _itemViewCategory:ItemViewCategoryEnum;
private var _modificationIndex:int;
private var _mounted:Boolean;
private var _name:String;
private var _position:int;
private var _premiumItem:Boolean;
private var _preview:ImageResource;
private var _remaingTimeInMS:int;
public function GarageItemInfo(param1:ItemCategoryEnum = null, param2:Long = null, param3:IGameObject = null, param4:ItemViewCategoryEnum = null, param5:int = 0, param6:Boolean = false, param7:String = null, param8:int = 0, param9:Boolean = false, param10:ImageResource = null, param11:int = 0) {
super();
this._category = param1;
this._garageItemId = param2;
this._item = param3;
this._itemViewCategory = param4;
this._modificationIndex = param5;
this._mounted = param6;
this._name = param7;
this._position = param8;
this._premiumItem = param9;
this._preview = param10;
this._remaingTimeInMS = param11;
}
public function get category() : ItemCategoryEnum {
return this._category;
}
public function set category(param1:ItemCategoryEnum) : void {
this._category = param1;
}
public function get garageItemId() : Long {
return this._garageItemId;
}
public function set garageItemId(param1:Long) : void {
this._garageItemId = param1;
}
public function get item() : IGameObject {
return this._item;
}
public function set item(param1:IGameObject) : void {
this._item = param1;
}
public function get itemViewCategory() : ItemViewCategoryEnum {
return this._itemViewCategory;
}
public function set itemViewCategory(param1:ItemViewCategoryEnum) : void {
this._itemViewCategory = param1;
}
public function get modificationIndex() : int {
return this._modificationIndex;
}
public function set modificationIndex(param1:int) : void {
this._modificationIndex = param1;
}
public function get mounted() : Boolean {
return this._mounted;
}
public function set mounted(param1:Boolean) : void {
this._mounted = param1;
}
public function get name() : String {
return this._name;
}
public function set name(param1:String) : void {
this._name = param1;
}
public function get position() : int {
return this._position;
}
public function set position(param1:int) : void {
this._position = param1;
}
public function get premiumItem() : Boolean {
return this._premiumItem;
}
public function set premiumItem(param1:Boolean) : void {
this._premiumItem = param1;
}
public function get preview() : ImageResource {
return this._preview;
}
public function set preview(param1:ImageResource) : void {
this._preview = param1;
}
public function get remaingTimeInMS() : int {
return this._remaingTimeInMS;
}
public function set remaingTimeInMS(param1:int) : void {
this._remaingTimeInMS = param1;
}
public function toString() : String {
var local1:String = "GarageItemInfo [";
local1 += "category = " + this.category + " ";
local1 += "garageItemId = " + this.garageItemId + " ";
local1 += "item = " + this.item + " ";
local1 += "itemViewCategory = " + this.itemViewCategory + " ";
local1 += "modificationIndex = " + this.modificationIndex + " ";
local1 += "mounted = " + this.mounted + " ";
local1 += "name = " + this.name + " ";
local1 += "position = " + this.position + " ";
local1 += "premiumItem = " + this.premiumItem + " ";
local1 += "preview = " + this.preview + " ";
local1 += "remaingTimeInMS = " + this.remaingTimeInMS + " ";
return local1 + "]";
}
}
}
|
package _codec.projects.tanks.client.battleservice.model.statistics {
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.battleservice.model.statistics.UserStat;
public class VectorCodecUserStatLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecUserStatLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(UserStat,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<UserStat> = new Vector.<UserStat>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = UserStat(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:UserStat = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<UserStat> = Vector.<UserStat>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.sfx
{
public class Blinker
{
private var initialInterval:int;
private var minInterval:int;
private var intervalDecrement:int;
private var maxValue:Number;
private var minValue:Number;
private var speedCoeff:Number;
private var value:Number;
private var speed:Number;
private var valueDelta:Number;
private var switchTime:int;
private var currInterval:int;
public function Blinker(initialInterval:int, minInterval:int, intervalDecrement:int, minValue:Number, maxValue:Number, speedCoeff:Number)
{
super();
this.initialInterval = initialInterval;
this.minInterval = minInterval;
this.intervalDecrement = intervalDecrement;
this.minValue = minValue;
this.maxValue = maxValue;
this.speedCoeff = speedCoeff;
this.valueDelta = maxValue - minValue;
}
public function init(now:int) : void
{
this.value = this.maxValue;
this.currInterval = this.initialInterval;
this.speed = this.getSpeed(-1);
this.switchTime = now + this.currInterval;
}
public function setMaxValue(value:Number) : void
{
if(value < this.minValue)
{
return;
}
this.maxValue = value;
this.valueDelta = this.maxValue - this.minValue;
}
public function setMinValue(value:Number) : void
{
if(value > this.maxValue)
{
return;
}
this.minValue = value;
this.valueDelta = this.maxValue - this.minValue;
}
public function updateValue(now:int, delta:int) : Number
{
this.value += this.speed * delta;
if(this.value > this.maxValue)
{
this.value = this.maxValue;
}
if(this.value < this.minValue)
{
this.value = this.minValue;
}
if(now >= this.switchTime)
{
if(this.currInterval > this.minInterval)
{
this.currInterval -= this.intervalDecrement;
if(this.currInterval < this.minInterval)
{
this.currInterval = this.minInterval;
}
}
this.switchTime = now + this.currInterval;
if(this.speed < 0)
{
this.speed = this.getSpeed(1);
}
else
{
this.speed = this.getSpeed(-1);
}
}
return this.value;
}
private function getSpeed(direction:Number) : Number
{
return direction * this.speedCoeff * this.valueDelta / this.currInterval;
}
}
}
|
package alternativa.gfx.agal
{
import flash.utils.ByteArray;
import flash.utils.Endian;
public class Shader
{
public static const v0:CommonRegister = new CommonRegister(0,4);
public static const v1:CommonRegister = new CommonRegister(1,4);
public static const v2:CommonRegister = new CommonRegister(2,4);
public static const v3:CommonRegister = new CommonRegister(3,4);
public static const v4:CommonRegister = new CommonRegister(4,4);
public static const v5:CommonRegister = new CommonRegister(5,4);
public static const v6:CommonRegister = new CommonRegister(6,4);
public static const v7:CommonRegister = new CommonRegister(7,4);
public static const cc:RelativeRegister = new RelativeRegister(0,1);
protected static const MOV:int = 0;
protected static const ADD:int = 1;
protected static const SUB:int = 2;
protected static const MUL:int = 3;
protected static const DIV:int = 4;
protected static const RCP:int = 5;
protected static const MIN:int = 6;
protected static const MAX:int = 7;
protected static const FRC:int = 8;
protected static const SQT:int = 9;
protected static const RSQ:int = 10;
protected static const POW:int = 11;
protected static const LOG:int = 12;
protected static const EXP:int = 13;
protected static const NRM:int = 14;
protected static const SIN:int = 15;
protected static const COS:int = 16;
protected static const CRS:int = 17;
protected static const DP3:int = 18;
protected static const DP4:int = 19;
protected static const ABS:int = 20;
protected static const NEG:int = 21;
protected static const SAT:int = 22;
protected static const M33:int = 23;
protected static const M44:int = 24;
protected static const M34:int = 25;
protected static const DDX:int = 26;
protected static const DDY:int = 27;
protected static const IFE:int = 28;
protected static const INE:int = 29;
protected static const IFG:int = 30;
protected static const IFL:int = 31;
protected static const ELS:int = 32;
protected static const EIF:int = 33;
protected static const TED:int = 38;
protected static const KIL:int = 39;
protected static const TEX:int = 40;
protected static const SGE:int = 41;
protected static const SLT:int = 42;
protected static const SGN:int = 43;
protected static const SEQ:int = 44;
protected static const SNE:int = 45;
protected var data:ByteArray;
public function Shader()
{
super();
this.data = new ByteArray();
this.data.endian = Endian.LITTLE_ENDIAN;
this.data.writeByte(160);
this.data.writeUnsignedInt(1);
this.data.writeByte(161);
}
public function mov(param1:Register, param2:Register) : void
{
this.op2(MOV,param1,param2);
}
public function add(param1:Register, param2:Register, param3:Register) : void
{
this.op3(ADD,param1,param2,param3);
}
public function sub(param1:Register, param2:Register, param3:Register) : void
{
this.op3(SUB,param1,param2,param3);
}
public function mul(param1:Register, param2:Register, param3:Register) : void
{
this.op3(MUL,param1,param2,param3);
}
public function div(param1:Register, param2:Register, param3:Register) : void
{
this.op3(DIV,param1,param2,param3);
}
public function rcp(param1:Register, param2:Register) : void
{
this.op2(RCP,param1,param2);
}
public function min(param1:Register, param2:Register, param3:Register) : void
{
this.op3(MIN,param1,param2,param3);
}
public function max(param1:Register, param2:Register, param3:Register) : void
{
this.op3(MAX,param1,param2,param3);
}
public function frc(param1:Register, param2:Register) : void
{
this.op2(FRC,param1,param2);
}
public function sqt(param1:Register, param2:Register) : void
{
this.op2(SQT,param1,param2);
}
public function rsq(param1:Register, param2:Register) : void
{
this.op2(RSQ,param1,param2);
}
public function pow(param1:Register, param2:Register, param3:Register) : void
{
this.op3(POW,param1,param2,param3);
}
public function log(param1:Register, param2:Register) : void
{
this.op2(LOG,param1,param2);
}
public function exp(param1:Register, param2:Register) : void
{
this.op2(EXP,param1,param2);
}
public function nrm(param1:Register, param2:Register) : void
{
this.op2(NRM,param1,param2);
}
public function sin(param1:Register, param2:Register) : void
{
this.op2(SIN,param1,param2);
}
public function cos(param1:Register, param2:Register) : void
{
this.op2(COS,param1,param2);
}
public function crs(param1:Register, param2:Register, param3:Register) : void
{
this.op3(CRS,param1,param2,param3);
}
public function dp3(param1:Register, param2:Register, param3:Register) : void
{
this.op3(DP3,param1,param2,param3);
}
public function dp4(param1:Register, param2:Register, param3:Register) : void
{
this.op3(DP4,param1,param2,param3);
}
public function abs(param1:Register, param2:Register) : void
{
this.op2(ABS,param1,param2);
}
public function neg(param1:Register, param2:Register) : void
{
this.op2(NEG,param1,param2);
}
public function sat(param1:Register, param2:Register) : void
{
this.op2(SAT,param1,param2);
}
public function m33(param1:Register, param2:Register, param3:Register) : void
{
this.op3(M33,param1,param2,param3);
}
public function m44(param1:Register, param2:Register, param3:Register) : void
{
this.op3(M44,param1,param2,param3);
}
public function m34(param1:Register, param2:Register, param3:Register) : void
{
this.op3(M34,param1,param2,param3);
}
public function sge(param1:Register, param2:Register, param3:Register) : void
{
this.op3(SGE,param1,param2,param3);
}
public function slt(param1:Register, param2:Register, param3:Register) : void
{
this.op3(SLT,param1,param2,param3);
}
public function sgn(param1:Register, param2:Register, param3:Register) : void
{
this.op3(SGN,param1,param2,param3);
}
public function seq(param1:Register, param2:Register, param3:Register) : void
{
this.op3(SEQ,param1,param2,param3);
}
public function sne(param1:Register, param2:Register, param3:Register) : void
{
this.op3(SNE,param1,param2,param3);
}
protected function op2(param1:int, param2:Register, param3:Register) : void
{
this.data.writeUnsignedInt(param1);
param2.writeDest(this.data);
param3.writeSource(this.data);
this.data.writeUnsignedInt(0);
this.data.writeUnsignedInt(0);
}
protected function op3(param1:int, param2:Register, param3:Register, param4:Register) : void
{
this.data.writeUnsignedInt(param1);
param2.writeDest(this.data);
param3.writeSource(this.data);
param4.writeSource(this.data);
}
public function get agalcode() : ByteArray
{
return this.data;
}
}
}
|
package projects.tanks.client.panel.model.usercountry {
public class UserCountryCC {
private var _countries:Vector.<CountryInfo>;
private var _defaultCountryCode:String;
private var _locationCheckEnabled:Boolean;
public function UserCountryCC(param1:Vector.<CountryInfo> = null, param2:String = null, param3:Boolean = false) {
super();
this._countries = param1;
this._defaultCountryCode = param2;
this._locationCheckEnabled = param3;
}
public function get countries() : Vector.<CountryInfo> {
return this._countries;
}
public function set countries(param1:Vector.<CountryInfo>) : void {
this._countries = param1;
}
public function get defaultCountryCode() : String {
return this._defaultCountryCode;
}
public function set defaultCountryCode(param1:String) : void {
this._defaultCountryCode = param1;
}
public function get locationCheckEnabled() : Boolean {
return this._locationCheckEnabled;
}
public function set locationCheckEnabled(param1:Boolean) : void {
this._locationCheckEnabled = param1;
}
public function toString() : String {
var local1:String = "UserCountryCC [";
local1 += "countries = " + this.countries + " ";
local1 += "defaultCountryCode = " + this.defaultCountryCode + " ";
local1 += "locationCheckEnabled = " + this.locationCheckEnabled + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.sfx {
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
public interface GraphicEffect {
function addedToScene(param1:Scene3DContainer) : void;
function play(param1:int, param2:GameCamera) : Boolean;
function destroy() : void;
function kill() : void;
}
}
|
package alternativa.engine3d.loaders.collada {
import alternativa.engine3d.alternativa3d;
import alternativa.engine3d.animation.AnimationClip;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Vertex;
import alternativa.engine3d.objects.Joint;
import alternativa.engine3d.objects.Skin;
import alternativa.engine3d.objects.VertexBinding;
import flash.utils.Dictionary;
use namespace alternativa3d;
use namespace collada;
public class DaeController extends DaeElement {
private var jointsBindMatrices:Vector.<Vector.<Number>>;
private var vcounts:Array;
private var indices:Array;
private var jointsInput:DaeInput;
private var weightsInput:DaeInput;
private var inputsStride:int;
public function DaeController(param1:XML, param2:DaeDocument) {
super(param1,param2);
}
override protected function parseImplementation() : Boolean {
var local1:XML = data.skin.vertex_weights[0];
if(local1 == null) {
return false;
}
var local2:XML = local1.vcount[0];
if(local2 == null) {
return false;
}
this.vcounts = parseIntsArray(local2);
var local3:XML = local1.v[0];
if(local3 == null) {
return false;
}
this.indices = parseIntsArray(local3);
this.parseInputs();
this.parseJointsBindMatrices();
return true;
}
private function parseInputs() : void {
var local5:DaeInput = null;
var local6:String = null;
var local7:int = 0;
var local1:XMLList = data.skin.vertex_weights.input;
var local2:int = 0;
var local3:int = 0;
var local4:int = int(local1.length());
for(; local3 < local4; local7 = local5.offset,local2 = local7 > local2 ? local7 : local2,local3++) {
local5 = new DaeInput(local1[local3],document);
local6 = local5.semantic;
if(local6 == null) {
continue;
}
switch(local6) {
case "JOINT":
if(this.jointsInput == null) {
this.jointsInput = local5;
}
break;
case "WEIGHT":
if(this.weightsInput == null) {
this.weightsInput = local5;
}
break;
}
}
this.inputsStride = local2 + 1;
}
private function parseJointsBindMatrices() : void {
var jointsXML:XML = null;
var jointsSource:DaeSource = null;
var stride:int = 0;
var count:int = 0;
var i:int = 0;
var index:int = 0;
var matrix:Vector.<Number> = null;
var j:int = 0;
jointsXML = data.skin.joints.input.(@semantic == "INV_BIND_MATRIX")[0];
if(jointsXML != null) {
jointsSource = document.findSource(jointsXML.@source[0]);
if(jointsSource != null) {
if(jointsSource.parse() && jointsSource.numbers != null && jointsSource.stride >= 16) {
stride = jointsSource.stride;
count = jointsSource.numbers.length / stride;
this.jointsBindMatrices = new Vector.<Vector.<Number>>(count);
i = 0;
while(i < count) {
index = stride * i;
matrix = new Vector.<Number>(16);
this.jointsBindMatrices[i] = matrix;
j = 0;
while(j < 16) {
matrix[j] = jointsSource.numbers[int(index + j)];
j++;
}
i++;
}
}
} else {
document.logger.logNotFoundError(jointsXML.@source[0]);
}
}
}
private function get geometry() : DaeGeometry {
var local1:DaeGeometry = document.findGeometry(data.skin.@source[0]);
if(local1 == null) {
document.logger.logNotFoundError(data.@source[0]);
}
return local1;
}
public function parseSkin(param1:Object, param2:Vector.<DaeNode>, param3:Vector.<DaeNode>) : DaeObject {
var local5:Skin = null;
var local6:DaeGeometry = null;
var local7:Vector.<Vertex> = null;
var local8:Vector.<DaeObject> = null;
var local4:XML = data.skin[0];
if(local4 != null) {
local5 = new Skin();
local6 = this.geometry;
if(local6 != null) {
local6.parse();
local7 = local6.fillInMesh(local5,param1);
this.applyBindShapeMatrix(local5);
local8 = this.addJointsToSkin(local5,param2,this.findNodes(param3));
this.setJointsBindMatrices(local8);
this.linkVerticesToJoints(local8,local7);
local5.normalizeWeights();
local6.cleanVertices(local5);
local5.calculateFacesNormals(true);
local5.calculateBounds();
return new DaeObject(local5,this.mergeJointsClips(local5,local8));
}
local5.calculateFacesNormals(true);
local5.calculateBounds();
return new DaeObject(local5);
}
return null;
}
private function mergeJointsClips(param1:Skin, param2:Vector.<DaeObject>) : AnimationClip {
var local7:DaeObject = null;
var local8:AnimationClip = null;
var local9:Object3D = null;
var local10:int = 0;
if(!this.hasJointsAnimation(param2)) {
return null;
}
var local3:AnimationClip = new AnimationClip();
var local4:Array = [param1];
var local5:int = 0;
var local6:int = int(param2.length);
while(local5 < local6) {
local7 = param2[local5];
local8 = local7.animation;
if(local8 != null) {
local10 = 0;
while(local10 < local8.numTracks) {
local3.addTrack(local8.getTrackAt(local10));
local10++;
}
} else {
local3.addTrack(local7.jointNode.createStaticTransformTrack());
}
local9 = local7.object;
local9.name = local7.jointNode.animName;
local4.push(local9);
local5++;
}
local3.alternativa3d::_objects = local4;
return local3;
}
private function hasJointsAnimation(param1:Vector.<DaeObject>) : Boolean {
var local4:DaeObject = null;
var local2:int = 0;
var local3:int = int(param1.length);
while(local2 < local3) {
local4 = param1[local2];
if(local4.animation != null) {
return true;
}
local2++;
}
return false;
}
private function setJointsBindMatrices(param1:Vector.<DaeObject>) : void {
var local4:DaeObject = null;
var local5:Vector.<Number> = null;
var local6:Joint = null;
var local2:int = 0;
var local3:int = int(this.jointsBindMatrices.length);
while(local2 < local3) {
local4 = param1[local2];
local5 = this.jointsBindMatrices[local2];
local6 = local4.object as Joint;
local6.alternativa3d::bma = local5[0];
local6.alternativa3d::bmb = local5[1];
local6.alternativa3d::bmc = local5[2];
local6.alternativa3d::bmd = local5[3];
local6.alternativa3d::bme = local5[4];
local6.alternativa3d::bmf = local5[5];
local6.alternativa3d::bmg = local5[6];
local6.alternativa3d::bmh = local5[7];
local6.alternativa3d::bmi = local5[8];
local6.alternativa3d::bmj = local5[9];
local6.alternativa3d::bmk = local5[10];
local6.alternativa3d::bml = local5[11];
local2++;
}
}
private function linkVertexToJoint(param1:Joint, param2:Vertex, param3:Number) : void {
var local4:VertexBinding = new VertexBinding();
local4.alternativa3d::next = param1.alternativa3d::vertexBindingList;
param1.alternativa3d::vertexBindingList = local4;
local4.alternativa3d::vertex = param2;
local4.alternativa3d::weight = param3;
while(true) {
param2 = param2.alternativa3d::value;
if(param2 == null) {
break;
}
local4 = new VertexBinding();
local4.alternativa3d::next = param1.alternativa3d::vertexBindingList;
param1.alternativa3d::vertexBindingList = local4;
local4.alternativa3d::vertex = param2;
local4.alternativa3d::weight = param3;
}
}
private function linkVerticesToJoints(param1:Vector.<DaeObject>, param2:Vector.<Vertex>) : void {
var local11:Vertex = null;
var local12:int = 0;
var local13:int = 0;
var local14:int = 0;
var local15:int = 0;
var local16:int = 0;
var local17:Number = NaN;
var local3:int = this.jointsInput.offset;
var local4:int = this.weightsInput.offset;
var local5:DaeSource = this.weightsInput.prepareSource(1);
var local6:Vector.<Number> = local5.numbers;
var local7:int = local5.stride;
var local8:int = 0;
var local9:int = 0;
var local10:int = int(param2.length);
while(local9 < local10) {
local11 = param2[local9];
local12 = int(this.vcounts[local9]);
local13 = 0;
while(local13 < local12) {
local14 = this.inputsStride * (local8 + local13);
local15 = int(this.indices[int(local14 + local3)]);
if(local15 >= 0) {
local16 = int(this.indices[int(local14 + local4)]);
local17 = local6[int(local7 * local16)];
this.linkVertexToJoint(Joint(param1[local15].object),local11,local17);
}
local13++;
}
local8 += local12;
local9++;
}
}
private function addJointsToSkin(param1:Skin, param2:Vector.<DaeNode>, param3:Vector.<DaeNode>) : Vector.<DaeObject> {
var local6:int = 0;
var local9:DaeNode = null;
var local10:DaeObject = null;
var local4:Dictionary = new Dictionary();
var local5:int = int(param3.length);
local6 = 0;
while(local6 < local5) {
local4[param3[local6]] = local6;
local6++;
}
var local7:Vector.<DaeObject> = new Vector.<DaeObject>(local5);
var local8:int = int(param2.length);
local6 = 0;
while(local6 < local8) {
local9 = param2[local6];
local10 = this.addRootJointToSkin(param1,local9,local7,local4);
this.addJointChildren(Joint(local10.object),local7,local9,local4);
local6++;
}
return local7;
}
private function addRootJointToSkin(param1:Skin, param2:DaeNode, param3:Vector.<DaeObject>, param4:Dictionary) : DaeObject {
var local5:Joint = new Joint();
local5.name = param2.name;
param1.addJoint(local5);
var local6:DaeObject = param2.applyAnimation(param2.applyTransformations(local5));
local6.jointNode = param2;
if(param2 in param4) {
param3[param4[param2]] = local6;
} else {
param3.push(local6);
}
return local6;
}
private function addJointChildren(param1:Joint, param2:Vector.<DaeObject>, param3:DaeNode, param4:Dictionary) : void {
var local5:DaeObject = null;
var local9:DaeNode = null;
var local10:Joint = null;
var local6:Vector.<DaeNode> = param3.nodes;
var local7:int = 0;
var local8:int = int(local6.length);
while(local7 < local8) {
local9 = local6[local7];
if(local9 in param4) {
local10 = new Joint();
local10.name = local9.name;
local5 = local9.applyAnimation(local9.applyTransformations(local10));
local5.jointNode = local9;
param2[param4[local9]] = local5;
param1.addChild(local10);
this.addJointChildren(local10,param2,local9,param4);
} else if(this.hasJointInDescendants(local9,param4)) {
local10 = new Joint();
local10.name = local9.name;
local5 = local9.applyAnimation(local9.applyTransformations(local10));
local5.jointNode = local9;
param2.push(local5);
param1.addChild(local10);
this.addJointChildren(local10,param2,local9,param4);
}
local7++;
}
}
private function hasJointInDescendants(param1:DaeNode, param2:Dictionary) : Boolean {
var local6:DaeNode = null;
var local3:Vector.<DaeNode> = param1.nodes;
var local4:int = 0;
var local5:int = int(local3.length);
while(local4 < local5) {
local6 = local3[local4];
if(local6 in param2 || this.hasJointInDescendants(local6,param2)) {
return true;
}
local4++;
}
return false;
}
private function applyBindShapeMatrix(param1:Skin) : void {
var local3:Array = null;
var local4:Number = NaN;
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Number = NaN;
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:Vertex = null;
var local17:Number = NaN;
var local18:Number = NaN;
var local19:Number = NaN;
var local2:XML = data.skin.bind_shape_matrix[0];
if(local2 != null) {
local3 = parseNumbersArray(local2);
if(local3.length >= 16) {
local4 = Number(local3[0]);
local5 = Number(local3[1]);
local6 = Number(local3[2]);
local7 = Number(local3[3]);
local8 = Number(local3[4]);
local9 = Number(local3[5]);
local10 = Number(local3[6]);
local11 = Number(local3[7]);
local12 = Number(local3[8]);
local13 = Number(local3[9]);
local14 = Number(local3[10]);
local15 = Number(local3[11]);
local16 = param1.alternativa3d::vertexList;
while(local16 != null) {
local17 = local16.x;
local18 = local16.y;
local19 = local16.z;
local16.x = local4 * local17 + local5 * local18 + local6 * local19 + local7;
local16.y = local8 * local17 + local9 * local18 + local10 * local19 + local11;
local16.z = local12 * local17 + local13 * local18 + local14 * local19 + local15;
local16 = local16.alternativa3d::next;
}
}
}
}
private function isRootJointNode(param1:DaeNode, param2:Dictionary) : Boolean {
var local3:DaeNode = param1.parent;
while(local3 != null) {
if(local3 in param2) {
return false;
}
local3 = local3.parent;
}
return true;
}
public function findRootJointNodes(param1:Vector.<DaeNode>) : Vector.<DaeNode> {
var local5:Dictionary = null;
var local6:Vector.<DaeNode> = null;
var local7:DaeNode = null;
var local2:Vector.<DaeNode> = this.findNodes(param1);
var local3:int = 0;
var local4:int = int(local2.length);
if(local4 > 0) {
local5 = new Dictionary();
local3 = 0;
while(local3 < local4) {
local5[local2[local3]] = local3;
local3++;
}
local6 = new Vector.<DaeNode>();
local3 = 0;
while(local3 < local4) {
local7 = local2[local3];
if(this.isRootJointNode(local7,local5)) {
local6.push(local7);
}
local3++;
}
return local6;
}
return null;
}
private function findNode(param1:String, param2:Vector.<DaeNode>) : DaeNode {
var local5:DaeNode = null;
var local3:int = int(param2.length);
var local4:int = 0;
while(local4 < local3) {
local5 = param2[local4].getNodeBySid(param1);
if(local5 != null) {
return local5;
}
local4++;
}
return null;
}
private function findNodes(param1:Vector.<DaeNode>) : Vector.<DaeNode> {
var jointsXML:XML = null;
var jointsSource:DaeSource = null;
var stride:int = 0;
var count:int = 0;
var nodes:Vector.<DaeNode> = null;
var i:int = 0;
var node:DaeNode = null;
var skeletons:Vector.<DaeNode> = param1;
jointsXML = data.skin.joints.input.(@semantic == "JOINT")[0];
if(jointsXML != null) {
jointsSource = document.findSource(jointsXML.@source[0]);
if(jointsSource != null) {
if(jointsSource.parse() && jointsSource.names != null) {
stride = jointsSource.stride;
count = jointsSource.names.length / stride;
nodes = new Vector.<DaeNode>(count);
i = 0;
while(i < count) {
node = this.findNode(jointsSource.names[int(stride * i)],skeletons);
if(node == null) {
}
nodes[i] = node;
i++;
}
return nodes;
}
} else {
document.logger.logNotFoundError(jointsXML.@source[0]);
}
}
return null;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.friend.battleinvite {
import alternativa.types.Long;
import flash.events.EventDispatcher;
import projects.tanks.client.commons.models.layout.LayoutState;
import projects.tanks.client.tanksservices.types.battle.BattleInfoData;
import projects.tanks.clients.fp10.libraries.tanksservices.model.friends.FriendState;
import projects.tanks.clients.fp10.libraries.tanksservices.service.battle.IBattleInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.layout.ILobbyLayoutService;
public class BattleInviteService extends EventDispatcher implements IBattleInviteService {
[Inject]
public static var friendInfoService:IFriendInfoService;
[Inject]
public static var battleInfoService:IBattleInfoService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var lobbyLayoutService:ILobbyLayoutService;
private var _receiveBattleInvite:Boolean;
public function BattleInviteService() {
super();
}
public function getAvailabilityInviteBattle(param1:Long) : Boolean {
var local2:Boolean = lobbyLayoutService.getCurrentState() == LayoutState.BATTLE ? battleInfoService.hasCurrentBattleId() : battleInfoService.hasCurrentSelectionBattleId();
return local2 && (friendInfoService.isFriendsInState(param1,FriendState.ACCEPTED) || Boolean(clanUserInfoService.inSameClan(param1)));
}
public function invite(param1:Long) : void {
dispatchEvent(new BattleInviteServiceEvent(BattleInviteServiceEvent.INVITE,param1));
}
public function accept(param1:Long, param2:BattleInfoData) : void {
var local3:BattleInviteServiceEvent = new BattleInviteServiceEvent(BattleInviteServiceEvent.ACCEPT,param1);
local3.battleData = param2;
dispatchEvent(local3);
}
public function reject(param1:Long) : void {
dispatchEvent(new BattleInviteServiceEvent(BattleInviteServiceEvent.REJECT,param1));
}
public function get receiveBattleInvite() : Boolean {
return this._receiveBattleInvite;
}
public function set receiveBattleInvite(param1:Boolean) : void {
if(this._receiveBattleInvite != param1) {
dispatchEvent(new BattleInviteEnableEvent(BattleInviteEnableEvent.UPDATE,param1));
}
this._receiveBattleInvite = param1;
}
public function removeInvite(param1:Long) : void {
dispatchEvent(new BattleInviteServiceEvent(BattleInviteServiceEvent.REMOVE_INVITE,param1));
}
}
}
|
package alternativa.tanks.models.battle.assault {
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.RayIntersectionData;
import alternativa.math.Matrix4;
import alternativa.math.Vector3;
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.BattleView;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.models.battle.commonflag.Flag;
import alternativa.tanks.models.battle.ctf.*;
import alternativa.tanks.models.battle.gui.markers.PointHudIndicator;
import flash.utils.Dictionary;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class AssaultHudIndicators implements Renderer {
[Inject]
public static var battleService:BattleService;
private static var emptyBase:Class = AssaultHudIndicators_emptyBase;
private static var flagAssault:Class = AssaultHudIndicators_flagAssault;
private static const m:Matrix4 = new Matrix4();
private static const m1:Matrix4 = new Matrix4();
private static const v:Vector3 = new Vector3();
private static const pointPosition:Vector3 = new Vector3();
private static const cameraPosition:Vector3 = new Vector3();
private static const direction:Vector3 = new Vector3();
private static const NEAR_MARKER_DISTANCE:Number = 6600;
private static const FAR_MARKER_DISTANCE:Number = 7000;
private var redMarkers:Dictionary = new Dictionary();
private var redBaseMarkers:Dictionary = new Dictionary();
private var markers:Array = [];
private var camera:Camera3D;
private var localTeam:BattleTeam;
public function AssaultHudIndicators() {
super();
this.camera = battleService.getBattleScene3D().getCamera();
}
private static function getPerspectiveScale(param1:Camera3D, param2:Vector3) : Number {
var local3:Number = Math.cos(param1.rotationX);
var local4:Number = Math.sin(param1.rotationX);
var local5:Number = Math.cos(param1.rotationY);
var local6:Number = Math.sin(param1.rotationY);
var local7:Number = Math.cos(param1.rotationZ);
var local8:Number = Math.sin(param1.rotationZ);
var local9:Number = local7 * local6 * local3 + local8 * local4;
var local10:Number = -local7 * local4 + local6 * local8 * local3;
var local11:Number = local5 * local3;
var local12:Number = -local9 * param1.x - local10 * param1.y - local11 * param1.z;
var local13:Number = param1.view.width * 0.5;
var local14:Number = param1.view.height * 0.5;
var local15:Number = Math.sqrt(local13 * local13 + local14 * local14) / Math.tan(param1.fov * 0.5);
var local16:Number = local9 * param2.x + local10 * param2.y + local11 * param2.z + local12;
return local15 / local16;
}
private static function composeObject3DMatrix(param1:Object3D) : Matrix4 {
var local13:Number = NaN;
var local14:Number = NaN;
var local2:Number = Math.cos(param1.rotationX);
var local3:Number = Math.sin(param1.rotationX);
var local4:Number = Math.cos(param1.rotationY);
var local5:Number = Math.sin(param1.rotationY);
var local6:Number = Math.cos(param1.rotationZ);
var local7:Number = Math.sin(param1.rotationZ);
var local8:Number = local6 * local5;
var local9:Number = local7 * local5;
var local10:Number = local4 * param1.scaleX;
var local11:Number = local3 * param1.scaleY;
var local12:Number = local2 * param1.scaleY;
local13 = local2 * param1.scaleZ;
local14 = local3 * param1.scaleZ;
m1.m00 = local6 * local10;
m1.m01 = local8 * local11 - local7 * local12;
m1.m02 = local8 * local13 + local7 * local14;
m1.m03 = param1.x;
m1.m10 = local7 * local10;
m1.m11 = local9 * local11 + local6 * local12;
m1.m12 = local9 * local13 - local6 * local14;
m1.m13 = param1.y;
m1.m20 = -local5 * param1.scaleX;
m1.m21 = local4 * local11;
m1.m22 = local4 * local13;
m1.m23 = param1.z;
return m1;
}
public function addRedFlag(param1:int, param2:Flag) : void {
var local3:PointHudIndicator = new PointHudIndicator(new flagAssault(),param2,null,new flagAssault());
this.redMarkers[param1] = local3;
battleService.getBattleView().addOverlayObject(local3);
this.markers.push(local3);
}
public function addRedBase(param1:int, param2:Object3D) : void {
var local3:PointHudIndicator = this.redMarkers[param1];
var local4:PointHudIndicator = new PointHudIndicator(new emptyBase(),new BaseIndicatorStateProvider(new Vector3(param2.x,param2.y,param2.z),local3));
local4.visibleToBlue = false;
this.redBaseMarkers[param1] = local4;
battleService.getBattleView().addOverlayObject(local4);
this.markers.push(local4);
}
public function setLocalTeam(param1:BattleTeam) : void {
this.localTeam = param1;
}
public function setFlagState(param1:int, param2:int) : void {
this.redMarkers[param1].setState(param2);
}
public function render(param1:int, param2:int) : void {
var local4:PointHudIndicator = null;
var local5:PointHudIndicator = null;
var local3:Matrix4 = this.calculateProjectionMatrix();
for each(local4 in this.redBaseMarkers) {
this.updateMarker(local3,local4);
}
for each(local5 in this.redMarkers) {
this.updateMarker(local3,local5);
}
this.sortChildren();
}
private function sortChildren() : void {
var local1:PointHudIndicator = null;
this.markers.sortOn("zindex",Array.DESCENDING | Array.NUMERIC);
for each(local1 in this.markers) {
battleService.getBattleView().addOverlayObject(local1);
}
}
private function updateMarker(param1:Matrix4, param2:PointHudIndicator) : void {
var local7:Number = NaN;
if(!param2.isActive(this.camera) || !param2.visibleFor(this.localTeam)) {
param2.visible = false;
return;
}
param2.readPosition3D(v);
v.transform4(param1);
this.projectToView(v);
var local3:Number = 15;
var local4:Number = this.getMarginY();
var local5:Boolean = this.isPointInsideViewport(v.x,v.y,local3,local4);
if(v.z > 0 && local5) {
local7 = this.getPointAlpha(param2);
if(local7 == 0) {
param2.visible = false;
param2.alpha = 0;
} else {
param2.visible = true;
param2.alpha = local7;
}
} else {
param2.alpha = 1;
param2.visible = false;
}
var local6:BattleView = battleService.getBattleView();
param2.x = int(v.x + local6.getWidth() / 2 - 12);
param2.y = int(v.y + local6.getHeight() / 2 - 12);
param2.zindex = this.getDistanceToCamera(param2);
}
private function getDistanceToCamera(param1:PointHudIndicator) : Number {
param1.readPosition3D(pointPosition);
cameraPosition.reset(this.camera.x,this.camera.y,this.camera.z);
direction.diff(pointPosition,cameraPosition);
return direction.length();
}
private function getPointAlpha(param1:PointHudIndicator) : Number {
var local2:Number = NaN;
param1.readPosition3D(pointPosition);
cameraPosition.reset(this.camera.x,this.camera.y,this.camera.z);
direction.diff(pointPosition,cameraPosition);
var local3:Number = direction.length();
direction.normalize();
var local4:RayIntersectionData = battleService.getBattleScene3D().raycast(cameraPosition,direction,battleService.getExcludedObjects3D());
var local5:Number = pointPosition.distanceTo(cameraPosition);
if(local5 < NEAR_MARKER_DISTANCE) {
local2 = 0;
} else if(local5 > FAR_MARKER_DISTANCE) {
local2 = 1;
} else {
local2 = (local5 - NEAR_MARKER_DISTANCE) / (FAR_MARKER_DISTANCE - NEAR_MARKER_DISTANCE);
}
return local2;
}
private function getMarginY() : int {
switch(battleService.getBattleView().getScreenSize()) {
case BattleView.MAX_SCREEN_SIZE:
return 70;
case BattleView.MAX_SCREEN_SIZE - 1:
return 40;
default:
return 15;
}
}
private function isPointInsideViewport(param1:Number, param2:Number, param3:Number, param4:Number) : Boolean {
var local5:BattleView = battleService.getBattleView();
var local6:Number = local5.getWidth() / 2 - param3;
var local7:Number = local5.getHeight() / 2 - param4;
return param1 >= -local6 && param1 <= local6 && param2 >= -local7 && param2 <= local7;
}
private function projectToView(param1:Vector3) : void {
var local2:Number = NaN;
var local3:Number = NaN;
if(param1.z > 0.001) {
param1.x = param1.x * this.camera.viewSizeX / param1.z;
param1.y = param1.y * this.camera.viewSizeY / param1.z;
} else if(param1.z < -0.001) {
param1.x = -param1.x * this.camera.viewSizeX / param1.z;
param1.y = -param1.y * this.camera.viewSizeY / param1.z;
} else {
local2 = Number(battleService.getBattleView().getDiagonalSquared());
local3 = Math.sqrt(param1.x * param1.x + param1.y * param1.y);
param1.x *= local2 / local3;
param1.y *= local2 / local3;
}
}
private function calculateProjectionMatrix() : Matrix4 {
var local5:Number = NaN;
var local6:Number = NaN;
var local7:Number = NaN;
var local8:Number = NaN;
var local10:Number = NaN;
var local12:Number = NaN;
var local14:Number = NaN;
var local1:Number = this.camera.viewSizeX / this.camera.focalLength;
var local2:Number = this.camera.viewSizeY / this.camera.focalLength;
var local3:Number = Math.cos(this.camera.rotationX);
var local4:Number = Math.sin(this.camera.rotationX);
local5 = Math.cos(this.camera.rotationY);
local6 = Math.sin(this.camera.rotationY);
local7 = Math.cos(this.camera.rotationZ);
local8 = Math.sin(this.camera.rotationZ);
var local9:Number = local7 * local6;
local10 = local8 * local6;
var local11:Number = local5 * this.camera.scaleX;
local12 = local4 * this.camera.scaleY;
var local13:Number = local3 * this.camera.scaleY;
local14 = local3 * this.camera.scaleZ;
var local15:Number = local4 * this.camera.scaleZ;
m.m00 = local7 * local11 * local1;
m.m01 = (local9 * local12 - local8 * local13) * local2;
m.m02 = local9 * local14 + local8 * local15;
m.m03 = this.camera.x;
m.m10 = local8 * local11 * local1;
m.m11 = (local10 * local12 + local7 * local13) * local2;
m.m12 = local10 * local14 - local7 * local15;
m.m13 = this.camera.y;
m.m20 = -local6 * this.camera.scaleX * local1;
m.m21 = local5 * local12 * local2;
m.m22 = local5 * local14;
m.m23 = this.camera.z;
var local16:Object3D = this.camera;
while(local16.parent != null) {
local16 = local16.parent;
m.append(composeObject3DMatrix(local16));
}
m.invert();
return m;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.userproperties {
import alternativa.types.Long;
import flash.events.EventDispatcher;
import platform.clients.fp10.libraries.alternativapartners.service.IPartnerService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.rank.RankService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.UidUtil;
public class UserPropertiesService extends EventDispatcher implements IUserPropertiesService {
[Inject]
public static var partnerService:IPartnerService;
[Inject]
public static var rankService:RankService;
private var _userId:Long;
private var _userName:String;
private var _score:int;
private var _rank:int;
private var _userProfileUrl:String;
private var _registrationTimestamp:int;
private var _hasSpectatorPermissions:Boolean;
private var _canUseGroup:Boolean;
private var inited:Boolean;
public function UserPropertiesService() {
super();
}
public function isInited() : Boolean {
return this.inited;
}
public function get userId() : Long {
return this._userId;
}
public function get userName() : String {
return this._userName;
}
public function set userName(param1:String) : void {
this._userName = param1;
}
public function get rank() : int {
return rankService.getNormalizedRankIndex(this._rank);
}
public function get fullRank() : int {
return this._rank;
}
public function get score() : int {
return this._score;
}
public function getUserProfileUrl(param1:String) : String {
return this._userProfileUrl + UidUtil.userNameWithoutClanTag(param1) + (!!partnerService.hasRatings() ? "?partners=1" : "");
}
public function get registrationTimestamp() : int {
return this._registrationTimestamp;
}
public function updateRank(param1:int) : void {
this._rank = param1;
dispatchEvent(new UserPropertiesServiceEvent(UserPropertiesServiceEvent.UPDATE_RANK,new UserProperties(this._userId,this._userName,this._score,this._rank)));
}
public function updateCanUseGroup(param1:Boolean) : void {
this._canUseGroup = param1;
}
public function updateScore(param1:int) : void {
this._score = param1;
dispatchEvent(new UserPropertiesServiceEvent(UserPropertiesServiceEvent.UPDATE_SCORE,new UserProperties(this._userId,this._userName,this._score,this._rank)));
}
public function init(param1:Long, param2:String, param3:int, param4:int, param5:String, param6:int, param7:Boolean, param8:Boolean) : void {
this._userId = param1;
this._userName = param2;
this._score = param3;
this._rank = param4;
this._userProfileUrl = param5;
this._registrationTimestamp = param6;
this._hasSpectatorPermissions = param7;
this._canUseGroup = param8;
this.inited = true;
dispatchEvent(new UserPropertiesServiceEvent(UserPropertiesServiceEvent.ON_INIT_USER_PROPERTIES));
}
public function initRank(param1:int) : void {
this._rank = param1;
}
public function hasSpectatorPermissions() : Boolean {
return this._hasSpectatorPermissions;
}
public function canUseGroup() : Boolean {
return this._canUseGroup;
}
public function isQuestsAvailableByRank() : Boolean {
return this._rank >= 0;
}
}
}
|
package projects.tanks.clients.flash.resources.tanks {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.core.Object3DContainer;
import alternativa.engine3d.core.Sorting;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.tanks.materials.AnimatedPaintMaterial;
import alternativa.tanks.materials.PaintMaterial;
import flash.display.BitmapData;
import flash.geom.ColorTransform;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
public class Tank3D extends Object3DContainer {
private static var defaultColormap:BitmapData;
public static const EXCLUDED:RegExp = /(box.*|fmnt.*|muzzle.*|laser|rocket)/i;
public static const TANK_PART:String = "tankPart";
private static const HULL_PART:int = 0;
private static const TURRET_PART:int = 1;
private var hullResource:Tanks3DSResource;
private var turretResource:Tanks3DSResource;
private var hull:Mesh;
private var turret:MeshContainer;
private var colormap:BitmapData;
private var materials:Vector.<TextureMaterial> = new Vector.<TextureMaterial>(2);
private var multiframeImageResource:MultiframeTextureResource;
public function Tank3D() {
super();
}
private static function getDefaultColorMap() : BitmapData {
if(defaultColormap == null) {
defaultColormap = new BitmapData(1,1,false,6710886);
}
return defaultColormap;
}
public static function cloneMesh(param1:Mesh) : Mesh {
var local2:Mesh = Mesh(param1.clone());
local2.name = TANK_PART;
local2.colorTransform = new ColorTransform();
local2.shadowMapAlphaThreshold = 0.1;
local2.calculateVerticesNormalsBySmoothingGroups(0.01);
return local2;
}
public function setColorMap(param1:BitmapData) : void {
this.multiframeImageResource = null;
this.destroyMaterials();
this.colormap = param1 != null ? param1 : getDefaultColorMap();
this.updateTurretTexture(this.turretResource,this.turret);
this.updatePartTexture(this.hullResource,this.hull,HULL_PART);
}
public function setTextureAnimation(param1:MultiframeTextureResource) : void {
this.colormap = null;
this.destroyMaterials();
this.multiframeImageResource = param1;
this.updateTurretTexture(this.turretResource,this.turret);
this.updatePartTexture(this.hullResource,this.hull,HULL_PART);
}
public function setHull(param1:Tanks3DSResource) : void {
if(this.hull != null) {
this.hull.setMaterialToAllFaces(null);
removeChild(this.hull);
}
if(param1 == null) {
return;
}
this.hullResource = param1;
this.hull = this.initMesh(cloneMesh(param1.objects[0] as Mesh));
addChild(this.hull);
if(this.turret != null) {
addChild(this.turret);
}
this.hull.x = 0;
this.hull.y = 0;
this.hull.z = 0;
this.updatePartTexture(param1,this.hull,HULL_PART);
this.updateMountPoint();
}
public function setTurret(param1:Tanks3DSResource) : void {
var local2:Mesh = null;
if(this.turret != null) {
for each(local2 in this.turret.getMeshes()) {
local2.setMaterialToAllFaces(null);
}
removeChild(this.turret);
}
if(param1 == null) {
return;
}
this.turretResource = param1;
this.turret = new MeshContainer();
this.turret.setMeshes(this.getMeshes(param1));
addChild(this.turret);
this.updateTurretTexture(param1,this.turret);
this.updateMountPoint();
}
private function getMeshes(param1:Tanks3DSResource) : Vector.<Mesh> {
var local3:Object3D = null;
var local2:Vector.<Mesh> = new Vector.<Mesh>();
for each(local3 in param1.objects) {
if(local3 is Mesh && !EXCLUDED.test(local3.name)) {
local2.push(this.initMesh(cloneMesh(local3 as Mesh)));
}
}
return local2;
}
private function updateTurretTexture(param1:Tanks3DSResource, param2:MeshContainer) : void {
if(param2 == null) {
return;
}
var local3:Vector.<Mesh> = param2.getMeshes();
var local4:TextureMaterial = this.updatePartTexture(param1,local3[0],TURRET_PART);
var local5:int = 1;
while(local5 < local3.length) {
local3[local5].setMaterialToAllFaces(local4);
local5++;
}
}
private function updatePartTexture(param1:Tanks3DSResource, param2:Mesh, param3:int) : TextureMaterial {
var local4:TextureMaterial = null;
if(param1 == null || param2 == null || this.colormap == null && this.multiframeImageResource == null) {
return null;
}
if(this.multiframeImageResource != null) {
local4 = this.createAnimatedTexture(param1,param3);
} else {
local4 = this.createTexture(param1,param3);
}
param2.setMaterialToAllFaces(local4);
return local4;
}
private function createAnimatedTexture(param1:Tanks3DSResource, param2:int) : TextureMaterial {
var local3:BitmapData = param1.textures["lightmap.jpg"];
var local4:BitmapData = param1.textures["details.png"];
var local5:int = this.multiframeImageResource.data.width / this.multiframeImageResource.frameWidth;
var local6:int = this.multiframeImageResource.data.height / this.multiframeImageResource.frameHeight;
var local7:AnimatedPaintMaterial = new AnimatedPaintMaterial(this.multiframeImageResource.data,local3,local4,local5,local6,this.multiframeImageResource.fps,this.multiframeImageResource.numFrames);
if(this.materials[param2] != null) {
this.materials[param2].dispose();
}
this.materials[param2] = local7;
return local7;
}
private function createTexture(param1:Tanks3DSResource, param2:int) : TextureMaterial {
var local3:BitmapData = param1.textures["lightmap.jpg"];
var local4:BitmapData = param1.textures["details.png"];
var local5:TextureMaterial = new PaintMaterial(this.colormap,local3,local4);
if(this.materials[param2] != null) {
this.materials[param2].dispose();
}
this.materials[param2] = local5;
return local5;
}
private function updateMountPoint() : void {
if(this.hull == null || this.turret == null) {
return;
}
var local1:Object3D = this.hullResource.getObjectsByName(/mount/i)[0];
this.turret.x = local1.x;
this.turret.y = local1.y;
this.turret.z = local1.z;
}
public function getMountPointX() : Number {
return this.turret == null ? 0 : Number(this.turret.x);
}
public function getMountPointY() : Number {
return this.turret == null ? 0 : Number(this.turret.y);
}
public function getMountPointZ() : Number {
return this.turret == null ? 0 : Number(this.turret.z);
}
public function destroy() : void {
this.destroyMaterials();
this.materials = null;
this.multiframeImageResource = null;
this.hull = null;
this.turret = null;
this.colormap = null;
this.hullResource = null;
this.turretResource = null;
}
private function destroyMaterials() : void {
if(this.materials[HULL_PART] != null) {
this.materials[HULL_PART].dispose();
this.materials[HULL_PART] = null;
}
if(this.materials[TURRET_PART] != null) {
this.materials[TURRET_PART].dispose();
this.materials[TURRET_PART] = null;
}
}
protected function initMesh(param1:Mesh) : Mesh {
if(param1.sorting != Sorting.DYNAMIC_BSP) {
param1.sorting = Sorting.DYNAMIC_BSP;
param1.calculateFacesNormals(true);
param1.optimizeForDynamicBSP();
param1.threshold = 0.01;
}
return param1;
}
}
}
|
package alternativa.init
{
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.service.IModelService;
import alternativa.tanks.locale.constants.TextConst;
import alternativa.tanks.locale.model.LocaleModel;
public class TanksLocaleActivator implements IBundleActivator
{
public static var osgi:OSGi;
private var localeModel:LocaleModel;
public function TanksLocaleActivator()
{
super();
}
public function start(osgi:OSGi) : void
{
TanksLocaleActivator.osgi = osgi;
var modelRegister:IModelService = osgi.getService(IModelService) as IModelService;
this.localeModel = new LocaleModel();
modelRegister.add(this.localeModel);
TextConst.init(osgi.getService(ILocaleService) as ILocaleService);
}
public function stop(osgi:OSGi) : void
{
var modelRegister:IModelService = osgi.getService(IModelService) as IModelService;
modelRegister.remove(this.localeModel.id);
this.localeModel = null;
TanksLocaleActivator.osgi = null;
}
}
}
|
package alternativa.tanks.models.weapon.gauss.state {
import alternativa.tanks.models.weapon.gauss.GaussEventType;
import alternativa.tanks.models.weapon.gauss.LocalGaussWeapon;
public class StunnedState implements IGaussState {
private var weapon:LocalGaussWeapon;
public function StunnedState(param1:LocalGaussWeapon) {
super();
this.weapon = param1;
}
public function enter(param1:int, param2:GaussEventType, param3:*) : void {
this.weapon.weaponStatus = 1;
}
public function update(param1:int, param2:int) : void {
}
}
}
|
package alternativa.tanks.camera {
public interface CameraController {
function deactivate() : void;
function activate(param1:GameCamera) : void;
function update(param1:GameCamera, param2:int, param3:int) : void;
}
}
|
package _codec.projects.tanks.client.commons.models.layout {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.EnumCodecInfo;
import projects.tanks.client.commons.models.layout.LayoutState;
public class VectorCodecLayoutStateLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecLayoutStateLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new EnumCodecInfo(LayoutState,false));
if(this.optionalElement) {
this.elementCodec = new OptionalCodecDecorator(this.elementCodec);
}
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:int = LengthCodecHelper.decodeLength(param1);
var local3:Vector.<LayoutState> = new Vector.<LayoutState>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = LayoutState(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:LayoutState = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<LayoutState> = Vector.<LayoutState>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.controller.commands.goto_ {
import alternativa.tanks.controller.events.GetNewCaptchaEvent;
import alternativa.tanks.controller.events.showform.ShowRegistrationFormEvent;
import alternativa.tanks.model.EntranceServerParamsModel;
import alternativa.tanks.model.EntranceUrlParamsModel;
import alternativa.tanks.model.RegistrationBackgroundModel;
import alternativa.tanks.service.IEntranceServerFacade;
import alternativa.tanks.tracker.ITrackerService;
import flash.display.Bitmap;
import org.robotlegs.mvcs.Command;
import projects.tanks.client.commons.models.captcha.CaptchaLocation;
public class GoToRegistrationCommand extends Command {
[Inject]
public var backgroundModel:RegistrationBackgroundModel;
[Inject]
public var serverParams:EntranceServerParamsModel;
[Inject]
public var paramsModel:EntranceUrlParamsModel;
[Inject]
public var serverFacade:IEntranceServerFacade;
[Inject]
public var trackerService:ITrackerService;
public function GoToRegistrationCommand() {
super();
}
override public function execute() : void {
var local1:Bitmap = this.backgroundModel.backgroundImage;
dispatch(new ShowRegistrationFormEvent(local1,this.serverParams.antiAddictionEnabled,this.serverParams.registrationCaptchaEnabled,this.serverParams.skipRegistrationEnabled,this.paramsModel.tutorialHash == null,this.serverParams.registrationThroughEmail));
this.trackerService.trackEvent("entrance","showRegistrationForm","");
if(this.serverParams.registrationCaptchaEnabled) {
dispatch(new GetNewCaptchaEvent(CaptchaLocation.REGISTER_FORM));
}
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.logging.payment {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.tanksservices.model.logging.payment.PaymentAction;
public class CodecPaymentAction implements ICodec {
public function CodecPaymentAction() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:PaymentAction = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = PaymentAction.OPEN_PAYMENT;
break;
case 1:
local2 = PaymentAction.COUNTRY_SELECT;
break;
case 2:
local2 = PaymentAction.MODE_CHOOSE;
break;
case 3:
local2 = PaymentAction.ITEM_CHOOSE;
break;
case 4:
local2 = PaymentAction.CLOSE_PAYMENT;
break;
case 5:
local2 = PaymentAction.PROCEED;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package com.alternativaplatform.projects.tanks.client.warfare.models.sfx.shoot.thunder
{
import scpacker.Base;
public class ThunderShootSFXModelBase extends Base
{
public function ThunderShootSFXModelBase()
{
super();
}
}
}
|
package alternativa.tanks.view.mainview.groupinvite {
import alternativa.tanks.gui.friends.list.dataprovider.FriendsDataProvider;
import alternativa.tanks.service.socialnetwork.vk.SNFriendsService;
import alternativa.tanks.service.socialnetwork.vk.SNFriendsServiceData;
import alternativa.tanks.service.socialnetwork.vk.SNFriendsServiceEvent;
import alternativa.types.Long;
import fl.controls.List;
import flash.display.Sprite;
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.battle.BattleLinkData;
import projects.tanks.clients.fp10.libraries.tanksservices.model.notifier.online.ClientOnlineNotifierData;
import projects.tanks.clients.fp10.libraries.tanksservices.service.friend.IFriendInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.matchmakinggroup.MatchmakingGroupService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.battle.IBattleNotifierService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.battle.LeaveBattleNotifierServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.battle.SetBattleNotifierServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.online.IOnlineNotifierService;
import projects.tanks.clients.fp10.libraries.tanksservices.service.notifier.online.OnlineNotifierServiceEvent;
import utils.ScrollStyleUtils;
public class InviteToGroupList extends Sprite {
[Inject]
public static var friendInfoService:IFriendInfoService;
[Inject]
public static var onlineNotifierService:IOnlineNotifierService;
[Inject]
public static var battleNotifierService:IBattleNotifierService;
[Inject]
public static var snFriendsService:SNFriendsService;
[Inject]
public static var matchmakingGroupService:MatchmakingGroupService;
protected var header:InviteHeader;
protected var list:List;
protected var dataProvider:FriendsDataProvider;
protected var listWidth:Number;
protected var listHeight:Number;
public function InviteToGroupList() {
super();
this.header = new InviteHeader();
addChild(this.header);
this.dataProvider = new FriendsDataProvider();
this.dataProvider.sortOn([FriendsDataProvider.ONLINE,FriendsDataProvider.UID],[Array.NUMERIC | Array.DESCENDING,Array.CASEINSENSITIVE]);
this.list = new List();
this.list.rowHeight = 20;
this.list.setStyle("cellRenderer",GroupInviteListRenderer);
this.list.focusEnabled = true;
this.list.selectable = false;
this.list.dataProvider = this.dataProvider;
ScrollStyleUtils.setGreenStyle(this.list);
addChild(this.list);
}
protected function onInviteUser(param1:InviteUserEvent) : void {
matchmakingGroupService.inviteUserToGroup(param1.getUserId());
}
public function init() : void {
this.list.addEventListener(InviteUserEvent.TYPE,this.onInviteUser);
snFriendsService.addEventListener(SNFriendsServiceEvent.GET_FRIENDS_COMPLETED,this.onGetFriends);
onlineNotifierService.addEventListener(OnlineNotifierServiceEvent.SET_ONLINE,this.onSetOnline);
battleNotifierService.addEventListener(SetBattleNotifierServiceEvent.SET_BATTLE,this.onSetBattle);
battleNotifierService.addEventListener(LeaveBattleNotifierServiceEvent.LEAVE,this.onLeaveBattle);
snFriendsService.requestFriends();
}
private function onGetFriends(param1:SNFriendsServiceEvent) : void {
var local4:Object = null;
var local2:SNFriendsServiceData = param1.getResult();
var local3:int = 0;
while(local3 < this.dataProvider.length) {
local4 = this.dataProvider.getItemAt(local3);
if(local4.snUid != "") {
this.dataProvider.setPropertiesById(local4.id,"isSNFriend",local2.areFriends(local4.snUid));
}
local3++;
}
}
public function resize(param1:Number, param2:Number) : void {
this.listWidth = param1;
this.listHeight = param2;
this.header.width = this.listWidth;
this.list.y = 20;
var local3:Boolean = this.list.verticalScrollBar.visible;
this.list.width = local3 ? this.listWidth + 6 : this.listWidth;
this.list.height = this.listHeight - 20;
}
public function filter(param1:String, param2:String) : void {
this.filterByProperty(param1,param2);
}
protected function onSetOnline(param1:OnlineNotifierServiceEvent) : void {
var local6:int = 0;
var local2:Boolean = false;
var local3:Vector.<ClientOnlineNotifierData> = param1.users;
var local4:int = int(local3.length);
var local5:int = 0;
while(local5 < local4) {
local6 = this.dataProvider.setOnlineUser(local3[local5],false);
local2 ||= local6 != -1;
local5++;
}
if(local2) {
this.dataProvider.reSort();
}
}
protected function onSetBattle(param1:SetBattleNotifierServiceEvent) : void {
var local6:int = 0;
var local2:Boolean = false;
var local3:Vector.<BattleLinkData> = param1.users;
var local4:int = int(local3.length);
var local5:int = 0;
while(local5 < local4) {
local6 = this.dataProvider.setBattleUser(local3[local5],false);
local2 ||= local6 != -1;
local5++;
}
if(local2 > 0) {
this.dataProvider.reSort();
}
}
protected function onLeaveBattle(param1:LeaveBattleNotifierServiceEvent) : void {
this.dataProvider.clearBattleUser(param1.userId);
}
protected function filterByProperty(param1:String, param2:String) : void {
this.dataProvider.setFilter(param1,param2);
this.resize(this.listWidth,this.listHeight);
}
public function hide() : void {
this.list.removeEventListener(InviteUserEvent.TYPE,this.onInviteUser);
snFriendsService.removeEventListener(SNFriendsServiceEvent.GET_FRIENDS_COMPLETED,this.onGetFriends);
onlineNotifierService.removeEventListener(OnlineNotifierServiceEvent.SET_ONLINE,this.onSetOnline);
battleNotifierService.removeEventListener(SetBattleNotifierServiceEvent.SET_BATTLE,this.onSetBattle);
battleNotifierService.removeEventListener(LeaveBattleNotifierServiceEvent.LEAVE,this.onLeaveBattle);
if(parent != null && parent.contains(this)) {
parent.removeChild(this);
this.dataProvider.removeAll();
}
}
public function fillList(param1:Vector.<Long>) : void {
var local2:Long = null;
this.dataProvider.removeAll();
this.dataProvider.resetFilter(false);
for each(local2 in param1) {
this.dataProvider.addUser(local2,false);
}
this.dataProvider.refresh();
}
public function removeUser(param1:Long) : void {
this.dataProvider.removeUser(param1);
}
}
}
|
package projects.tanks.client.garage.models.item.present {
import platform.client.fp10.core.resource.types.ImageResource;
public class PresentItemCC {
private var _image:ImageResource;
public function PresentItemCC(param1:ImageResource = null) {
super();
this._image = param1;
}
public function get image() : ImageResource {
return this._image;
}
public function set image(param1:ImageResource) : void {
this._image = param1;
}
public function toString() : String {
var local1:String = "PresentItemCC [";
local1 += "image = " + this.image + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.controller.events {
import flash.events.Event;
public class ParseUrlParamsEvent extends Event {
public static const PARSE_URL_PARAMS_EVENT:String = "PARSE_URL_PARAMS_EVENT";
public function ParseUrlParamsEvent() {
super(PARSE_URL_PARAMS_EVENT);
}
}
}
|
package controls.statassets
{
import assets.stat.hall_ARROW;
import assets.stat.hall_HEADER;
import flash.display.BitmapData;
public class StatLineHeader extends StatLineBase
{
protected var _selected:Boolean = false;
protected var ar:BitmapData;
public function StatLineHeader()
{
super();
tl = new hall_HEADER(1,1);
px = new BitmapData(1,1,false,5898034);
this.ar = new hall_ARROW(1,1);
}
public function set selected(value:Boolean) : void
{
this._selected = value;
this.draw();
}
override protected function draw() : void
{
super.draw();
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.model {
[ModelInterface]
public interface IFriends {
function isLocal() : Boolean;
}
}
|
package alternativa.tanks.service.settings.keybinding {
import alternativa.osgi.service.locale.ILocaleService;
import flash.ui.Keyboard;
import flash.utils.Dictionary;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class KeyCodesConverter {
private static var keyCodeToLabel:Dictionary;
[Inject]
public static var localeService:ILocaleService;
public function KeyCodesConverter() {
super();
this.initLabelDictionary();
}
public function keyCodeToString(param1:uint) : String {
var local2:String = keyCodeToLabel[param1];
return local2 == null ? "" : local2;
}
private function initLabelDictionary() : void {
keyCodeToLabel = new Dictionary();
keyCodeToLabel[Keyboard.NUMBER_0] = "0";
keyCodeToLabel[Keyboard.NUMBER_1] = "1";
keyCodeToLabel[Keyboard.NUMBER_2] = "2";
keyCodeToLabel[Keyboard.NUMBER_3] = "3";
keyCodeToLabel[Keyboard.NUMBER_4] = "4";
keyCodeToLabel[Keyboard.NUMBER_5] = "5";
keyCodeToLabel[Keyboard.NUMBER_6] = "6";
keyCodeToLabel[Keyboard.NUMBER_7] = "7";
keyCodeToLabel[Keyboard.NUMBER_8] = "8";
keyCodeToLabel[Keyboard.NUMBER_9] = "9";
keyCodeToLabel[Keyboard.MINUS] = "-";
keyCodeToLabel[Keyboard.EQUAL] = "=";
keyCodeToLabel[Keyboard.Q] = "Q";
keyCodeToLabel[Keyboard.W] = "W";
keyCodeToLabel[Keyboard.E] = "E";
keyCodeToLabel[Keyboard.R] = "R";
keyCodeToLabel[Keyboard.T] = "T";
keyCodeToLabel[Keyboard.Y] = "Y";
keyCodeToLabel[Keyboard.U] = "U";
keyCodeToLabel[Keyboard.I] = "I";
keyCodeToLabel[Keyboard.O] = "O";
keyCodeToLabel[Keyboard.P] = "P";
keyCodeToLabel[Keyboard.A] = "A";
keyCodeToLabel[Keyboard.S] = "S";
keyCodeToLabel[Keyboard.D] = "D";
keyCodeToLabel[Keyboard.F] = "F";
keyCodeToLabel[Keyboard.G] = "G";
keyCodeToLabel[Keyboard.H] = "H";
keyCodeToLabel[Keyboard.J] = "J";
keyCodeToLabel[Keyboard.K] = "K";
keyCodeToLabel[Keyboard.L] = "L";
keyCodeToLabel[Keyboard.Z] = "Z";
keyCodeToLabel[Keyboard.X] = "X";
keyCodeToLabel[Keyboard.C] = "C";
keyCodeToLabel[Keyboard.V] = "V";
keyCodeToLabel[Keyboard.B] = "B";
keyCodeToLabel[Keyboard.N] = "N";
keyCodeToLabel[Keyboard.M] = "M";
keyCodeToLabel[Keyboard.LEFT] = localeService.getText(TanksLocale.TEXT_KEYBOARD_KEY_LEFT);
keyCodeToLabel[Keyboard.UP] = localeService.getText(TanksLocale.TEXT_KEYBOARD_KEY_UP);
keyCodeToLabel[Keyboard.RIGHT] = localeService.getText(TanksLocale.TEXT_KEYBOARD_KEY_RIGHT);
keyCodeToLabel[Keyboard.DOWN] = localeService.getText(TanksLocale.TEXT_KEYBOARD_KEY_DOWN);
keyCodeToLabel[Keyboard.NUMPAD_0] = "NumPad 0";
keyCodeToLabel[Keyboard.NUMPAD_1] = "NumPad 1";
keyCodeToLabel[Keyboard.NUMPAD_2] = "NumPad 2";
keyCodeToLabel[Keyboard.NUMPAD_3] = "NumPad 3";
keyCodeToLabel[Keyboard.NUMPAD_4] = "NumPad 4";
keyCodeToLabel[Keyboard.NUMPAD_5] = "NumPad 5";
keyCodeToLabel[Keyboard.NUMPAD_6] = "NumPad 6";
keyCodeToLabel[Keyboard.NUMPAD_7] = "NumPad 7";
keyCodeToLabel[Keyboard.NUMPAD_8] = "NumPad 8";
keyCodeToLabel[Keyboard.NUMPAD_9] = "NumPad 9";
keyCodeToLabel[Keyboard.NUMPAD_ADD] = "NumPad +";
keyCodeToLabel[Keyboard.NUMPAD_SUBTRACT] = "NumPad -";
keyCodeToLabel[Keyboard.NUMPAD_DECIMAL] = "NumPad .";
keyCodeToLabel[Keyboard.NUMPAD_DIVIDE] = "NumPad /";
keyCodeToLabel[Keyboard.NUMPAD_ENTER] = "NumPad Enter";
keyCodeToLabel[Keyboard.LEFTBRACKET] = "[";
keyCodeToLabel[Keyboard.RIGHTBRACKET] = "]";
keyCodeToLabel[Keyboard.BACKSLASH] = "\\";
keyCodeToLabel[Keyboard.SEMICOLON] = ";";
keyCodeToLabel[Keyboard.QUOTE] = "\'";
keyCodeToLabel[Keyboard.COMMA] = ",";
keyCodeToLabel[Keyboard.PERIOD] = ".";
keyCodeToLabel[Keyboard.SLASH] = "/";
keyCodeToLabel[Keyboard.PAGE_DOWN] = localeService.getText(TanksLocale.TEXT_KEYBOARD_KEY_PG_DN);
keyCodeToLabel[Keyboard.PAGE_UP] = localeService.getText(TanksLocale.TEXT_KEYBOARD_KEY_PG_UP);
keyCodeToLabel[Keyboard.SPACE] = localeService.getText(TanksLocale.TEXT_KEYBOARD_KEY_SPACE);
keyCodeToLabel[Keyboard.SHIFT] = "Shift";
}
}
}
|
package alternativa.tanks.help
{
import alternativa.init.OSGi;
import alternativa.init.TanksServicesActivator;
import alternativa.osgi.service.console.IConsoleService;
import alternativa.osgi.service.mainContainer.IMainContainerService;
import alternativa.osgi.service.storage.IStorageService;
import flash.display.DisplayObjectContainer;
import flash.display.Sprite;
import flash.display.Stage;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.net.SharedObject;
import flash.text.TextFormat;
import flash.utils.Dictionary;
public class HelpService implements IHelpService
{
private var osgi:OSGi;
private var storage:SharedObject;
private var stage:Stage;
private var helpLayer:DisplayObjectContainer;
private var helpContainer:Sprite;
private var helpGroups:Dictionary;
private var mainGroupObjects:Array;
private var advancedUser:Boolean;
private var hideTimers:Array;
private var lock:Boolean;
public function HelpService()
{
super();
this.osgi = TanksServicesActivator.osgi;
var mainContainerService:IMainContainerService = this.osgi.getService(IMainContainerService) as IMainContainerService;
this.stage = mainContainerService.stage;
this.helpLayer = mainContainerService.noticesLayer;
this.helpContainer = new Sprite();
this.helpGroups = new Dictionary();
this.mainGroupObjects = new Array();
this.hideTimers = new Array();
this.storage = IStorageService(this.osgi.getService(IStorageService)).getStorage();
if(this.storage.data.helperShowNum == null)
{
this.storage.data.helperShowNum = new Dictionary();
}
this.advancedUser = this.storage.data.userRank != null && this.storage.data.userRank >= 6;
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP","advancedUser: %1",this.advancedUser);
this.stage.addEventListener(Event.RESIZE,this.onStageResize);
}
public function registerHelper(groupKey:String, helperId:int, helper:Helper, showByHelpButtonClick:Boolean) : void
{
var consoleSerivce:IConsoleService = IConsoleService(this.osgi.getService(IConsoleService));
consoleSerivce.writeToConsoleChannel("HELP","\nregisterHelper");
consoleSerivce.writeToConsoleChannel("HELP"," groupKey: %1",groupKey);
consoleSerivce.writeToConsoleChannel("HELP"," helperId: %1",helperId);
consoleSerivce.writeToConsoleChannel("HELP"," helper: %1",helper);
var helpers:Dictionary = this.helpGroups[groupKey];
if(helpers == null)
{
helpers = new Dictionary();
this.helpGroups[groupKey] = helpers;
}
helpers[helperId] = helper;
if(showByHelpButtonClick)
{
this.mainGroupObjects.push(helper);
}
var helperShowNum:Dictionary = this.storage.data.helperShowNum as Dictionary;
if(helperShowNum == null)
{
helperShowNum = new Dictionary();
}
if(helperShowNum[groupKey] == null)
{
helperShowNum[groupKey] = new Array();
}
if(helperShowNum[groupKey][helperId] == null)
{
helperShowNum[groupKey][helperId] = helper.showNum;
}
else
{
helper.showNum = helperShowNum[groupKey][helperId];
}
helper.id = helperId;
helper.groupKey = groupKey;
}
public function unregisterHelper(groupKey:String, helperId:int) : void
{
var consoleService:IConsoleService = IConsoleService(this.osgi.getService(IConsoleService));
consoleService.writeToConsoleChannel("HELP","\nunregisterHelper");
consoleService.writeToConsoleChannel("HELP"," groupKey: %1",groupKey);
consoleService.writeToConsoleChannel("HELP"," helperId: %1",helperId);
var helpers:Dictionary = this.helpGroups[groupKey];
if(helpers == null)
{
return;
}
var helper:Helper = helpers[helperId];
if(helper == null)
{
return;
}
consoleService.writeToConsoleChannel("HELP"," helper: %1",helper);
this.doHideHelper(helper);
delete helpers[helperId];
var index:int = this.mainGroupObjects.indexOf(helper);
if(index != -1)
{
this.mainGroupObjects.splice(index,1);
}
}
public function showHelper(groupKey:String, helperId:int, useTimer:Boolean = false) : void
{
var helper:Helper = null;
var helperShowNum:Vector.<Object> = null;
var s:int = 0;
var i:int = 0;
var obj:Object = null;
var timer:HelperTimer = null;
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP","showHelper groupKey: %1, helperId: %2, advancedUser: %3",groupKey,helperId,this.advancedUser);
if(!this.advancedUser)
{
helper = this.getHelper(groupKey,helperId);
if(helper == null)
{
return;
}
if(!this.helpLayer.contains(this.helpContainer))
{
this.helpLayer.addChild(this.helpContainer);
}
if(helper.showLimit == -1 || helper.showLimit != -1 && helper.showNum < helper.showLimit)
{
if(!this.helpContainer.contains(helper))
{
helper.showNum += 1;
helperShowNum = this.storage.data.helperShowNum != null && this.storage.data.helperShowNum is Vector.<Object> ? this.storage.data.helperShowNum : new Vector.<Object>();
s = -1;
for(i = 0; i < helperShowNum.length; i++)
{
if(helperShowNum[i].hasOwnProperty("groupKey") && helperShowNum[i].groupKey == groupKey)
{
s = i;
}
}
if(s == -1)
{
obj = new Object();
obj.groupKey = groupKey;
obj.helper = new Array();
obj.helper[helperId] = helper.showNum;
helperShowNum.push(obj);
}
else
{
helperShowNum[s].helper[helperId] = helper.showNum;
}
this.storage.data.helperShowNum = helperShowNum;
this.helpContainer.addChild(helper);
helper.draw(helper.size);
helper.align(this.stage.stageWidth,this.stage.stageHeight);
helper.addEventListener(MouseEvent.MOUSE_DOWN,this.onHelperClick);
if(useTimer)
{
timer = new HelperTimer(helper.showDuration,1);
timer.helper = helper;
helper.timer = timer;
timer.addEventListener(TimerEvent.TIMER_COMPLETE,this.onHelperTimer);
this.hideTimers.push(timer);
timer.reset();
timer.start();
}
}
}
}
}
public function hideHelper(groupKey:String, helperId:int) : void
{
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP","hideHelper groupKey: %1, helperId: %2",groupKey,helperId);
if(!this.advancedUser)
{
this.doHideHelper(this.getHelper(groupKey,helperId));
}
}
public function showHelp() : void
{
var i:int = 0;
var helper:Helper = null;
var index:int = 0;
if(!this.lock)
{
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP","showHelp");
if(!this.helpLayer.contains(this.helpContainer))
{
this.helpLayer.addChild(this.helpContainer);
}
for(i = 0; i < this.mainGroupObjects.length; i++)
{
helper = this.mainGroupObjects[i] as Helper;
if(!this.helpContainer.contains(helper))
{
this.helpContainer.addChild(helper);
helper.draw(helper.size);
helper.align(this.stage.stageWidth,this.stage.stageHeight);
}
else
{
index = this.hideTimers.indexOf(helper.timer);
if(index != -1)
{
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP"," helper %1 %2 timer stop",helper.groupKey,helper.id);
(this.hideTimers[index] as HelperTimer).stop();
this.hideTimers.splice(index,1);
}
}
}
this.stage.addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
}
}
public function hideHelp() : void
{
var helper:Helper = null;
var index:int = 0;
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP","hideHelp");
for(var i:int = 0; i < this.mainGroupObjects.length; i++)
{
helper = this.mainGroupObjects[i];
index = this.hideTimers.indexOf(helper.timer);
if(index != -1)
{
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP"," helper %1 %2 timer stop",helper.groupKey,helper.id);
(this.hideTimers[index] as HelperTimer).stop();
this.hideTimers.splice(index,1);
}
if(this.helpContainer.contains(helper))
{
this.helpContainer.removeChild(helper);
}
}
if(this.helpContainer.numChildren == 0)
{
if(this.helpLayer.contains(this.helpContainer))
{
this.helpLayer.removeChild(this.helpContainer);
}
this.helpContainer = new Sprite();
}
this.stage.removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDown);
}
public function setHelperTextFormat(format:TextFormat) : void
{
BubbleHelper.textFormat = format;
}
private function onMouseDown(e:MouseEvent) : void
{
this.hideHelp();
this.lock = true;
this.stage.addEventListener(MouseEvent.MOUSE_DOWN,this.unlock);
}
private function unlock(e:MouseEvent) : void
{
this.lock = false;
this.stage.removeEventListener(MouseEvent.MOUSE_DOWN,this.unlock);
}
private function onHelperTimer(e:TimerEvent) : void
{
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP","onHelperTimer");
var timer:HelperTimer = e.target as HelperTimer;
var helper:Helper = timer.helper;
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP"," helper.groupKey: %1",helper.groupKey);
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP"," helper.id: %1",helper.id);
this.hideHelper(helper.groupKey,helper.id);
}
private function onHelperClick(e:MouseEvent) : void
{
var helper:Helper = null;
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP","onHelperClick");
if(e.target is Helper)
{
helper = e.target as Helper;
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP"," helper.groupKey: %1",helper.groupKey);
(this.osgi.getService(IConsoleService) as IConsoleService).writeToConsoleChannel("HELP"," helper.id: %1",helper.id);
this.hideHelper(helper.groupKey,helper.id);
}
}
private function onStageResize(e:Event) : void
{
var i:int = 0;
var helper:Helper = null;
if(this.helpLayer.contains(this.helpContainer))
{
for(i = 0; i < this.helpContainer.numChildren; i++)
{
helper = this.helpContainer.getChildAt(i) as Helper;
if(helper != null)
{
helper.align(this.stage.stageWidth,this.stage.stageHeight);
}
}
}
}
private function getHelper(groupKey:String, helperId:int) : Helper
{
var helpers:Dictionary = this.helpGroups[groupKey];
if(helpers == null)
{
return null;
}
return helpers[helperId];
}
private function doHideHelper(helper:Helper) : void
{
var index:int = 0;
if(helper == null)
{
return;
}
if(this.helpContainer.contains(helper))
{
this.helpContainer.removeChild(helper);
}
helper.removeEventListener(MouseEvent.MOUSE_DOWN,this.onHelperClick);
var timer:HelperTimer = helper.timer;
if(timer != null)
{
timer.stop();
index = this.hideTimers.indexOf(timer);
if(index != -1)
{
this.hideTimers.splice(index,1);
}
}
}
}
}
|
package projects.tanks.clients.fp10.models.tankspartnersmodel.partners.miniplay {
import alternativa.osgi.service.launcherparams.ILauncherParams;
import flash.utils.Dictionary;
import platform.client.core.general.socialnetwork.types.LoginParameters;
import platform.client.fp10.core.service.address.AddressService;
import platform.clients.fp10.libraries.alternativapartners.type.IParametersListener;
import platform.clients.fp10.libraries.alternativapartners.type.IPartner;
import projects.tanks.client.partners.impl.miniplay.IMiniplayLoginModelBase;
import projects.tanks.client.partners.impl.miniplay.MiniplayLoginModelBase;
[ModelInfo]
public class MiniplayLoginModel extends MiniplayLoginModelBase implements IMiniplayLoginModelBase, IPartner {
[Inject]
public static var addressService:AddressService;
[Inject]
public static var paramsService:ILauncherParams;
private static const USER_TOKEN_PARAM:String = "mp_api_user_token";
private static const USER_ID_PARAM:String = "mp_api_user_id";
public function MiniplayLoginModel() {
super();
}
public function getLoginParameters(param1:IParametersListener) : void {
var local2:Dictionary = new Dictionary();
local2[USER_TOKEN_PARAM] = paramsService.getParameter(USER_TOKEN_PARAM);
local2[USER_ID_PARAM] = paramsService.getParameter(USER_ID_PARAM);
param1.onSetParameters(new LoginParameters(local2));
}
public function hasPaymentAction() : Boolean {
return false;
}
public function paymentAction() : void {
}
public function getFailRedirectUrl() : String {
return "http://tankionline.com/pt_BR";
}
public function isExternalLoginAllowed() : Boolean {
return false;
}
public function hasRatings() : Boolean {
return true;
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.