code stringlengths 57 237k |
|---|
package mx.core
{
public interface IRepeaterClient
{
function get instanceIndices() : Array;
function set instanceIndices(param1:Array) : void;
function get isDocument() : Boolean;
function get repeaterIndices() : Array;
function set repeaterIndices(param1:Array) : void;
function get repeaters() : Array;
function set repeaters(param1:Array) : void;
function initializeRepeaterArrays(param1:IRepeaterClient) : void;
}
}
|
package alternativa.tanks.battle.scene3d {
import alternativa.tanks.battle.DeferredAction;
public class DeferredRendererDeletion implements DeferredAction {
private var renderGroup:RenderGroup;
private var renderer:Renderer;
public function DeferredRendererDeletion(param1:RenderGroup, param2:Renderer) {
super();
this.renderGroup = param1;
this.renderer = param2;
}
public function execute() : void {
this.renderGroup.removeRenderer(this.renderer);
}
}
}
|
package _codec.projects.tanks.client.battleservice.model.performance {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import projects.tanks.client.battleservice.model.performance.PerformanceCC;
public class CodecPerformanceCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_alertFPSRatioThreshold:ICodec;
private var codec_alertFPSThreshold:ICodec;
private var codec_alertMinTestTime:ICodec;
private var codec_alertPingRatioThreshold:ICodec;
private var codec_alertPingThreshold:ICodec;
private var codec_indicatorHighFPS:ICodec;
private var codec_indicatorHighFPSColor:ICodec;
private var codec_indicatorHighPing:ICodec;
private var codec_indicatorHighPingColor:ICodec;
private var codec_indicatorLowFPS:ICodec;
private var codec_indicatorLowFPSColor:ICodec;
private var codec_indicatorLowPing:ICodec;
private var codec_indicatorLowPingColor:ICodec;
private var codec_indicatorVeryHighPing:ICodec;
private var codec_indicatorVeryHighPingColor:ICodec;
private var codec_indicatorVeryLowFPS:ICodec;
private var codec_indicatorVeryLowFPSColor:ICodec;
private var codec_qualityFPSThreshold:ICodec;
private var codec_qualityIdleTime:ICodec;
private var codec_qualityMaxAttempts:ICodec;
private var codec_qualityRatioThreshold:ICodec;
private var codec_qualityTestTime:ICodec;
private var codec_qualityVisualizationSpeed:ICodec;
public function CodecPerformanceCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_alertFPSRatioThreshold = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_alertFPSThreshold = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_alertMinTestTime = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_alertPingRatioThreshold = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_alertPingThreshold = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_indicatorHighFPS = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_indicatorHighFPSColor = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_indicatorHighPing = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_indicatorHighPingColor = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_indicatorLowFPS = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_indicatorLowFPSColor = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_indicatorLowPing = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_indicatorLowPingColor = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_indicatorVeryHighPing = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_indicatorVeryHighPingColor = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_indicatorVeryLowFPS = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_indicatorVeryLowFPSColor = param1.getCodec(new TypeCodecInfo(String,true));
this.codec_qualityFPSThreshold = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_qualityIdleTime = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_qualityMaxAttempts = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_qualityRatioThreshold = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_qualityTestTime = param1.getCodec(new TypeCodecInfo(Float,false));
this.codec_qualityVisualizationSpeed = param1.getCodec(new TypeCodecInfo(Float,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:PerformanceCC = new PerformanceCC();
local2.alertFPSRatioThreshold = this.codec_alertFPSRatioThreshold.decode(param1) as Number;
local2.alertFPSThreshold = this.codec_alertFPSThreshold.decode(param1) as Number;
local2.alertMinTestTime = this.codec_alertMinTestTime.decode(param1) as Number;
local2.alertPingRatioThreshold = this.codec_alertPingRatioThreshold.decode(param1) as Number;
local2.alertPingThreshold = this.codec_alertPingThreshold.decode(param1) as Number;
local2.indicatorHighFPS = this.codec_indicatorHighFPS.decode(param1) as int;
local2.indicatorHighFPSColor = this.codec_indicatorHighFPSColor.decode(param1) as String;
local2.indicatorHighPing = this.codec_indicatorHighPing.decode(param1) as int;
local2.indicatorHighPingColor = this.codec_indicatorHighPingColor.decode(param1) as String;
local2.indicatorLowFPS = this.codec_indicatorLowFPS.decode(param1) as int;
local2.indicatorLowFPSColor = this.codec_indicatorLowFPSColor.decode(param1) as String;
local2.indicatorLowPing = this.codec_indicatorLowPing.decode(param1) as int;
local2.indicatorLowPingColor = this.codec_indicatorLowPingColor.decode(param1) as String;
local2.indicatorVeryHighPing = this.codec_indicatorVeryHighPing.decode(param1) as int;
local2.indicatorVeryHighPingColor = this.codec_indicatorVeryHighPingColor.decode(param1) as String;
local2.indicatorVeryLowFPS = this.codec_indicatorVeryLowFPS.decode(param1) as int;
local2.indicatorVeryLowFPSColor = this.codec_indicatorVeryLowFPSColor.decode(param1) as String;
local2.qualityFPSThreshold = this.codec_qualityFPSThreshold.decode(param1) as Number;
local2.qualityIdleTime = this.codec_qualityIdleTime.decode(param1) as Number;
local2.qualityMaxAttempts = this.codec_qualityMaxAttempts.decode(param1) as int;
local2.qualityRatioThreshold = this.codec_qualityRatioThreshold.decode(param1) as Number;
local2.qualityTestTime = this.codec_qualityTestTime.decode(param1) as Number;
local2.qualityVisualizationSpeed = this.codec_qualityVisualizationSpeed.decode(param1) as Number;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:PerformanceCC = PerformanceCC(param2);
this.codec_alertFPSRatioThreshold.encode(param1,local3.alertFPSRatioThreshold);
this.codec_alertFPSThreshold.encode(param1,local3.alertFPSThreshold);
this.codec_alertMinTestTime.encode(param1,local3.alertMinTestTime);
this.codec_alertPingRatioThreshold.encode(param1,local3.alertPingRatioThreshold);
this.codec_alertPingThreshold.encode(param1,local3.alertPingThreshold);
this.codec_indicatorHighFPS.encode(param1,local3.indicatorHighFPS);
this.codec_indicatorHighFPSColor.encode(param1,local3.indicatorHighFPSColor);
this.codec_indicatorHighPing.encode(param1,local3.indicatorHighPing);
this.codec_indicatorHighPingColor.encode(param1,local3.indicatorHighPingColor);
this.codec_indicatorLowFPS.encode(param1,local3.indicatorLowFPS);
this.codec_indicatorLowFPSColor.encode(param1,local3.indicatorLowFPSColor);
this.codec_indicatorLowPing.encode(param1,local3.indicatorLowPing);
this.codec_indicatorLowPingColor.encode(param1,local3.indicatorLowPingColor);
this.codec_indicatorVeryHighPing.encode(param1,local3.indicatorVeryHighPing);
this.codec_indicatorVeryHighPingColor.encode(param1,local3.indicatorVeryHighPingColor);
this.codec_indicatorVeryLowFPS.encode(param1,local3.indicatorVeryLowFPS);
this.codec_indicatorVeryLowFPSColor.encode(param1,local3.indicatorVeryLowFPSColor);
this.codec_qualityFPSThreshold.encode(param1,local3.qualityFPSThreshold);
this.codec_qualityIdleTime.encode(param1,local3.qualityIdleTime);
this.codec_qualityMaxAttempts.encode(param1,local3.qualityMaxAttempts);
this.codec_qualityRatioThreshold.encode(param1,local3.qualityRatioThreshold);
this.codec_qualityTestTime.encode(param1,local3.qualityTestTime);
this.codec_qualityVisualizationSpeed.encode(param1,local3.qualityVisualizationSpeed);
}
}
}
|
package projects.tanks.client.battlefield.models.user.configuration {
public interface ITankConfigurationModelBase {
}
}
|
package projects.tanks.client.panel.model.payment.modes.alipay {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import projects.tanks.client.panel.model.payment.types.PaymentRequestUrl;
public class AlipayPaymentModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:AlipayPaymentModelServer;
private var client:IAlipayPaymentModelBase = IAlipayPaymentModelBase(this);
private var modelId:Long = Long.getLong(905082594,773468886);
private var _receiveUrlId:Long = Long.getLong(2018754756,-1674743349);
private var _receiveUrl_urlCodec:ICodec;
public function AlipayPaymentModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new AlipayPaymentModelServer(IModel(this));
this._receiveUrl_urlCodec = this._protocol.getCodec(new TypeCodecInfo(PaymentRequestUrl,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._receiveUrlId:
this.client.receiveUrl(PaymentRequestUrl(this._receiveUrl_urlCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package projects.tanks.client.clans.notifier {
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 ClanNotifierModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function ClanNotifierModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.entrance.model.users.pushnotification {
public class NotificationClientPlatform {
public static const ANDROID:NotificationClientPlatform = new NotificationClientPlatform(0,"ANDROID");
public static const WEB:NotificationClientPlatform = new NotificationClientPlatform(1,"WEB");
private var _value:int;
private var _name:String;
public function NotificationClientPlatform(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<NotificationClientPlatform> {
var local1:Vector.<NotificationClientPlatform> = new Vector.<NotificationClientPlatform>();
local1.push(ANDROID);
local1.push(WEB);
return local1;
}
public function toString() : String {
return "NotificationClientPlatform [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package projects.tanks.client.clans.panel.notification {
public class ClanPanelNotificationCC {
private var _numberNotifications:int;
private var _restrictionTimeJoinClanInSec:int;
public function ClanPanelNotificationCC(param1:int = 0, param2:int = 0) {
super();
this._numberNotifications = param1;
this._restrictionTimeJoinClanInSec = param2;
}
public function get numberNotifications() : int {
return this._numberNotifications;
}
public function set numberNotifications(param1:int) : void {
this._numberNotifications = param1;
}
public function get restrictionTimeJoinClanInSec() : int {
return this._restrictionTimeJoinClanInSec;
}
public function set restrictionTimeJoinClanInSec(param1:int) : void {
this._restrictionTimeJoinClanInSec = param1;
}
public function toString() : String {
var local1:String = "ClanPanelNotificationCC [";
local1 += "numberNotifications = " + this.numberNotifications + " ";
local1 += "restrictionTimeJoinClanInSec = " + this.restrictionTimeJoinClanInSec + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.models.tank {
import projects.tanks.client.users.services.chatmoderator.ChatModeratorLevel;
public class UserInfo {
public var name:String;
public var rank:int;
public var isLocal:Boolean;
public var chatModeratorLevel:ChatModeratorLevel;
public var hasPremium:Boolean;
public function UserInfo(param1:String, param2:int, param3:Boolean, param4:ChatModeratorLevel, param5:Boolean) {
super();
this.name = param1;
this.rank = param2;
this.isLocal = param3;
this.chatModeratorLevel = param4;
this.hasPremium = param5;
}
}
}
|
package forms.buttons
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class MainPanelRatingButton_overBtn extends BitmapAsset
{
public function MainPanelRatingButton_overBtn()
{
super();
}
}
}
|
package alternativa.tanks.models.weapon.railgun {
import alternativa.math.Vector3;
import alternativa.physics.Body;
public class DirectionShotResult {
public static const DEFAULT_EFFICIENCY:Number = -100;
public var shotEfficiency:Number = -100;
public var targets:Vector.<Body> = new Vector.<Body>();
public var hitPoints:Vector.<Vector3> = new Vector.<Vector3>();
public var staticHitPoint:Vector3 = new Vector3();
public var staticHitNormal:Vector3 = new Vector3();
public var hasStaticHit:Boolean;
public var numFriendlyTargets:int;
public function DirectionShotResult() {
super();
}
public function clear() : void {
this.targets.length = 0;
this.hitPoints.length = 0;
this.shotEfficiency = DEFAULT_EFFICIENCY;
this.hasStaticHit = false;
this.numFriendlyTargets = 0;
}
public function setStaticHitPoint(param1:Vector3, param2:Vector3) : void {
this.staticHitPoint.copy(param1);
this.staticHitNormal.copy(param2);
this.hasStaticHit = true;
}
public function addTarget(param1:Body, param2:Vector3) : void {
this.targets.push(param1);
this.hitPoints.push(param2);
}
public function addFriendlyTarget(param1:Body, param2:Vector3) : void {
this.addTarget(param1,param2);
++this.numFriendlyTargets;
}
public function containsEnemyTargets() : Boolean {
return this.targets.length > this.numFriendlyTargets;
}
}
}
|
package alternativa.tanks.models.battle.facilities {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class BattleUnloadListenerAdapt implements BattleUnloadListener {
private var object:IGameObject;
private var impl:BattleUnloadListener;
public function BattleUnloadListenerAdapt(param1:IGameObject, param2:BattleUnloadListener) {
super();
this.object = param1;
this.impl = param2;
}
public function battleUnload() : void {
try {
Model.object = this.object;
this.impl.battleUnload();
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.model.item.buyable {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IBuyableAdapt implements IBuyable {
private var object:IGameObject;
private var impl:IBuyable;
public function IBuyableAdapt(param1:IGameObject, param2:IBuyable) {
super();
this.object = param1;
this.impl = param2;
}
public function getPriceWithoutDiscount() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getPriceWithoutDiscount());
}
finally {
Model.popObject();
}
return result;
}
public function getPrice() : int {
var result:int = 0;
try {
Model.object = this.object;
result = int(this.impl.getPrice());
}
finally {
Model.popObject();
}
return result;
}
public function isBuyable() : Boolean {
var result:Boolean = false;
try {
Model.object = this.object;
result = Boolean(this.impl.isBuyable());
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.friend {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.types.Long;
import flash.events.EventDispatcher;
import projects.tanks.clients.fp10.libraries.TanksLocale;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.AlertServiceEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.alertservices.IAlertService;
public class FriendActionService extends EventDispatcher implements IFriendActionService {
[Inject]
public static var alertService:IAlertService;
[Inject]
public static var localeService:ILocaleService;
public function FriendActionService() {
super();
}
public function add(param1:Long) : void {
dispatchEvent(new FriendActionServiceEvent(FriendActionServiceEvent.ADD,param1));
}
public function accept(param1:Long) : void {
dispatchEvent(new FriendActionServiceEvent(FriendActionServiceEvent.ACCEPT,param1));
}
public function breakItOff(param1:Long) : void {
dispatchEvent(new FriendActionServiceEvent(FriendActionServiceEvent.BREAK_OFF,param1));
}
public function reject(param1:Long) : void {
dispatchEvent(new FriendActionServiceEvent(FriendActionServiceEvent.REJECT,param1));
}
public function rejectAllIncoming() : void {
dispatchEvent(new FriendActionServiceEvent(FriendActionServiceEvent.REJECT_ALL_INCOMING,null));
}
public function addByUid(param1:String) : void {
dispatchEvent(new FriendActionServiceUidEvent(FriendActionServiceUidEvent.ADD,param1));
}
public function alreadyInIncomingFriends(param1:String, param2:Long) : void {
var uid:String = param1;
var userId:Long = param2;
var alertMessage:String = localeService.getText(TanksLocale.TEXT_FRIENDS_ALREADY_HAVE_INCOMING).replace("%USERNAME%",uid);
alertService.showAlert(alertMessage,Vector.<String>([localeService.getText(TanksLocale.TEXT_FRIENDS_YES),localeService.getText(TanksLocale.TEXT_FRIENDS_CANCEL_BUTTON_TEXT)]));
alertService.addEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,function(param1:AlertServiceEvent):void {
alertService.removeEventListener(AlertServiceEvent.ALERT_BUTTON_PRESSED,arguments.callee);
if(param1.typeButton == localeService.getText(TanksLocale.TEXT_FRIENDS_YES)) {
accept(userId);
}
});
}
public function alreadyInAcceptedFriends(param1:String) : void {
var local2:String = localeService.getText(TanksLocale.TEXT_FRIENDS_PLAYER_ALREADY_IN_LIST_ALERT).replace("%USERNAME%",param1);
alertService.showAlert(local2,Vector.<String>([localeService.getText(TanksLocale.TEXT_ALERT_ANSWER_OK)]));
}
public function alreadyInOutgoingFriends(param1:String) : void {
var local2:String = localeService.getText(TanksLocale.TEXT_FRIENDS_REQUEST_EXIST_ALERT).replace("%USERNAME%",param1);
alertService.showAlert(local2,Vector.<String>([localeService.getText(TanksLocale.TEXT_ALERT_ANSWER_OK)]));
}
public function incomingLimitExceeded() : void {
alertService.showAlert(localeService.getText(TanksLocale.TEXT_INCOMING_LIMIT_EXCEEDED_ALERT),Vector.<String>([localeService.getText(TanksLocale.TEXT_ALERT_ANSWER_OK)]));
}
public function yourAcceptedLimitExceeded() : void {
alertService.showAlert(localeService.getText(TanksLocale.TEXT_YOUR_ACCEPTED_LIMIT_EXCEEDED_ALERT),Vector.<String>([localeService.getText(TanksLocale.TEXT_ALERT_ANSWER_OK)]));
}
public function acceptedLimitExceeded(param1:String) : void {
alertService.showAlert(localeService.getText(TanksLocale.TEXT_ACCEPTED_LIMIT_EXCEEDED_ALERT).replace("%USERNAME%",param1),Vector.<String>([localeService.getText(TanksLocale.TEXT_ALERT_ANSWER_OK)]));
}
public function requestAccepted(param1:Long) : void {
dispatchEvent(new FriendActionServiceUidEvent(FriendActionServiceUidEvent.REQUEST_ACCEPTED,null,param1));
}
}
}
|
package alternativa.tanks.servermodels.registartion.password {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IPasswordRegistrationAdapt implements IPasswordRegistration {
private var object:IGameObject;
private var impl:IPasswordRegistration;
public function IPasswordRegistrationAdapt(param1:IGameObject, param2:IPasswordRegistration) {
super();
this.object = param1;
this.impl = param2;
}
public function register(param1:String, param2:String, param3:String, param4:Boolean, param5:String, param6:String, param7:String) : void {
var uid:String = param1;
var password:String = param2;
var registeredUrl:String = param3;
var rememberMe:Boolean = param4;
var referralHash:String = param5;
var realName:String = param6;
var idNumber:String = param7;
try {
Model.object = this.object;
this.impl.register(uid,password,registeredUrl,rememberMe,referralHash,realName,idNumber);
}
finally {
Model.popObject();
}
}
public function checkCallsign(param1:String) : void {
var callsign:String = param1;
try {
Model.object = this.object;
this.impl.checkCallsign(callsign);
}
finally {
Model.popObject();
}
}
}
}
|
package alternativa.tanks.font.services {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.locale.ILocaleService;
import flash.text.TextFormat;
public class TanksFontsFormatServiceImpl implements TanksFontsFormatService {
private var format:TextFormat;
private var embedded:Boolean;
public function TanksFontsFormatServiceImpl() {
super();
var local1:String = ILocaleService(OSGi.getInstance().getService(ILocaleService)).language;
this.embedded = this.isEmbeddedFontsInLang(local1);
this.format = this.getFontsFormatInLang(local1);
}
public function isEmbeddedFonts() : Boolean {
return this.embedded;
}
public function getFontsFormat() : TextFormat {
return this.format;
}
public function isEmbeddedFontsInLang(param1:String) : Boolean {
return param1 != "cn" && param1 != "fa";
}
public function getFontsFormatInLang(param1:String) : TextFormat {
var local2:TextFormat = null;
switch(param1) {
case "cn":
local2 = new TextFormat("simsun");
local2.indent = 0;
break;
case "fa":
local2 = new TextFormat("IRANSans");
local2.indent = 0;
break;
default:
local2 = new TextFormat("MyriadPro",12,false);
}
local2.color = 16777215;
return local2;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_minelayerIconClass.png")]
public class DeviceIcons_minelayerIconClass extends BitmapAsset {
public function DeviceIcons_minelayerIconClass() {
super();
}
}
}
|
package alternativa.tanks.sfx {
import alternativa.math.Vector3;
import alternativa.tanks.camera.GameCamera;
public interface ISound3DEffect {
function play(param1:int, param2:GameCamera) : void;
function destroy() : void;
function kill() : void;
function set enabled(param1:Boolean) : void;
function readPosition(param1:Vector3) : void;
function get numSounds() : int;
}
}
|
package projects.tanks.client.battleservice.model.battle.team {
public class BattleTeam {
public static const RED:BattleTeam = new BattleTeam(0,"RED");
public static const BLUE:BattleTeam = new BattleTeam(1,"BLUE");
public static const NONE:BattleTeam = new BattleTeam(2,"NONE");
private var _value:int;
private var _name:String;
public function BattleTeam(param1:int, param2:String) {
super();
this._value = param1;
this._name = param2;
}
public static function get values() : Vector.<BattleTeam> {
var local1:Vector.<BattleTeam> = new Vector.<BattleTeam>();
local1.push(RED);
local1.push(BLUE);
local1.push(NONE);
return local1;
}
public function toString() : String {
return "BattleTeam [" + this._name + "]";
}
public function get value() : int {
return this._value;
}
public function get name() : String {
return this._name;
}
}
}
|
package alternativa.tanks.models.battle.ctf {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.ctf.CTFHudIndicators_flagMovingBlue.png")]
public class CTFHudIndicators_flagMovingBlue extends BitmapAsset {
public function CTFHudIndicators_flagMovingBlue() {
super();
}
}
}
|
package alternativa.engine3d.materials {
import alternativa.engine3d.core.ShadowMap;
import alternativa.gfx.agal.FragmentShader;
import alternativa.gfx.agal.SamplerDim;
import alternativa.gfx.agal.SamplerFilter;
import alternativa.gfx.agal.SamplerMipMap;
import alternativa.gfx.agal.SamplerRepeat;
import alternativa.gfx.agal.SamplerType;
public class TextureMaterialFragmentShader extends FragmentShader {
public function TextureMaterialFragmentShader(param1:Boolean, param2:Boolean, param3:Boolean, param4:Boolean, param5:Boolean, param6:Boolean, param7:Boolean, param8:Boolean, param9:Boolean, param10:Boolean, param11:Boolean, param12:Boolean, param13:Boolean, param14:Boolean, param15:Boolean, param16:Boolean, param17:Boolean, param18:Boolean, param19:Boolean) {
var local24:int = 0;
super();
var local20:SamplerRepeat = param1 ? SamplerRepeat.WRAP : SamplerRepeat.CLAMP;
var local21:SamplerFilter = param2 ? SamplerFilter.LINEAR : SamplerFilter.NEAREST;
var local22:SamplerMipMap = param3 ? (param2 ? SamplerMipMap.LINEAR : SamplerMipMap.NEAREST) : SamplerMipMap.NONE;
var local23:SamplerType = param4 ? SamplerType.DXT1 : SamplerType.RGBA;
tex(ft0,v0,fs0.dim(SamplerDim.D2).repeat(local20).filter(local21).mipmap(local22).type(local23));
if(param6) {
sub(ft1.w,ft0,fc[14]);
kil(ft1.w);
}
if(param7) {
add(ft1.w,ft0,fc[18]);
div(ft0.xyz,ft0,ft1.w);
}
if(param8) {
mul(ft0.xyz,ft0,fc[0]);
add(ft0.xyz,ft0,fc[1]);
}
if(param9) {
mul(ft0.w,ft0,fc[0]);
}
if(param10) {
abs(ft1,v0.z);
sat(ft1,ft1);
sub(ft1,fc[17],ft1);
mul(ft0.w,ft0,ft1);
}
if(param12 || param13 || param14 || param16) {
div(ft4,v1,v1.z);
mul(ft4.xy,ft4,fc[18]);
add(ft4.xy,ft4,fc[18]);
}
if(param12 || param13 || param14) {
mul(ft3,ft4,fc[4]);
}
if(param12 || param13) {
tex(ft1,ft3,fs1.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
}
if(param14) {
tex(ft6,ft3,fs5.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
}
if(param12) {
dp3(ft2,ft1,fc[17]);
sub(ft2,ft2,v1);
abs(ft2,ft2);
div(ft2,ft2,fc[14]);
sat(ft2,ft2);
mul(ft0.w,ft0,ft2.z);
}
if(param13) {
mul(ft2,fc[12],ft1.w);
sub(ft2,fc[17].w,ft2);
mul(ft0.xyz,ft0,ft2);
}
if(param16) {
mov(ft5,fc[5]);
mul(ft5.z,ft5,v2);
mul(ft3,ft4,fc[7]);
tex(ft1,ft3,fs3.dim(SamplerDim.D2).repeat(SamplerRepeat.WRAP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
mul(ft1.z,ft1,fc[6]);
mul(ft2,ft1.z,ft1);
local24 = 0;
while(local24 < ShadowMap.numSamples) {
if(local24 == 0) {
add(ft1,ft2,v2);
tex(ft1,ft1,fs2.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
dp3(ft1,ft1,ft5);
sat(ft1,ft1);
mov(ft4,ft1);
} else {
if(local24 % 2 > 0) {
dp3(ft3.x,ft2,fc[8]);
dp3(ft3.y,ft2,fc[9]);
add(ft1,ft3,v2);
} else {
dp3(ft2.x,ft3,fc[8]);
dp3(ft2.y,ft3,fc[9]);
add(ft1,ft2,v2);
}
tex(ft1,ft1,fs2.dim(SamplerDim.D2).repeat(SamplerRepeat.CLAMP).filter(SamplerFilter.NEAREST).mipmap(SamplerMipMap.NONE));
dp3(ft1,ft1,ft5);
sat(ft1,ft1);
add(ft4,ft4,ft1);
}
local24++;
}
mul(ft2,ft4,fc[6]);
sat(ft1,v2);
mul(ft2,ft2,ft1);
mul(ft2.w,ft2,fc[7]);
}
if(param11) {
if(param16) {
sat(ft1,v1);
max(ft2,ft2,ft1);
} else {
sat(ft2,v1);
}
}
if(param16 || param11) {
sub(ft2,fc[17],ft2);
mul(ft2,fc[10],ft2.w);
add(ft2,ft2,fc[11]);
if(param14) {
add(ft6,ft6,ft6);
add(ft2,ft2,ft6);
} else if(param15) {
add(ft2,ft2,fc[13]);
}
mul(ft0.xyz,ft0,ft2);
} else if(param14) {
add(ft2,ft6,ft6);
mul(ft0.xyz,ft0,ft2);
} else if(param15) {
mul(ft0.xyz,ft0,fc[13]);
}
if(param17) {
if(param18) {
mul(ft0.xyz,ft0,fc[13].w);
add(ft0.xyz,ft0,fc[13]);
} else {
sat(ft1,v0);
mul(ft1,ft1,fc[2]);
if(param19) {
sub(ft1,fc[17],ft1);
mul(ft0.w,ft0,ft1);
} else {
mul(ft1.xyz,fc[2],ft1.w);
sub(ft1.w,fc[17],ft1);
mul(ft0.xyz,ft0,ft1.w);
add(ft0.xyz,ft0,ft1);
}
}
}
mov(oc,ft0);
}
}
}
|
package alternativa.tanks.services.ping {
public class PingServiceImpl implements PingService {
private var ping:Number = 0;
public function PingServiceImpl() {
super();
}
public function getPing() : Number {
return this.ping;
}
public function setPing(param1:Number) : void {
this.ping = param1;
}
}
}
|
package alternativa.types {
public class Byte {
public function Byte() {
super();
}
}
}
|
package projects.tanks.clients.fp10.Prelauncher.makeup {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/projects.tanks.clients.fp10.Prelauncher.makeup.MakeUp_wikiActiveIconMakeUp.png")]
public class MakeUp_wikiActiveIconMakeUp extends BitmapAsset {
public function MakeUp_wikiActiveIconMakeUp() {
super();
}
}
}
|
package alternativa.tanks.sfx.levelup {
import alternativa.engine3d.core.Object3D;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.tanks.battle.scene3d.scene3dcontainer.Scene3DContainer;
import alternativa.tanks.camera.GameCamera;
import alternativa.tanks.sfx.GraphicEffect;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
import flash.display.BlendMode;
public class LightBeamEffect extends PooledObject implements GraphicEffect {
private static const BASE_SIZE:Number = 300;
private var beam:LightBeam;
private var delay:int;
private var time:int;
private var height:Number;
private var maxHeight:Number;
private var heightSpeed:Number;
private var fadeSpeed:Number;
private var x:Number;
private var y:Number;
private var z:Number;
private var turret:Object3D;
private var container:Scene3DContainer;
public function LightBeamEffect(param1:Pool) {
super(param1);
this.beam = new LightBeam(BASE_SIZE);
this.beam.blendMode = BlendMode.ADD;
}
public function init(param1:int, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Object3D, param11:TextureMaterial) : void {
this.delay = param1;
this.beam.scaleX = param2 / BASE_SIZE;
this.height = param3;
this.maxHeight = param4;
this.heightSpeed = param5;
this.fadeSpeed = param6;
this.x = param7;
this.y = param8;
this.z = param9;
this.turret = param10;
this.beam.init(param11);
this.beam.softAttenuation = 150;
this.beam.depthMapAlphaThreshold = 2;
this.beam.shadowMapAlphaThreshold = 2;
this.beam.useShadowMap = false;
this.beam.useLight = false;
this.beam.alpha = 0;
this.time = 0;
}
public function addedToScene(param1:Scene3DContainer) : void {
this.container = param1;
param1.addChild(this.beam);
}
public function play(param1:int, param2:GameCamera) : Boolean {
if(this.height >= this.maxHeight && this.beam.alpha <= 0) {
return false;
}
this.beam.x = this.turret.x + this.x;
this.beam.y = this.turret.y + this.y;
this.beam.z = this.turret.z + this.z;
this.beam.rotationZ = param2.rotationZ;
this.time += param1;
if(this.time >= this.delay) {
if(this.height < this.maxHeight) {
this.height += this.maxHeight * this.heightSpeed * param1 * 0.001;
if(this.height >= this.maxHeight) {
this.height = this.maxHeight;
}
this.beam.scaleZ = this.height / BASE_SIZE;
this.beam.alpha = this.height / this.maxHeight;
} else {
this.beam.alpha -= this.fadeSpeed * param1 * 0.001;
if(this.beam.alpha < 0) {
this.beam.alpha = 0;
}
}
}
return true;
}
public function destroy() : void {
this.container.removeChild(this.beam);
this.container = null;
this.turret = null;
this.beam.clear();
recycle();
}
public function kill() : void {
this.height = this.maxHeight;
this.beam.alpha = 0;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.sfx.colortransform.struct {
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.sfx.colortransform.struct.ColorTransformStruct;
public class VectorCodecColorTransformStructLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecColorTransformStructLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ColorTransformStruct,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.<ColorTransformStruct> = new Vector.<ColorTransformStruct>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ColorTransformStruct(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ColorTransformStruct = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ColorTransformStruct> = Vector.<ColorTransformStruct>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package alternativa.tanks.models.tank.explosion {
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.sfx.LightAnimation;
import platform.client.fp10.core.type.IGameObject;
[ModelInterface]
public interface ITankExplosionModel {
function createExplosionEffects(param1:IGameObject, param2:Tank, param3:LightAnimation) : void;
}
}
|
package alternativa.tanks.gui.clanmanagement.clanmemberlist.list {
import alternativa.tanks.gui.icons.AcceptedIndicator;
import alternativa.types.Long;
import base.DiscreteSprite;
import flash.display.Sprite;
import flash.events.Event;
import forms.ColorConstants;
import forms.userlabel.UserLabel;
public class ClanUserItem extends DiscreteSprite {
protected static const MARGIN:int = 10;
protected var _userLabel:UserLabel;
protected var userContainer:Sprite;
protected var _deleteIndicator:DeleteIndicator;
protected var _acceptedIndicator:AcceptedIndicator;
private var _width:Number = 1;
private var _height:Number = 1;
public function ClanUserItem() {
super();
}
protected function onResize(param1:Event = null) : void {
}
protected function createUserLabel(param1:Long) : Sprite {
var local2:UserLabelContainer = new UserLabelContainer();
this._userLabel = new UserLabel(param1,false);
this._userLabel.showClanProfile = false;
this._userLabel.showInviteToClan = false;
this._userLabel.x = -3;
local2.addChild(this._userLabel);
this._userLabel.setUidColor(ColorConstants.GREEN_LABEL);
return local2;
}
protected function redrawBackground() : void {
if(this.width <= 0) {
return;
}
graphics.clear();
graphics.beginFill(0,0);
graphics.drawRect(0,0,this.width,20);
graphics.endFill();
}
public function get deleteIndicator() : DeleteIndicator {
return this._deleteIndicator;
}
public function get acceptedIndicator() : AcceptedIndicator {
return this._acceptedIndicator;
}
public function isSelf() : Boolean {
return this._userLabel.self;
}
override public function get width() : Number {
return this._width;
}
override public function set width(param1:Number) : void {
this._width = param1;
this.onResize();
}
override public function get height() : Number {
return this._height;
}
override public function set height(param1:Number) : void {
this._height = param1;
this.onResize();
}
}
}
|
package utils {
import flash.display.BitmapData;
public class FlipBitmapDataUtils {
public function FlipBitmapDataUtils() {
super();
}
public static function flipH(param1:BitmapData) : BitmapData {
var local4:int = 0;
var local2:BitmapData = new BitmapData(param1.width,param1.height,true);
var local3:int = 0;
while(local3 < param1.width) {
local4 = 0;
while(local4 < param1.height) {
local2.setPixel32(local3,local4,param1.getPixel32(param1.width - 1 - local3,local4));
local4++;
}
local3++;
}
return local2;
}
public static function flipW(param1:BitmapData) : BitmapData {
var local4:int = 0;
var local2:BitmapData = new BitmapData(param1.width,param1.height,true);
var local3:int = 0;
while(local3 < param1.width) {
local4 = 0;
while(local4 < param1.height) {
local2.setPixel32(local3,local4,param1.getPixel32(local3,param1.height - 1 - local4));
local4++;
}
local3++;
}
return local2;
}
}
}
|
package alternativa.tanks.model.news
{
import assets.scroller.color.ScrollThumbSkinGreen;
import assets.scroller.color.ScrollTrackGreen;
import fl.containers.ScrollPane;
import fl.controls.ScrollPolicy;
import flash.display.Sprite;
public class NewsOutput extends ScrollPane
{
private var _cont:Sprite;
public function NewsOutput()
{
this._cont = new Sprite();
super();
this.source = this._cont;
this.horizontalScrollPolicy = ScrollPolicy.OFF;
this.focusEnabled = false;
setStyle("downArrowUpSkin",ScrollArrowDownGreen);
setStyle("downArrowDownSkin",ScrollArrowDownGreen);
setStyle("downArrowOverSkin",ScrollArrowDownGreen);
setStyle("downArrowDisabledSkin",ScrollArrowDownGreen);
setStyle("upArrowUpSkin",ScrollArrowUpGreen);
setStyle("upArrowDownSkin",ScrollArrowUpGreen);
setStyle("upArrowOverSkin",ScrollArrowUpGreen);
setStyle("upArrowDisabledSkin",ScrollArrowUpGreen);
setStyle("trackUpSkin",ScrollTrackGreen);
setStyle("trackDownSkin",ScrollTrackGreen);
setStyle("trackOverSkin",ScrollTrackGreen);
setStyle("trackDisabledSkin",ScrollTrackGreen);
setStyle("thumbUpSkin",ScrollThumbSkinGreen);
setStyle("thumbDownSkin",ScrollThumbSkinGreen);
setStyle("thumbOverSkin",ScrollThumbSkinGreen);
setStyle("thumbDisabledSkin",ScrollThumbSkinGreen);
this.width = 480;
this.height = NewsWindow.MAX_HEIGHT - 70;
}
public function addItem(item:NewsItem) : void
{
this._cont.addChild(item);
this.update();
}
}
}
|
package projects.tanks.client.panel.model.shop.androidspecialoffer.rank {
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 AndroidOffersRankModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:AndroidOffersRankModelServer;
private var client:IAndroidOffersRankModelBase = IAndroidOffersRankModelBase(this);
private var modelId:Long = Long.getLong(359824795,312311046);
public function AndroidOffersRankModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new AndroidOffersRankModelServer(IModel(this));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package _codec.platform.client.core.general.resourcelocale.format {
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 platform.client.core.general.resourcelocale.format.ImagePair;
public class VectorCodecImagePairLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecImagePairLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(ImagePair,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.<ImagePair> = new Vector.<ImagePair>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = ImagePair(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:ImagePair = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<ImagePair> = Vector.<ImagePair>(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.gui.confirm {
import flash.events.Event;
public class ConfirmAlertEvent extends Event {
public static const BUY_ITEM:String = "ConfirmAlertEventBuyItem";
public var cost:int = 0;
public function ConfirmAlertEvent(param1:int) {
super(BUY_ITEM,true);
this.cost = param1;
}
}
}
|
package alternativa.tanks.models.weapon.streamweapon {
import platform.client.fp10.core.type.IGameObject;
[ModelInterface]
public interface StreamWeaponReconfiguredListener {
function streamWeaponReconfigured(param1:IGameObject, param2:Number) : void;
function streamWeaponDistanceChanged(param1:IGameObject, param2:Number) : void;
}
}
|
package com.alternativaplatform.projects.tanks.client.models.battlefield
{
import scpacker.Base;
public class BattlefieldModelBase extends Base
{
public function BattlefieldModelBase()
{
super();
}
}
}
|
package alternativa.tanks.model.presents {
import alternativa.tanks.gui.presents.NewPresentsAlert;
import alternativa.tanks.gui.presents.NewPresentsAlertEvent;
import alternativa.tanks.service.notificationcategories.INotificationGarageCategoriesService;
import projects.tanks.client.commons.types.ItemViewCategoryEnum;
import projects.tanks.client.panel.model.presents.INewPresentsShowingModelBase;
import projects.tanks.client.panel.model.presents.NewPresentsShowingModelBase;
[ModelInfo]
public class NewPresentsShowingModel extends NewPresentsShowingModelBase implements INewPresentsShowingModelBase {
[Inject]
public static var notificationGarageCategoriesService:INotificationGarageCategoriesService;
public function NewPresentsShowingModel() {
super();
}
public function showAlert() : void {
var local1:NewPresentsAlert = new NewPresentsAlert();
local1.addEventListener(NewPresentsAlertEvent.ACCEPT,getFunctionWrapper(this.accept));
local1.addEventListener(NewPresentsAlertEvent.ACCEPT,getFunctionWrapper(this.cancel));
notificationGarageCategoriesService.notifyAboutNewItemsInCategory(ItemViewCategoryEnum.GIVEN_PRESENTS);
}
private function cancel(param1:NewPresentsAlertEvent) : void {
this.closeDialog(NewPresentsAlert(param1.target));
}
private function accept(param1:NewPresentsAlertEvent) : void {
this.closeDialog(NewPresentsAlert(param1.target));
server.showPresents();
}
private function closeDialog(param1:NewPresentsAlert) : void {
param1.removeEventListener(NewPresentsAlertEvent.ACCEPT,getFunctionWrapper(this.accept));
param1.removeEventListener(NewPresentsAlertEvent.CANCEL,getFunctionWrapper(this.cancel));
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapons.common.stream {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import projects.tanks.client.battlefield.models.tankparts.weapons.common.discrete.TargetHit;
import projects.tanks.client.battlefield.types.Vector3d;
public class StreamWeaponCommunicationModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:StreamWeaponCommunicationModelServer;
private var client:IStreamWeaponCommunicationModelBase = IStreamWeaponCommunicationModelBase(this);
private var modelId:Long = Long.getLong(2040386917,729965137);
private var _startFireId:Long = Long.getLong(1582297866,2028596660);
private var _stopFireId:Long = Long.getLong(2129251848,-1338052132);
private var _updateTargetsId:Long = Long.getLong(338478335,1466416629);
private var _updateTargets_directionCodec:ICodec;
private var _updateTargets_targetsCodec:ICodec;
public function StreamWeaponCommunicationModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new StreamWeaponCommunicationModelServer(IModel(this));
this._updateTargets_directionCodec = this._protocol.getCodec(new TypeCodecInfo(Vector3d,false));
this._updateTargets_targetsCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(TargetHit,false),false,1));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._startFireId:
this.client.startFire();
break;
case this._stopFireId:
this.client.stopFire();
break;
case this._updateTargetsId:
this.client.updateTargets(Vector3d(this._updateTargets_directionCodec.decode(param2)),this._updateTargets_targetsCodec.decode(param2) as Vector.<TargetHit>);
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.weapon.shaft.states.transitionhandlers {
import alternativa.tanks.models.weapon.shaft.ShaftWeapon;
import alternativa.tanks.models.weapon.shaft.states.ITransitionHandler;
public class ManualTargetingStopHandler implements ITransitionHandler {
private var weapon:ShaftWeapon;
public function ManualTargetingStopHandler(param1:ShaftWeapon) {
super();
this.weapon = param1;
}
public function execute(param1:*) : void {
if(param1) {
this.weapon.onTargetingModeStop();
}
}
}
}
|
package projects.tanks.client.tanksservices.model.notifier.battle {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
public class BattleNotifierModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BattleNotifierModelServer;
private var client:IBattleNotifierModelBase = IBattleNotifierModelBase(this);
private var modelId:Long = Long.getLong(904565121,-177943041);
private var _leaveBattleId:Long = Long.getLong(1976915722,-215540987);
private var _leaveBattle_userIdCodec:ICodec;
private var _leaveGroupId:Long = Long.getLong(617960803,1927590436);
private var _leaveGroup_userIdCodec:ICodec;
private var _setBattleId:Long = Long.getLong(534256502,-1360731802);
private var _setBattle_usersCodec:ICodec;
public function BattleNotifierModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BattleNotifierModelServer(IModel(this));
this._leaveBattle_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._leaveGroup_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._setBattle_usersCodec = this._protocol.getCodec(new CollectionCodecInfo(new TypeCodecInfo(BattleNotifierData,false),false,1));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._leaveBattleId:
this.client.leaveBattle(Long(this._leaveBattle_userIdCodec.decode(param2)));
break;
case this._leaveGroupId:
this.client.leaveGroup(Long(this._leaveGroup_userIdCodec.decode(param2)));
break;
case this._setBattleId:
this.client.setBattle(this._setBattle_usersCodec.decode(param2) as Vector.<BattleNotifierData>);
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package _codec.projects.tanks.client.commons.types {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import projects.tanks.client.commons.types.ItemViewCategoryEnum;
public class CodecItemViewCategoryEnum implements ICodec {
public function CodecItemViewCategoryEnum() {
super();
}
public function init(param1:IProtocol) : void {
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ItemViewCategoryEnum = null;
var local3:int = int(param1.reader.readInt());
switch(local3) {
case 0:
local2 = ItemViewCategoryEnum.WEAPON;
break;
case 1:
local2 = ItemViewCategoryEnum.ARMOR;
break;
case 2:
local2 = ItemViewCategoryEnum.PAINT;
break;
case 3:
local2 = ItemViewCategoryEnum.INVENTORY;
break;
case 4:
local2 = ItemViewCategoryEnum.KIT;
break;
case 5:
local2 = ItemViewCategoryEnum.SPECIAL;
break;
case 6:
local2 = ItemViewCategoryEnum.GIVEN_PRESENTS;
break;
case 7:
local2 = ItemViewCategoryEnum.RESISTANCE;
break;
case 8:
local2 = ItemViewCategoryEnum.DRONE;
break;
case 9:
local2 = ItemViewCategoryEnum.INVISIBLE;
}
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:int = int(param2.value);
param1.writer.writeInt(local3);
}
}
}
|
package alternativa.tanks.model.shop.event
{
import flash.events.Event;
public class ShopItemChosen extends Event
{
public static const EVENT_TYPE:String = "ShopItemChosenEVENT";
public var itemId:String;
public var gridPosition:int;
public function ShopItemChosen(param1:String, param2:int)
{
super(EVENT_TYPE,true);
this.itemId = param1;
this.gridPosition = param2;
}
}
}
|
package alternativa.tanks.battle.objects.tank.controllers {
import alternativa.tanks.service.settings.keybinding.GameActionEnum;
import flash.utils.Dictionary;
public class TurretActions {
public static const LEFT:int = 1;
public static const RIGHT:int = 2;
public static const CENTER:int = 4;
public static const UP:int = 8;
public static const DOWN:int = 16;
public static const DEFAULT:TurretActions = createDefault();
private var mappings:Dictionary = new Dictionary();
public function TurretActions() {
super();
}
private static function createDefault() : TurretActions {
var local1:TurretActions = new TurretActions();
local1.setMapping(GameActionEnum.ROTATE_TURRET_LEFT,LEFT);
local1.setMapping(GameActionEnum.ROTATE_TURRET_RIGHT,RIGHT);
local1.setMapping(GameActionEnum.CENTER_TURRET,CENTER);
return local1;
}
public function setMapping(param1:GameActionEnum, param2:int) : void {
this.mappings[param1] = param2;
}
public function getTurretAction(param1:GameActionEnum) : int {
return this.mappings[param1];
}
}
}
|
package alternativa.tanks.models.dom.hud
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class MarkerBitmaps_blueMarkerClass extends BitmapAsset
{
public function MarkerBitmaps_blueMarkerClass()
{
super();
}
}
}
|
package alternativa.engine3d.materials
{
import flash.display.BitmapData;
public class MaterialEntry
{
public var keyData:Object;
public var texture:BitmapData;
public var material:TextureMaterial;
public var referenceCount:int;
public function MaterialEntry(param1:Object, param2:TextureMaterial)
{
super();
this.keyData = param1;
this.texture = param1 as BitmapData;
this.material = param2;
}
}
}
|
package controls.scroller.green {
import controls.scroller.*;
public class ScrollThumbSkinGreen extends ScrollThumbSkin {
public function ScrollThumbSkinGreen() {
super();
}
override public function initSkin() : void {
toppng = new ScrollSkinGreen.thumbTop().bitmapData;
midpng = new ScrollSkinGreen.thumbMiddle().bitmapData;
}
}
}
|
package _codec.projects.tanks.client.battlefield.models.tankparts.weapons.machinegun.sfx {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.MultiframeTextureResource;
import platform.client.fp10.core.resource.types.SoundResource;
import platform.client.fp10.core.resource.types.TextureResource;
import projects.tanks.client.battlefield.models.tankparts.sfx.lighting.entity.LightingSFXEntity;
import projects.tanks.client.battlefield.models.tankparts.weapons.machinegun.sfx.MachineGunSFXCC;
public class CodecMachineGunSFXCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_chainStartSound:ICodec;
private var codec_crumbsTexture:ICodec;
private var codec_dustTexture:ICodec;
private var codec_fireAcrossTexture:ICodec;
private var codec_fireAlongTexture:ICodec;
private var codec_hitSound:ICodec;
private var codec_lightingSFXEntity:ICodec;
private var codec_longFailSound:ICodec;
private var codec_shootEndSound:ICodec;
private var codec_shootSound:ICodec;
private var codec_smokeTexture:ICodec;
private var codec_sparklesTexture:ICodec;
private var codec_tankHitSound:ICodec;
private var codec_tankSparklesTexture:ICodec;
private var codec_tracerTexture:ICodec;
private var codec_turbineStartSound:ICodec;
public function CodecMachineGunSFXCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_chainStartSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_crumbsTexture = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_dustTexture = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
this.codec_fireAcrossTexture = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
this.codec_fireAlongTexture = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
this.codec_hitSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_lightingSFXEntity = param1.getCodec(new TypeCodecInfo(LightingSFXEntity,false));
this.codec_longFailSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_shootEndSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_shootSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_smokeTexture = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
this.codec_sparklesTexture = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
this.codec_tankHitSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
this.codec_tankSparklesTexture = param1.getCodec(new TypeCodecInfo(MultiframeTextureResource,false));
this.codec_tracerTexture = param1.getCodec(new TypeCodecInfo(TextureResource,false));
this.codec_turbineStartSound = param1.getCodec(new TypeCodecInfo(SoundResource,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:MachineGunSFXCC = new MachineGunSFXCC();
local2.chainStartSound = this.codec_chainStartSound.decode(param1) as SoundResource;
local2.crumbsTexture = this.codec_crumbsTexture.decode(param1) as TextureResource;
local2.dustTexture = this.codec_dustTexture.decode(param1) as MultiframeTextureResource;
local2.fireAcrossTexture = this.codec_fireAcrossTexture.decode(param1) as MultiframeTextureResource;
local2.fireAlongTexture = this.codec_fireAlongTexture.decode(param1) as MultiframeTextureResource;
local2.hitSound = this.codec_hitSound.decode(param1) as SoundResource;
local2.lightingSFXEntity = this.codec_lightingSFXEntity.decode(param1) as LightingSFXEntity;
local2.longFailSound = this.codec_longFailSound.decode(param1) as SoundResource;
local2.shootEndSound = this.codec_shootEndSound.decode(param1) as SoundResource;
local2.shootSound = this.codec_shootSound.decode(param1) as SoundResource;
local2.smokeTexture = this.codec_smokeTexture.decode(param1) as MultiframeTextureResource;
local2.sparklesTexture = this.codec_sparklesTexture.decode(param1) as MultiframeTextureResource;
local2.tankHitSound = this.codec_tankHitSound.decode(param1) as SoundResource;
local2.tankSparklesTexture = this.codec_tankSparklesTexture.decode(param1) as MultiframeTextureResource;
local2.tracerTexture = this.codec_tracerTexture.decode(param1) as TextureResource;
local2.turbineStartSound = this.codec_turbineStartSound.decode(param1) as SoundResource;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:MachineGunSFXCC = MachineGunSFXCC(param2);
this.codec_chainStartSound.encode(param1,local3.chainStartSound);
this.codec_crumbsTexture.encode(param1,local3.crumbsTexture);
this.codec_dustTexture.encode(param1,local3.dustTexture);
this.codec_fireAcrossTexture.encode(param1,local3.fireAcrossTexture);
this.codec_fireAlongTexture.encode(param1,local3.fireAlongTexture);
this.codec_hitSound.encode(param1,local3.hitSound);
this.codec_lightingSFXEntity.encode(param1,local3.lightingSFXEntity);
this.codec_longFailSound.encode(param1,local3.longFailSound);
this.codec_shootEndSound.encode(param1,local3.shootEndSound);
this.codec_shootSound.encode(param1,local3.shootSound);
this.codec_smokeTexture.encode(param1,local3.smokeTexture);
this.codec_sparklesTexture.encode(param1,local3.sparklesTexture);
this.codec_tankHitSound.encode(param1,local3.tankHitSound);
this.codec_tankSparklesTexture.encode(param1,local3.tankSparklesTexture);
this.codec_tracerTexture.encode(param1,local3.tracerTexture);
this.codec_turbineStartSound.encode(param1,local3.turbineStartSound);
}
}
}
|
package projects.tanks.clients.fp10.libraries.tanksservices.service.clan {
import flash.events.Event;
public class RestrictionJoinClanEvent extends Event {
public static const UPDATE:String = "RestrictionJoinClanEvent.UPDATE";
public function RestrictionJoinClanEvent(param1:String, param2:Boolean = false, param3:Boolean = false) {
super(param1,param2,param3);
}
}
}
|
package projects.tanks.client.entrance.model.entrance.partners {
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.core.general.socialnetwork.types.LoginParameters;
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 CompositePartnerModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var _bindAccountId:Long = Long.getLong(1281188716,1940951489);
private var _bindAccount_uidOrEmailCodec:ICodec;
private var _bindAccount_passwordCodec:ICodec;
private var _finishRegistrationId:Long = Long.getLong(148803981,-1046498619);
private var _finishRegistration_uidCodec:ICodec;
private var _finishRegistration_domainCodec:ICodec;
private var _loadPartnerObjectOnClientId:Long = Long.getLong(1684542055,1718261084);
private var _loadPartnerObjectOnClient_partnerIdCodec:ICodec;
private var _loginViaPartnerId:Long = Long.getLong(1290469154,1689202484);
private var _loginViaPartner_partnerIdCodec:ICodec;
private var _loginViaPartner_urlParamsCodec:ICodec;
private var model:IModel;
public function CompositePartnerModelServer(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._bindAccount_uidOrEmailCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._bindAccount_passwordCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._finishRegistration_uidCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._finishRegistration_domainCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._loadPartnerObjectOnClient_partnerIdCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._loginViaPartner_partnerIdCodec = this.protocol.getCodec(new TypeCodecInfo(String,false));
this._loginViaPartner_urlParamsCodec = this.protocol.getCodec(new TypeCodecInfo(LoginParameters,false));
}
public function bindAccount(param1:String, param2:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._bindAccount_uidOrEmailCodec.encode(this.protocolBuffer,param1);
this._bindAccount_passwordCodec.encode(this.protocolBuffer,param2);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local3:SpaceCommand = new SpaceCommand(Model.object.id,this._bindAccountId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function finishRegistration(param1:String, param2:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._finishRegistration_uidCodec.encode(this.protocolBuffer,param1);
this._finishRegistration_domainCodec.encode(this.protocolBuffer,param2);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local3:SpaceCommand = new SpaceCommand(Model.object.id,this._finishRegistrationId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
public function loadPartnerObjectOnClient(param1:String) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._loadPartnerObjectOnClient_partnerIdCodec.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._loadPartnerObjectOnClientId,this.protocolBuffer);
var local3:IGameObject = Model.object;
var local4:ISpace = local3.space;
local4.commandSender.sendCommand(local2);
this.protocolBuffer.optionalMap.clear();
}
public function loginViaPartner(param1:String, param2:LoginParameters) : void {
ByteArray(this.protocolBuffer.writer).position = 0;
ByteArray(this.protocolBuffer.writer).length = 0;
this._loginViaPartner_partnerIdCodec.encode(this.protocolBuffer,param1);
this._loginViaPartner_urlParamsCodec.encode(this.protocolBuffer,param2);
ByteArray(this.protocolBuffer.writer).position = 0;
if(Model.object == null) {
throw new Error("Execute method without model context.");
}
var local3:SpaceCommand = new SpaceCommand(Model.object.id,this._loginViaPartnerId,this.protocolBuffer);
var local4:IGameObject = Model.object;
var local5:ISpace = local4.space;
local5.commandSender.sendCommand(local3);
this.protocolBuffer.optionalMap.clear();
}
}
}
|
package projects.tanks.client.panel.model.payment.modes.android {
public interface IAndroidPayModelBase {
function consume(param1:String) : void;
}
}
|
package alternativa.tanks.gui.itemslist {
import alternativa.osgi.service.clientlog.IClientLog;
import fl.controls.listClasses.CellRenderer;
import fl.controls.listClasses.ListData;
import flash.display.DisplayObject;
import platform.client.fp10.core.resource.IResourceLoadingListener;
import platform.client.fp10.core.resource.Resource;
import platform.client.fp10.core.resource.types.ImageResource;
public class PartsListRenderer extends CellRenderer implements IResourceLoadingListener {
[Inject]
public static var clientLog:IClientLog;
private static var defaultStyles:Object = {
"upSkin":null,
"downSkin":null,
"overSkin":null,
"disabledSkin":null,
"selectedDisabledSkin":null,
"selectedUpSkin":null,
"selectedDownSkin":null,
"selectedOverSkin":null,
"textFormat":null,
"disabledTextFormat":null,
"embedFonts":null,
"textPadding":5
};
private var nicon:DisplayObject;
private var sicon:DisplayObject;
public function PartsListRenderer() {
super();
this.buttonMode = true;
this.useHandCursor = true;
}
override public function set data(param1:Object) : void {
_data = param1;
this.nicon = param1.iconNormal;
this.sicon = param1.iconSelected;
}
override public function set listData(param1:ListData) : void {
var local2:ImageResource = _data.dat.preview as ImageResource;
if(local2 != null) {
if(local2.data == null) {
local2.loadLazyResource(this);
}
}
_listData = param1;
label = _listData.label;
if(this.nicon != null && this.sicon != null) {
setStyle("icon",this.nicon);
setStyle("selectedUpIcon",this.sicon);
setStyle("selectedOverIcon",this.sicon);
setStyle("selectedDownIcon",this.sicon);
}
}
override protected function drawBackground() : void {
}
override protected function drawLayout() : void {
}
override protected function drawIcon() : void {
var local2:String = null;
var local1:DisplayObject = icon;
local2 = enabled ? mouseState : "disabled";
if(selected) {
local2 = "selected" + local2.substr(0,1).toUpperCase() + local2.substr(1);
}
local2 += "Icon";
var local3:Object = getStyleValue(local2);
if(local3 == null) {
local3 = getStyleValue("icon");
}
if(local3 != null) {
icon = getDisplayObjectInstance(local3);
}
if(icon != null) {
addChildAt(icon,1);
}
if(local1 != null && local1 != icon && local1.parent == this) {
removeChild(local1);
}
}
public function onResourceLoadingStart(param1:Resource) : void {
}
public function onResourceLoadingProgress(param1:Resource, param2:int) : void {
}
public function onResourceLoadingComplete(param1:Resource) : void {
}
public function onResourceLoadingError(param1:Resource, param2:String) : void {
}
public function onResourceLoadingFatalError(param1:Resource, param2:String) : void {
}
}
}
|
package platform.client.fp10.core.resource {
public class ResourceStatus {
public static const QUEUED:String = "Queued";
public static const REQUESTED:String = "Data requested";
public static const LOADED:String = "Loaded";
public static const LOAD_ERROR:String = "Loading error";
public static const UNLOADED:String = "Unloaded";
public function ResourceStatus() {
super();
}
}
}
|
package alternativa.tanks.models.weapon.weakening {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class IWeaponWeakeningModelAdapt implements IWeaponWeakeningModel {
private var object:IGameObject;
private var impl:IWeaponWeakeningModel;
public function IWeaponWeakeningModelAdapt(param1:IGameObject, param2:IWeaponWeakeningModel) {
super();
this.object = param1;
this.impl = param2;
}
public function getDistanceWeakening() : DistanceWeakening {
var result:DistanceWeakening = null;
try {
Model.object = this.object;
result = this.impl.getDistanceWeakening();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package assets.windowinner.bitmaps {
import flash.display.BitmapData;
[Embed(source="/_assets/assets.windowinner.bitmaps.WindowInnerLeft.png")]
public class WindowInnerLeft extends BitmapData {
public function WindowInnerLeft(param1:int, param2:int, param3:Boolean = true, param4:uint = 0) {
super(param1,param2,param3,param4);
}
}
}
|
package projects.tanks.client.panel.model.shop.challenges.toclient {
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
public class ChallengeShopItemsCC {
private var _shopBattlePass:IGameObject;
private var _shopBattlePassId:Long;
private var _starsBundle:IGameObject;
private var _starsBundleId:Long;
public function ChallengeShopItemsCC(param1:IGameObject = null, param2:Long = null, param3:IGameObject = null, param4:Long = null) {
super();
this._shopBattlePass = param1;
this._shopBattlePassId = param2;
this._starsBundle = param3;
this._starsBundleId = param4;
}
public function get shopBattlePass() : IGameObject {
return this._shopBattlePass;
}
public function set shopBattlePass(param1:IGameObject) : void {
this._shopBattlePass = param1;
}
public function get shopBattlePassId() : Long {
return this._shopBattlePassId;
}
public function set shopBattlePassId(param1:Long) : void {
this._shopBattlePassId = param1;
}
public function get starsBundle() : IGameObject {
return this._starsBundle;
}
public function set starsBundle(param1:IGameObject) : void {
this._starsBundle = param1;
}
public function get starsBundleId() : Long {
return this._starsBundleId;
}
public function set starsBundleId(param1:Long) : void {
this._starsBundleId = param1;
}
public function toString() : String {
var local1:String = "ChallengeShopItemsCC [";
local1 += "shopBattlePass = " + this.shopBattlePass + " ";
local1 += "shopBattlePassId = " + this.shopBattlePassId + " ";
local1 += "starsBundle = " + this.starsBundle + " ";
local1 += "starsBundleId = " + this.starsBundleId + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.bonuses {
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.scene3d.Renderer;
import alternativa.tanks.utils.objectpool.Pool;
import alternativa.tanks.utils.objectpool.PooledObject;
public class SpawnAnimation extends PooledObject implements Renderer {
[Inject]
public static var battleService:BattleService;
private static const ALPHA_SPEED:Number = 0.001;
private var object:ISpawnableObject;
private var alpha:Number = 0;
public function SpawnAnimation(param1:Pool) {
super(param1);
}
public function start(param1:ISpawnableObject) : void {
this.object = param1;
this.alpha = 0;
param1.addSignal(this.destroy);
battleService.getBattleScene3D().addRenderer(this,0);
}
public function render(param1:int, param2:int) : void {
this.alpha += ALPHA_SPEED * param2;
if(this.alpha > 1) {
this.alpha = 1;
}
this.object.setAlpha(this.alpha);
if(this.alpha >= 1) {
this.destroy();
}
}
private function destroy() : void {
if(this.object != null) {
battleService.getBattleScene3D().removeRenderer(this,0);
this.object.removeSignal(this.destroy);
this.object = null;
recycle();
}
}
}
}
|
package alternativa.tanks.model.challenge
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class ChallengeCongratulationWindow_cryBitmap extends BitmapAsset
{
public function ChallengeCongratulationWindow_cryBitmap()
{
super();
}
}
}
|
package alternativa.tanks.utils {
public class BitVector {
private var elements:Vector.<int>;
public function BitVector(param1:uint) {
super();
this.elements = new Vector.<int>(param1 >> 5,true);
}
public function setBit(param1:int) : void {
var local2:int = param1 >> 5;
this.elements[local2] |= 1 << (param1 & 0x1F);
}
public function clearBit(param1:int) : void {
var local2:int = param1 >> 5;
this.elements[local2] &= ~(1 << (param1 & 0x1F));
}
public function getBit(param1:int) : int {
var local2:int = param1 >> 5;
return this.elements[local2] >> (param1 & 0x1F) & 1;
}
public function clear() : void {
var local1:int = 0;
while(local1 < this.elements.length) {
this.elements[local1] = 0;
local1++;
}
}
}
}
|
package mx.core {
public interface ILayoutDirectionElement {
function get layoutDirection() : String;
function set layoutDirection(value:String) : void;
function invalidateLayoutDirection() : void;
}
}
|
package projects.tanks.client.tanksservices.model.logging {
public class UserActionsLoggerCC {
private var _loggingEnabled:Boolean;
public function UserActionsLoggerCC(param1:Boolean = false) {
super();
this._loggingEnabled = param1;
}
public function get loggingEnabled() : Boolean {
return this._loggingEnabled;
}
public function set loggingEnabled(param1:Boolean) : void {
this._loggingEnabled = param1;
}
public function toString() : String {
var local1:String = "UserActionsLoggerCC [";
local1 += "loggingEnabled = " + this.loggingEnabled + " ";
return local1 + "]";
}
}
}
|
package alternativa.tanks.gui.communication.button {
public interface CommunicationPanelTabControl {
function getCategory() : String;
function get enabled() : Boolean;
function set enabled(param1:Boolean) : void;
}
}
|
package alternativa.utils {
public final class Long {
private var _low:uint;
private var _high:uint;
public function Long(param1:uint, param2:uint) {
super();
this._high = param1;
this._low = param2;
}
private function get low() : int {
return this._low;
}
private function get high() : uint {
return this._high;
}
public function toOct() : String {
var local4:uint = 0;
var local5:uint = 0;
var local1:String = "";
var local2:String = "";
var local3:uint = 63;
var local6:uint = 0;
var local7:int = 0;
while(local7 < 5) {
local4 = uint((this.high & local3 << 4 + local6) >>> local6 + 4);
local5 = uint((this.low & local3 << local6) >>> local6);
local1 = this._toOct(local4) + local1;
local2 = this._toOct(local5) + local2;
local6 += 6;
local7++;
}
var local8:String = local1 + this._toOct(((this.high & uint(15)) << 2) + (this.low >>> 30)) + local2;
return this.trimLeadingZeros(local8);
}
private function trimLeadingZeros(param1:String) : String {
var local2:int = 0;
while(local2 < param1.length && param1.charAt(local2) == "0") {
local2++;
}
return param1.substr(local2);
}
private function _toOct(param1:uint) : String {
var local2:String = param1.toString(8);
return (local2.length < 2 ? "0" : "") + local2;
}
}
}
|
package projects.tanks.client.battlefield.models.drone {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
public class DroneIndicatorModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function DroneIndicatorModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package alternativa.tanks.models.effects.common.bonuscommon
{
public class BonusConst
{
public static const BONUS_HALF_SIZE:Number = 75;
public static const COS_ONE_DEGREE:Number = Math.cos(Math.PI / 180);
public static const PARACHUTE_OFFSET_Z:Number = 50;
public static const BONUS_OFFSET_Z:Number = 450;
public static const ANGULAR_SPEED_Z:Number = 0.1;
public static const BOUND_SPHERE_RADIUS:Number = Math.sqrt(2) * BONUS_HALF_SIZE * 1.6;
public function BonusConst()
{
super();
}
}
}
|
package alternativa.tanks.models.battle.gui.drone {
import alternativa.tanks.battle.BattleService;
import alternativa.tanks.battle.events.BattleEventDispatcher;
import alternativa.tanks.battle.events.BattleEventSupport;
import alternativa.tanks.battle.events.BattleFinishEvent;
import alternativa.tanks.battle.events.TankActivationEvent;
import alternativa.tanks.battle.events.TankLoadedEvent;
import alternativa.tanks.battle.events.TankUnloadedEvent;
import alternativa.tanks.battle.events.death.TankDeadEvent;
import alternativa.tanks.battle.objects.tank.Tank;
import alternativa.tanks.models.battle.gui.inventory.IInventoryPanel;
import alternativa.tanks.models.battle.gui.inventory.InventoryItem;
import alternativa.tanks.models.drones.Drone;
import alternativa.tanks.models.inventory.IInventoryModel;
import alternativa.tanks.models.inventory.InventoryItemType;
import alternativa.tanks.models.inventory.InventoryLock;
import alternativa.tanks.models.tank.ITankModel;
import alternativa.tanks.models.tank.TankSet;
import alternativa.tanks.models.tank.configuration.TankConfiguration;
import alternativa.tanks.models.tank.event.TankEntityCreationListener;
import alternativa.tanks.service.settings.ISettingsService;
import alternativa.tanks.sfx.drone.DroneSFX;
import alternativa.tanks.sfx.drone.DroneSFXData;
import alternativa.utils.TextureMaterialRegistry;
import flash.utils.Dictionary;
import platform.client.fp10.core.model.ObjectLoadListener;
import platform.client.fp10.core.model.ObjectUnloadListener;
import projects.tanks.client.battlefield.models.drone.DroneIndicatorCC;
import projects.tanks.client.battlefield.models.drone.DroneIndicatorModelBase;
import projects.tanks.client.battlefield.models.drone.IDroneIndicatorModelBase;
import projects.tanks.client.battlefield.models.user.tank.TankLogicState;
import projects.tanks.clients.flash.commons.models.coloring.IColoring;
import projects.tanks.clients.flash.resources.object3ds.IObject3DS;
import projects.tanks.clients.flash.resources.resource.Tanks3DSResource;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.settings.UserSettingsChangedEvent;
import projects.tanks.clients.fp10.libraries.tanksservices.service.logging.settings.UserSettingsChangedService;
[ModelInfo]
public class DroneIndicatorModel extends DroneIndicatorModelBase implements IDroneIndicatorModelBase, IDroneModel, TankEntityCreationListener, ObjectLoadListener, ObjectUnloadListener {
[Inject]
public static var inventoryPanel:IInventoryPanel;
[Inject]
public static var battleService:BattleService;
[Inject]
public static var textureMaterialRegistry:TextureMaterialRegistry;
[Inject]
public static var settingsService:ISettingsService;
[Inject]
public static var battleEventDispatcher:BattleEventDispatcher;
[Inject]
public static var settingsChangedService:UserSettingsChangedService;
private var localTank:Tank;
private var droneIndicatorItem:InventoryItem;
private var battleEventSupport:BattleEventSupport;
private var drones:Dictionary = new Dictionary();
public function DroneIndicatorModel() {
super();
this.battleEventSupport = new BattleEventSupport(battleEventDispatcher);
this.battleEventSupport.addEventHandler(TankActivationEvent,this.onTankActivation);
this.battleEventSupport.addEventHandler(TankDeadEvent,this.onTankDeactivation);
this.battleEventSupport.addEventHandler(BattleFinishEvent,this.onBattleFinish);
this.battleEventSupport.addEventHandler(TankUnloadedEvent,this.onTankUnloaded);
this.battleEventSupport.addEventHandler(TankLoadedEvent,this.onTankLoad);
this.battleEventSupport.activateHandlers();
}
public function onTankEntityCreated(param1:Tank, param2:Boolean, param3:TankLogicState) : void {
var local4:DroneIndicatorCC = this.getSavedState();
if(local4 == null) {
putData(DroneIndicatorCC,getInitParam());
}
this.initDrones(param1,param2,param3);
this.getSavedState().timeToReloadMs = 0;
if(param2) {
this.localTank = param1;
this.updateBatteryIndicator();
}
}
private function updateBatteryIndicator() : void {
inventoryPanel.setVisible(InventoryItemType.BATTERY,this.hasDrone(),false);
}
public function initDrones(param1:Tank, param2:Boolean, param3:TankLogicState) : void {
var local4:DroneIndicatorCC = null;
var local5:IInventoryModel = null;
if(this.hasDrone()) {
local4 = DroneIndicatorCC(getData(DroneIndicatorCC));
if(param2) {
this.droneIndicatorItem = new InventoryItem(null,InventoryItemType.BATTERY,local4.batteryAmount,null);
inventoryPanel.assignItemToSlot(this.droneIndicatorItem,InventoryItemType.BATTERY);
if(local4.timeToReloadMs != 0) {
inventoryPanel.activateCooldown(InventoryItemType.BATTERY,local4.timeToReloadMs);
}
local5 = IInventoryModel(battleService.getBattle().adapt(IInventoryModel));
local5.lockItem(InventoryItemType.BATTERY,InventoryLock.FORCED,!local4.droneReady);
}
this.initDrone(param1,param2);
this.setCooldownState(param1,local4.timeToReloadMs);
this.setDroneState(param1,local4.droneReady);
if(!param2) {
this.onTankActiveStateChanged(param1,param3 == TankLogicState.ACTIVE);
}
}
}
public function ready() : void {
this.setDroneReadiness(true);
}
public function notReady() : void {
this.setDroneReadiness(false);
}
public function reload(param1:int) : void {
var local2:Tank = object.adapt(ITankModel).getTank();
this.cooldown(local2,param1);
if(local2 == this.localTank) {
inventoryPanel.activateCooldown(InventoryItemType.BATTERY,param1);
}
}
public function setDroneReadiness(param1:Boolean) : void {
var local3:IInventoryModel = null;
var local2:Tank = object.adapt(ITankModel).getTank();
this.setDroneState(local2,param1);
this.getSavedState().droneReady = param1;
if(local2 == this.localTank) {
inventoryPanel.setVisible(InventoryItemType.BATTERY,this.hasDrone(),false);
local3 = IInventoryModel(battleService.getBattle().adapt(IInventoryModel));
local3.lockItem(InventoryItemType.BATTERY,InventoryLock.FORCED,!param1);
}
}
public function setBatteriesAmount(param1:int) : void {
this.droneIndicatorItem.count = param1;
this.getSavedState().batteryAmount = param1;
inventoryPanel.itemUpdateCount(this.droneIndicatorItem);
}
private function initDrone(param1:Tank, param2:Boolean) : void {
var local3:TankConfiguration = TankConfiguration(param1.user.adapt(TankConfiguration));
var local4:TankSet = ITankModel(object.adapt(ITankModel)).getTankSet();
var local5:Tanks3DSResource = IObject3DS(local4.drone.adapt(IObject3DS)).getResource3DS();
var local6:DroneSFXData = DroneSFX(local4.drone.adapt(DroneSFX)).getSfxData();
var local7:IColoring = IColoring(local3.getColoringObject().adapt(IColoring));
this.drones[param1] = new Drone(param1,param2,battleService,local5,settingsService,textureMaterialRegistry,local7,local6);
}
private function cooldown(param1:Tank, param2:int) : void {
var local3:Drone = this.drones[param1];
if(local3 != null) {
local3.cooldown(param2);
}
}
private function setDroneState(param1:Tank, param2:Boolean) : void {
var local3:Drone = this.drones[param1];
if(local3 != null) {
local3.setState(param2);
}
}
private function setCooldownState(param1:Tank, param2:int) : void {
var local3:Drone = this.drones[param1];
if(local3 != null) {
local3.setInitialCooldownState(param2);
}
}
private function hasDrone() : Boolean {
return ITankModel(object.adapt(ITankModel)).getTankSet().drone != null;
}
private function onTankActivation(param1:TankActivationEvent) : void {
this.onTankActiveStateChanged(param1.tank,true);
}
private function onTankDeactivation(param1:TankDeadEvent) : void {
this.onTankActiveStateChanged(ITankModel(param1.victim.adapt(ITankModel)).getTank(),false);
}
private function onBattleFinish(param1:BattleFinishEvent) : void {
var local2:Drone = null;
for each(local2 in this.drones) {
local2.onTankActiveStateChanged(false);
}
}
private function onTankActiveStateChanged(param1:Tank, param2:Boolean) : void {
var local3:Drone = this.drones[param1];
if(local3 != null) {
local3.onTankActiveStateChanged(param2);
}
}
private function onSettingsChanged(param1:UserSettingsChangedEvent) : void {
var local2:Drone = null;
for each(local2 in this.drones) {
local2.updateGameSettings();
}
}
public function objectLoaded() : void {
settingsChangedService.addEventListener(UserSettingsChangedEvent.TYPE,this.onSettingsChanged);
}
public function objectUnloaded() : void {
settingsChangedService.removeEventListener(UserSettingsChangedEvent.TYPE,this.onSettingsChanged);
this.destroy();
}
private function destroy() : void {
var local1:Tank = ITankModel(object.adapt(ITankModel)).getTank();
this.destroyDroneForTank(local1);
}
private function destroyDroneForTank(param1:Tank) : void {
var local2:Drone = this.drones[param1];
if(local2 != null) {
if(Boolean(local2.getCurrentRenderer())) {
local2.getCurrentRenderer().stop();
}
local2.destroy();
}
delete this.drones[param1];
}
private function getSavedState() : DroneIndicatorCC {
return DroneIndicatorCC(getData(DroneIndicatorCC));
}
private function onTankLoad(param1:TankLoadedEvent) : void {
if(param1.isLocal) {
this.localTank = param1.tank;
this.updateBatteryIndicator();
}
}
private function onTankUnloaded(param1:TankUnloadedEvent) : void {
delete global[this.destroyDroneForTank(param1.tank)];
}
public function canOverheal() : Boolean {
return getInitParam().canOverheal;
}
}
}
|
package alternativa.tanks.models.battle.gui.inventory.cooldown {
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import utils.graphics.SectorMask;
public class CooldownIndicator extends Sprite {
private var _sectorMask:SectorMask;
public function CooldownIndicator(param1:BitmapData) {
super();
var local2:Bitmap = new Bitmap(param1);
addChild(local2);
this._sectorMask = new SectorMask(local2.width);
addChild(this._sectorMask);
mask = this._sectorMask;
}
public function setProgress(param1:Number, param2:Number) : void {
this._sectorMask.setProgress(param1,param2);
}
}
}
|
package alternativa.tanks.models.tank.configuration {
import alternativa.types.Long;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battlefield.models.user.configuration.ITankConfigurationModelBase;
import projects.tanks.client.battlefield.models.user.configuration.TankConfigurationModelBase;
[ModelInfo]
public class TankConfigurationModel extends TankConfigurationModelBase implements ITankConfigurationModelBase, TankConfiguration {
public function TankConfigurationModel() {
super();
}
public function getHullObject() : IGameObject {
return object.space.getObject(getInitParam().hullId);
}
public function getWeaponObject() : IGameObject {
return object.space.getObject(getInitParam().weaponId);
}
public function getColoringObject() : IGameObject {
return object.space.getObject(getInitParam().coloringId);
}
public function hasDrone() : Boolean {
return getInitParam().droneId != Long.getLong(0,0);
}
public function getDrone() : IGameObject {
return object.space.getObject(getInitParam().droneId);
}
}
}
|
package projects.tanks.client.entrance.model.entrance.clienthalt {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class ServerHaltEntranceModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ServerHaltEntranceModelServer;
private var client:IServerHaltEntranceModelBase = IServerHaltEntranceModelBase(this);
private var modelId:Long = Long.getLong(946668342,813083086);
private var _serverHaltId:Long = Long.getLong(1338714818,1184888981);
public function ServerHaltEntranceModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ServerHaltEntranceModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ServerHaltEntranceCC,false)));
}
protected function getInitParam() : ServerHaltEntranceCC {
return ServerHaltEntranceCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._serverHaltId:
this.client.serverHalt();
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.news
{
import mx.core.BitmapAsset;
[ExcludeClass]
public class NewsIcons_hand_crystalls extends BitmapAsset
{
public function NewsIcons_hand_crystalls()
{
super();
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.notifier.premium {
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.tanksservices.model.notifier.premium.PremiumNotifierCC;
public class CodecPremiumNotifierCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_lifeTimeInSeconds:ICodec;
public function CodecPremiumNotifierCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_lifeTimeInSeconds = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:PremiumNotifierCC = new PremiumNotifierCC();
local2.lifeTimeInSeconds = this.codec_lifeTimeInSeconds.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:PremiumNotifierCC = PremiumNotifierCC(param2);
this.codec_lifeTimeInSeconds.encode(param1,local3.lifeTimeInSeconds);
}
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.score {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.gui.gui.statistics.field.score.RugbyScoreIndicator_blueScoreClass.png")]
public class RugbyScoreIndicator_blueScoreClass extends BitmapAsset {
public function RugbyScoreIndicator_blueScoreClass() {
super();
}
}
}
|
package alternativa.tanks.model.info {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.resource.types.ImageResource;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.battleselect.model.battle.BattleInfoCC;
public class IBattleInfoAdapt implements IBattleInfo {
private var object:IGameObject;
private var impl:IBattleInfo;
public function IBattleInfoAdapt(param1:IGameObject, param2:IBattleInfo) {
super();
this.object = param1;
this.impl = param2;
}
public function getConstructor() : BattleInfoCC {
var result:BattleInfoCC = null;
try {
Model.object = this.object;
result = this.impl.getConstructor();
}
finally {
Model.popObject();
}
return result;
}
public function getPreviewResource() : ImageResource {
var result:ImageResource = null;
try {
Model.object = this.object;
result = this.impl.getPreviewResource();
}
finally {
Model.popObject();
}
return result;
}
}
}
|
package projects.tanks.client.battlefield.models.battle.gui.chat {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import projects.tanks.client.battleservice.model.battle.team.BattleTeam;
public class BattleChatModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:BattleChatModelServer;
private var client:IBattleChatModelBase = IBattleChatModelBase(this);
private var modelId:Long = Long.getLong(1254001332,-1596966842);
private var _addMessageId:Long = Long.getLong(1268063749,-1740285311);
private var _addMessage_userIdCodec:ICodec;
private var _addMessage_messageCodec:ICodec;
private var _addMessage_typeCodec:ICodec;
private var _addSpectatorTeamMessageId:Long = Long.getLong(1310559631,-90978751);
private var _addSpectatorTeamMessage_uidCodec:ICodec;
private var _addSpectatorTeamMessage_messageCodec:ICodec;
private var _addSystemMessageId:Long = Long.getLong(211790396,868140590);
private var _addSystemMessage_messageCodec:ICodec;
private var _addTeamMessageId:Long = Long.getLong(540625227,-85921692);
private var _addTeamMessage_userIdCodec:ICodec;
private var _addTeamMessage_messageCodec:ICodec;
private var _addTeamMessage_typeCodec:ICodec;
private var _updateTeamHeaderId:Long = Long.getLong(159380621,1692473102);
private var _updateTeamHeader_headerCodec:ICodec;
public function BattleChatModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new BattleChatModelServer(IModel(this));
this._addMessage_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._addMessage_messageCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._addMessage_typeCodec = this._protocol.getCodec(new EnumCodecInfo(BattleTeam,false));
this._addSpectatorTeamMessage_uidCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._addSpectatorTeamMessage_messageCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._addSystemMessage_messageCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._addTeamMessage_userIdCodec = this._protocol.getCodec(new TypeCodecInfo(Long,false));
this._addTeamMessage_messageCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
this._addTeamMessage_typeCodec = this._protocol.getCodec(new EnumCodecInfo(BattleTeam,false));
this._updateTeamHeader_headerCodec = this._protocol.getCodec(new TypeCodecInfo(String,false));
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._addMessageId:
this.client.addMessage(Long(this._addMessage_userIdCodec.decode(param2)),String(this._addMessage_messageCodec.decode(param2)),BattleTeam(this._addMessage_typeCodec.decode(param2)));
break;
case this._addSpectatorTeamMessageId:
this.client.addSpectatorTeamMessage(String(this._addSpectatorTeamMessage_uidCodec.decode(param2)),String(this._addSpectatorTeamMessage_messageCodec.decode(param2)));
break;
case this._addSystemMessageId:
this.client.addSystemMessage(String(this._addSystemMessage_messageCodec.decode(param2)));
break;
case this._addTeamMessageId:
this.client.addTeamMessage(Long(this._addTeamMessage_userIdCodec.decode(param2)),String(this._addTeamMessage_messageCodec.decode(param2)),BattleTeam(this._addTeamMessage_typeCodec.decode(param2)));
break;
case this._updateTeamHeaderId:
this.client.updateTeamHeader(String(this._updateTeamHeader_headerCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.model.panel
{
public interface IBattleSettings
{
function get showSkyBox() : Boolean;
function get showFPS() : Boolean;
function get showBattleChat() : Boolean;
function get adaptiveFPS() : Boolean;
function get enableMipMapping() : Boolean;
function get inverseBackDriving() : Boolean;
function get bgSound() : Boolean;
function get muteSound() : Boolean;
function get showShadowsTank() : Boolean;
function get fog() : Boolean;
function get dust() : Boolean;
function get useSoftParticle() : Boolean;
function get shadows() : Boolean;
function get defferedLighting() : Boolean;
function get animationTracks() : Boolean;
function get animationDamage() : Boolean;
function get shadowUnderTanks() : Boolean;
function get coloredFPS() : Boolean;
function get useSSAO() : Boolean;
}
}
|
package alternativa.tanks.gui.friends {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.friends.FriendsWindowStateBigButton_ButtonDownCenter.png")]
public class FriendsWindowStateBigButton_ButtonDownCenter extends BitmapAsset {
public function FriendsWindowStateBigButton_ButtonDownCenter() {
super();
}
}
}
|
package _codec.projects.tanks.client.tanksservices.model.notifier.premium {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.tanksservices.model.notifier.premium.PremiumNotifierCC;
public class VectorCodecPremiumNotifierCCLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecPremiumNotifierCCLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(PremiumNotifierCC,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.<PremiumNotifierCC> = new Vector.<PremiumNotifierCC>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = PremiumNotifierCC(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:PremiumNotifierCC = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<PremiumNotifierCC> = Vector.<PremiumNotifierCC>(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.gui.battle {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.gui.panel.StarsIcon;
import assets.Diamond;
import controls.base.DefaultButtonBase;
import controls.base.LabelBase;
import flash.display.Bitmap;
import flash.events.MouseEvent;
import flash.text.TextLineMetrics;
import forms.ColorConstants;
import projects.tanks.clients.flash.commons.services.notification.Notification;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class BattleFinishNotification extends Notification {
[Inject]
public static var localeService:ILocaleService;
private static const DEFAULT_BUTTON_WIDTH:int = 96;
private var _messageLabel:LabelBase;
private var _rejectButton:DefaultButtonBase;
private var _diamond:Diamond;
private var _stars:Bitmap;
protected var _showStars:Boolean;
public function BattleFinishNotification() {
super();
}
override protected function init() : void {
super.init();
this._messageLabel = new LabelBase();
this._messageLabel.color = ColorConstants.GREEN_LABEL;
this._messageLabel.mouseEnabled = false;
addChild(this._messageLabel);
this._messageLabel.htmlText = message;
this._diamond = new Diamond();
addChild(this._diamond);
this._stars = new StarsIcon.icon_class();
if(this._showStars) {
addChild(this._stars);
}
this._rejectButton = new DefaultButtonBase();
this._rejectButton.width = DEFAULT_BUTTON_WIDTH;
this._rejectButton.label = localeService.getText(TanksLocale.TEXT_CLOSE_LABEL);
addChild(this._rejectButton);
autoClosable = false;
}
override protected function setEvents() : void {
super.setEvents();
this._rejectButton.addEventListener(MouseEvent.CLICK,this.onRejectClick);
}
override protected function removeEvents() : void {
super.removeEvents();
this._rejectButton.removeEventListener(MouseEvent.CLICK,this.onRejectClick);
}
private function onRejectClick(param1:MouseEvent) : void {
this.closeNotification();
}
override protected function closeNotification() : void {
hide();
}
override protected function resize() : void {
var local4:TextLineMetrics = null;
this._messageLabel.x = GAP + 9;
this._messageLabel.y = GAP + 7;
var local1:int = this._messageLabel.numLines - (this._showStars ? 2 : 1);
var local2:TextLineMetrics = this._messageLabel.getLineMetrics(local1);
this._diamond.x = int(this._messageLabel.x + local2.width + 6);
this._diamond.y = int(this._messageLabel.y + local2.height * local1 + local2.descent * (local1 - 1));
if(this._showStars) {
local4 = this._messageLabel.getLineMetrics(this._messageLabel.numLines - 1);
this._stars.x = int(this._messageLabel.x + local4.width + 6);
this._stars.y = int(this._messageLabel.y + this._messageLabel.height - 14);
}
_innerHeight = this._messageLabel.y + this._messageLabel.height - 3;
var local3:int = this._messageLabel.x + this._messageLabel.width + GAP * 2;
if(local3 > _width) {
_width = local3;
}
this._rejectButton.x = _width - this._rejectButton.width - GAP;
this._rejectButton.y = _innerHeight + 16;
_height = this._rejectButton.y + this._rejectButton.height + GAP + 1;
super.resize();
}
protected function getStarsRewardText(param1:int) : String {
return "<font color=\"#f3c800\">" + String(param1) + "</font>";
}
}
}
|
package projects.tanks.client.battleservice.model.battle.dm {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.OptionalMap;
import alternativa.protocol.ProtocolBuffer;
import flash.utils.ByteArray;
import platform.client.fp10.core.model.IModel;
public class BattleDMModelServer {
private var protocol:IProtocol;
private var protocolBuffer:ProtocolBuffer;
private var model:IModel;
public function BattleDMModelServer(param1:IModel) {
super();
this.model = param1;
var local2:ByteArray = new ByteArray();
this.protocol = IProtocol(OSGi.getInstance().getService(IProtocol));
this.protocolBuffer = new ProtocolBuffer(local2,local2,new OptionalMap());
}
}
}
|
package projects.tanks.client.battlefield.models.tankparts.weapon.common {
import alternativa.osgi.OSGi;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Float;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class WeaponCommonModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:WeaponCommonModelServer;
private var client:IWeaponCommonModelBase = IWeaponCommonModelBase(this);
private var modelId:Long = Long.getLong(288238981,44520685);
private var _setBuffedId:Long = Long.getLong(222121220,-2013237836);
private var _setBuffed_buffedCodec:ICodec;
private var _setBuffed_kickbackCodec:ICodec;
public function WeaponCommonModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new WeaponCommonModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(WeaponCommonCC,false)));
this._setBuffed_buffedCodec = this._protocol.getCodec(new TypeCodecInfo(Boolean,false));
this._setBuffed_kickbackCodec = this._protocol.getCodec(new TypeCodecInfo(Float,false));
}
protected function getInitParam() : WeaponCommonCC {
return WeaponCommonCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
switch(param1) {
case this._setBuffedId:
this.client.setBuffed(Boolean(this._setBuffed_buffedCodec.decode(param2)),Number(this._setBuffed_kickbackCodec.decode(param2)));
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.sfx.shoot.snowman
{
import alternativa.engine3d.core.Camera3D;
import alternativa.engine3d.core.Object3D;
import alternativa.init.Main;
import alternativa.math.Vector3;
import alternativa.model.IObjectLoadListener;
import alternativa.object.ClientObject;
import alternativa.service.IModelService;
import alternativa.tanks.engine3d.MaterialType;
import alternativa.tanks.engine3d.TextureAnimation;
import alternativa.tanks.models.battlefield.BattlefieldModel;
import alternativa.tanks.models.battlefield.IBattleField;
import alternativa.tanks.models.sfx.AnimatedLightEffect;
import alternativa.tanks.models.sfx.LightDataManager;
import alternativa.tanks.models.sfx.MuzzlePositionProvider;
import alternativa.tanks.models.sfx.SpriteShotEffect;
import alternativa.tanks.models.sfx.colortransform.ColorTransformEntry;
import alternativa.tanks.models.sfx.colortransform.IColorTransformModel;
import alternativa.tanks.models.sfx.shoot.ICommonShootSFX;
import alternativa.tanks.models.weapon.snowman.SnowmanShot;
import alternativa.tanks.services.materialregistry.IMaterialRegistry;
import alternativa.tanks.services.objectpool.IObjectPoolService;
import alternativa.tanks.sfx.AnimatedSpriteEffectNew;
import alternativa.tanks.sfx.EffectsPair;
import alternativa.tanks.sfx.Sound3D;
import alternativa.tanks.sfx.Sound3DEffect;
import alternativa.tanks.sfx.SoundOptions;
import alternativa.tanks.sfx.StaticObject3DPositionProvider;
import alternativa.tanks.utils.GraphicsUtils;
import flash.display.BitmapData;
import flash.geom.ColorTransform;
import scpacker.resource.ResourceType;
import scpacker.resource.ResourceUtil;
public class SnowmanSFXModel implements ICommonShootSFX, ISnowmanSFX, IObjectLoadListener
{
private static var materialRegistry:IMaterialRegistry;
private static var objectPoolService:IObjectPoolService;
private static var turretPosition:Vector3 = new Vector3();
private static var bfModel:BattlefieldModel;
public function SnowmanSFXModel()
{
super();
materialRegistry = IMaterialRegistry(Main.osgi.getService(IMaterialRegistry));
objectPoolService = IObjectPoolService(Main.osgi.getService(IObjectPoolService));
bfModel = Main.osgi.getService(IBattleField) as BattlefieldModel;
}
public function initObject(clientObject:ClientObject, explosionSoundId:String, explosionTextureId:String, plasmaTextureId:String, shotSoundId:String, shotTextureId:String) : void
{
var data:SnowmanSFXData = new SnowmanSFXData();
var flashTexture:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,shotTextureId).bitmapData;
data.shotFlashMaterial = materialRegistry.textureMaterialRegistry.getMaterial(MaterialType.EFFECT,flashTexture,1,false);
var plasmaTexture:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,plasmaTextureId).bitmapData;
data.shotMaterials = materialRegistry.materialSequenceRegistry.getSequence(MaterialType.EFFECT,plasmaTexture,plasmaTexture.height,SnowmanShot.SIZE / plasmaTexture.height).materials;
var explosionTexture:BitmapData = ResourceUtil.getResource(ResourceType.IMAGE,explosionTextureId).bitmapData;
data.explosionMaterials = materialRegistry.materialSequenceRegistry.getSequence(MaterialType.EFFECT,explosionTexture,explosionTexture.height,3).materials;
data.shotSound = ResourceUtil.getResource(ResourceType.SOUND,shotSoundId).sound;
data.explosionSound = ResourceUtil.getResource(ResourceType.SOUND,explosionSoundId).sound;
data.explosionData = GraphicsUtils.getTextureAnimation(null,explosionTexture,200,200);
data.explosionData.fps = 30;
data.shotData = GraphicsUtils.getTextureAnimation(null,plasmaTexture,150,150);
data.shotData.fps = 30;
clientObject.putParams(SnowmanSFXModel,data);
}
public function createShotEffects(clientObject:ClientObject, muzzleLocalPos:Vector3, turret:Object3D, camera:Camera3D) : EffectsPair
{
var sound:Sound3D = null;
var data:SnowmanSFXData = this.getSnowmanSFXData(clientObject);
var shotEffect:SpriteShotEffect = SpriteShotEffect(objectPoolService.objectPool.getObject(SpriteShotEffect));
shotEffect.init(data.shotFlashMaterial,muzzleLocalPos,turret,10,80,50,50,data.colorTransform);
var soundEffect:Sound3DEffect = null;
if(data.shotSound != null)
{
sound = Sound3D.create(data.shotSound,SoundOptions.nearRadius,SoundOptions.farRadius,SoundOptions.farDelimiter,0.8);
turretPosition.x = turret.x;
turretPosition.y = turret.y;
turretPosition.z = turret.z;
soundEffect = Sound3DEffect.create(objectPoolService.objectPool,null,turretPosition,sound);
}
this.createMuzzleLightEffect(muzzleLocalPos,turret,clientObject);
return new EffectsPair(shotEffect,soundEffect);
}
private function createMuzzleLightEffect(param1:Vector3, param2:Object3D, turretObject:ClientObject) : void
{
var _loc3_:AnimatedLightEffect = AnimatedLightEffect(objectPoolService.objectPool.getObject(AnimatedLightEffect));
var _loc4_:MuzzlePositionProvider = MuzzlePositionProvider(objectPoolService.objectPool.getObject(MuzzlePositionProvider));
_loc4_.init(param2,param1);
_loc3_.init(_loc4_,LightDataManager.getLightDataExplosion(turretObject.id));
bfModel.addGraphicEffect(_loc3_);
}
public function createExplosionEffects(clientObject:ClientObject, pos:Vector3, camera:Camera3D, weakeningCoeff:Number) : EffectsPair
{
var data:SnowmanSFXData = this.getSnowmanSFXData(clientObject);
var size:Number = 180 * (1 + weakeningCoeff);
var explosionEffect:AnimatedSpriteEffectNew = AnimatedSpriteEffectNew(objectPoolService.objectPool.getObject(AnimatedSpriteEffectNew));
var animation:TextureAnimation = data.explosionData;
var position:StaticObject3DPositionProvider = StaticObject3DPositionProvider(objectPoolService.objectPool.getObject(StaticObject3DPositionProvider));
position.init(pos,50);
explosionEffect.init(size,size,animation,6.28 * Math.random(),position);
this.createExplosionLightEffect(pos,clientObject);
return new EffectsPair(explosionEffect,null);
}
private function createExplosionLightEffect(param1:Vector3, turretObject:ClientObject) : void
{
var _loc2_:AnimatedLightEffect = AnimatedLightEffect(objectPoolService.objectPool.getObject(AnimatedLightEffect));
var _loc3_:StaticObject3DPositionProvider = StaticObject3DPositionProvider(objectPoolService.objectPool.getObject(StaticObject3DPositionProvider));
_loc3_.init(param1,110);
_loc2_.init(_loc3_,LightDataManager.getLightDataExplosion(turretObject.id));
bfModel.addGraphicEffect(_loc2_);
}
public function getSnowmanSFXData(clientObject:ClientObject) : SnowmanSFXData
{
return SnowmanSFXData(clientObject.getParams(SnowmanSFXModel));
}
public function objectLoaded(clientObject:ClientObject) : void
{
var sfxData:SnowmanSFXData = null;
var colorTransforms:Vector.<ColorTransformEntry> = null;
var ctStruct:ColorTransformEntry = null;
var modelService:IModelService = IModelService(Main.osgi.getService(IModelService));
var colorTransformModel:IColorTransformModel = IColorTransformModel(modelService.getModelForObject(clientObject,IColorTransformModel));
if(colorTransformModel != null)
{
sfxData = this.getSnowmanSFXData(clientObject);
colorTransforms = colorTransformModel.getModelData(clientObject);
ctStruct = colorTransforms[0];
sfxData.colorTransform = new ColorTransform(ctStruct.redMultiplier,ctStruct.greenMultiplier,ctStruct.blueMultiplier,ctStruct.alphaMultiplier,ctStruct.redOffset,ctStruct.greenOffset,ctStruct.blueOffset,ctStruct.alphaOffset);
}
}
public function objectUnloaded(clientObject:ClientObject) : void
{
}
}
}
|
package alternativa.tanks.gui.clanmanagement {
import alternativa.osgi.service.display.IDisplay;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.ContextMenuPermissionLabel;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.IClanActionListener;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.IClanPositionListener;
import alternativa.tanks.gui.clanmanagement.clanmemberlist.members.HeaderClanMemberList;
import alternativa.tanks.models.clan.membersdata.ClanMembersDataService;
import alternativa.tanks.models.clan.permission.IClanPermissionsModel;
import alternativa.tanks.models.service.ClanService;
import alternativa.types.Long;
import base.DiscreteSprite;
import controls.TankWindow;
import controls.TankWindowInner;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.geom.Point;
import projects.tanks.client.clans.clan.clanmembersdata.UserData;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.client.clans.clan.permissions.ClanPermission;
import projects.tanks.clients.fp10.libraries.tanksservices.service.clan.ClanUserInfoService;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.AlertUtils;
import projects.tanks.clients.fp10.libraries.tanksservices.utils.KeyUpListenerPriority;
public class ClanPermissionsManager extends DiscreteSprite implements IClanPositionListener, IClanActionListener {
[Inject]
public static var clanService:ClanService;
[Inject]
public static var clanUserInfoService:ClanUserInfoService;
[Inject]
public static var display:IDisplay;
[Inject]
public static var clanMembersDataService:ClanMembersDataService;
private static var menu:ClanPermissionsManager;
public static var permissionsModel:IClanPermissionsModel;
private static var currentId:Long;
private static var positionUpdateListeners:Vector.<IClanPositionListener> = new Vector.<IClanPositionListener>();
private static const MARGIN:int = 6;
private var window:TankWindow;
private var windowInner:TankWindowInner;
private var id:Long;
private var numPositions:int = 0;
public function ClanPermissionsManager(param1:Long, param2:Long) {
super();
this.id = param1;
currentId = param2;
this.window = new TankWindow();
addChild(this.window);
this.windowInner = new TankWindowInner(0,0,TankWindowInner.GREEN);
this.windowInner.x = MARGIN;
this.windowInner.y = MARGIN;
this.window.addChild(this.windowInner);
this.createPermissions(clanMembersDataService.getPermission(param2));
addPositionUpdateListener(this);
ClanActionsManager.addActionsUpdateListener(this);
addEventListener(MouseEvent.ROLL_OUT,this.mouseOut);
display.stage.addEventListener(MouseEvent.CLICK,this.onContextMenuClick);
display.stage.addEventListener(Event.DEACTIVATE,this.onContextMenuDeactivate);
display.stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUp,false,KeyUpListenerPriority.CONTEXT_MENU);
}
public static function resize(param1:int) : void {
if(menu != null) {
menu.resize(param1);
}
}
public static function setScreenPosition(param1:ContextMenuPermissionLabel) : void {
var local2:Point = null;
if(menu != null && menu.id == param1.userId) {
local2 = param1.localToGlobal(new Point(0,0));
menu.setScreenPosition(local2);
}
}
public static function addPositionUpdateListener(param1:IClanPositionListener) : void {
positionUpdateListeners.push(param1);
}
public static function removePositionListener(param1:IClanPositionListener) : void {
var local2:int = int(positionUpdateListeners.indexOf(param1));
if(local2 >= 0) {
positionUpdateListeners.splice(local2,1);
}
}
public static function removePositionListeners() : void {
positionUpdateListeners = new Vector.<IClanPositionListener>();
}
public static function updatePositions(param1:UserData) : void {
var local2:IClanPositionListener = null;
for each(local2 in positionUpdateListeners) {
if(local2.userId == param1.userId) {
local2.dataChanged(param1);
}
}
ClanActionsManager.updateActions();
}
public static function show(param1:Long, param2:Long, param3:ContextMenuPermissionLabel) : void {
if(menu != null) {
remove();
}
menu = new ClanPermissionsManager(param1,param2);
menu.setScreenPosition(param3.localToGlobal(new Point(0,0)));
menu.resize(HeaderClanMemberList.getPositionColumnWidth());
display.stage.addChild(menu);
}
private static function remove() : void {
menu.parent.removeChild(menu);
menu.removeListeners();
menu = null;
}
private static function permissionByValue(param1:int) : ClanPermission {
var local2:ClanPermission = null;
for each(local2 in ClanPermission.values) {
if(local2.value == param1) {
return local2;
}
}
return null;
}
public static function removeListeners() : void {
positionUpdateListeners = new Vector.<IClanPositionListener>();
}
private function onContextMenuClick(param1:MouseEvent) : void {
if(param1.target.parent != null && param1.target.parent as ContextMenuPermissionLabel == null) {
remove();
}
}
private function onContextMenuDeactivate(param1:Event) : void {
remove();
}
private function mouseOut(param1:MouseEvent) : void {
remove();
}
private function onKeyUp(param1:KeyboardEvent) : void {
if(AlertUtils.isCancelKey(param1.keyCode)) {
param1.stopImmediatePropagation();
remove();
}
}
public function dataChanged(param1:UserData) : void {
remove();
}
public function updateActions() : void {
remove();
}
private function createPermissions(param1:ClanPermission) : void {
var local4:ContextMenuPermissionLabel = null;
var local2:int = 0;
var local3:int = param1.value + 1;
while(local3 < ClanPermission.values.length - 1) {
local4 = ContextMenuPermissionLabel.createPositionLabel(permissionByValue(local3));
local4.y = local2;
local4.addEventListener(MouseEvent.CLICK,this.onPickPosition,false,0,true);
this.windowInner.addChild(local4);
local2 += ContextMenuPermissionLabel.HEIGHT;
++this.numPositions;
local3++;
}
}
private function onPickPosition(param1:MouseEvent) : void {
var local2:ContextMenuPermissionLabel = null;
if(Boolean(clanUserInfoService.hasAction(ClanAction.PERMISSION_DISTRIBUTION)) && param1.target.parent != null && param1.target.parent as ContextMenuPermissionLabel != null) {
local2 = param1.target.parent as ContextMenuPermissionLabel;
permissionsModel.setPosition(menu.id,local2.permission);
remove();
}
}
public function setScreenPosition(param1:Point) : void {
menu.x = param1.x - MARGIN;
menu.y = param1.y - MARGIN;
if(menu.y > display.stage.height - 60 - menu.height) {
menu.y = display.stage.height - 60 - menu.height;
}
}
public function resize(param1:int) : void {
var local3:ContextMenuPermissionLabel = null;
this.windowInner.width = param1;
this.windowInner.height = ContextMenuPermissionLabel.HEIGHT * this.numPositions;
var local2:int = 0;
while(local2 < this.windowInner.numChildren) {
if(this.windowInner.getChildAt(local2) is ContextMenuPermissionLabel) {
local3 = ContextMenuPermissionLabel(this.windowInner.getChildAt(local2));
local3.width = this.windowInner.width;
}
local2++;
}
this.window.width = param1 + 2 * MARGIN;
this.window.height = 2 * MARGIN + this.windowInner.height;
}
public function removeListeners() : void {
removePositionListener(this);
ClanActionsManager.removeActionsListener(this);
removeEventListener(MouseEvent.ROLL_OUT,this.mouseOut);
display.stage.removeEventListener(MouseEvent.CLICK,this.onContextMenuClick);
display.stage.removeEventListener(Event.DEACTIVATE,this.onContextMenuDeactivate);
display.stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUp);
}
public function get userId() : Long {
return this.id;
}
}
}
|
package alternativa.engine3d.loaders.events {
import flash.events.Event;
import flash.events.ProgressEvent;
public class LoaderProgressEvent extends ProgressEvent {
public static const LOADER_PROGRESS:String = "loaderProgress";
private var _filesTotal:int;
private var _filesLoaded:int;
private var _totalProgress:Number = 0;
public function LoaderProgressEvent(param1:String, param2:int, param3:int, param4:Number = 0, param5:uint = 0, param6:uint = 0) {
super(param1,false,false,param5,param6);
this._filesTotal = param2;
this._filesLoaded = param3;
this._totalProgress = param4;
}
public function get filesTotal() : int {
return this._filesTotal;
}
public function get filesLoaded() : int {
return this._filesLoaded;
}
public function get totalProgress() : Number {
return this._totalProgress;
}
override public function clone() : Event {
return new LoaderProgressEvent(type,this._filesTotal,this._filesLoaded,this._totalProgress,bytesLoaded,bytesTotal);
}
override public function toString() : String {
return "[LoaderProgressEvent filesTotal=" + this._filesTotal + ", filesLoaded=" + this._filesLoaded + ", totalProgress=" + this._totalProgress.toFixed(2) + "]";
}
}
}
|
package com.alternativaplatform.projects.tanks.client.models.tank
{
public class TankSpawnState
{
public static var NEWCOME:TankSpawnState = new TankSpawnState("NEWCOME");
public static var ACTIVE:TankSpawnState = new TankSpawnState("ACTIVE");
public static var SUICIDE:TankSpawnState = new TankSpawnState("SUICIDE");
private var name:String;
public function TankSpawnState(name:String)
{
super();
this.name = name;
}
public function toString() : String
{
return this.name;
}
}
}
|
package com.alternativaplatform.projects.tanks.client.models.tank
{
import alternativa.types.Long;
public class TankResources
{
public var deadTankColoringId:Long;
public function TankResources()
{
super();
}
}
}
|
package alternativa.tanks.gui.premiumaccount {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.gui.premiumaccount.PremiumAccountIcons_premiumIconForWelcomeAlertClass.png")]
public class PremiumAccountIcons_premiumIconForWelcomeAlertClass extends BitmapAsset {
public function PremiumAccountIcons_premiumIconForWelcomeAlertClass() {
super();
}
}
}
|
package projects.tanks.client.clans.osgi {
import _codec.projects.tanks.client.clans.clan.clanflag.CodecClanFlag;
import _codec.projects.tanks.client.clans.clan.clanflag.VectorCodecClanFlagLevel1;
import _codec.projects.tanks.client.clans.clan.clanfriends.CodecClanFriendsCC;
import _codec.projects.tanks.client.clans.clan.clanfriends.VectorCodecClanFriendsCCLevel1;
import _codec.projects.tanks.client.clans.clan.clanmembersdata.CodecClanMembersCC;
import _codec.projects.tanks.client.clans.clan.clanmembersdata.CodecUserData;
import _codec.projects.tanks.client.clans.clan.clanmembersdata.VectorCodecClanMembersCCLevel1;
import _codec.projects.tanks.client.clans.clan.clanmembersdata.VectorCodecUserDataLevel1;
import _codec.projects.tanks.client.clans.clan.info.CodecClanInfoCC;
import _codec.projects.tanks.client.clans.clan.info.VectorCodecClanInfoCCLevel1;
import _codec.projects.tanks.client.clans.clan.permissions.CodecClanAction;
import _codec.projects.tanks.client.clans.clan.permissions.CodecClanPermission;
import _codec.projects.tanks.client.clans.clan.permissions.CodecClanPermissionsCC;
import _codec.projects.tanks.client.clans.clan.permissions.VectorCodecClanActionLevel1;
import _codec.projects.tanks.client.clans.clan.permissions.VectorCodecClanPermissionLevel1;
import _codec.projects.tanks.client.clans.clan.permissions.VectorCodecClanPermissionsCCLevel1;
import _codec.projects.tanks.client.clans.container.CodecContainerCC;
import _codec.projects.tanks.client.clans.container.VectorCodecContainerCCLevel1;
import _codec.projects.tanks.client.clans.license.user.CodecLicenseClanUserCC;
import _codec.projects.tanks.client.clans.license.user.VectorCodecLicenseClanUserCCLevel1;
import _codec.projects.tanks.client.clans.notifier.CodecClanNotifierData;
import _codec.projects.tanks.client.clans.notifier.VectorCodecClanNotifierDataLevel1;
import _codec.projects.tanks.client.clans.panel.foreignclan.CodecForeignClanCC;
import _codec.projects.tanks.client.clans.panel.foreignclan.CodecForeignClanData;
import _codec.projects.tanks.client.clans.panel.foreignclan.VectorCodecForeignClanCCLevel1;
import _codec.projects.tanks.client.clans.panel.foreignclan.VectorCodecForeignClanDataLevel1;
import _codec.projects.tanks.client.clans.panel.loadingclan.CodecClanLoadingPanelCC;
import _codec.projects.tanks.client.clans.panel.loadingclan.VectorCodecClanLoadingPanelCCLevel1;
import _codec.projects.tanks.client.clans.panel.notification.CodecClanPanelNotificationCC;
import _codec.projects.tanks.client.clans.panel.notification.VectorCodecClanPanelNotificationCCLevel1;
import _codec.projects.tanks.client.clans.space.createclan.CodecClanCreateCC;
import _codec.projects.tanks.client.clans.space.createclan.VectorCodecClanCreateCCLevel1;
import _codec.projects.tanks.client.clans.user.CodecClanUserCC;
import _codec.projects.tanks.client.clans.user.VectorCodecClanUserCCLevel1;
import alternativa.osgi.OSGi;
import alternativa.osgi.bundle.IBundleActivator;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.EnumCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.registry.ModelRegistry;
import projects.tanks.client.clans.clan.clanflag.ClanFlag;
import projects.tanks.client.clans.clan.clanfriends.ClanFriendsCC;
import projects.tanks.client.clans.clan.clanmembersdata.ClanMembersCC;
import projects.tanks.client.clans.clan.clanmembersdata.UserData;
import projects.tanks.client.clans.clan.info.ClanInfoCC;
import projects.tanks.client.clans.clan.permissions.ClanAction;
import projects.tanks.client.clans.clan.permissions.ClanPermission;
import projects.tanks.client.clans.clan.permissions.ClanPermissionsCC;
import projects.tanks.client.clans.container.ContainerCC;
import projects.tanks.client.clans.license.user.LicenseClanUserCC;
import projects.tanks.client.clans.notifier.ClanNotifierData;
import projects.tanks.client.clans.panel.foreignclan.ForeignClanCC;
import projects.tanks.client.clans.panel.foreignclan.ForeignClanData;
import projects.tanks.client.clans.panel.loadingclan.ClanLoadingPanelCC;
import projects.tanks.client.clans.panel.notification.ClanPanelNotificationCC;
import projects.tanks.client.clans.space.createclan.ClanCreateCC;
import projects.tanks.client.clans.user.ClanUserCC;
public class Activator implements IBundleActivator {
public static var osgi:OSGi;
public function Activator() {
super();
}
public function start(param1:OSGi) : void {
var local4:ICodec = null;
osgi = param1;
var local2:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local2.register(Long.getLong(454139398,-2069165154),Long.getLong(1925555464,-742779729));
local2.register(Long.getLong(454139398,-2069165154),Long.getLong(680200609,-1147294464));
local2.register(Long.getLong(454139398,-2069165154),Long.getLong(1659309065,-71192762));
local2.register(Long.getLong(454139398,-2069165154),Long.getLong(1659309105,-102307188));
local2.register(Long.getLong(454139398,-2069165154),Long.getLong(1767156062,-1193480447));
local2.register(Long.getLong(454139398,-2069165154),Long.getLong(615510449,-291351864));
local2.register(Long.getLong(454139398,-2069165154),Long.getLong(1820972193,-1147714599));
local2.register(Long.getLong(454139398,-2069165154),Long.getLong(1902588706,-1770274302));
local2.register(Long.getLong(454139398,-2069165154),Long.getLong(1149292226,-49512386));
local2.register(Long.getLong(202978443,152865914),Long.getLong(1980347621,1611632721));
local2.register(Long.getLong(202978443,152865914),Long.getLong(1261234115,476186094));
local2.register(Long.getLong(1575927935,-367368112),Long.getLong(946943636,-1512579195));
local2.register(Long.getLong(1575927935,-367368112),Long.getLong(709518332,1700494084));
local2.register(Long.getLong(525873271,1744909560),Long.getLong(123212251,-1982333947));
local2.register(Long.getLong(1889621503,1893984398),Long.getLong(2135860306,-1585042188));
local2.register(Long.getLong(1889621503,1893984398),Long.getLong(526095397,633372847));
local2.register(Long.getLong(1889621503,1893984398),Long.getLong(489547868,-896284526));
local2.register(Long.getLong(1647741962,-1293471250),Long.getLong(264735719,2108782023));
local2.register(Long.getLong(794660588,-483099162),Long.getLong(492813833,1824512689));
local2.register(Long.getLong(794660588,-483099162),Long.getLong(1902640351,1514469490));
local2.register(Long.getLong(1448266566,-1893699662),Long.getLong(47370739,-335983741));
local2.register(Long.getLong(1448266566,-1893699662),Long.getLong(1468492941,414226622));
local2.register(Long.getLong(1408324582,-1932105818),Long.getLong(340356364,-824818575));
local2.register(Long.getLong(1408324582,-1932105818),Long.getLong(1961112713,-2039360050));
local2.register(Long.getLong(1602467880,168781542),Long.getLong(871743923,-1602562917));
local2.register(Long.getLong(1978103354,1644120870),Long.getLong(742414901,491655143));
local2.register(Long.getLong(1978103354,1644120870),Long.getLong(521749674,-1882127080));
local2.register(Long.getLong(1850785827,-2022019480),Long.getLong(2052398186,-511753871));
local2.register(Long.getLong(1029456312,194126704),Long.getLong(2072556979,560987130));
local2.register(Long.getLong(1029456312,194126704),Long.getLong(1821924666,143246274));
local2.register(Long.getLong(1029456312,194126704),Long.getLong(1269926118,-537285713));
local2.register(Long.getLong(1029456312,194126704),Long.getLong(2037318745,22259876));
local2.register(Long.getLong(1029456312,194126704),Long.getLong(1203575776,253980200));
local2.register(Long.getLong(1029456312,194126704),Long.getLong(763277444,804297489));
local2.register(Long.getLong(606942677,1590617894),Long.getLong(1587343137,-1916924187));
local2.register(Long.getLong(606942677,1590617894),Long.getLong(723365112,-1678221051));
local2.register(Long.getLong(606942677,1590617894),Long.getLong(1322847239,424158635));
local2.register(Long.getLong(1406824912,-478599334),Long.getLong(224690586,33129736));
local2.register(Long.getLong(1406824912,-478599334),Long.getLong(661618191,747527866));
local2.register(Long.getLong(1406824912,-478599334),Long.getLong(255752141,-162666891));
local2.register(Long.getLong(1406824912,-478599334),Long.getLong(1686179352,1619108917));
local2.register(Long.getLong(1406824912,-478599334),Long.getLong(2117528051,-1228799124));
local2.register(Long.getLong(1406824912,-478599334),Long.getLong(899591349,1207281551));
local2.register(Long.getLong(1406824912,-478599334),Long.getLong(255677344,1199269997));
local2.register(Long.getLong(1406824912,-478599334),Long.getLong(180626480,535638748));
local2.register(Long.getLong(1420566941,-260091189),Long.getLong(511635594,2072865495));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(57363867,1237781863));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(618126442,-725356522));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(1671975780,-1329402274));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(57363920,-817863194));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(57363960,-848977620));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(325235064,-2121980921));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(1693514433,32146500));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(944293305,-1852342578));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(1492352330,720837769));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(1273341198,-1482111631));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(193176875,2068732989));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(193176886,893937818));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(1136230800,538530230));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(2062667168,-2002974215));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(1570177194,1280257195));
local2.register(Long.getLong(259670316,1522052296),Long.getLong(321756128,1414681448));
local2.register(Long.getLong(471234096,-1683897946),Long.getLong(1264515209,-1616011663));
local2.register(Long.getLong(471234096,-1683897946),Long.getLong(545265830,-796542002));
local2.register(Long.getLong(1233534043,-1972982554),Long.getLong(1928764250,-1868285925));
local2.register(Long.getLong(1233534043,-1972982554),Long.getLong(337850372,-157499174));
local2.register(Long.getLong(1120804751,-1974844538),Long.getLong(591561906,1809211473));
local2.register(Long.getLong(1120804751,-1974844538),Long.getLong(1158549911,-1988807186));
local2.register(Long.getLong(151267905,-1393229156),Long.getLong(1638331388,1514392729));
local2.register(Long.getLong(151267905,-1393229156),Long.getLong(751334509,-1941322344));
local2.register(Long.getLong(205268203,-139952058),Long.getLong(230800152,-1398596335));
local2.register(Long.getLong(205268203,-139952058),Long.getLong(1435129862,-1648365870));
var local3:IProtocol = IProtocol(osgi.getService(IProtocol));
local4 = new CodecClanFlag();
local3.registerCodec(new TypeCodecInfo(ClanFlag,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanFlag,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanFriendsCC();
local3.registerCodec(new TypeCodecInfo(ClanFriendsCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanFriendsCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanMembersCC();
local3.registerCodec(new TypeCodecInfo(ClanMembersCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanMembersCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecUserData();
local3.registerCodec(new TypeCodecInfo(UserData,false),local4);
local3.registerCodec(new TypeCodecInfo(UserData,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanInfoCC();
local3.registerCodec(new TypeCodecInfo(ClanInfoCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanInfoCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanAction();
local3.registerCodec(new EnumCodecInfo(ClanAction,false),local4);
local3.registerCodec(new EnumCodecInfo(ClanAction,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanPermission();
local3.registerCodec(new EnumCodecInfo(ClanPermission,false),local4);
local3.registerCodec(new EnumCodecInfo(ClanPermission,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanPermissionsCC();
local3.registerCodec(new TypeCodecInfo(ClanPermissionsCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanPermissionsCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecContainerCC();
local3.registerCodec(new TypeCodecInfo(ContainerCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ContainerCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecLicenseClanUserCC();
local3.registerCodec(new TypeCodecInfo(LicenseClanUserCC,false),local4);
local3.registerCodec(new TypeCodecInfo(LicenseClanUserCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanNotifierData();
local3.registerCodec(new TypeCodecInfo(ClanNotifierData,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanNotifierData,true),new OptionalCodecDecorator(local4));
local4 = new CodecForeignClanCC();
local3.registerCodec(new TypeCodecInfo(ForeignClanCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ForeignClanCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecForeignClanData();
local3.registerCodec(new TypeCodecInfo(ForeignClanData,false),local4);
local3.registerCodec(new TypeCodecInfo(ForeignClanData,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanLoadingPanelCC();
local3.registerCodec(new TypeCodecInfo(ClanLoadingPanelCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanLoadingPanelCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanPanelNotificationCC();
local3.registerCodec(new TypeCodecInfo(ClanPanelNotificationCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanPanelNotificationCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanCreateCC();
local3.registerCodec(new TypeCodecInfo(ClanCreateCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanCreateCC,true),new OptionalCodecDecorator(local4));
local4 = new CodecClanUserCC();
local3.registerCodec(new TypeCodecInfo(ClanUserCC,false),local4);
local3.registerCodec(new TypeCodecInfo(ClanUserCC,true),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanFlagLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanFlag,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanFlag,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanFlagLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanFlag,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanFlag,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanFriendsCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanFriendsCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanFriendsCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanFriendsCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanFriendsCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanFriendsCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanMembersCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanMembersCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanMembersCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanMembersCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanMembersCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanMembersCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecUserDataLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(UserData,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(UserData,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecUserDataLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(UserData,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(UserData,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanInfoCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanInfoCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanInfoCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanInfoCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanInfoCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanInfoCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanActionLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ClanAction,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ClanAction,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanActionLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ClanAction,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ClanAction,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanPermissionLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ClanPermission,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ClanPermission,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanPermissionLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ClanPermission,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new EnumCodecInfo(ClanPermission,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanPermissionsCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanPermissionsCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanPermissionsCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanPermissionsCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanPermissionsCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanPermissionsCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecContainerCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ContainerCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ContainerCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecContainerCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ContainerCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ContainerCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecLicenseClanUserCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(LicenseClanUserCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(LicenseClanUserCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecLicenseClanUserCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(LicenseClanUserCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(LicenseClanUserCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanNotifierDataLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanNotifierData,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanNotifierData,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanNotifierDataLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanNotifierData,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanNotifierData,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecForeignClanCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ForeignClanCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ForeignClanCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecForeignClanCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ForeignClanCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ForeignClanCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecForeignClanDataLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ForeignClanData,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ForeignClanData,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecForeignClanDataLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ForeignClanData,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ForeignClanData,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanLoadingPanelCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanLoadingPanelCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanLoadingPanelCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanLoadingPanelCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanLoadingPanelCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanLoadingPanelCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanPanelNotificationCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanPanelNotificationCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanPanelNotificationCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanPanelNotificationCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanPanelNotificationCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanPanelNotificationCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanCreateCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanCreateCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanCreateCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanCreateCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanCreateCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanCreateCC,true),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanUserCCLevel1(false);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanUserCC,false),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanUserCC,false),true,1),new OptionalCodecDecorator(local4));
local4 = new VectorCodecClanUserCCLevel1(true);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanUserCC,true),false,1),local4);
local3.registerCodec(new CollectionCodecInfo(new TypeCodecInfo(ClanUserCC,true),true,1),new OptionalCodecDecorator(local4));
}
public function stop(param1:OSGi) : void {
}
}
}
|
package alternativa.tanks.models.user.accepted {
import alternativa.types.Long;
import projects.tanks.client.clans.user.accepted.ClanUserAcceptedModelBase;
import projects.tanks.client.clans.user.accepted.IClanUserAcceptedModelBase;
[ModelInfo]
public class ClanUserAcceptedModel extends ClanUserAcceptedModelBase implements IClanUserAcceptedModelBase {
public function ClanUserAcceptedModel() {
super();
}
public function onAdding(param1:Long) : void {
}
public function onRemoved(param1:Long) : void {
}
}
}
|
package _codec.projects.tanks.client.panel.model.shopabonement {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.type.IGameObject;
import projects.tanks.client.panel.model.shopabonement.ShopAbonementsCC;
public class CodecShopAbonementsCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_categoriesWithBonus:ICodec;
public function CodecShopAbonementsCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_categoriesWithBonus = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(IGameObject,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:ShopAbonementsCC = new ShopAbonementsCC();
local2.categoriesWithBonus = this.codec_categoriesWithBonus.decode(param1) as Vector.<IGameObject>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:ShopAbonementsCC = ShopAbonementsCC(param2);
this.codec_categoriesWithBonus.encode(param1,local3.categoriesWithBonus);
}
}
}
|
package alternativa.tanks.models.battle.battlefield.map {
import alternativa.engine3d.core.Face;
import alternativa.engine3d.materials.TextureMaterial;
import alternativa.engine3d.objects.Mesh;
import alternativa.proplib.objects.PropMesh;
import alternativa.utils.textureutils.TextureByteData;
public class TexturedMeshesCollection implements TexturedPropsCollection {
private var meshes:Vector.<Mesh> = new Vector.<Mesh>();
private var propMesh:PropMesh;
private var textureName:String;
private var excludedMaterialName:String;
public function TexturedMeshesCollection(param1:PropMesh, param2:String) {
super();
this.propMesh = param1;
this.textureName = param2;
}
public function add(param1:Mesh, param2:String = null) : void {
this.excludedMaterialName = param2;
this.meshes.push(param1);
}
public function getTextureData() : TextureByteData {
return this.propMesh.textures.getValue(this.textureName);
}
public function setMaterial(param1:TextureMaterial) : void {
var local2:Mesh = null;
var local3:Face = null;
for each(local2 in this.meshes) {
for each(local3 in local2.faces) {
if(Boolean(this.excludedMaterialName) && local3.material.name != this.excludedMaterialName) {
local3.material = param1;
}
}
local2.removeVertex(local2.addVertex(0,0,0));
}
}
}
}
|
package alternativa.tanks.model.item.availabledevices {
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.type.IGameObject;
public class AvailableDevicesAdapt implements AvailableDevices {
private var object:IGameObject;
private var impl:AvailableDevices;
public function AvailableDevicesAdapt(param1:IGameObject, param2:AvailableDevices) {
super();
this.object = param1;
this.impl = param2;
}
public function loadDevices() : void {
try {
Model.object = this.object;
this.impl.loadDevices();
}
finally {
Model.popObject();
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.quest.showing {
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.quest.showing.QuestPrizeInfo;
public class VectorCodecQuestPrizeInfoLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecQuestPrizeInfoLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(QuestPrizeInfo,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.<QuestPrizeInfo> = new Vector.<QuestPrizeInfo>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = QuestPrizeInfo(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:QuestPrizeInfo = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<QuestPrizeInfo> = Vector.<QuestPrizeInfo>(param2);
var local5:int = int(local3.length);
LengthCodecHelper.encodeLength(param1,local5);
var local6:int = 0;
while(local6 < local5) {
this.elementCodec.encode(param1,local3[local6]);
local6++;
}
}
}
}
|
package projects.tanks.client.entrance.model.entrance.newbie {
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 NewbieRegistrationModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:NewbieRegistrationModelServer;
private var client:INewbieRegistrationModelBase = INewbieRegistrationModelBase(this);
private var modelId:Long = Long.getLong(1743693009,-1561207791);
public function NewbieRegistrationModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new NewbieRegistrationModelServer(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 projects.tanks.client.panel.model.shop.featuring {
import alternativa.osgi.OSGi;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import alternativa.types.Long;
import platform.client.fp10.core.model.IModel;
import platform.client.fp10.core.model.impl.Model;
import platform.client.fp10.core.registry.ModelRegistry;
public class ShopItemFeaturingModelBase extends Model {
private var _protocol:IProtocol = IProtocol(OSGi.getInstance().getService(IProtocol));
protected var server:ShopItemFeaturingModelServer;
private var client:IShopItemFeaturingModelBase = IShopItemFeaturingModelBase(this);
private var modelId:Long = Long.getLong(1418336240,1735229935);
public function ShopItemFeaturingModelBase() {
super();
this.initCodecs();
}
protected function initCodecs() : void {
this.server = new ShopItemFeaturingModelServer(IModel(this));
var local1:ModelRegistry = ModelRegistry(OSGi.getInstance().getService(ModelRegistry));
local1.registerModelConstructorCodec(this.modelId,this._protocol.getCodec(new TypeCodecInfo(ShopItemFeaturingCC,false)));
}
protected function getInitParam() : ShopItemFeaturingCC {
return ShopItemFeaturingCC(initParams[Model.object]);
}
override public function invoke(param1:Long, param2:ProtocolBuffer) : void {
var local3:* = param1;
switch(false ? 0 : 0) {
}
}
override public function get id() : Long {
return this.modelId;
}
}
}
|
package alternativa.tanks.models.battle.battlefield.keyboard {
import mx.core.BitmapAsset;
[ExcludeClass]
[Embed(source="/_assets/alternativa.tanks.models.battle.battlefield.keyboard.DeviceIcons_adaptiverechargehammerIconClass.png")]
public class DeviceIcons_adaptiverechargehammerIconClass extends BitmapAsset {
public function DeviceIcons_adaptiverechargehammerIconClass() {
super();
}
}
}
|
package alternativa.tanks.model.item.container.gui {
import alternativa.osgi.service.locale.ILocaleService;
import alternativa.tanks.model.garage.passtoshop.PassToShopService;
import alternativa.tanks.model.item.container.ContainerPanelAction;
import controls.buttons.h50px.GreyBigButton;
import flash.display.DisplayObjectContainer;
import flash.events.MouseEvent;
import platform.client.fp10.core.type.AutoClosable;
import projects.tanks.clients.fp10.libraries.TanksLocale;
public class ContainerPanel implements AutoClosable {
[Inject]
public static var localeService:ILocaleService;
[Inject]
public static var passToShop:PassToShopService;
private var buyButton:GreyBigButton = new GreyBigButton();
private var openButton:GreyBigButton = new GreyBigButton();
private var panelActions:ContainerPanelAction;
private var openListener:Function;
public function ContainerPanel(param1:ContainerPanelAction, param2:Function) {
super();
this.panelActions = param1;
this.openListener = param2;
this.buyButton.label = localeService.getText(TanksLocale.TEXT_GARAGE_INFO_PANEL_BUTTON_BUY_TEXT);
this.buyButton.visible = Boolean(passToShop.isPassToShopEnabled()) && Boolean(param1.needBuyButton());
this.buyButton.addEventListener(MouseEvent.CLICK,this.onBuyClick);
this.openButton.label = localeService.getText(TanksLocale.TEXT_LOOT_OPEN_BUTTON);
this.openButton.addEventListener(MouseEvent.CLICK,this.onOpenClick);
}
public function setOpenButtonEnabled(param1:Boolean) : void {
this.openButton.enabled = param1;
}
private function onBuyClick(param1:MouseEvent) : void {
this.panelActions.clickBuyButton();
}
private function onOpenClick(param1:MouseEvent) : void {
this.openListener.call();
}
public function close() : void {
this.buyButton.removeEventListener(MouseEvent.CLICK,this.onBuyClick);
this.openButton.removeEventListener(MouseEvent.CLICK,this.onOpenClick);
this.buyButton = null;
this.openButton = null;
}
public function updateActionElements(param1:DisplayObjectContainer) : void {
param1.addChild(this.buyButton);
param1.addChild(this.openButton);
this.buyButton.x = 11;
if(this.buyButton.visible) {
this.openButton.x = this.buyButton.x + (this.buyButton.width + 15) * 2;
} else {
this.openButton.x = 11;
}
}
}
}
|
package _codec.projects.tanks.client.panel.model.usercountry {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.panel.model.usercountry.CountryInfo;
public class CodecCountryInfo implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_countryCode:ICodec;
private var codec_countryName:ICodec;
public function CodecCountryInfo() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_countryCode = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_countryName = param1.getCodec(new TypeCodecInfo(String,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:CountryInfo = new CountryInfo();
local2.countryCode = this.codec_countryCode.decode(param1) as String;
local2.countryName = this.codec_countryName.decode(param1) as String;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:CountryInfo = CountryInfo(param2);
this.codec_countryCode.encode(param1,local3.countryCode);
this.codec_countryName.encode(param1,local3.countryName);
}
}
}
|
package _codec.projects.tanks.client.panel.model.mobilequest.quest {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.TypeCodecInfo;
import platform.client.fp10.core.resource.types.ImageResource;
import projects.tanks.client.panel.model.mobilequest.quest.MobileQuestReward;
public class CodecMobileQuestReward implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_count:ICodec;
private var codec_hint:ICodec;
private var codec_name:ICodec;
private var codec_preview:ICodec;
private var codec_step:ICodec;
public function CodecMobileQuestReward() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_count = param1.getCodec(new TypeCodecInfo(int,false));
this.codec_hint = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_name = param1.getCodec(new TypeCodecInfo(String,false));
this.codec_preview = param1.getCodec(new TypeCodecInfo(ImageResource,false));
this.codec_step = param1.getCodec(new TypeCodecInfo(int,false));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:MobileQuestReward = new MobileQuestReward();
local2.count = this.codec_count.decode(param1) as int;
local2.hint = this.codec_hint.decode(param1) as String;
local2.name = this.codec_name.decode(param1) as String;
local2.preview = this.codec_preview.decode(param1) as ImageResource;
local2.step = this.codec_step.decode(param1) as int;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:MobileQuestReward = MobileQuestReward(param2);
this.codec_count.encode(param1,local3.count);
this.codec_hint.encode(param1,local3.hint);
this.codec_name.encode(param1,local3.name);
this.codec_preview.encode(param1,local3.preview);
this.codec_step.encode(param1,local3.step);
}
}
}
|
package projects.tanks.client.garage.skins {
public interface IMountSkinItemModelBase {
}
}
|
package alternativa.tanks.models.battle.gui.gui.statistics.field.timelimit {
import alternativa.tanks.models.battle.gui.gui.statistics.field.wink.WinkManager;
import flash.display.DisplayObject;
import flash.filters.BitmapFilter;
import flash.filters.BitmapFilterQuality;
import flash.filters.DropShadowFilter;
import flash.geom.ColorTransform;
public class RedTimeLimitField extends TimeLimitField {
public function RedTimeLimitField(param1:int, param2:DisplayObject, param3:WinkManager, param4:Boolean) {
super(param1,param2,param3,param4);
label.color = 16742220;
param2.transform.colorTransform = new ColorTransform(0,0,0,1,255,119,76);
filters = [this.getBitmapFilter()];
}
private function getBitmapFilter() : BitmapFilter {
var local1:Number = 0;
var local2:Number = 45;
var local3:Number = 1;
var local4:Number = 1;
var local5:Number = 1;
var local6:Number = 1;
var local7:Number = 0.65;
var local8:Boolean = false;
var local9:Boolean = false;
var local10:Number = BitmapFilterQuality.HIGH;
return new DropShadowFilter(local6,local2,local1,local3,local4,local5,local7,local10,local8,local9);
}
}
}
|
package _codec.projects.tanks.client.garage.models.item.relativeproperties {
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.codec.OptionalCodecDecorator;
import alternativa.protocol.impl.LengthCodecHelper;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.garage.models.item.relativeproperties.RelativeProperty;
public class VectorCodecRelativePropertyLevel1 implements ICodec {
private var elementCodec:ICodec;
private var optionalElement:Boolean;
public function VectorCodecRelativePropertyLevel1(param1:Boolean) {
super();
this.optionalElement = param1;
}
public function init(param1:IProtocol) : void {
this.elementCodec = param1.getCodec(new TypeCodecInfo(RelativeProperty,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.<RelativeProperty> = new Vector.<RelativeProperty>(local2,true);
var local4:int = 0;
while(local4 < local2) {
local3[local4] = RelativeProperty(this.elementCodec.decode(param1));
local4++;
}
return local3;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
var local4:RelativeProperty = null;
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:Vector.<RelativeProperty> = Vector.<RelativeProperty>(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 _codec.projects.tanks.client.battlefield.models.bonus.battle.bonusregions {
import alternativa.osgi.OSGi;
import alternativa.osgi.service.clientlog.IClientLog;
import alternativa.protocol.ICodec;
import alternativa.protocol.IProtocol;
import alternativa.protocol.ProtocolBuffer;
import alternativa.protocol.info.CollectionCodecInfo;
import alternativa.protocol.info.TypeCodecInfo;
import projects.tanks.client.battlefield.models.bonus.battle.bonusregions.BonusRegionData;
import projects.tanks.client.battlefield.models.bonus.battle.bonusregions.BonusRegionResource;
import projects.tanks.client.battlefield.models.bonus.battle.bonusregions.BonusRegionsCC;
public class CodecBonusRegionsCC implements ICodec {
public static var log:IClientLog = IClientLog(OSGi.getInstance().getService(IClientLog));
private var codec_bonusRegionResources:ICodec;
private var codec_bonusRegions:ICodec;
public function CodecBonusRegionsCC() {
super();
}
public function init(param1:IProtocol) : void {
this.codec_bonusRegionResources = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(BonusRegionResource,false),false,1));
this.codec_bonusRegions = param1.getCodec(new CollectionCodecInfo(new TypeCodecInfo(BonusRegionData,false),false,1));
}
public function decode(param1:ProtocolBuffer) : Object {
var local2:BonusRegionsCC = new BonusRegionsCC();
local2.bonusRegionResources = this.codec_bonusRegionResources.decode(param1) as Vector.<BonusRegionResource>;
local2.bonusRegions = this.codec_bonusRegions.decode(param1) as Vector.<BonusRegionData>;
return local2;
}
public function encode(param1:ProtocolBuffer, param2:Object) : void {
if(param2 == null) {
throw new Error("Object is null. Use @ProtocolOptional annotation.");
}
var local3:BonusRegionsCC = BonusRegionsCC(param2);
this.codec_bonusRegionResources.encode(param1,local3.bonusRegionResources);
this.codec_bonusRegions.encode(param1,local3.bonusRegions);
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.